// Do NOT change. Changes will be lost next time file is generated #define R__DICTIONARY_FILENAME builddIlinuxx8664gccdIRAT_Dict #define R__NO_DEPRECATION /*******************************************************************/ #include #include #include #include #include #define G__DICTIONARY #include "ROOT/RConfig.hxx" #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" // Header files passed as explicit arguments #include "RAT/DS/BitMask.hh" #include "RAT/DS/Calib.hh" #include "RAT/DS/ClassifierResult.hh" #include "RAT/DS/DataQCFlags.hh" #include "RAT/DS/DataNotFound.hh" #include "RAT/DS/Digitiser.hh" #include "RAT/DS/ECAHeader.hh" #include "RAT/DS/EV.hh" #include "RAT/DS/FitResult.hh" #include "RAT/DS/FitVertex.hh" #include "RAT/DS/HeaderInfo.hh" #include "RAT/DS/Meta.hh" #include "RAT/DS/MetaDB.hh" #include "RAT/DS/MC.hh" #include "RAT/DS/MCEV.hh" #include "RAT/DS/MCHit.hh" #include "RAT/DS/MCPMT.hh" #include "RAT/DS/MCParticle.hh" #include "RAT/DS/MCPE.hh" #include "RAT/DS/MCPhoton.hh" #include "RAT/DS/MCTrack.hh" #include "RAT/DS/MCTrackStep.hh" #include "RAT/DS/PMT.hh" #include "RAT/DS/PMTSet.hh" #include "RAT/DS/Entry.hh" #include "RAT/DS/Run.hh" #include "RAT/DS/SOC.hh" #include "RAT/DS/SOCPMT.hh" #include "RAT/DS/TrigHeader.hh" #include "RAT/DS/UniversalTime.hh" #include "RAT/DU/DataCleaningBits.hh" #include "RAT/DU/DataQualityBits.hh" #include "RAT/DU/ChanSWStatus.hh" #include "RAT/DU/TrigBits.hh" #include "RAT/DU/DSReader.hh" #include "RAT/DU/EffectiveVelocity.hh" #include "RAT/DU/GroupVelocity.hh" #include "RAT/DU/LightPathCalculator.hh" #include "RAT/DU/PMTInfo.hh" #include "RAT/DU/PanelInfo.hh" #include "RAT/DU/ChanHWStatus.hh" #include "RAT/DU/PMTCalStatus.hh" #include "RAT/DU/ReactorNuOsc.hh" #include "RAT/DU/ShadowingCalculator.hh" #include "RAT/DU/Segmentor.hh" #include "RAT/DU/SOCReader.hh" #include "RAT/DU/Utility.hh" #include "RAT/PeakFinder.hh" #include "RAT/TrackNav.hh" #include "RAT/TrackNode.hh" #include "RAT/TrackCursor.hh" #include "RAT/PgSQLBackend.hh" #include "RAT/DB.hh" #include "RAT/DBLink.hh" #include "RAT/DBTable.hh" #include "RAT/DBCommandLoader.hh" #include "RAT/DBTextLoader.hh" #include "RAT/DBJsonLoader.hh" #include "RAT/HTTPDownloader.hh" #include "RAT/Log.hh" #include "RAT/MetaInformation.hh" #include "RAT/zdab_file.hh" #include "RAT/zdab_convert.hh" #include "RAT/Record_Info.hh" #include "RAT/PZdabFile.hh" #include "RAT/BitManip.hh" #include "RAT/FlatMap.hh" #include "RAT/DataCleaningUtility.hh" #include "RAT/SunUtil.hh" #include "RAT/Version.hh" #include "RAT/DataCleaningUtility.hh" #include "RAT/GLG4StringUtil.hh" #include "RAT/PhysicsUtil.hh" #include "RAT/QuadraticRoots.hh" #include "RAT/VectorTools.hh" #include "RAT/FitterPMT.hh" #include "RAT/DU/ReconCorrector.hh" #include "RAT/DU/EnergySystematics.hh" #include "RAT/DU/ReconCalibrator.hh" #include "RAT/DU/TimeResidualCalculator.hh" #include "RAT/DU/Point3D.hh" #include "RAT/LightPath.hh" #include "RAT/LightPathFitter.hh" #include "RAT/LightPathStraightFitter.hh" #include "RAT/LightPathStraightScint.hh" #include "RAT/LightPathStraightScintWater.hh" #include "RAT/DU/DetectorStateCorrection.hh" // Header files passed via #pragma extra_include // The generated code does not explicitly qualify STL entities namespace std {} using namespace std; namespace RAT { namespace ROOTDict { inline ::ROOT::TGenericClassInfo *GenerateInitInstance(); static TClass *RAT_Dictionary(); // Function generating the singleton type initializer inline ::ROOT::TGenericClassInfo *GenerateInitInstance() { static ::ROOT::TGenericClassInfo instance("RAT", 0 /*version*/, "RAT/DS/BitMask.hh", 31, ::ROOT::Internal::DefineBehavior((void*)nullptr,(void*)nullptr), &RAT_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 *RAT_Dictionary() { return GenerateInitInstance()->GetClass(); } } } namespace ratzdab { namespace ROOTDict { inline ::ROOT::TGenericClassInfo *GenerateInitInstance(); static TClass *ratzdab_Dictionary(); // Function generating the singleton type initializer inline ::ROOT::TGenericClassInfo *GenerateInitInstance() { static ::ROOT::TGenericClassInfo instance("ratzdab", 0 /*version*/, "RAT/zdab_convert.hh", 55, ::ROOT::Internal::DefineBehavior((void*)nullptr,(void*)nullptr), &ratzdab_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 *ratzdab_Dictionary() { return GenerateInitInstance()->GetClass(); } } } namespace ratzdab { namespace unpack { namespace ROOTDict { inline ::ROOT::TGenericClassInfo *GenerateInitInstance(); static TClass *ratzdabcLcLunpack_Dictionary(); // Function generating the singleton type initializer inline ::ROOT::TGenericClassInfo *GenerateInitInstance() { static ::ROOT::TGenericClassInfo instance("ratzdab::unpack", 0 /*version*/, "RAT/zdab_convert.hh", 58, ::ROOT::Internal::DefineBehavior((void*)nullptr,(void*)nullptr), &ratzdabcLcLunpack_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 *ratzdabcLcLunpack_Dictionary() { return GenerateInitInstance()->GetClass(); } } } } namespace ratzdab { namespace pack { namespace ROOTDict { inline ::ROOT::TGenericClassInfo *GenerateInitInstance(); static TClass *ratzdabcLcLpack_Dictionary(); // Function generating the singleton type initializer inline ::ROOT::TGenericClassInfo *GenerateInitInstance() { static ::ROOT::TGenericClassInfo instance("ratzdab::pack", 0 /*version*/, "RAT/zdab_convert.hh", 75, ::ROOT::Internal::DefineBehavior((void*)nullptr,(void*)nullptr), &ratzdabcLcLpack_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 *ratzdabcLcLpack_Dictionary() { return GenerateInitInstance()->GetClass(); } } } } namespace RAT { namespace util { namespace ROOTDict { inline ::ROOT::TGenericClassInfo *GenerateInitInstance(); static TClass *RATcLcLutil_Dictionary(); // Function generating the singleton type initializer inline ::ROOT::TGenericClassInfo *GenerateInitInstance() { static ::ROOT::TGenericClassInfo instance("RAT::util", 0 /*version*/, "RAT/PhysicsUtil.hh", 13, ::ROOT::Internal::DefineBehavior((void*)nullptr,(void*)nullptr), &RATcLcLutil_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 *RATcLcLutil_Dictionary() { return GenerateInitInstance()->GetClass(); } } } } namespace ROOT { static TClass *exception_Dictionary(); static void exception_TClassManip(TClass*); static void *new_exception(void *p = nullptr); static void *newArray_exception(Long_t size, void *p); static void delete_exception(void *p); static void deleteArray_exception(void *p); static void destruct_exception(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::exception*) { ::exception *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::exception)); static ::ROOT::TGenericClassInfo instance("exception", "new", 61, typeid(::exception), ::ROOT::Internal::DefineBehavior(ptr, ptr), &exception_Dictionary, isa_proxy, 2, sizeof(::exception) ); instance.SetNew(&new_exception); instance.SetNewArray(&newArray_exception); instance.SetDelete(&delete_exception); instance.SetDeleteArray(&deleteArray_exception); instance.SetDestructor(&destruct_exception); instance.AdoptAlternate(::ROOT::AddClassAlternate("exception","std::exception")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *exception_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); exception_TClassManip(theClass); return theClass; } static void exception_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *pairlEstringcOstringgR_Dictionary(); static void pairlEstringcOstringgR_TClassManip(TClass*); static void *new_pairlEstringcOstringgR(void *p = nullptr); static void *newArray_pairlEstringcOstringgR(Long_t size, void *p); static void delete_pairlEstringcOstringgR(void *p); static void deleteArray_pairlEstringcOstringgR(void *p); static void destruct_pairlEstringcOstringgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const pair*) { pair *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair)); static ::ROOT::TGenericClassInfo instance("pair", "string", 185, typeid(pair), ::ROOT::Internal::DefineBehavior(ptr, ptr), &pairlEstringcOstringgR_Dictionary, isa_proxy, 4, sizeof(pair) ); instance.SetNew(&new_pairlEstringcOstringgR); instance.SetNewArray(&newArray_pairlEstringcOstringgR); instance.SetDelete(&delete_pairlEstringcOstringgR); instance.SetDeleteArray(&deleteArray_pairlEstringcOstringgR); instance.SetDestructor(&destruct_pairlEstringcOstringgR); instance.AdoptAlternate(::ROOT::AddClassAlternate("pair","pair")); instance.AdoptAlternate(::ROOT::AddClassAlternate("pair","std::pair, std::allocator >, std::__cxx11::basic_string, std::allocator > >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *pairlEstringcOstringgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); pairlEstringcOstringgR_TClassManip(theClass); return theClass; } static void pairlEstringcOstringgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR_Dictionary(); static void pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR_TClassManip(TClass*); static void *new_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p = nullptr); static void *newArray_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(Long_t size, void *p); static void delete_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p); static void deleteArray_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p); static void destruct_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const pair*) { pair *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair)); static ::ROOT::TGenericClassInfo instance("pair", "string", 185, typeid(pair), ::ROOT::Internal::DefineBehavior(ptr, ptr), &pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR_Dictionary, isa_proxy, 4, sizeof(pair) ); instance.SetNew(&new_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR); instance.SetNewArray(&newArray_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR); instance.SetDelete(&delete_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR); instance.SetDeleteArray(&deleteArray_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR); instance.SetDestructor(&destruct_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR); instance.AdoptAlternate(::ROOT::AddClassAlternate("pair","pair")); instance.AdoptAlternate(::ROOT::AddClassAlternate("pair","std::pair")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR_TClassManip(theClass); return theClass; } static void pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_Dictionary(); static void pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_TClassManip(TClass*); static void *new_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p = nullptr); static void *newArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(Long_t size, void *p); static void delete_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p); static void deleteArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p); static void destruct_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const pair >*) { pair > *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair >)); static ::ROOT::TGenericClassInfo instance("pair >", "string", 185, typeid(pair >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_Dictionary, isa_proxy, 4, sizeof(pair >) ); instance.SetNew(&new_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR); instance.SetNewArray(&newArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR); instance.SetDelete(&delete_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR); instance.SetDeleteArray(&deleteArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR); instance.SetDestructor(&destruct_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR); instance.AdoptAlternate(::ROOT::AddClassAlternate("pair >","pair >")); instance.AdoptAlternate(::ROOT::AddClassAlternate("pair >","std::pair >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast >*>(nullptr))->GetClass(); pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_TClassManip(theClass); return theClass; } static void pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_Dictionary(); static void pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_TClassManip(TClass*); static void *new_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p = nullptr); static void *newArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(Long_t size, void *p); static void delete_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p); static void deleteArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p); static void destruct_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const pair >*) { pair > *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair >)); static ::ROOT::TGenericClassInfo instance("pair >", "string", 185, typeid(pair >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_Dictionary, isa_proxy, 4, sizeof(pair >) ); instance.SetNew(&new_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR); instance.SetNewArray(&newArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR); instance.SetDelete(&delete_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR); instance.SetDeleteArray(&deleteArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR); instance.SetDestructor(&destruct_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR); instance.AdoptAlternate(::ROOT::AddClassAlternate("pair >","pair >")); instance.AdoptAlternate(::ROOT::AddClassAlternate("pair >","std::pair >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast >*>(nullptr))->GetClass(); pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_TClassManip(theClass); return theClass; } static void pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_Dictionary(); static void pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_TClassManip(TClass*); static void *new_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p = nullptr); static void *newArray_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(Long_t size, void *p); static void delete_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p); static void deleteArray_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p); static void destruct_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const pair >*) { pair > *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair >)); static ::ROOT::TGenericClassInfo instance("pair >", "string", 185, typeid(pair >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_Dictionary, isa_proxy, 4, sizeof(pair >) ); instance.SetNew(&new_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR); instance.SetNewArray(&newArray_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR); instance.SetDelete(&delete_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR); instance.SetDeleteArray(&deleteArray_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR); instance.SetDestructor(&destruct_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR); instance.AdoptAlternate(::ROOT::AddClassAlternate("pair >","pair >")); instance.AdoptAlternate(::ROOT::AddClassAlternate("pair >","std::pair >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast >*>(nullptr))->GetClass(); pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_TClassManip(theClass); return theClass; } static void pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR_Dictionary(); static void pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR_TClassManip(TClass*); static void *new_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p = nullptr); static void *newArray_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(Long_t size, void *p); static void delete_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p); static void deleteArray_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p); static void destruct_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const pair*) { pair *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair)); static ::ROOT::TGenericClassInfo instance("pair", "string", 185, typeid(pair), ::ROOT::Internal::DefineBehavior(ptr, ptr), &pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR_Dictionary, isa_proxy, 4, sizeof(pair) ); instance.SetNew(&new_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR); instance.SetNewArray(&newArray_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR); instance.SetDelete(&delete_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR); instance.SetDeleteArray(&deleteArray_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR); instance.SetDestructor(&destruct_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR); instance.AdoptAlternate(::ROOT::AddClassAlternate("pair","pair")); instance.AdoptAlternate(::ROOT::AddClassAlternate("pair","std::pair")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR_TClassManip(theClass); return theClass; } static void pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLBitMask(void *p = nullptr); static void *newArray_RATcLcLDScLcLBitMask(Long_t size, void *p); static void delete_RATcLcLDScLcLBitMask(void *p); static void deleteArray_RATcLcLDScLcLBitMask(void *p); static void destruct_RATcLcLDScLcLBitMask(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::BitMask*) { ::RAT::DS::BitMask *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::BitMask >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::BitMask", ::RAT::DS::BitMask::Class_Version(), "RAT/DS/BitMask.hh", 36, typeid(::RAT::DS::BitMask), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::BitMask::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::BitMask) ); instance.SetNew(&new_RATcLcLDScLcLBitMask); instance.SetNewArray(&newArray_RATcLcLDScLcLBitMask); instance.SetDelete(&delete_RATcLcLDScLcLBitMask); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLBitMask); instance.SetDestructor(&destruct_RATcLcLDScLcLBitMask); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::BitMask*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::BitMask*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLCalib(void *p = nullptr); static void *newArray_RATcLcLDScLcLCalib(Long_t size, void *p); static void delete_RATcLcLDScLcLCalib(void *p); static void deleteArray_RATcLcLDScLcLCalib(void *p); static void destruct_RATcLcLDScLcLCalib(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::Calib*) { ::RAT::DS::Calib *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::Calib >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::Calib", ::RAT::DS::Calib::Class_Version(), "RAT/DS/Calib.hh", 28, typeid(::RAT::DS::Calib), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::Calib::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::Calib) ); instance.SetNew(&new_RATcLcLDScLcLCalib); instance.SetNewArray(&newArray_RATcLcLDScLcLCalib); instance.SetDelete(&delete_RATcLcLDScLcLCalib); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLCalib); instance.SetDestructor(&destruct_RATcLcLDScLcLCalib); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::Calib*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::Calib*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLDScLcLDataNotFound_Dictionary(); static void RATcLcLDScLcLDataNotFound_TClassManip(TClass*); static void delete_RATcLcLDScLcLDataNotFound(void *p); static void deleteArray_RATcLcLDScLcLDataNotFound(void *p); static void destruct_RATcLcLDScLcLDataNotFound(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::DataNotFound*) { ::RAT::DS::DataNotFound *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::DS::DataNotFound)); static ::ROOT::TGenericClassInfo instance("RAT::DS::DataNotFound", "RAT/DS/DataNotFound.hh", 36, typeid(::RAT::DS::DataNotFound), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLDScLcLDataNotFound_Dictionary, isa_proxy, 2, sizeof(::RAT::DS::DataNotFound) ); instance.SetDelete(&delete_RATcLcLDScLcLDataNotFound); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLDataNotFound); instance.SetDestructor(&destruct_RATcLcLDScLcLDataNotFound); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::DataNotFound*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::DataNotFound*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLDScLcLDataNotFound_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLDScLcLDataNotFound_TClassManip(theClass); return theClass; } static void RATcLcLDScLcLDataNotFound_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLClassifierResult(void *p = nullptr); static void *newArray_RATcLcLDScLcLClassifierResult(Long_t size, void *p); static void delete_RATcLcLDScLcLClassifierResult(void *p); static void deleteArray_RATcLcLDScLcLClassifierResult(void *p); static void destruct_RATcLcLDScLcLClassifierResult(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::ClassifierResult*) { ::RAT::DS::ClassifierResult *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::ClassifierResult >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::ClassifierResult", ::RAT::DS::ClassifierResult::Class_Version(), "RAT/DS/ClassifierResult.hh", 67, typeid(::RAT::DS::ClassifierResult), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::ClassifierResult::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::ClassifierResult) ); instance.SetNew(&new_RATcLcLDScLcLClassifierResult); instance.SetNewArray(&newArray_RATcLcLDScLcLClassifierResult); instance.SetDelete(&delete_RATcLcLDScLcLClassifierResult); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLClassifierResult); instance.SetDestructor(&destruct_RATcLcLDScLcLClassifierResult); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::ClassifierResult*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::ClassifierResult*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLDataQCFlags(void *p = nullptr); static void *newArray_RATcLcLDScLcLDataQCFlags(Long_t size, void *p); static void delete_RATcLcLDScLcLDataQCFlags(void *p); static void deleteArray_RATcLcLDScLcLDataQCFlags(void *p); static void destruct_RATcLcLDScLcLDataQCFlags(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::DataQCFlags*) { ::RAT::DS::DataQCFlags *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::DataQCFlags >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::DataQCFlags", ::RAT::DS::DataQCFlags::Class_Version(), "RAT/DS/DataQCFlags.hh", 35, typeid(::RAT::DS::DataQCFlags), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::DataQCFlags::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::DataQCFlags) ); instance.SetNew(&new_RATcLcLDScLcLDataQCFlags); instance.SetNewArray(&newArray_RATcLcLDScLcLDataQCFlags); instance.SetDelete(&delete_RATcLcLDScLcLDataQCFlags); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLDataQCFlags); instance.SetDestructor(&destruct_RATcLcLDScLcLDataQCFlags); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::DataQCFlags*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::DataQCFlags*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLDigitiser(void *p = nullptr); static void *newArray_RATcLcLDScLcLDigitiser(Long_t size, void *p); static void delete_RATcLcLDScLcLDigitiser(void *p); static void deleteArray_RATcLcLDScLcLDigitiser(void *p); static void destruct_RATcLcLDScLcLDigitiser(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::Digitiser*) { ::RAT::DS::Digitiser *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::Digitiser >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::Digitiser", ::RAT::DS::Digitiser::Class_Version(), "RAT/DS/Digitiser.hh", 32, typeid(::RAT::DS::Digitiser), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::Digitiser::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::Digitiser) ); instance.SetNew(&new_RATcLcLDScLcLDigitiser); instance.SetNewArray(&newArray_RATcLcLDScLcLDigitiser); instance.SetDelete(&delete_RATcLcLDScLcLDigitiser); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLDigitiser); instance.SetDestructor(&destruct_RATcLcLDScLcLDigitiser); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::Digitiser*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::Digitiser*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLECAHeader(void *p = nullptr); static void *newArray_RATcLcLDScLcLECAHeader(Long_t size, void *p); static void delete_RATcLcLDScLcLECAHeader(void *p); static void deleteArray_RATcLcLDScLcLECAHeader(void *p); static void destruct_RATcLcLDScLcLECAHeader(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::ECAHeader*) { ::RAT::DS::ECAHeader *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::ECAHeader >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::ECAHeader", ::RAT::DS::ECAHeader::Class_Version(), "RAT/DS/ECAHeader.hh", 29, typeid(::RAT::DS::ECAHeader), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::ECAHeader::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::ECAHeader) ); instance.SetNew(&new_RATcLcLDScLcLECAHeader); instance.SetNewArray(&newArray_RATcLcLDScLcLECAHeader); instance.SetDelete(&delete_RATcLcLDScLcLECAHeader); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLECAHeader); instance.SetDestructor(&destruct_RATcLcLDScLcLECAHeader); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::ECAHeader*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::ECAHeader*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLUniversalTime(void *p = nullptr); static void *newArray_RATcLcLDScLcLUniversalTime(Long_t size, void *p); static void delete_RATcLcLDScLcLUniversalTime(void *p); static void deleteArray_RATcLcLDScLcLUniversalTime(void *p); static void destruct_RATcLcLDScLcLUniversalTime(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::UniversalTime*) { ::RAT::DS::UniversalTime *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::UniversalTime >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::UniversalTime", ::RAT::DS::UniversalTime::Class_Version(), "RAT/DS/UniversalTime.hh", 27, typeid(::RAT::DS::UniversalTime), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::UniversalTime::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::UniversalTime) ); instance.SetNew(&new_RATcLcLDScLcLUniversalTime); instance.SetNewArray(&newArray_RATcLcLDScLcLUniversalTime); instance.SetDelete(&delete_RATcLcLDScLcLUniversalTime); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLUniversalTime); instance.SetDestructor(&destruct_RATcLcLDScLcLUniversalTime); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::UniversalTime*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::UniversalTime*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static TClass *ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary(); static void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_TClassManip(TClass*); static void *new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p = nullptr); static void *newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(Long_t size, void *p); static void delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p); static void deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p); static void destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>*) { ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag> *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>)); static ::ROOT::TGenericClassInfo instance("ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>", "Math/GenVector/DisplacementVector3D.h", 58, typeid(::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>), ::ROOT::Internal::DefineBehavior(ptr, ptr), &ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary, isa_proxy, 4, sizeof(::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>) ); instance.SetNew(&new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR); instance.SetNewArray(&newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR); instance.SetDelete(&delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR); instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR); instance.SetDestructor(&destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR); instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>","ROOT::Math::XYZVector")); instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>","ROOT::Math::DisplacementVector3D, ROOT::Math::DefaultCoordinateSystemTag>")); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>*) { return GenerateInitInstanceLocal(static_cast<::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast,ROOT::Math::DefaultCoordinateSystemTag>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast,ROOT::Math::DefaultCoordinateSystemTag>*>(nullptr))->GetClass(); ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_TClassManip(theClass); return theClass; } static void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary(); static void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_TClassManip(TClass*); static void *new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p = nullptr); static void *newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(Long_t size, void *p); static void delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p); static void deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p); static void destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>*) { ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag> *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>)); static ::ROOT::TGenericClassInfo instance("ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>", "Math/GenVector/DisplacementVector3D.h", 58, typeid(::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>), ::ROOT::Internal::DefineBehavior(ptr, ptr), &ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary, isa_proxy, 4, sizeof(::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>) ); instance.SetNew(&new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR); instance.SetNewArray(&newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR); instance.SetDelete(&delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR); instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR); instance.SetDestructor(&destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR); instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>","ROOT::Math::XYZVectorF")); instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>","ROOT::Math::DisplacementVector3D, ROOT::Math::DefaultCoordinateSystemTag>")); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>*) { return GenerateInitInstanceLocal(static_cast<::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast,ROOT::Math::DefaultCoordinateSystemTag>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast,ROOT::Math::DefaultCoordinateSystemTag>*>(nullptr))->GetClass(); ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_TClassManip(theClass); return theClass; } static void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary(); static void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_TClassManip(TClass*); static void *new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p = nullptr); static void *newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(Long_t size, void *p); static void delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p); static void deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p); static void destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>*) { ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag> *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>)); static ::ROOT::TGenericClassInfo instance("ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>", "Math/GenVector/DisplacementVector3D.h", 58, typeid(::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>), ::ROOT::Internal::DefineBehavior(ptr, ptr), &ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary, isa_proxy, 4, sizeof(::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>) ); instance.SetNew(&new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR); instance.SetNewArray(&newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR); instance.SetDelete(&delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR); instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR); instance.SetDestructor(&destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR); instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>","ROOT::Math::Polar3DVector")); instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>","ROOT::Math::DisplacementVector3D, ROOT::Math::DefaultCoordinateSystemTag>")); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>*) { return GenerateInitInstanceLocal(static_cast<::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast,ROOT::Math::DefaultCoordinateSystemTag>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast,ROOT::Math::DefaultCoordinateSystemTag>*>(nullptr))->GetClass(); ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_TClassManip(theClass); return theClass; } static void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary(); static void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_TClassManip(TClass*); static void *new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p = nullptr); static void *newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(Long_t size, void *p); static void delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p); static void deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p); static void destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>*) { ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag> *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>)); static ::ROOT::TGenericClassInfo instance("ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>", "Math/GenVector/DisplacementVector3D.h", 58, typeid(::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>), ::ROOT::Internal::DefineBehavior(ptr, ptr), &ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary, isa_proxy, 4, sizeof(::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>) ); instance.SetNew(&new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR); instance.SetNewArray(&newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR); instance.SetDelete(&delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR); instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR); instance.SetDestructor(&destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR); instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>","ROOT::Math::Polar3DVectorF")); instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>","ROOT::Math::DisplacementVector3D, ROOT::Math::DefaultCoordinateSystemTag>")); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>*) { return GenerateInitInstanceLocal(static_cast<::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast,ROOT::Math::DefaultCoordinateSystemTag>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast,ROOT::Math::DefaultCoordinateSystemTag>*>(nullptr))->GetClass(); ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_TClassManip(theClass); return theClass; } static void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *ROOTcLcLMathcLcLCartesian3DlEfloatgR_Dictionary(); static void ROOTcLcLMathcLcLCartesian3DlEfloatgR_TClassManip(TClass*); static void *new_ROOTcLcLMathcLcLCartesian3DlEfloatgR(void *p = nullptr); static void *newArray_ROOTcLcLMathcLcLCartesian3DlEfloatgR(Long_t size, void *p); static void delete_ROOTcLcLMathcLcLCartesian3DlEfloatgR(void *p); static void deleteArray_ROOTcLcLMathcLcLCartesian3DlEfloatgR(void *p); static void destruct_ROOTcLcLMathcLcLCartesian3DlEfloatgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Cartesian3D*) { ::ROOT::Math::Cartesian3D *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Cartesian3D)); static ::ROOT::TGenericClassInfo instance("ROOT::Math::Cartesian3D", "Math/GenVector/Cartesian3D.h", 46, typeid(::ROOT::Math::Cartesian3D), ::ROOT::Internal::DefineBehavior(ptr, ptr), &ROOTcLcLMathcLcLCartesian3DlEfloatgR_Dictionary, isa_proxy, 4, sizeof(::ROOT::Math::Cartesian3D) ); instance.SetNew(&new_ROOTcLcLMathcLcLCartesian3DlEfloatgR); instance.SetNewArray(&newArray_ROOTcLcLMathcLcLCartesian3DlEfloatgR); instance.SetDelete(&delete_ROOTcLcLMathcLcLCartesian3DlEfloatgR); instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLCartesian3DlEfloatgR); instance.SetDestructor(&destruct_ROOTcLcLMathcLcLCartesian3DlEfloatgR); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Cartesian3D*) { return GenerateInitInstanceLocal(static_cast<::ROOT::Math::Cartesian3D*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *ROOTcLcLMathcLcLCartesian3DlEfloatgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); ROOTcLcLMathcLcLCartesian3DlEfloatgR_TClassManip(theClass); return theClass; } static void ROOTcLcLMathcLcLCartesian3DlEfloatgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *ROOTcLcLMathcLcLPolar3DlEfloatgR_Dictionary(); static void ROOTcLcLMathcLcLPolar3DlEfloatgR_TClassManip(TClass*); static void *new_ROOTcLcLMathcLcLPolar3DlEfloatgR(void *p = nullptr); static void *newArray_ROOTcLcLMathcLcLPolar3DlEfloatgR(Long_t size, void *p); static void delete_ROOTcLcLMathcLcLPolar3DlEfloatgR(void *p); static void deleteArray_ROOTcLcLMathcLcLPolar3DlEfloatgR(void *p); static void destruct_ROOTcLcLMathcLcLPolar3DlEfloatgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Polar3D*) { ::ROOT::Math::Polar3D *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Polar3D)); static ::ROOT::TGenericClassInfo instance("ROOT::Math::Polar3D", "Math/GenVector/Polar3D.h", 45, typeid(::ROOT::Math::Polar3D), ::ROOT::Internal::DefineBehavior(ptr, ptr), &ROOTcLcLMathcLcLPolar3DlEfloatgR_Dictionary, isa_proxy, 4, sizeof(::ROOT::Math::Polar3D) ); instance.SetNew(&new_ROOTcLcLMathcLcLPolar3DlEfloatgR); instance.SetNewArray(&newArray_ROOTcLcLMathcLcLPolar3DlEfloatgR); instance.SetDelete(&delete_ROOTcLcLMathcLcLPolar3DlEfloatgR); instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLPolar3DlEfloatgR); instance.SetDestructor(&destruct_ROOTcLcLMathcLcLPolar3DlEfloatgR); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Polar3D*) { return GenerateInitInstanceLocal(static_cast<::ROOT::Math::Polar3D*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *ROOTcLcLMathcLcLPolar3DlEfloatgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); ROOTcLcLMathcLcLPolar3DlEfloatgR_TClassManip(theClass); return theClass; } static void ROOTcLcLMathcLcLPolar3DlEfloatgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLFitVertex(void *p = nullptr); static void *newArray_RATcLcLDScLcLFitVertex(Long_t size, void *p); static void delete_RATcLcLDScLcLFitVertex(void *p); static void deleteArray_RATcLcLDScLcLFitVertex(void *p); static void destruct_RATcLcLDScLcLFitVertex(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::FitVertex*) { ::RAT::DS::FitVertex *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::FitVertex >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::FitVertex", ::RAT::DS::FitVertex::Class_Version(), "RAT/DS/FitVertex.hh", 58, typeid(::RAT::DS::FitVertex), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::FitVertex::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::FitVertex) ); instance.SetNew(&new_RATcLcLDScLcLFitVertex); instance.SetNewArray(&newArray_RATcLcLDScLcLFitVertex); instance.SetDelete(&delete_RATcLcLDScLcLFitVertex); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLFitVertex); instance.SetDestructor(&destruct_RATcLcLDScLcLFitVertex); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::FitVertex*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::FitVertex*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLFitResult(void *p = nullptr); static void *newArray_RATcLcLDScLcLFitResult(Long_t size, void *p); static void delete_RATcLcLDScLcLFitResult(void *p); static void deleteArray_RATcLcLDScLcLFitResult(void *p); static void destruct_RATcLcLDScLcLFitResult(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::FitResult*) { ::RAT::DS::FitResult *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::FitResult >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::FitResult", ::RAT::DS::FitResult::Class_Version(), "RAT/DS/FitResult.hh", 68, typeid(::RAT::DS::FitResult), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::FitResult::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::FitResult) ); instance.SetNew(&new_RATcLcLDScLcLFitResult); instance.SetNewArray(&newArray_RATcLcLDScLcLFitResult); instance.SetDelete(&delete_RATcLcLDScLcLFitResult); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLFitResult); instance.SetDestructor(&destruct_RATcLcLDScLcLFitResult); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::FitResult*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::FitResult*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR_Dictionary(); static void RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR_TClassManip(TClass*); static void *new_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(void *p = nullptr); static void *newArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(Long_t size, void *p); static void delete_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(void *p); static void deleteArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(void *p); static void destruct_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::FitClassifierCollection*) { ::RAT::DS::FitClassifierCollection *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::FitClassifierCollection >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::FitClassifierCollection", ::RAT::DS::FitClassifierCollection::Class_Version(), "RAT/DS/FitClassifierCollection.hh", 32, typeid(::RAT::DS::FitClassifierCollection), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR_Dictionary, isa_proxy, 4, sizeof(::RAT::DS::FitClassifierCollection) ); instance.SetNew(&new_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR); instance.SetNewArray(&newArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR); instance.SetDelete(&delete_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR); instance.SetDestructor(&destruct_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR); instance.AdoptAlternate(::ROOT::AddClassAlternate("RAT::DS::FitClassifierCollection","RAT::DS::FitCollection")); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::FitClassifierCollection*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::FitClassifierCollection*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR_TClassManip(theClass); return theClass; } static void RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR_Dictionary(); static void RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR_TClassManip(TClass*); static void *new_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(void *p = nullptr); static void *newArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(Long_t size, void *p); static void delete_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(void *p); static void deleteArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(void *p); static void destruct_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::FitClassifierCollection*) { ::RAT::DS::FitClassifierCollection *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::FitClassifierCollection >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::FitClassifierCollection", ::RAT::DS::FitClassifierCollection::Class_Version(), "RAT/DS/FitClassifierCollection.hh", 32, typeid(::RAT::DS::FitClassifierCollection), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR_Dictionary, isa_proxy, 4, sizeof(::RAT::DS::FitClassifierCollection) ); instance.SetNew(&new_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR); instance.SetNewArray(&newArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR); instance.SetDelete(&delete_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR); instance.SetDestructor(&destruct_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR); instance.AdoptAlternate(::ROOT::AddClassAlternate("RAT::DS::FitClassifierCollection","RAT::DS::ClassifierCollection")); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::FitClassifierCollection*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::FitClassifierCollection*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR_TClassManip(theClass); return theClass; } static void RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *jsoncLcLValue_Dictionary(); static void jsoncLcLValue_TClassManip(TClass*); static void *new_jsoncLcLValue(void *p = nullptr); static void *newArray_jsoncLcLValue(Long_t size, void *p); static void delete_jsoncLcLValue(void *p); static void deleteArray_jsoncLcLValue(void *p); static void destruct_jsoncLcLValue(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::json::Value*) { ::json::Value *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::json::Value)); static ::ROOT::TGenericClassInfo instance("json::Value", "RAT/json.hh", 67, typeid(::json::Value), ::ROOT::Internal::DefineBehavior(ptr, ptr), &jsoncLcLValue_Dictionary, isa_proxy, 0, sizeof(::json::Value) ); instance.SetNew(&new_jsoncLcLValue); instance.SetNewArray(&newArray_jsoncLcLValue); instance.SetDelete(&delete_jsoncLcLValue); instance.SetDeleteArray(&deleteArray_jsoncLcLValue); instance.SetDestructor(&destruct_jsoncLcLValue); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::json::Value*) { return GenerateInitInstanceLocal(static_cast<::json::Value*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *jsoncLcLValue_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); jsoncLcLValue_TClassManip(theClass); return theClass; } static void jsoncLcLValue_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLLog_Dictionary(); static void RATcLcLLog_TClassManip(TClass*); static void *new_RATcLcLLog(void *p = nullptr); static void delete_RATcLcLLog(void *p); static void deleteArray_RATcLcLLog(void *p); static void destruct_RATcLcLLog(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::Log*) { ::RAT::Log *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::Log)); static ::ROOT::TGenericClassInfo instance("RAT::Log", "RAT/Log.hh", 123, typeid(::RAT::Log), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLLog_Dictionary, isa_proxy, 4, sizeof(::RAT::Log) ); instance.SetNew(&new_RATcLcLLog); instance.SetDelete(&delete_RATcLcLLog); instance.SetDeleteArray(&deleteArray_RATcLcLLog); instance.SetDestructor(&destruct_RATcLcLLog); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::Log*) { return GenerateInitInstanceLocal(static_cast<::RAT::Log*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLLog_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLLog_TClassManip(theClass); return theClass; } static void RATcLcLLog_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLBitManip_Dictionary(); static void RATcLcLBitManip_TClassManip(TClass*); static void *new_RATcLcLBitManip(void *p = nullptr); static void *newArray_RATcLcLBitManip(Long_t size, void *p); static void delete_RATcLcLBitManip(void *p); static void deleteArray_RATcLcLBitManip(void *p); static void destruct_RATcLcLBitManip(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::BitManip*) { ::RAT::BitManip *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::BitManip)); static ::ROOT::TGenericClassInfo instance("RAT::BitManip", "RAT/BitManip.hh", 22, typeid(::RAT::BitManip), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLBitManip_Dictionary, isa_proxy, 4, sizeof(::RAT::BitManip) ); instance.SetNew(&new_RATcLcLBitManip); instance.SetNewArray(&newArray_RATcLcLBitManip); instance.SetDelete(&delete_RATcLcLBitManip); instance.SetDeleteArray(&deleteArray_RATcLcLBitManip); instance.SetDestructor(&destruct_RATcLcLBitManip); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::BitManip*) { return GenerateInitInstanceLocal(static_cast<::RAT::BitManip*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLBitManip_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLBitManip_TClassManip(theClass); return theClass; } static void RATcLcLBitManip_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLDScLcLPMTlEDouble32_tgR_Dictionary(); static void RATcLcLDScLcLPMTlEDouble32_tgR_TClassManip(TClass*); static void *new_RATcLcLDScLcLPMTlEDouble32_tgR(void *p = nullptr); static void *newArray_RATcLcLDScLcLPMTlEDouble32_tgR(Long_t size, void *p); static void delete_RATcLcLDScLcLPMTlEDouble32_tgR(void *p); static void deleteArray_RATcLcLDScLcLPMTlEDouble32_tgR(void *p); static void destruct_RATcLcLDScLcLPMTlEDouble32_tgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::PMT*) { ::RAT::DS::PMT *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::PMT >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::PMT", ::RAT::DS::PMT::Class_Version(), "RAT/DS/PMT.hh", 55, typeid(::RAT::DS::PMT), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLDScLcLPMTlEDouble32_tgR_Dictionary, isa_proxy, 4, sizeof(::RAT::DS::PMT) ); instance.SetNew(&new_RATcLcLDScLcLPMTlEDouble32_tgR); instance.SetNewArray(&newArray_RATcLcLDScLcLPMTlEDouble32_tgR); instance.SetDelete(&delete_RATcLcLDScLcLPMTlEDouble32_tgR); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLPMTlEDouble32_tgR); instance.SetDestructor(&destruct_RATcLcLDScLcLPMTlEDouble32_tgR); instance.AdoptAlternate(::ROOT::AddClassAlternate("RAT::DS::PMT","RAT::DS::PMTFloat")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLDScLcLPMTlEDouble32_tgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); RATcLcLDScLcLPMTlEDouble32_tgR_TClassManip(theClass); return theClass; } static void RATcLcLDScLcLPMTlEDouble32_tgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLDScLcLPMTlEunsignedsPshortgR_Dictionary(); static void RATcLcLDScLcLPMTlEunsignedsPshortgR_TClassManip(TClass*); static void *new_RATcLcLDScLcLPMTlEunsignedsPshortgR(void *p = nullptr); static void *newArray_RATcLcLDScLcLPMTlEunsignedsPshortgR(Long_t size, void *p); static void delete_RATcLcLDScLcLPMTlEunsignedsPshortgR(void *p); static void deleteArray_RATcLcLDScLcLPMTlEunsignedsPshortgR(void *p); static void destruct_RATcLcLDScLcLPMTlEunsignedsPshortgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::PMT*) { ::RAT::DS::PMT *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::PMT >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::PMT", ::RAT::DS::PMT::Class_Version(), "RAT/DS/PMT.hh", 55, typeid(::RAT::DS::PMT), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLDScLcLPMTlEunsignedsPshortgR_Dictionary, isa_proxy, 4, sizeof(::RAT::DS::PMT) ); instance.SetNew(&new_RATcLcLDScLcLPMTlEunsignedsPshortgR); instance.SetNewArray(&newArray_RATcLcLDScLcLPMTlEunsignedsPshortgR); instance.SetDelete(&delete_RATcLcLDScLcLPMTlEunsignedsPshortgR); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLPMTlEunsignedsPshortgR); instance.SetDestructor(&destruct_RATcLcLDScLcLPMTlEunsignedsPshortgR); instance.AdoptAlternate(::ROOT::AddClassAlternate("RAT::DS::PMT","RAT::DS::PMTUncal")); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::PMT*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::PMT*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLDScLcLPMTlEunsignedsPshortgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); RATcLcLDScLcLPMTlEunsignedsPshortgR_TClassManip(theClass); return theClass; } static void RATcLcLDScLcLPMTlEunsignedsPshortgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLPMTCal(void *p = nullptr); static void *newArray_RATcLcLDScLcLPMTCal(Long_t size, void *p); static void delete_RATcLcLDScLcLPMTCal(void *p); static void deleteArray_RATcLcLDScLcLPMTCal(void *p); static void destruct_RATcLcLDScLcLPMTCal(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::PMTCal*) { ::RAT::DS::PMTCal *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::PMTCal >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::PMTCal", ::RAT::DS::PMTCal::Class_Version(), "RAT/DS/PMT.hh", 224, typeid(::RAT::DS::PMTCal), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::PMTCal::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::PMTCal) ); instance.SetNew(&new_RATcLcLDScLcLPMTCal); instance.SetNewArray(&newArray_RATcLcLDScLcLPMTCal); instance.SetDelete(&delete_RATcLcLDScLcLPMTCal); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLPMTCal); instance.SetDestructor(&destruct_RATcLcLDScLcLPMTCal); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::PMTCal*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::PMTCal*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLMCHit(void *p = nullptr); static void *newArray_RATcLcLDScLcLMCHit(Long_t size, void *p); static void delete_RATcLcLDScLcLMCHit(void *p); static void deleteArray_RATcLcLDScLcLMCHit(void *p); static void destruct_RATcLcLDScLcLMCHit(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::MCHit*) { ::RAT::DS::MCHit *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::MCHit >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::MCHit", ::RAT::DS::MCHit::Class_Version(), "RAT/DS/MCHit.hh", 33, typeid(::RAT::DS::MCHit), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::MCHit::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::MCHit) ); instance.SetNew(&new_RATcLcLDScLcLMCHit); instance.SetNewArray(&newArray_RATcLcLDScLcLMCHit); instance.SetDelete(&delete_RATcLcLDScLcLMCHit); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMCHit); instance.SetDestructor(&destruct_RATcLcLDScLcLMCHit); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::MCHit*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::MCHit*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDUcLcLPMTInfo(void *p = nullptr); static void *newArray_RATcLcLDUcLcLPMTInfo(Long_t size, void *p); static void delete_RATcLcLDUcLcLPMTInfo(void *p); static void deleteArray_RATcLcLDUcLcLPMTInfo(void *p); static void destruct_RATcLcLDUcLcLPMTInfo(void *p); static void streamer_RATcLcLDUcLcLPMTInfo(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::PMTInfo*) { ::RAT::DU::PMTInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::PMTInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DU::PMTInfo", ::RAT::DU::PMTInfo::Class_Version(), "RAT/DU/PMTInfo.hh", 47, typeid(::RAT::DU::PMTInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DU::PMTInfo::Dictionary, isa_proxy, 16, sizeof(::RAT::DU::PMTInfo) ); instance.SetNew(&new_RATcLcLDUcLcLPMTInfo); instance.SetNewArray(&newArray_RATcLcLDUcLcLPMTInfo); instance.SetDelete(&delete_RATcLcLDUcLcLPMTInfo); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLPMTInfo); instance.SetDestructor(&destruct_RATcLcLDUcLcLPMTInfo); instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLPMTInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::PMTInfo*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::PMTInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_Dictionary(); static void RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_TClassManip(TClass*); static void *new_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p = nullptr); static void *newArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(Long_t size, void *p); static void delete_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p); static void deleteArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p); static void destruct_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::PMTSet >*) { ::RAT::DS::PMTSet > *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::PMTSet > >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::PMTSet >", ::RAT::DS::PMTSet >::Class_Version(), "RAT/DS/PMTSet.hh", 48, typeid(::RAT::DS::PMTSet >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_Dictionary, isa_proxy, 4, sizeof(::RAT::DS::PMTSet >) ); instance.SetNew(&new_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR); instance.SetNewArray(&newArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR); instance.SetDelete(&delete_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR); instance.SetDestructor(&destruct_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR); instance.AdoptAlternate(::ROOT::AddClassAlternate("RAT::DS::PMTSet >","RAT::DS::UncalPMTs")); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::PMTSet >*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::PMTSet >*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast >*>(nullptr))->GetClass(); RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_TClassManip(theClass); return theClass; } static void RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR_Dictionary(); static void RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR_TClassManip(TClass*); static void *new_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(void *p = nullptr); static void *newArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(Long_t size, void *p); static void delete_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(void *p); static void deleteArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(void *p); static void destruct_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::PMTSet*) { ::RAT::DS::PMTSet *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::PMTSet >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::PMTSet", ::RAT::DS::PMTSet::Class_Version(), "RAT/DS/PMTSet.hh", 48, typeid(::RAT::DS::PMTSet), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR_Dictionary, isa_proxy, 4, sizeof(::RAT::DS::PMTSet) ); instance.SetNew(&new_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR); instance.SetNewArray(&newArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR); instance.SetDelete(&delete_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR); instance.SetDestructor(&destruct_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR); instance.AdoptAlternate(::ROOT::AddClassAlternate("RAT::DS::PMTSet","RAT::DS::CalPMTs")); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::PMTSet*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::PMTSet*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR_TClassManip(theClass); return theClass; } static void RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR_Dictionary(); static void RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR_TClassManip(TClass*); static void *new_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(void *p = nullptr); static void *newArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(Long_t size, void *p); static void delete_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(void *p); static void deleteArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(void *p); static void destruct_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::PMTSet*) { ::RAT::DS::PMTSet *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::PMTSet >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::PMTSet", ::RAT::DS::PMTSet::Class_Version(), "RAT/DS/PMTSet.hh", 48, typeid(::RAT::DS::PMTSet), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR_Dictionary, isa_proxy, 4, sizeof(::RAT::DS::PMTSet) ); instance.SetNew(&new_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR); instance.SetNewArray(&newArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR); instance.SetDelete(&delete_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR); instance.SetDestructor(&destruct_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR); instance.AdoptAlternate(::ROOT::AddClassAlternate("RAT::DS::PMTSet","RAT::DS::MCHits")); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::PMTSet*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::PMTSet*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR_TClassManip(theClass); return theClass; } static void RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLEV(void *p = nullptr); static void *newArray_RATcLcLDScLcLEV(Long_t size, void *p); static void delete_RATcLcLDScLcLEV(void *p); static void deleteArray_RATcLcLDScLcLEV(void *p); static void destruct_RATcLcLDScLcLEV(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::EV*) { ::RAT::DS::EV *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::EV >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::EV", ::RAT::DS::EV::Class_Version(), "RAT/DS/EV.hh", 72, typeid(::RAT::DS::EV), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::EV::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::EV) ); instance.SetNew(&new_RATcLcLDScLcLEV); instance.SetNewArray(&newArray_RATcLcLDScLcLEV); instance.SetDelete(&delete_RATcLcLDScLcLEV); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLEV); instance.SetDestructor(&destruct_RATcLcLDScLcLEV); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::EV*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::EV*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLTrigHeader(void *p = nullptr); static void *newArray_RATcLcLDScLcLTrigHeader(Long_t size, void *p); static void delete_RATcLcLDScLcLTrigHeader(void *p); static void deleteArray_RATcLcLDScLcLTrigHeader(void *p); static void destruct_RATcLcLDScLcLTrigHeader(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::TrigHeader*) { ::RAT::DS::TrigHeader *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::TrigHeader >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::TrigHeader", ::RAT::DS::TrigHeader::Class_Version(), "RAT/DS/TrigHeader.hh", 32, typeid(::RAT::DS::TrigHeader), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::TrigHeader::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::TrigHeader) ); instance.SetNew(&new_RATcLcLDScLcLTrigHeader); instance.SetNewArray(&newArray_RATcLcLDScLcLTrigHeader); instance.SetDelete(&delete_RATcLcLDScLcLTrigHeader); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLTrigHeader); instance.SetDestructor(&destruct_RATcLcLDScLcLTrigHeader); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::TrigHeader*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::TrigHeader*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLHeaderInfo(void *p = nullptr); static void *newArray_RATcLcLDScLcLHeaderInfo(Long_t size, void *p); static void delete_RATcLcLDScLcLHeaderInfo(void *p); static void deleteArray_RATcLcLDScLcLHeaderInfo(void *p); static void destruct_RATcLcLDScLcLHeaderInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::HeaderInfo*) { ::RAT::DS::HeaderInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::HeaderInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::HeaderInfo", ::RAT::DS::HeaderInfo::Class_Version(), "RAT/DS/HeaderInfo.hh", 38, typeid(::RAT::DS::HeaderInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::HeaderInfo::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::HeaderInfo) ); instance.SetNew(&new_RATcLcLDScLcLHeaderInfo); instance.SetNewArray(&newArray_RATcLcLDScLcLHeaderInfo); instance.SetDelete(&delete_RATcLcLDScLcLHeaderInfo); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLHeaderInfo); instance.SetDestructor(&destruct_RATcLcLDScLcLHeaderInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::HeaderInfo*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::HeaderInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLMetaDB(void *p = nullptr); static void *newArray_RATcLcLDScLcLMetaDB(Long_t size, void *p); static void delete_RATcLcLDScLcLMetaDB(void *p); static void deleteArray_RATcLcLDScLcLMetaDB(void *p); static void destruct_RATcLcLDScLcLMetaDB(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::MetaDB*) { ::RAT::DS::MetaDB *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::MetaDB >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::MetaDB", ::RAT::DS::MetaDB::Class_Version(), "RAT/DS/MetaDB.hh", 29, typeid(::RAT::DS::MetaDB), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::MetaDB::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::MetaDB) ); instance.SetNew(&new_RATcLcLDScLcLMetaDB); instance.SetNewArray(&newArray_RATcLcLDScLcLMetaDB); instance.SetDelete(&delete_RATcLcLDScLcLMetaDB); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMetaDB); instance.SetDestructor(&destruct_RATcLcLDScLcLMetaDB); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::MetaDB*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::MetaDB*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLMeta(void *p = nullptr); static void *newArray_RATcLcLDScLcLMeta(Long_t size, void *p); static void delete_RATcLcLDScLcLMeta(void *p); static void deleteArray_RATcLcLDScLcLMeta(void *p); static void destruct_RATcLcLDScLcLMeta(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::Meta*) { ::RAT::DS::Meta *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::Meta >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::Meta", ::RAT::DS::Meta::Class_Version(), "RAT/DS/Meta.hh", 34, typeid(::RAT::DS::Meta), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::Meta::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::Meta) ); instance.SetNew(&new_RATcLcLDScLcLMeta); instance.SetNewArray(&newArray_RATcLcLDScLcLMeta); instance.SetDelete(&delete_RATcLcLDScLcLMeta); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMeta); instance.SetDestructor(&destruct_RATcLcLDScLcLMeta); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::Meta*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::Meta*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLMCParticle(void *p = nullptr); static void *newArray_RATcLcLDScLcLMCParticle(Long_t size, void *p); static void delete_RATcLcLDScLcLMCParticle(void *p); static void deleteArray_RATcLcLDScLcLMCParticle(void *p); static void destruct_RATcLcLDScLcLMCParticle(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::MCParticle*) { ::RAT::DS::MCParticle *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::MCParticle >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::MCParticle", ::RAT::DS::MCParticle::Class_Version(), "RAT/DS/MCParticle.hh", 28, typeid(::RAT::DS::MCParticle), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::MCParticle::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::MCParticle) ); instance.SetNew(&new_RATcLcLDScLcLMCParticle); instance.SetNewArray(&newArray_RATcLcLDScLcLMCParticle); instance.SetDelete(&delete_RATcLcLDScLcLMCParticle); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMCParticle); instance.SetDestructor(&destruct_RATcLcLDScLcLMCParticle); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::MCParticle*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::MCParticle*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLMCTrackStep(void *p = nullptr); static void *newArray_RATcLcLDScLcLMCTrackStep(Long_t size, void *p); static void delete_RATcLcLDScLcLMCTrackStep(void *p); static void deleteArray_RATcLcLDScLcLMCTrackStep(void *p); static void destruct_RATcLcLDScLcLMCTrackStep(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::MCTrackStep*) { ::RAT::DS::MCTrackStep *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::MCTrackStep >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::MCTrackStep", ::RAT::DS::MCTrackStep::Class_Version(), "RAT/DS/MCTrackStep.hh", 39, typeid(::RAT::DS::MCTrackStep), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::MCTrackStep::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::MCTrackStep) ); instance.SetNew(&new_RATcLcLDScLcLMCTrackStep); instance.SetNewArray(&newArray_RATcLcLDScLcLMCTrackStep); instance.SetDelete(&delete_RATcLcLDScLcLMCTrackStep); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMCTrackStep); instance.SetDestructor(&destruct_RATcLcLDScLcLMCTrackStep); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::MCTrackStep*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::MCTrackStep*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLMCTrack(void *p = nullptr); static void *newArray_RATcLcLDScLcLMCTrack(Long_t size, void *p); static void delete_RATcLcLDScLcLMCTrack(void *p); static void deleteArray_RATcLcLDScLcLMCTrack(void *p); static void destruct_RATcLcLDScLcLMCTrack(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::MCTrack*) { ::RAT::DS::MCTrack *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::MCTrack >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::MCTrack", ::RAT::DS::MCTrack::Class_Version(), "RAT/DS/MCTrack.hh", 35, typeid(::RAT::DS::MCTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::MCTrack::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::MCTrack) ); instance.SetNew(&new_RATcLcLDScLcLMCTrack); instance.SetNewArray(&newArray_RATcLcLDScLcLMCTrack); instance.SetDelete(&delete_RATcLcLDScLcLMCTrack); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMCTrack); instance.SetDestructor(&destruct_RATcLcLDScLcLMCTrack); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::MCTrack*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::MCTrack*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLMCPhoton(void *p = nullptr); static void *newArray_RATcLcLDScLcLMCPhoton(Long_t size, void *p); static void delete_RATcLcLDScLcLMCPhoton(void *p); static void deleteArray_RATcLcLDScLcLMCPhoton(void *p); static void destruct_RATcLcLDScLcLMCPhoton(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::MCPhoton*) { ::RAT::DS::MCPhoton *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::MCPhoton >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::MCPhoton", ::RAT::DS::MCPhoton::Class_Version(), "RAT/DS/MCPhoton.hh", 52, typeid(::RAT::DS::MCPhoton), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::MCPhoton::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::MCPhoton) ); instance.SetNew(&new_RATcLcLDScLcLMCPhoton); instance.SetNewArray(&newArray_RATcLcLDScLcLMCPhoton); instance.SetDelete(&delete_RATcLcLDScLcLMCPhoton); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMCPhoton); instance.SetDestructor(&destruct_RATcLcLDScLcLMCPhoton); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::MCPhoton*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::MCPhoton*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLMCPE(void *p = nullptr); static void *newArray_RATcLcLDScLcLMCPE(Long_t size, void *p); static void delete_RATcLcLDScLcLMCPE(void *p); static void deleteArray_RATcLcLDScLcLMCPE(void *p); static void destruct_RATcLcLDScLcLMCPE(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::MCPE*) { ::RAT::DS::MCPE *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::MCPE >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::MCPE", ::RAT::DS::MCPE::Class_Version(), "RAT/DS/MCPE.hh", 52, typeid(::RAT::DS::MCPE), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::MCPE::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::MCPE) ); instance.SetNew(&new_RATcLcLDScLcLMCPE); instance.SetNewArray(&newArray_RATcLcLDScLcLMCPE); instance.SetDelete(&delete_RATcLcLDScLcLMCPE); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMCPE); instance.SetDestructor(&destruct_RATcLcLDScLcLMCPE); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::MCPE*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::MCPE*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLMCPMT(void *p = nullptr); static void *newArray_RATcLcLDScLcLMCPMT(Long_t size, void *p); static void delete_RATcLcLDScLcLMCPMT(void *p); static void deleteArray_RATcLcLDScLcLMCPMT(void *p); static void destruct_RATcLcLDScLcLMCPMT(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::MCPMT*) { ::RAT::DS::MCPMT *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::MCPMT >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::MCPMT", ::RAT::DS::MCPMT::Class_Version(), "RAT/DS/MCPMT.hh", 34, typeid(::RAT::DS::MCPMT), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::MCPMT::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::MCPMT) ); instance.SetNew(&new_RATcLcLDScLcLMCPMT); instance.SetNewArray(&newArray_RATcLcLDScLcLMCPMT); instance.SetDelete(&delete_RATcLcLDScLcLMCPMT); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMCPMT); instance.SetDestructor(&destruct_RATcLcLDScLcLMCPMT); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::MCPMT*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::MCPMT*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLMC(void *p = nullptr); static void *newArray_RATcLcLDScLcLMC(Long_t size, void *p); static void delete_RATcLcLDScLcLMC(void *p); static void deleteArray_RATcLcLDScLcLMC(void *p); static void destruct_RATcLcLDScLcLMC(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::MC*) { ::RAT::DS::MC *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::MC >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::MC", ::RAT::DS::MC::Class_Version(), "RAT/DS/MC.hh", 51, typeid(::RAT::DS::MC), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::MC::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::MC) ); instance.SetNew(&new_RATcLcLDScLcLMC); instance.SetNewArray(&newArray_RATcLcLDScLcLMC); instance.SetDelete(&delete_RATcLcLDScLcLMC); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMC); instance.SetDestructor(&destruct_RATcLcLDScLcLMC); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::MC*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::MC*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLMCEV(void *p = nullptr); static void *newArray_RATcLcLDScLcLMCEV(Long_t size, void *p); static void delete_RATcLcLDScLcLMCEV(void *p); static void deleteArray_RATcLcLDScLcLMCEV(void *p); static void destruct_RATcLcLDScLcLMCEV(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::MCEV*) { ::RAT::DS::MCEV *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::MCEV >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::MCEV", ::RAT::DS::MCEV::Class_Version(), "RAT/DS/MCEV.hh", 34, typeid(::RAT::DS::MCEV), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::MCEV::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::MCEV) ); instance.SetNew(&new_RATcLcLDScLcLMCEV); instance.SetNewArray(&newArray_RATcLcLDScLcLMCEV); instance.SetDelete(&delete_RATcLcLDScLcLMCEV); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMCEV); instance.SetDestructor(&destruct_RATcLcLDScLcLMCEV); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::MCEV*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::MCEV*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLEntry(void *p = nullptr); static void *newArray_RATcLcLDScLcLEntry(Long_t size, void *p); static void delete_RATcLcLDScLcLEntry(void *p); static void deleteArray_RATcLcLDScLcLEntry(void *p); static void destruct_RATcLcLDScLcLEntry(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::Entry*) { ::RAT::DS::Entry *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::Entry >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::Entry", ::RAT::DS::Entry::Class_Version(), "RAT/DS/Entry.hh", 65, typeid(::RAT::DS::Entry), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::Entry::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::Entry) ); instance.SetNew(&new_RATcLcLDScLcLEntry); instance.SetNewArray(&newArray_RATcLcLDScLcLEntry); instance.SetDelete(&delete_RATcLcLDScLcLEntry); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLEntry); instance.SetDestructor(&destruct_RATcLcLDScLcLEntry); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::Entry*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::Entry*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLSOCPMT(void *p = nullptr); static void *newArray_RATcLcLDScLcLSOCPMT(Long_t size, void *p); static void delete_RATcLcLDScLcLSOCPMT(void *p); static void deleteArray_RATcLcLDScLcLSOCPMT(void *p); static void destruct_RATcLcLDScLcLSOCPMT(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::SOCPMT*) { ::RAT::DS::SOCPMT *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::SOCPMT >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::SOCPMT", ::RAT::DS::SOCPMT::Class_Version(), "RAT/DS/SOCPMT.hh", 34, typeid(::RAT::DS::SOCPMT), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::SOCPMT::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::SOCPMT) ); instance.SetNew(&new_RATcLcLDScLcLSOCPMT); instance.SetNewArray(&newArray_RATcLcLDScLcLSOCPMT); instance.SetDelete(&delete_RATcLcLDScLcLSOCPMT); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLSOCPMT); instance.SetDestructor(&destruct_RATcLcLDScLcLSOCPMT); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::SOCPMT*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::SOCPMT*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLSOC(void *p = nullptr); static void *newArray_RATcLcLDScLcLSOC(Long_t size, void *p); static void delete_RATcLcLDScLcLSOC(void *p); static void deleteArray_RATcLcLDScLcLSOC(void *p); static void destruct_RATcLcLDScLcLSOC(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::SOC*) { ::RAT::DS::SOC *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::SOC >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::SOC", ::RAT::DS::SOC::Class_Version(), "RAT/DS/SOC.hh", 40, typeid(::RAT::DS::SOC), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::SOC::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::SOC) ); instance.SetNew(&new_RATcLcLDScLcLSOC); instance.SetNewArray(&newArray_RATcLcLDScLcLSOC); instance.SetDelete(&delete_RATcLcLDScLcLSOC); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLSOC); instance.SetDestructor(&destruct_RATcLcLDScLcLSOC); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::SOC*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::SOC*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDScLcLRun(void *p = nullptr); static void *newArray_RATcLcLDScLcLRun(Long_t size, void *p); static void delete_RATcLcLDScLcLRun(void *p); static void deleteArray_RATcLcLDScLcLRun(void *p); static void destruct_RATcLcLDScLcLRun(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::Run*) { ::RAT::DS::Run *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::Run >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DS::Run", ::RAT::DS::Run::Class_Version(), "RAT/DS/Run.hh", 47, typeid(::RAT::DS::Run), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DS::Run::Dictionary, isa_proxy, 4, sizeof(::RAT::DS::Run) ); instance.SetNew(&new_RATcLcLDScLcLRun); instance.SetNewArray(&newArray_RATcLcLDScLcLRun); instance.SetDelete(&delete_RATcLcLDScLcLRun); instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLRun); instance.SetDestructor(&destruct_RATcLcLDScLcLRun); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::Run*) { return GenerateInitInstanceLocal(static_cast<::RAT::DS::Run*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDUcLcLDataCleaningBits(void *p = nullptr); static void *newArray_RATcLcLDUcLcLDataCleaningBits(Long_t size, void *p); static void delete_RATcLcLDUcLcLDataCleaningBits(void *p); static void deleteArray_RATcLcLDUcLcLDataCleaningBits(void *p); static void destruct_RATcLcLDUcLcLDataCleaningBits(void *p); static void streamer_RATcLcLDUcLcLDataCleaningBits(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::DataCleaningBits*) { ::RAT::DU::DataCleaningBits *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::DataCleaningBits >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DU::DataCleaningBits", ::RAT::DU::DataCleaningBits::Class_Version(), "RAT/DU/DataCleaningBits.hh", 33, typeid(::RAT::DU::DataCleaningBits), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DU::DataCleaningBits::Dictionary, isa_proxy, 16, sizeof(::RAT::DU::DataCleaningBits) ); instance.SetNew(&new_RATcLcLDUcLcLDataCleaningBits); instance.SetNewArray(&newArray_RATcLcLDUcLcLDataCleaningBits); instance.SetDelete(&delete_RATcLcLDUcLcLDataCleaningBits); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLDataCleaningBits); instance.SetDestructor(&destruct_RATcLcLDUcLcLDataCleaningBits); instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLDataCleaningBits); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::DataCleaningBits*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::DataCleaningBits*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDUcLcLDataQualityBits(void *p = nullptr); static void *newArray_RATcLcLDUcLcLDataQualityBits(Long_t size, void *p); static void delete_RATcLcLDUcLcLDataQualityBits(void *p); static void deleteArray_RATcLcLDUcLcLDataQualityBits(void *p); static void destruct_RATcLcLDUcLcLDataQualityBits(void *p); static void streamer_RATcLcLDUcLcLDataQualityBits(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::DataQualityBits*) { ::RAT::DU::DataQualityBits *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::DataQualityBits >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DU::DataQualityBits", ::RAT::DU::DataQualityBits::Class_Version(), "RAT/DU/DataQualityBits.hh", 34, typeid(::RAT::DU::DataQualityBits), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DU::DataQualityBits::Dictionary, isa_proxy, 16, sizeof(::RAT::DU::DataQualityBits) ); instance.SetNew(&new_RATcLcLDUcLcLDataQualityBits); instance.SetNewArray(&newArray_RATcLcLDUcLcLDataQualityBits); instance.SetDelete(&delete_RATcLcLDUcLcLDataQualityBits); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLDataQualityBits); instance.SetDestructor(&destruct_RATcLcLDUcLcLDataQualityBits); instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLDataQualityBits); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::DataQualityBits*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::DataQualityBits*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDUcLcLChanSWStatus(void *p = nullptr); static void *newArray_RATcLcLDUcLcLChanSWStatus(Long_t size, void *p); static void delete_RATcLcLDUcLcLChanSWStatus(void *p); static void deleteArray_RATcLcLDUcLcLChanSWStatus(void *p); static void destruct_RATcLcLDUcLcLChanSWStatus(void *p); static void streamer_RATcLcLDUcLcLChanSWStatus(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::ChanSWStatus*) { ::RAT::DU::ChanSWStatus *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::ChanSWStatus >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DU::ChanSWStatus", ::RAT::DU::ChanSWStatus::Class_Version(), "RAT/DU/ChanSWStatus.hh", 28, typeid(::RAT::DU::ChanSWStatus), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DU::ChanSWStatus::Dictionary, isa_proxy, 16, sizeof(::RAT::DU::ChanSWStatus) ); instance.SetNew(&new_RATcLcLDUcLcLChanSWStatus); instance.SetNewArray(&newArray_RATcLcLDUcLcLChanSWStatus); instance.SetDelete(&delete_RATcLcLDUcLcLChanSWStatus); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLChanSWStatus); instance.SetDestructor(&destruct_RATcLcLDUcLcLChanSWStatus); instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLChanSWStatus); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::ChanSWStatus*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::ChanSWStatus*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDUcLcLTrigBits(void *p = nullptr); static void *newArray_RATcLcLDUcLcLTrigBits(Long_t size, void *p); static void delete_RATcLcLDUcLcLTrigBits(void *p); static void deleteArray_RATcLcLDUcLcLTrigBits(void *p); static void destruct_RATcLcLDUcLcLTrigBits(void *p); static void streamer_RATcLcLDUcLcLTrigBits(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::TrigBits*) { ::RAT::DU::TrigBits *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::TrigBits >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DU::TrigBits", ::RAT::DU::TrigBits::Class_Version(), "RAT/DU/TrigBits.hh", 29, typeid(::RAT::DU::TrigBits), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DU::TrigBits::Dictionary, isa_proxy, 16, sizeof(::RAT::DU::TrigBits) ); instance.SetNew(&new_RATcLcLDUcLcLTrigBits); instance.SetNewArray(&newArray_RATcLcLDUcLcLTrigBits); instance.SetDelete(&delete_RATcLcLDUcLcLTrigBits); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLTrigBits); instance.SetDestructor(&destruct_RATcLcLDUcLcLTrigBits); instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLTrigBits); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::TrigBits*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::TrigBits*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void delete_RATcLcLDUcLcLDSReader(void *p); static void deleteArray_RATcLcLDUcLcLDSReader(void *p); static void destruct_RATcLcLDUcLcLDSReader(void *p); static void streamer_RATcLcLDUcLcLDSReader(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::DSReader*) { ::RAT::DU::DSReader *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::DSReader >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DU::DSReader", ::RAT::DU::DSReader::Class_Version(), "RAT/DU/DSReader.hh", 50, typeid(::RAT::DU::DSReader), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DU::DSReader::Dictionary, isa_proxy, 16, sizeof(::RAT::DU::DSReader) ); instance.SetDelete(&delete_RATcLcLDUcLcLDSReader); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLDSReader); instance.SetDestructor(&destruct_RATcLcLDUcLcLDSReader); instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLDSReader); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::DSReader*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::DSReader*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDUcLcLEffectiveVelocity(void *p = nullptr); static void *newArray_RATcLcLDUcLcLEffectiveVelocity(Long_t size, void *p); static void delete_RATcLcLDUcLcLEffectiveVelocity(void *p); static void deleteArray_RATcLcLDUcLcLEffectiveVelocity(void *p); static void destruct_RATcLcLDUcLcLEffectiveVelocity(void *p); static void streamer_RATcLcLDUcLcLEffectiveVelocity(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::EffectiveVelocity*) { ::RAT::DU::EffectiveVelocity *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::EffectiveVelocity >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DU::EffectiveVelocity", ::RAT::DU::EffectiveVelocity::Class_Version(), "RAT/DU/EffectiveVelocity.hh", 34, typeid(::RAT::DU::EffectiveVelocity), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DU::EffectiveVelocity::Dictionary, isa_proxy, 16, sizeof(::RAT::DU::EffectiveVelocity) ); instance.SetNew(&new_RATcLcLDUcLcLEffectiveVelocity); instance.SetNewArray(&newArray_RATcLcLDUcLcLEffectiveVelocity); instance.SetDelete(&delete_RATcLcLDUcLcLEffectiveVelocity); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLEffectiveVelocity); instance.SetDestructor(&destruct_RATcLcLDUcLcLEffectiveVelocity); instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLEffectiveVelocity); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::EffectiveVelocity*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::EffectiveVelocity*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLDBTable_Dictionary(); static void RATcLcLDBTable_TClassManip(TClass*); static void *new_RATcLcLDBTable(void *p = nullptr); static void *newArray_RATcLcLDBTable(Long_t size, void *p); static void delete_RATcLcLDBTable(void *p); static void deleteArray_RATcLcLDBTable(void *p); static void destruct_RATcLcLDBTable(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DBTable*) { ::RAT::DBTable *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::DBTable)); static ::ROOT::TGenericClassInfo instance("RAT::DBTable", "RAT/DBTable.hh", 24, typeid(::RAT::DBTable), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLDBTable_Dictionary, isa_proxy, 4, sizeof(::RAT::DBTable) ); instance.SetNew(&new_RATcLcLDBTable); instance.SetNewArray(&newArray_RATcLcLDBTable); instance.SetDelete(&delete_RATcLcLDBTable); instance.SetDeleteArray(&deleteArray_RATcLcLDBTable); instance.SetDestructor(&destruct_RATcLcLDBTable); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DBTable*) { return GenerateInitInstanceLocal(static_cast<::RAT::DBTable*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLDBTable_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLDBTable_TClassManip(theClass); return theClass; } static void RATcLcLDBTable_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLDBLink_Dictionary(); static void RATcLcLDBLink_TClassManip(TClass*); static void delete_RATcLcLDBLink(void *p); static void deleteArray_RATcLcLDBLink(void *p); static void destruct_RATcLcLDBLink(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DBLink*) { ::RAT::DBLink *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::DBLink)); static ::ROOT::TGenericClassInfo instance("RAT::DBLink", "RAT/DBLink.hh", 51, typeid(::RAT::DBLink), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLDBLink_Dictionary, isa_proxy, 4, sizeof(::RAT::DBLink) ); instance.SetDelete(&delete_RATcLcLDBLink); instance.SetDeleteArray(&deleteArray_RATcLcLDBLink); instance.SetDestructor(&destruct_RATcLcLDBLink); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DBLink*) { return GenerateInitInstanceLocal(static_cast<::RAT::DBLink*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLDBLink_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLDBLink_TClassManip(theClass); return theClass; } static void RATcLcLDBLink_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR_Dictionary(); static void stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR_TClassManip(TClass*); static void *new_stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR(void *p = nullptr); static void *newArray_stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR(Long_t size, void *p); static void delete_stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR(void *p); static void deleteArray_stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR(void *p); static void destruct_stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::stlplus::simple_ptr_nocopy*) { ::stlplus::simple_ptr_nocopy *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::stlplus::simple_ptr_nocopy)); static ::ROOT::TGenericClassInfo instance("stlplus::simple_ptr_nocopy", "stlplus3/containers/simple_ptr.hpp", 271, typeid(::stlplus::simple_ptr_nocopy), ::ROOT::Internal::DefineBehavior(ptr, ptr), &stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR_Dictionary, isa_proxy, 4, sizeof(::stlplus::simple_ptr_nocopy) ); instance.SetNew(&new_stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR); instance.SetNewArray(&newArray_stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR); instance.SetDelete(&delete_stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR); instance.SetDeleteArray(&deleteArray_stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR); instance.SetDestructor(&destruct_stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR); instance.AdoptAlternate(::ROOT::AddClassAlternate("stlplus::simple_ptr_nocopy","RAT::DBLinkPtr")); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::stlplus::simple_ptr_nocopy*) { return GenerateInitInstanceLocal(static_cast<::stlplus::simple_ptr_nocopy*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR_TClassManip(theClass); return theClass; } static void stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDB(void *p = nullptr); static void *newArray_RATcLcLDB(Long_t size, void *p); static void delete_RATcLcLDB(void *p); static void deleteArray_RATcLcLDB(void *p); static void destruct_RATcLcLDB(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DB*) { ::RAT::DB *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DB >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DB", ::RAT::DB::Class_Version(), "RAT/DB.hh", 204, typeid(::RAT::DB), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DB::Dictionary, isa_proxy, 4, sizeof(::RAT::DB) ); instance.SetNew(&new_RATcLcLDB); instance.SetNewArray(&newArray_RATcLcLDB); instance.SetDelete(&delete_RATcLcLDB); instance.SetDeleteArray(&deleteArray_RATcLcLDB); instance.SetDestructor(&destruct_RATcLcLDB); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DB*) { return GenerateInitInstanceLocal(static_cast<::RAT::DB*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDUcLcLGroupVelocity(void *p = nullptr); static void *newArray_RATcLcLDUcLcLGroupVelocity(Long_t size, void *p); static void delete_RATcLcLDUcLcLGroupVelocity(void *p); static void deleteArray_RATcLcLDUcLcLGroupVelocity(void *p); static void destruct_RATcLcLDUcLcLGroupVelocity(void *p); static void streamer_RATcLcLDUcLcLGroupVelocity(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::GroupVelocity*) { ::RAT::DU::GroupVelocity *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::GroupVelocity >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DU::GroupVelocity", ::RAT::DU::GroupVelocity::Class_Version(), "RAT/DU/GroupVelocity.hh", 33, typeid(::RAT::DU::GroupVelocity), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DU::GroupVelocity::Dictionary, isa_proxy, 16, sizeof(::RAT::DU::GroupVelocity) ); instance.SetNew(&new_RATcLcLDUcLcLGroupVelocity); instance.SetNewArray(&newArray_RATcLcLDUcLcLGroupVelocity); instance.SetDelete(&delete_RATcLcLDUcLcLGroupVelocity); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLGroupVelocity); instance.SetDestructor(&destruct_RATcLcLDUcLcLGroupVelocity); instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLGroupVelocity); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::GroupVelocity*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::GroupVelocity*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDUcLcLPoint3D(void *p = nullptr); static void *newArray_RATcLcLDUcLcLPoint3D(Long_t size, void *p); static void delete_RATcLcLDUcLcLPoint3D(void *p); static void deleteArray_RATcLcLDUcLcLPoint3D(void *p); static void destruct_RATcLcLDUcLcLPoint3D(void *p); static void streamer_RATcLcLDUcLcLPoint3D(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::Point3D*) { ::RAT::DU::Point3D *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::Point3D >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DU::Point3D", ::RAT::DU::Point3D::Class_Version(), "RAT/DU/Point3D.hh", 27, typeid(::RAT::DU::Point3D), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DU::Point3D::Dictionary, isa_proxy, 16, sizeof(::RAT::DU::Point3D) ); instance.SetNew(&new_RATcLcLDUcLcLPoint3D); instance.SetNewArray(&newArray_RATcLcLDUcLcLPoint3D); instance.SetDelete(&delete_RATcLcLDUcLcLPoint3D); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLPoint3D); instance.SetDestructor(&destruct_RATcLcLDUcLcLPoint3D); instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLPoint3D); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::Point3D*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::Point3D*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDUcLcLLightPathCalculator(void *p = nullptr); static void *newArray_RATcLcLDUcLcLLightPathCalculator(Long_t size, void *p); static void delete_RATcLcLDUcLcLLightPathCalculator(void *p); static void deleteArray_RATcLcLDUcLcLLightPathCalculator(void *p); static void destruct_RATcLcLDUcLcLLightPathCalculator(void *p); static void streamer_RATcLcLDUcLcLLightPathCalculator(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::LightPathCalculator*) { ::RAT::DU::LightPathCalculator *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::LightPathCalculator >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DU::LightPathCalculator", ::RAT::DU::LightPathCalculator::Class_Version(), "RAT/DU/LightPathCalculator.hh", 70, typeid(::RAT::DU::LightPathCalculator), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DU::LightPathCalculator::Dictionary, isa_proxy, 16, sizeof(::RAT::DU::LightPathCalculator) ); instance.SetNew(&new_RATcLcLDUcLcLLightPathCalculator); instance.SetNewArray(&newArray_RATcLcLDUcLcLLightPathCalculator); instance.SetDelete(&delete_RATcLcLDUcLcLLightPathCalculator); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLLightPathCalculator); instance.SetDestructor(&destruct_RATcLcLDUcLcLLightPathCalculator); instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLLightPathCalculator); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::LightPathCalculator*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::LightPathCalculator*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDUcLcLPanelInfo(void *p = nullptr); static void *newArray_RATcLcLDUcLcLPanelInfo(Long_t size, void *p); static void delete_RATcLcLDUcLcLPanelInfo(void *p); static void deleteArray_RATcLcLDUcLcLPanelInfo(void *p); static void destruct_RATcLcLDUcLcLPanelInfo(void *p); static void streamer_RATcLcLDUcLcLPanelInfo(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::PanelInfo*) { ::RAT::DU::PanelInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::PanelInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DU::PanelInfo", ::RAT::DU::PanelInfo::Class_Version(), "RAT/DU/PanelInfo.hh", 45, typeid(::RAT::DU::PanelInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DU::PanelInfo::Dictionary, isa_proxy, 16, sizeof(::RAT::DU::PanelInfo) ); instance.SetNew(&new_RATcLcLDUcLcLPanelInfo); instance.SetNewArray(&newArray_RATcLcLDUcLcLPanelInfo); instance.SetDelete(&delete_RATcLcLDUcLcLPanelInfo); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLPanelInfo); instance.SetDestructor(&destruct_RATcLcLDUcLcLPanelInfo); instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLPanelInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::PanelInfo*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::PanelInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDUcLcLChanHWStatus(void *p = nullptr); static void *newArray_RATcLcLDUcLcLChanHWStatus(Long_t size, void *p); static void delete_RATcLcLDUcLcLChanHWStatus(void *p); static void deleteArray_RATcLcLDUcLcLChanHWStatus(void *p); static void destruct_RATcLcLDUcLcLChanHWStatus(void *p); static void streamer_RATcLcLDUcLcLChanHWStatus(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::ChanHWStatus*) { ::RAT::DU::ChanHWStatus *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::ChanHWStatus >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DU::ChanHWStatus", ::RAT::DU::ChanHWStatus::Class_Version(), "RAT/DU/ChanHWStatus.hh", 40, typeid(::RAT::DU::ChanHWStatus), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DU::ChanHWStatus::Dictionary, isa_proxy, 16, sizeof(::RAT::DU::ChanHWStatus) ); instance.SetNew(&new_RATcLcLDUcLcLChanHWStatus); instance.SetNewArray(&newArray_RATcLcLDUcLcLChanHWStatus); instance.SetDelete(&delete_RATcLcLDUcLcLChanHWStatus); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLChanHWStatus); instance.SetDestructor(&destruct_RATcLcLDUcLcLChanHWStatus); instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLChanHWStatus); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::ChanHWStatus*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::ChanHWStatus*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDUcLcLPMTCalStatus(void *p = nullptr); static void *newArray_RATcLcLDUcLcLPMTCalStatus(Long_t size, void *p); static void delete_RATcLcLDUcLcLPMTCalStatus(void *p); static void deleteArray_RATcLcLDUcLcLPMTCalStatus(void *p); static void destruct_RATcLcLDUcLcLPMTCalStatus(void *p); static void streamer_RATcLcLDUcLcLPMTCalStatus(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::PMTCalStatus*) { ::RAT::DU::PMTCalStatus *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::PMTCalStatus >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DU::PMTCalStatus", ::RAT::DU::PMTCalStatus::Class_Version(), "RAT/DU/PMTCalStatus.hh", 32, typeid(::RAT::DU::PMTCalStatus), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DU::PMTCalStatus::Dictionary, isa_proxy, 16, sizeof(::RAT::DU::PMTCalStatus) ); instance.SetNew(&new_RATcLcLDUcLcLPMTCalStatus); instance.SetNewArray(&newArray_RATcLcLDUcLcLPMTCalStatus); instance.SetDelete(&delete_RATcLcLDUcLcLPMTCalStatus); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLPMTCalStatus); instance.SetDestructor(&destruct_RATcLcLDUcLcLPMTCalStatus); instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLPMTCalStatus); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::PMTCalStatus*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::PMTCalStatus*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLDUcLcLReactorNuOsc_Dictionary(); static void RATcLcLDUcLcLReactorNuOsc_TClassManip(TClass*); static void *new_RATcLcLDUcLcLReactorNuOsc(void *p = nullptr); static void *newArray_RATcLcLDUcLcLReactorNuOsc(Long_t size, void *p); static void delete_RATcLcLDUcLcLReactorNuOsc(void *p); static void deleteArray_RATcLcLDUcLcLReactorNuOsc(void *p); static void destruct_RATcLcLDUcLcLReactorNuOsc(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::ReactorNuOsc*) { ::RAT::DU::ReactorNuOsc *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::DU::ReactorNuOsc)); static ::ROOT::TGenericClassInfo instance("RAT::DU::ReactorNuOsc", "RAT/DU/ReactorNuOsc.hh", 36, typeid(::RAT::DU::ReactorNuOsc), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLDUcLcLReactorNuOsc_Dictionary, isa_proxy, 0, sizeof(::RAT::DU::ReactorNuOsc) ); instance.SetNew(&new_RATcLcLDUcLcLReactorNuOsc); instance.SetNewArray(&newArray_RATcLcLDUcLcLReactorNuOsc); instance.SetDelete(&delete_RATcLcLDUcLcLReactorNuOsc); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLReactorNuOsc); instance.SetDestructor(&destruct_RATcLcLDUcLcLReactorNuOsc); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::ReactorNuOsc*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::ReactorNuOsc*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLDUcLcLReactorNuOsc_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLDUcLcLReactorNuOsc_TClassManip(theClass); return theClass; } static void RATcLcLDUcLcLReactorNuOsc_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLDUcLcLShadowingCalculator_Dictionary(); static void RATcLcLDUcLcLShadowingCalculator_TClassManip(TClass*); static void *new_RATcLcLDUcLcLShadowingCalculator(void *p = nullptr); static void *newArray_RATcLcLDUcLcLShadowingCalculator(Long_t size, void *p); static void delete_RATcLcLDUcLcLShadowingCalculator(void *p); static void deleteArray_RATcLcLDUcLcLShadowingCalculator(void *p); static void destruct_RATcLcLDUcLcLShadowingCalculator(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::ShadowingCalculator*) { ::RAT::DU::ShadowingCalculator *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::DU::ShadowingCalculator)); static ::ROOT::TGenericClassInfo instance("RAT::DU::ShadowingCalculator", "RAT/DU/ShadowingCalculator.hh", 55, typeid(::RAT::DU::ShadowingCalculator), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLDUcLcLShadowingCalculator_Dictionary, isa_proxy, 0, sizeof(::RAT::DU::ShadowingCalculator) ); instance.SetNew(&new_RATcLcLDUcLcLShadowingCalculator); instance.SetNewArray(&newArray_RATcLcLDUcLcLShadowingCalculator); instance.SetDelete(&delete_RATcLcLDUcLcLShadowingCalculator); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLShadowingCalculator); instance.SetDestructor(&destruct_RATcLcLDUcLcLShadowingCalculator); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::ShadowingCalculator*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::ShadowingCalculator*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLDUcLcLShadowingCalculator_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLDUcLcLShadowingCalculator_TClassManip(theClass); return theClass; } static void RATcLcLDUcLcLShadowingCalculator_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDUcLcLSegmentor(void *p = nullptr); static void *newArray_RATcLcLDUcLcLSegmentor(Long_t size, void *p); static void delete_RATcLcLDUcLcLSegmentor(void *p); static void deleteArray_RATcLcLDUcLcLSegmentor(void *p); static void destruct_RATcLcLDUcLcLSegmentor(void *p); static void streamer_RATcLcLDUcLcLSegmentor(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::Segmentor*) { ::RAT::DU::Segmentor *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::Segmentor >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DU::Segmentor", ::RAT::DU::Segmentor::Class_Version(), "RAT/DU/Segmentor.hh", 44, typeid(::RAT::DU::Segmentor), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DU::Segmentor::Dictionary, isa_proxy, 16, sizeof(::RAT::DU::Segmentor) ); instance.SetNew(&new_RATcLcLDUcLcLSegmentor); instance.SetNewArray(&newArray_RATcLcLDUcLcLSegmentor); instance.SetDelete(&delete_RATcLcLDUcLcLSegmentor); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLSegmentor); instance.SetDestructor(&destruct_RATcLcLDUcLcLSegmentor); instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLSegmentor); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::Segmentor*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::Segmentor*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void delete_RATcLcLDUcLcLSOCReader(void *p); static void deleteArray_RATcLcLDUcLcLSOCReader(void *p); static void destruct_RATcLcLDUcLcLSOCReader(void *p); static void streamer_RATcLcLDUcLcLSOCReader(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::SOCReader*) { ::RAT::DU::SOCReader *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::SOCReader >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DU::SOCReader", ::RAT::DU::SOCReader::Class_Version(), "RAT/DU/SOCReader.hh", 46, typeid(::RAT::DU::SOCReader), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DU::SOCReader::Dictionary, isa_proxy, 16, sizeof(::RAT::DU::SOCReader) ); instance.SetDelete(&delete_RATcLcLDUcLcLSOCReader); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLSOCReader); instance.SetDestructor(&destruct_RATcLcLDUcLcLSOCReader); instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLSOCReader); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::SOCReader*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::SOCReader*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLDUcLcLReconCorrector_Dictionary(); static void RATcLcLDUcLcLReconCorrector_TClassManip(TClass*); static void *new_RATcLcLDUcLcLReconCorrector(void *p = nullptr); static void *newArray_RATcLcLDUcLcLReconCorrector(Long_t size, void *p); static void delete_RATcLcLDUcLcLReconCorrector(void *p); static void deleteArray_RATcLcLDUcLcLReconCorrector(void *p); static void destruct_RATcLcLDUcLcLReconCorrector(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::ReconCorrector*) { ::RAT::DU::ReconCorrector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::DU::ReconCorrector)); static ::ROOT::TGenericClassInfo instance("RAT::DU::ReconCorrector", "RAT/DU/ReconCorrector.hh", 31, typeid(::RAT::DU::ReconCorrector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLDUcLcLReconCorrector_Dictionary, isa_proxy, 4, sizeof(::RAT::DU::ReconCorrector) ); instance.SetNew(&new_RATcLcLDUcLcLReconCorrector); instance.SetNewArray(&newArray_RATcLcLDUcLcLReconCorrector); instance.SetDelete(&delete_RATcLcLDUcLcLReconCorrector); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLReconCorrector); instance.SetDestructor(&destruct_RATcLcLDUcLcLReconCorrector); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::ReconCorrector*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::ReconCorrector*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLDUcLcLReconCorrector_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLDUcLcLReconCorrector_TClassManip(theClass); return theClass; } static void RATcLcLDUcLcLReconCorrector_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLDUcLcLReconCalibrator_Dictionary(); static void RATcLcLDUcLcLReconCalibrator_TClassManip(TClass*); static void *new_RATcLcLDUcLcLReconCalibrator(void *p = nullptr); static void *newArray_RATcLcLDUcLcLReconCalibrator(Long_t size, void *p); static void delete_RATcLcLDUcLcLReconCalibrator(void *p); static void deleteArray_RATcLcLDUcLcLReconCalibrator(void *p); static void destruct_RATcLcLDUcLcLReconCalibrator(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::ReconCalibrator*) { ::RAT::DU::ReconCalibrator *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::DU::ReconCalibrator)); static ::ROOT::TGenericClassInfo instance("RAT::DU::ReconCalibrator", "RAT/DU/ReconCalibrator.hh", 41, typeid(::RAT::DU::ReconCalibrator), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLDUcLcLReconCalibrator_Dictionary, isa_proxy, 4, sizeof(::RAT::DU::ReconCalibrator) ); instance.SetNew(&new_RATcLcLDUcLcLReconCalibrator); instance.SetNewArray(&newArray_RATcLcLDUcLcLReconCalibrator); instance.SetDelete(&delete_RATcLcLDUcLcLReconCalibrator); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLReconCalibrator); instance.SetDestructor(&destruct_RATcLcLDUcLcLReconCalibrator); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::ReconCalibrator*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::ReconCalibrator*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLDUcLcLReconCalibrator_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLDUcLcLReconCalibrator_TClassManip(theClass); return theClass; } static void RATcLcLDUcLcLReconCalibrator_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLFitterPMT_Dictionary(); static void RATcLcLFitterPMT_TClassManip(TClass*); static void *new_RATcLcLFitterPMT(void *p = nullptr); static void *newArray_RATcLcLFitterPMT(Long_t size, void *p); static void delete_RATcLcLFitterPMT(void *p); static void deleteArray_RATcLcLFitterPMT(void *p); static void destruct_RATcLcLFitterPMT(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::FitterPMT*) { ::RAT::FitterPMT *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::FitterPMT)); static ::ROOT::TGenericClassInfo instance("RAT::FitterPMT", "RAT/FitterPMT.hh", 35, typeid(::RAT::FitterPMT), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLFitterPMT_Dictionary, isa_proxy, 4, sizeof(::RAT::FitterPMT) ); instance.SetNew(&new_RATcLcLFitterPMT); instance.SetNewArray(&newArray_RATcLcLFitterPMT); instance.SetDelete(&delete_RATcLcLFitterPMT); instance.SetDeleteArray(&deleteArray_RATcLcLFitterPMT); instance.SetDestructor(&destruct_RATcLcLFitterPMT); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::FitterPMT*) { return GenerateInitInstanceLocal(static_cast<::RAT::FitterPMT*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLFitterPMT_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLFitterPMT_TClassManip(theClass); return theClass; } static void RATcLcLFitterPMT_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDUcLcLTimeResidualCalculator(void *p = nullptr); static void *newArray_RATcLcLDUcLcLTimeResidualCalculator(Long_t size, void *p); static void delete_RATcLcLDUcLcLTimeResidualCalculator(void *p); static void deleteArray_RATcLcLDUcLcLTimeResidualCalculator(void *p); static void destruct_RATcLcLDUcLcLTimeResidualCalculator(void *p); static void streamer_RATcLcLDUcLcLTimeResidualCalculator(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::TimeResidualCalculator*) { ::RAT::DU::TimeResidualCalculator *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::TimeResidualCalculator >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DU::TimeResidualCalculator", ::RAT::DU::TimeResidualCalculator::Class_Version(), "RAT/DU/TimeResidualCalculator.hh", 36, typeid(::RAT::DU::TimeResidualCalculator), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DU::TimeResidualCalculator::Dictionary, isa_proxy, 16, sizeof(::RAT::DU::TimeResidualCalculator) ); instance.SetNew(&new_RATcLcLDUcLcLTimeResidualCalculator); instance.SetNewArray(&newArray_RATcLcLDUcLcLTimeResidualCalculator); instance.SetDelete(&delete_RATcLcLDUcLcLTimeResidualCalculator); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLTimeResidualCalculator); instance.SetDestructor(&destruct_RATcLcLDUcLcLTimeResidualCalculator); instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLTimeResidualCalculator); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::TimeResidualCalculator*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::TimeResidualCalculator*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDUcLcLDetectorStateCorrection(void *p = nullptr); static void *newArray_RATcLcLDUcLcLDetectorStateCorrection(Long_t size, void *p); static void delete_RATcLcLDUcLcLDetectorStateCorrection(void *p); static void deleteArray_RATcLcLDUcLcLDetectorStateCorrection(void *p); static void destruct_RATcLcLDUcLcLDetectorStateCorrection(void *p); static void streamer_RATcLcLDUcLcLDetectorStateCorrection(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::DetectorStateCorrection*) { ::RAT::DU::DetectorStateCorrection *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::DetectorStateCorrection >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DU::DetectorStateCorrection", ::RAT::DU::DetectorStateCorrection::Class_Version(), "RAT/DU/DetectorStateCorrection.hh", 33, typeid(::RAT::DU::DetectorStateCorrection), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DU::DetectorStateCorrection::Dictionary, isa_proxy, 16, sizeof(::RAT::DU::DetectorStateCorrection) ); instance.SetNew(&new_RATcLcLDUcLcLDetectorStateCorrection); instance.SetNewArray(&newArray_RATcLcLDUcLcLDetectorStateCorrection); instance.SetDelete(&delete_RATcLcLDUcLcLDetectorStateCorrection); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLDetectorStateCorrection); instance.SetDestructor(&destruct_RATcLcLDUcLcLDetectorStateCorrection); instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLDetectorStateCorrection); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::DetectorStateCorrection*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::DetectorStateCorrection*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLDUcLcLUtility(void *p = nullptr); static void delete_RATcLcLDUcLcLUtility(void *p); static void deleteArray_RATcLcLDUcLcLUtility(void *p); static void destruct_RATcLcLDUcLcLUtility(void *p); static void streamer_RATcLcLDUcLcLUtility(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::Utility*) { ::RAT::DU::Utility *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::Utility >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DU::Utility", ::RAT::DU::Utility::Class_Version(), "RAT/DU/Utility.hh", 64, typeid(::RAT::DU::Utility), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DU::Utility::Dictionary, isa_proxy, 16, sizeof(::RAT::DU::Utility) ); instance.SetNew(&new_RATcLcLDUcLcLUtility); instance.SetDelete(&delete_RATcLcLDUcLcLUtility); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLUtility); instance.SetDestructor(&destruct_RATcLcLDUcLcLUtility); instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLUtility); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::Utility*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::Utility*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RATcLcLTrackNode(void *p = nullptr); static void *newArray_RATcLcLTrackNode(Long_t size, void *p); static void delete_RATcLcLTrackNode(void *p); static void deleteArray_RATcLcLTrackNode(void *p); static void destruct_RATcLcLTrackNode(void *p); static void streamer_RATcLcLTrackNode(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::TrackNode*) { ::RAT::TrackNode *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::TrackNode >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::TrackNode", ::RAT::TrackNode::Class_Version(), "RAT/TrackNode.hh", 11, typeid(::RAT::TrackNode), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::TrackNode::Dictionary, isa_proxy, 16, sizeof(::RAT::TrackNode) ); instance.SetNew(&new_RATcLcLTrackNode); instance.SetNewArray(&newArray_RATcLcLTrackNode); instance.SetDelete(&delete_RATcLcLTrackNode); instance.SetDeleteArray(&deleteArray_RATcLcLTrackNode); instance.SetDestructor(&destruct_RATcLcLTrackNode); instance.SetStreamerFunc(&streamer_RATcLcLTrackNode); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::TrackNode*) { return GenerateInitInstanceLocal(static_cast<::RAT::TrackNode*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLTrackCursor_Dictionary(); static void RATcLcLTrackCursor_TClassManip(TClass*); static void delete_RATcLcLTrackCursor(void *p); static void deleteArray_RATcLcLTrackCursor(void *p); static void destruct_RATcLcLTrackCursor(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::TrackCursor*) { ::RAT::TrackCursor *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::TrackCursor)); static ::ROOT::TGenericClassInfo instance("RAT::TrackCursor", "RAT/TrackCursor.hh", 17, typeid(::RAT::TrackCursor), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLTrackCursor_Dictionary, isa_proxy, 0, sizeof(::RAT::TrackCursor) ); instance.SetDelete(&delete_RATcLcLTrackCursor); instance.SetDeleteArray(&deleteArray_RATcLcLTrackCursor); instance.SetDestructor(&destruct_RATcLcLTrackCursor); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::TrackCursor*) { return GenerateInitInstanceLocal(static_cast<::RAT::TrackCursor*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLTrackCursor_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLTrackCursor_TClassManip(theClass); return theClass; } static void RATcLcLTrackCursor_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLTrackNav_Dictionary(); static void RATcLcLTrackNav_TClassManip(TClass*); static void delete_RATcLcLTrackNav(void *p); static void deleteArray_RATcLcLTrackNav(void *p); static void destruct_RATcLcLTrackNav(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::TrackNav*) { ::RAT::TrackNav *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::TrackNav)); static ::ROOT::TGenericClassInfo instance("RAT::TrackNav", "RAT/TrackNav.hh", 15, typeid(::RAT::TrackNav), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLTrackNav_Dictionary, isa_proxy, 0, sizeof(::RAT::TrackNav) ); instance.SetDelete(&delete_RATcLcLTrackNav); instance.SetDeleteArray(&deleteArray_RATcLcLTrackNav); instance.SetDestructor(&destruct_RATcLcLTrackNav); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::TrackNav*) { return GenerateInitInstanceLocal(static_cast<::RAT::TrackNav*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLTrackNav_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLTrackNav_TClassManip(theClass); return theClass; } static void RATcLcLTrackNav_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLPgSQLBackend_Dictionary(); static void RATcLcLPgSQLBackend_TClassManip(TClass*); static void *new_RATcLcLPgSQLBackend(void *p = nullptr); static void *newArray_RATcLcLPgSQLBackend(Long_t size, void *p); static void delete_RATcLcLPgSQLBackend(void *p); static void deleteArray_RATcLcLPgSQLBackend(void *p); static void destruct_RATcLcLPgSQLBackend(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::PgSQLBackend*) { ::RAT::PgSQLBackend *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::PgSQLBackend)); static ::ROOT::TGenericClassInfo instance("RAT::PgSQLBackend", "RAT/PgSQLBackend.hh", 28, typeid(::RAT::PgSQLBackend), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLPgSQLBackend_Dictionary, isa_proxy, 4, sizeof(::RAT::PgSQLBackend) ); instance.SetNew(&new_RATcLcLPgSQLBackend); instance.SetNewArray(&newArray_RATcLcLPgSQLBackend); instance.SetDelete(&delete_RATcLcLPgSQLBackend); instance.SetDeleteArray(&deleteArray_RATcLcLPgSQLBackend); instance.SetDestructor(&destruct_RATcLcLPgSQLBackend); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::PgSQLBackend*) { return GenerateInitInstanceLocal(static_cast<::RAT::PgSQLBackend*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLPgSQLBackend_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLPgSQLBackend_TClassManip(theClass); return theClass; } static void RATcLcLPgSQLBackend_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLDBCommandLoader_Dictionary(); static void RATcLcLDBCommandLoader_TClassManip(TClass*); static void *new_RATcLcLDBCommandLoader(void *p = nullptr); static void *newArray_RATcLcLDBCommandLoader(Long_t size, void *p); static void delete_RATcLcLDBCommandLoader(void *p); static void deleteArray_RATcLcLDBCommandLoader(void *p); static void destruct_RATcLcLDBCommandLoader(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DBCommandLoader*) { ::RAT::DBCommandLoader *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::DBCommandLoader)); static ::ROOT::TGenericClassInfo instance("RAT::DBCommandLoader", "RAT/DBCommandLoader.hh", 28, typeid(::RAT::DBCommandLoader), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLDBCommandLoader_Dictionary, isa_proxy, 4, sizeof(::RAT::DBCommandLoader) ); instance.SetNew(&new_RATcLcLDBCommandLoader); instance.SetNewArray(&newArray_RATcLcLDBCommandLoader); instance.SetDelete(&delete_RATcLcLDBCommandLoader); instance.SetDeleteArray(&deleteArray_RATcLcLDBCommandLoader); instance.SetDestructor(&destruct_RATcLcLDBCommandLoader); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DBCommandLoader*) { return GenerateInitInstanceLocal(static_cast<::RAT::DBCommandLoader*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLDBCommandLoader_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLDBCommandLoader_TClassManip(theClass); return theClass; } static void RATcLcLDBCommandLoader_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLDBTextLoader_Dictionary(); static void RATcLcLDBTextLoader_TClassManip(TClass*); static void *new_RATcLcLDBTextLoader(void *p = nullptr); static void *newArray_RATcLcLDBTextLoader(Long_t size, void *p); static void delete_RATcLcLDBTextLoader(void *p); static void deleteArray_RATcLcLDBTextLoader(void *p); static void destruct_RATcLcLDBTextLoader(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DBTextLoader*) { ::RAT::DBTextLoader *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::DBTextLoader)); static ::ROOT::TGenericClassInfo instance("RAT::DBTextLoader", "RAT/DBTextLoader.hh", 108, typeid(::RAT::DBTextLoader), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLDBTextLoader_Dictionary, isa_proxy, 4, sizeof(::RAT::DBTextLoader) ); instance.SetNew(&new_RATcLcLDBTextLoader); instance.SetNewArray(&newArray_RATcLcLDBTextLoader); instance.SetDelete(&delete_RATcLcLDBTextLoader); instance.SetDeleteArray(&deleteArray_RATcLcLDBTextLoader); instance.SetDestructor(&destruct_RATcLcLDBTextLoader); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DBTextLoader*) { return GenerateInitInstanceLocal(static_cast<::RAT::DBTextLoader*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLDBTextLoader_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLDBTextLoader_TClassManip(theClass); return theClass; } static void RATcLcLDBTextLoader_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLDBJsonLoader_Dictionary(); static void RATcLcLDBJsonLoader_TClassManip(TClass*); static void *new_RATcLcLDBJsonLoader(void *p = nullptr); static void *newArray_RATcLcLDBJsonLoader(Long_t size, void *p); static void delete_RATcLcLDBJsonLoader(void *p); static void deleteArray_RATcLcLDBJsonLoader(void *p); static void destruct_RATcLcLDBJsonLoader(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DBJsonLoader*) { ::RAT::DBJsonLoader *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::DBJsonLoader)); static ::ROOT::TGenericClassInfo instance("RAT::DBJsonLoader", "RAT/DBJsonLoader.hh", 16, typeid(::RAT::DBJsonLoader), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLDBJsonLoader_Dictionary, isa_proxy, 4, sizeof(::RAT::DBJsonLoader) ); instance.SetNew(&new_RATcLcLDBJsonLoader); instance.SetNewArray(&newArray_RATcLcLDBJsonLoader); instance.SetDelete(&delete_RATcLcLDBJsonLoader); instance.SetDeleteArray(&deleteArray_RATcLcLDBJsonLoader); instance.SetDestructor(&destruct_RATcLcLDBJsonLoader); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DBJsonLoader*) { return GenerateInitInstanceLocal(static_cast<::RAT::DBJsonLoader*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLDBJsonLoader_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLDBJsonLoader_TClassManip(theClass); return theClass; } static void RATcLcLDBJsonLoader_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLHTTPDownloader_Dictionary(); static void RATcLcLHTTPDownloader_TClassManip(TClass*); static void *new_RATcLcLHTTPDownloader(void *p = nullptr); static void *newArray_RATcLcLHTTPDownloader(Long_t size, void *p); static void delete_RATcLcLHTTPDownloader(void *p); static void deleteArray_RATcLcLHTTPDownloader(void *p); static void destruct_RATcLcLHTTPDownloader(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::HTTPDownloader*) { ::RAT::HTTPDownloader *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::HTTPDownloader)); static ::ROOT::TGenericClassInfo instance("RAT::HTTPDownloader", "RAT/HTTPDownloader.hh", 21, typeid(::RAT::HTTPDownloader), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLHTTPDownloader_Dictionary, isa_proxy, 4, sizeof(::RAT::HTTPDownloader) ); instance.SetNew(&new_RATcLcLHTTPDownloader); instance.SetNewArray(&newArray_RATcLcLHTTPDownloader); instance.SetDelete(&delete_RATcLcLHTTPDownloader); instance.SetDeleteArray(&deleteArray_RATcLcLHTTPDownloader); instance.SetDestructor(&destruct_RATcLcLHTTPDownloader); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::HTTPDownloader*) { return GenerateInitInstanceLocal(static_cast<::RAT::HTTPDownloader*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLHTTPDownloader_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLHTTPDownloader_TClassManip(theClass); return theClass; } static void RATcLcLHTTPDownloader_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLMetaInformation_Dictionary(); static void RATcLcLMetaInformation_TClassManip(TClass*); static void *new_RATcLcLMetaInformation(void *p = nullptr); static void delete_RATcLcLMetaInformation(void *p); static void deleteArray_RATcLcLMetaInformation(void *p); static void destruct_RATcLcLMetaInformation(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::MetaInformation*) { ::RAT::MetaInformation *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::MetaInformation)); static ::ROOT::TGenericClassInfo instance("RAT::MetaInformation", "RAT/MetaInformation.hh", 37, typeid(::RAT::MetaInformation), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLMetaInformation_Dictionary, isa_proxy, 4, sizeof(::RAT::MetaInformation) ); instance.SetNew(&new_RATcLcLMetaInformation); instance.SetDelete(&delete_RATcLcLMetaInformation); instance.SetDeleteArray(&deleteArray_RATcLcLMetaInformation); instance.SetDestructor(&destruct_RATcLcLMetaInformation); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::MetaInformation*) { return GenerateInitInstanceLocal(static_cast<::RAT::MetaInformation*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLMetaInformation_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLMetaInformation_TClassManip(theClass); return theClass; } static void RATcLcLMetaInformation_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *ratzdabcLcLunknown_record_error_Dictionary(); static void ratzdabcLcLunknown_record_error_TClassManip(TClass*); static void *new_ratzdabcLcLunknown_record_error(void *p = nullptr); static void *newArray_ratzdabcLcLunknown_record_error(Long_t size, void *p); static void delete_ratzdabcLcLunknown_record_error(void *p); static void deleteArray_ratzdabcLcLunknown_record_error(void *p); static void destruct_ratzdabcLcLunknown_record_error(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::ratzdab::unknown_record_error*) { ::ratzdab::unknown_record_error *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ratzdab::unknown_record_error)); static ::ROOT::TGenericClassInfo instance("ratzdab::unknown_record_error", "RAT/zdab_convert.hh", 92, typeid(::ratzdab::unknown_record_error), ::ROOT::Internal::DefineBehavior(ptr, ptr), &ratzdabcLcLunknown_record_error_Dictionary, isa_proxy, 2, sizeof(::ratzdab::unknown_record_error) ); instance.SetNew(&new_ratzdabcLcLunknown_record_error); instance.SetNewArray(&newArray_ratzdabcLcLunknown_record_error); instance.SetDelete(&delete_ratzdabcLcLunknown_record_error); instance.SetDeleteArray(&deleteArray_ratzdabcLcLunknown_record_error); instance.SetDestructor(&destruct_ratzdabcLcLunknown_record_error); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::ratzdab::unknown_record_error*) { return GenerateInitInstanceLocal(static_cast<::ratzdab::unknown_record_error*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *ratzdabcLcLunknown_record_error_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); ratzdabcLcLunknown_record_error_TClassManip(theClass); return theClass; } static void ratzdabcLcLunknown_record_error_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *ratzdabcLcLzdabfile_Dictionary(); static void ratzdabcLcLzdabfile_TClassManip(TClass*); static void delete_ratzdabcLcLzdabfile(void *p); static void deleteArray_ratzdabcLcLzdabfile(void *p); static void destruct_ratzdabcLcLzdabfile(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::ratzdab::zdabfile*) { ::ratzdab::zdabfile *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ratzdab::zdabfile)); static ::ROOT::TGenericClassInfo instance("ratzdab::zdabfile", "RAT/zdab_file.hh", 24, typeid(::ratzdab::zdabfile), ::ROOT::Internal::DefineBehavior(ptr, ptr), &ratzdabcLcLzdabfile_Dictionary, isa_proxy, 2, sizeof(::ratzdab::zdabfile) ); instance.SetDelete(&delete_ratzdabcLcLzdabfile); instance.SetDeleteArray(&deleteArray_ratzdabcLcLzdabfile); instance.SetDestructor(&destruct_ratzdabcLcLzdabfile); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::ratzdab::zdabfile*) { return GenerateInitInstanceLocal(static_cast<::ratzdab::zdabfile*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *ratzdabcLcLzdabfile_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); ratzdabcLcLzdabfile_TClassManip(theClass); return theClass; } static void ratzdabcLcLzdabfile_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *ratzdabcLcLzdabfilecLcLzdab_file_read_error_Dictionary(); static void ratzdabcLcLzdabfilecLcLzdab_file_read_error_TClassManip(TClass*); static void *new_ratzdabcLcLzdabfilecLcLzdab_file_read_error(void *p = nullptr); static void *newArray_ratzdabcLcLzdabfilecLcLzdab_file_read_error(Long_t size, void *p); static void delete_ratzdabcLcLzdabfilecLcLzdab_file_read_error(void *p); static void deleteArray_ratzdabcLcLzdabfilecLcLzdab_file_read_error(void *p); static void destruct_ratzdabcLcLzdabfilecLcLzdab_file_read_error(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::ratzdab::zdabfile::zdab_file_read_error*) { ::ratzdab::zdabfile::zdab_file_read_error *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ratzdab::zdabfile::zdab_file_read_error)); static ::ROOT::TGenericClassInfo instance("ratzdab::zdabfile::zdab_file_read_error", "RAT/zdab_file.hh", 41, typeid(::ratzdab::zdabfile::zdab_file_read_error), ::ROOT::Internal::DefineBehavior(ptr, ptr), &ratzdabcLcLzdabfilecLcLzdab_file_read_error_Dictionary, isa_proxy, 2, sizeof(::ratzdab::zdabfile::zdab_file_read_error) ); instance.SetNew(&new_ratzdabcLcLzdabfilecLcLzdab_file_read_error); instance.SetNewArray(&newArray_ratzdabcLcLzdabfilecLcLzdab_file_read_error); instance.SetDelete(&delete_ratzdabcLcLzdabfilecLcLzdab_file_read_error); instance.SetDeleteArray(&deleteArray_ratzdabcLcLzdabfilecLcLzdab_file_read_error); instance.SetDestructor(&destruct_ratzdabcLcLzdabfilecLcLzdab_file_read_error); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::ratzdab::zdabfile::zdab_file_read_error*) { return GenerateInitInstanceLocal(static_cast<::ratzdab::zdabfile::zdab_file_read_error*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *ratzdabcLcLzdabfilecLcLzdab_file_read_error_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); ratzdabcLcLzdabfilecLcLzdab_file_read_error_TClassManip(theClass); return theClass; } static void ratzdabcLcLzdabfilecLcLzdab_file_read_error_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RunRecord_Dictionary(); static void RunRecord_TClassManip(TClass*); static void *new_RunRecord(void *p = nullptr); static void *newArray_RunRecord(Long_t size, void *p); static void delete_RunRecord(void *p); static void deleteArray_RunRecord(void *p); static void destruct_RunRecord(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RunRecord*) { ::RunRecord *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RunRecord)); static ::ROOT::TGenericClassInfo instance("RunRecord", "RAT/Record_Info.hh", 138, typeid(::RunRecord), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RunRecord_Dictionary, isa_proxy, 2, sizeof(::RunRecord) ); instance.SetNew(&new_RunRecord); instance.SetNewArray(&newArray_RunRecord); instance.SetDelete(&delete_RunRecord); instance.SetDeleteArray(&deleteArray_RunRecord); instance.SetDestructor(&destruct_RunRecord); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RunRecord*) { return GenerateInitInstanceLocal(static_cast<::RunRecord*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RunRecord_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RunRecord_TClassManip(theClass); return theClass; } static void RunRecord_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *TriggerInfo_Dictionary(); static void TriggerInfo_TClassManip(TClass*); static void *new_TriggerInfo(void *p = nullptr); static void *newArray_TriggerInfo(Long_t size, void *p); static void delete_TriggerInfo(void *p); static void deleteArray_TriggerInfo(void *p); static void destruct_TriggerInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::TriggerInfo*) { ::TriggerInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TriggerInfo)); static ::ROOT::TGenericClassInfo instance("TriggerInfo", "RAT/Record_Info.hh", 206, typeid(::TriggerInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &TriggerInfo_Dictionary, isa_proxy, 2, sizeof(::TriggerInfo) ); instance.SetNew(&new_TriggerInfo); instance.SetNewArray(&newArray_TriggerInfo); instance.SetDelete(&delete_TriggerInfo); instance.SetDeleteArray(&deleteArray_TriggerInfo); instance.SetDestructor(&destruct_TriggerInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::TriggerInfo*) { return GenerateInitInstanceLocal(static_cast<::TriggerInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *TriggerInfo_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); TriggerInfo_TClassManip(theClass); return theClass; } static void TriggerInfo_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *EpedRecord_Dictionary(); static void EpedRecord_TClassManip(TClass*); static void *new_EpedRecord(void *p = nullptr); static void *newArray_EpedRecord(Long_t size, void *p); static void delete_EpedRecord(void *p); static void deleteArray_EpedRecord(void *p); static void destruct_EpedRecord(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::EpedRecord*) { ::EpedRecord *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::EpedRecord)); static ::ROOT::TGenericClassInfo instance("EpedRecord", "RAT/Record_Info.hh", 269, typeid(::EpedRecord), ::ROOT::Internal::DefineBehavior(ptr, ptr), &EpedRecord_Dictionary, isa_proxy, 2, sizeof(::EpedRecord) ); instance.SetNew(&new_EpedRecord); instance.SetNewArray(&newArray_EpedRecord); instance.SetDelete(&delete_EpedRecord); instance.SetDeleteArray(&deleteArray_EpedRecord); instance.SetDestructor(&destruct_EpedRecord); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::EpedRecord*) { return GenerateInitInstanceLocal(static_cast<::EpedRecord*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *EpedRecord_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); EpedRecord_TClassManip(theClass); return theClass; } static void EpedRecord_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *ManipRopeStatus_Dictionary(); static void ManipRopeStatus_TClassManip(TClass*); static void *new_ManipRopeStatus(void *p = nullptr); static void *newArray_ManipRopeStatus(Long_t size, void *p); static void delete_ManipRopeStatus(void *p); static void deleteArray_ManipRopeStatus(void *p); static void destruct_ManipRopeStatus(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::ManipRopeStatus*) { ::ManipRopeStatus *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ManipRopeStatus)); static ::ROOT::TGenericClassInfo instance("ManipRopeStatus", "RAT/Record_Info.hh", 343, typeid(::ManipRopeStatus), ::ROOT::Internal::DefineBehavior(ptr, ptr), &ManipRopeStatus_Dictionary, isa_proxy, 2, sizeof(::ManipRopeStatus) ); instance.SetNew(&new_ManipRopeStatus); instance.SetNewArray(&newArray_ManipRopeStatus); instance.SetDelete(&delete_ManipRopeStatus); instance.SetDeleteArray(&deleteArray_ManipRopeStatus); instance.SetDestructor(&destruct_ManipRopeStatus); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::ManipRopeStatus*) { return GenerateInitInstanceLocal(static_cast<::ManipRopeStatus*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *ManipRopeStatus_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); ManipRopeStatus_TClassManip(theClass); return theClass; } static void ManipRopeStatus_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *MTCReadoutData_Dictionary(); static void MTCReadoutData_TClassManip(TClass*); static void *new_MTCReadoutData(void *p = nullptr); static void *newArray_MTCReadoutData(Long_t size, void *p); static void delete_MTCReadoutData(void *p); static void deleteArray_MTCReadoutData(void *p); static void destruct_MTCReadoutData(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::MTCReadoutData*) { ::MTCReadoutData *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::MTCReadoutData)); static ::ROOT::TGenericClassInfo instance("MTCReadoutData", "RAT/Record_Info.hh", 618, typeid(::MTCReadoutData), ::ROOT::Internal::DefineBehavior(ptr, ptr), &MTCReadoutData_Dictionary, isa_proxy, 2, sizeof(::MTCReadoutData) ); instance.SetNew(&new_MTCReadoutData); instance.SetNewArray(&newArray_MTCReadoutData); instance.SetDelete(&delete_MTCReadoutData); instance.SetDeleteArray(&deleteArray_MTCReadoutData); instance.SetDestructor(&destruct_MTCReadoutData); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::MTCReadoutData*) { return GenerateInitInstanceLocal(static_cast<::MTCReadoutData*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *MTCReadoutData_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); MTCReadoutData_TClassManip(theClass); return theClass; } static void MTCReadoutData_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *PmtEventRecord_Dictionary(); static void PmtEventRecord_TClassManip(TClass*); static void *new_PmtEventRecord(void *p = nullptr); static void *newArray_PmtEventRecord(Long_t size, void *p); static void delete_PmtEventRecord(void *p); static void deleteArray_PmtEventRecord(void *p); static void destruct_PmtEventRecord(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::PmtEventRecord*) { ::PmtEventRecord *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::PmtEventRecord)); static ::ROOT::TGenericClassInfo instance("PmtEventRecord", "RAT/Record_Info.hh", 775, typeid(::PmtEventRecord), ::ROOT::Internal::DefineBehavior(ptr, ptr), &PmtEventRecord_Dictionary, isa_proxy, 2, sizeof(::PmtEventRecord) ); instance.SetNew(&new_PmtEventRecord); instance.SetNewArray(&newArray_PmtEventRecord); instance.SetDelete(&delete_PmtEventRecord); instance.SetDeleteArray(&deleteArray_PmtEventRecord); instance.SetDestructor(&destruct_PmtEventRecord); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::PmtEventRecord*) { return GenerateInitInstanceLocal(static_cast<::PmtEventRecord*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *PmtEventRecord_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); PmtEventRecord_TClassManip(theClass); return theClass; } static void PmtEventRecord_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *PZdabFile_Dictionary(); static void PZdabFile_TClassManip(TClass*); static void *new_PZdabFile(void *p = nullptr); static void *newArray_PZdabFile(Long_t size, void *p); static void delete_PZdabFile(void *p); static void deleteArray_PZdabFile(void *p); static void destruct_PZdabFile(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::PZdabFile*) { ::PZdabFile *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::PZdabFile)); static ::ROOT::TGenericClassInfo instance("PZdabFile", "RAT/PZdabFile.hh", 154, typeid(::PZdabFile), ::ROOT::Internal::DefineBehavior(ptr, ptr), &PZdabFile_Dictionary, isa_proxy, 0, sizeof(::PZdabFile) ); instance.SetNew(&new_PZdabFile); instance.SetNewArray(&newArray_PZdabFile); instance.SetDelete(&delete_PZdabFile); instance.SetDeleteArray(&deleteArray_PZdabFile); instance.SetDestructor(&destruct_PZdabFile); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::PZdabFile*) { return GenerateInitInstanceLocal(static_cast<::PZdabFile*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *PZdabFile_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); PZdabFile_TClassManip(theClass); return theClass; } static void PZdabFile_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static void delete_RATcLcLDUcLcLEnergySystematics(void *p); static void deleteArray_RATcLcLDUcLcLEnergySystematics(void *p); static void destruct_RATcLcLDUcLcLEnergySystematics(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::EnergySystematics*) { ::RAT::DU::EnergySystematics *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::EnergySystematics >(nullptr); static ::ROOT::TGenericClassInfo instance("RAT::DU::EnergySystematics", ::RAT::DU::EnergySystematics::Class_Version(), "RAT/DU/EnergySystematics.hh", 23, typeid(::RAT::DU::EnergySystematics), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RAT::DU::EnergySystematics::Dictionary, isa_proxy, 4, sizeof(::RAT::DU::EnergySystematics) ); instance.SetDelete(&delete_RATcLcLDUcLcLEnergySystematics); instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLEnergySystematics); instance.SetDestructor(&destruct_RATcLcLDUcLcLEnergySystematics); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::EnergySystematics*) { return GenerateInitInstanceLocal(static_cast<::RAT::DU::EnergySystematics*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLLPcLcLLightPath_Dictionary(); static void RATcLcLLPcLcLLightPath_TClassManip(TClass*); static void *new_RATcLcLLPcLcLLightPath(void *p = nullptr); static void *newArray_RATcLcLLPcLcLLightPath(Long_t size, void *p); static void delete_RATcLcLLPcLcLLightPath(void *p); static void deleteArray_RATcLcLLPcLcLLightPath(void *p); static void destruct_RATcLcLLPcLcLLightPath(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::LP::LightPath*) { ::RAT::LP::LightPath *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::LP::LightPath)); static ::ROOT::TGenericClassInfo instance("RAT::LP::LightPath", "RAT/LightPath.hh", 27, typeid(::RAT::LP::LightPath), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLLPcLcLLightPath_Dictionary, isa_proxy, 4, sizeof(::RAT::LP::LightPath) ); instance.SetNew(&new_RATcLcLLPcLcLLightPath); instance.SetNewArray(&newArray_RATcLcLLPcLcLLightPath); instance.SetDelete(&delete_RATcLcLLPcLcLLightPath); instance.SetDeleteArray(&deleteArray_RATcLcLLPcLcLLightPath); instance.SetDestructor(&destruct_RATcLcLLPcLcLLightPath); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::LP::LightPath*) { return GenerateInitInstanceLocal(static_cast<::RAT::LP::LightPath*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLLPcLcLLightPath_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLLPcLcLLightPath_TClassManip(theClass); return theClass; } static void RATcLcLLPcLcLLightPath_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLLPcLcLLightPathFitter_Dictionary(); static void RATcLcLLPcLcLLightPathFitter_TClassManip(TClass*); static void delete_RATcLcLLPcLcLLightPathFitter(void *p); static void deleteArray_RATcLcLLPcLcLLightPathFitter(void *p); static void destruct_RATcLcLLPcLcLLightPathFitter(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::LP::LightPathFitter*) { ::RAT::LP::LightPathFitter *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::LP::LightPathFitter)); static ::ROOT::TGenericClassInfo instance("RAT::LP::LightPathFitter", "RAT/LightPathFitter.hh", 18, typeid(::RAT::LP::LightPathFitter), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLLPcLcLLightPathFitter_Dictionary, isa_proxy, 4, sizeof(::RAT::LP::LightPathFitter) ); instance.SetDelete(&delete_RATcLcLLPcLcLLightPathFitter); instance.SetDeleteArray(&deleteArray_RATcLcLLPcLcLLightPathFitter); instance.SetDestructor(&destruct_RATcLcLLPcLcLLightPathFitter); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::LP::LightPathFitter*) { return GenerateInitInstanceLocal(static_cast<::RAT::LP::LightPathFitter*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLLPcLcLLightPathFitter_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLLPcLcLLightPathFitter_TClassManip(theClass); return theClass; } static void RATcLcLLPcLcLLightPathFitter_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLLPcLcLLightPathStraightFitter_Dictionary(); static void RATcLcLLPcLcLLightPathStraightFitter_TClassManip(TClass*); static void *new_RATcLcLLPcLcLLightPathStraightFitter(void *p = nullptr); static void *newArray_RATcLcLLPcLcLLightPathStraightFitter(Long_t size, void *p); static void delete_RATcLcLLPcLcLLightPathStraightFitter(void *p); static void deleteArray_RATcLcLLPcLcLLightPathStraightFitter(void *p); static void destruct_RATcLcLLPcLcLLightPathStraightFitter(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::LP::LightPathStraightFitter*) { ::RAT::LP::LightPathStraightFitter *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::LP::LightPathStraightFitter)); static ::ROOT::TGenericClassInfo instance("RAT::LP::LightPathStraightFitter", "RAT/LightPathStraightFitter.hh", 23, typeid(::RAT::LP::LightPathStraightFitter), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLLPcLcLLightPathStraightFitter_Dictionary, isa_proxy, 4, sizeof(::RAT::LP::LightPathStraightFitter) ); instance.SetNew(&new_RATcLcLLPcLcLLightPathStraightFitter); instance.SetNewArray(&newArray_RATcLcLLPcLcLLightPathStraightFitter); instance.SetDelete(&delete_RATcLcLLPcLcLLightPathStraightFitter); instance.SetDeleteArray(&deleteArray_RATcLcLLPcLcLLightPathStraightFitter); instance.SetDestructor(&destruct_RATcLcLLPcLcLLightPathStraightFitter); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::LP::LightPathStraightFitter*) { return GenerateInitInstanceLocal(static_cast<::RAT::LP::LightPathStraightFitter*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLLPcLcLLightPathStraightFitter_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLLPcLcLLightPathStraightFitter_TClassManip(theClass); return theClass; } static void RATcLcLLPcLcLLightPathStraightFitter_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLLPcLcLLightPathStraightScint_Dictionary(); static void RATcLcLLPcLcLLightPathStraightScint_TClassManip(TClass*); static void *new_RATcLcLLPcLcLLightPathStraightScint(void *p = nullptr); static void *newArray_RATcLcLLPcLcLLightPathStraightScint(Long_t size, void *p); static void delete_RATcLcLLPcLcLLightPathStraightScint(void *p); static void deleteArray_RATcLcLLPcLcLLightPathStraightScint(void *p); static void destruct_RATcLcLLPcLcLLightPathStraightScint(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::LP::LightPathStraightScint*) { ::RAT::LP::LightPathStraightScint *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::LP::LightPathStraightScint)); static ::ROOT::TGenericClassInfo instance("RAT::LP::LightPathStraightScint", "RAT/LightPathStraightScint.hh", 25, typeid(::RAT::LP::LightPathStraightScint), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLLPcLcLLightPathStraightScint_Dictionary, isa_proxy, 4, sizeof(::RAT::LP::LightPathStraightScint) ); instance.SetNew(&new_RATcLcLLPcLcLLightPathStraightScint); instance.SetNewArray(&newArray_RATcLcLLPcLcLLightPathStraightScint); instance.SetDelete(&delete_RATcLcLLPcLcLLightPathStraightScint); instance.SetDeleteArray(&deleteArray_RATcLcLLPcLcLLightPathStraightScint); instance.SetDestructor(&destruct_RATcLcLLPcLcLLightPathStraightScint); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::LP::LightPathStraightScint*) { return GenerateInitInstanceLocal(static_cast<::RAT::LP::LightPathStraightScint*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLLPcLcLLightPathStraightScint_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLLPcLcLLightPathStraightScint_TClassManip(theClass); return theClass; } static void RATcLcLLPcLcLLightPathStraightScint_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *RATcLcLLPcLcLLightPathStraightScintWater_Dictionary(); static void RATcLcLLPcLcLLightPathStraightScintWater_TClassManip(TClass*); static void *new_RATcLcLLPcLcLLightPathStraightScintWater(void *p = nullptr); static void *newArray_RATcLcLLPcLcLLightPathStraightScintWater(Long_t size, void *p); static void delete_RATcLcLLPcLcLLightPathStraightScintWater(void *p); static void deleteArray_RATcLcLLPcLcLLightPathStraightScintWater(void *p); static void destruct_RATcLcLLPcLcLLightPathStraightScintWater(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::LP::LightPathStraightScintWater*) { ::RAT::LP::LightPathStraightScintWater *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::LP::LightPathStraightScintWater)); static ::ROOT::TGenericClassInfo instance("RAT::LP::LightPathStraightScintWater", "RAT/LightPathStraightScintWater.hh", 24, typeid(::RAT::LP::LightPathStraightScintWater), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RATcLcLLPcLcLLightPathStraightScintWater_Dictionary, isa_proxy, 4, sizeof(::RAT::LP::LightPathStraightScintWater) ); instance.SetNew(&new_RATcLcLLPcLcLLightPathStraightScintWater); instance.SetNewArray(&newArray_RATcLcLLPcLcLLightPathStraightScintWater); instance.SetDelete(&delete_RATcLcLLPcLcLLightPathStraightScintWater); instance.SetDeleteArray(&deleteArray_RATcLcLLPcLcLLightPathStraightScintWater); instance.SetDestructor(&destruct_RATcLcLLPcLcLLightPathStraightScintWater); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RAT::LP::LightPathStraightScintWater*) { return GenerateInitInstanceLocal(static_cast<::RAT::LP::LightPathStraightScintWater*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RATcLcLLPcLcLLightPathStraightScintWater_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RATcLcLLPcLcLLightPathStraightScintWater_TClassManip(theClass); return theClass; } static void RATcLcLLPcLcLLightPathStraightScintWater_TClassManip(TClass* ){ } } // end of namespace ROOT namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr BitMask::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *BitMask::Class_Name() { return "RAT::DS::BitMask"; } //______________________________________________________________________________ const char *BitMask::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::BitMask*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int BitMask::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::BitMask*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *BitMask::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::BitMask*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *BitMask::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::BitMask*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr Calib::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *Calib::Class_Name() { return "RAT::DS::Calib"; } //______________________________________________________________________________ const char *Calib::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::Calib*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int Calib::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::Calib*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *Calib::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::Calib*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *Calib::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::Calib*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr ClassifierResult::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *ClassifierResult::Class_Name() { return "RAT::DS::ClassifierResult"; } //______________________________________________________________________________ const char *ClassifierResult::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::ClassifierResult*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int ClassifierResult::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::ClassifierResult*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *ClassifierResult::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::ClassifierResult*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *ClassifierResult::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::ClassifierResult*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr DataQCFlags::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *DataQCFlags::Class_Name() { return "RAT::DS::DataQCFlags"; } //______________________________________________________________________________ const char *DataQCFlags::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::DataQCFlags*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int DataQCFlags::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::DataQCFlags*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *DataQCFlags::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::DataQCFlags*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *DataQCFlags::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::DataQCFlags*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr Digitiser::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *Digitiser::Class_Name() { return "RAT::DS::Digitiser"; } //______________________________________________________________________________ const char *Digitiser::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::Digitiser*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int Digitiser::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::Digitiser*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *Digitiser::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::Digitiser*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *Digitiser::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::Digitiser*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr ECAHeader::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *ECAHeader::Class_Name() { return "RAT::DS::ECAHeader"; } //______________________________________________________________________________ const char *ECAHeader::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::ECAHeader*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int ECAHeader::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::ECAHeader*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *ECAHeader::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::ECAHeader*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *ECAHeader::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::ECAHeader*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr UniversalTime::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *UniversalTime::Class_Name() { return "RAT::DS::UniversalTime"; } //______________________________________________________________________________ const char *UniversalTime::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::UniversalTime*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int UniversalTime::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::UniversalTime*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *UniversalTime::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::UniversalTime*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *UniversalTime::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::UniversalTime*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr FitVertex::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *FitVertex::Class_Name() { return "RAT::DS::FitVertex"; } //______________________________________________________________________________ const char *FitVertex::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::FitVertex*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int FitVertex::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::FitVertex*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *FitVertex::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::FitVertex*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *FitVertex::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::FitVertex*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr FitResult::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *FitResult::Class_Name() { return "RAT::DS::FitResult"; } //______________________________________________________________________________ const char *FitResult::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::FitResult*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int FitResult::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::FitResult*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *FitResult::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::FitResult*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *FitResult::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::FitResult*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ template <> atomic_TClass_ptr FitClassifierCollection::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ template <> const char *FitClassifierCollection::Class_Name() { return "RAT::DS::FitClassifierCollection"; } //______________________________________________________________________________ template <> const char *FitClassifierCollection::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ template <> int FitClassifierCollection::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ template <> TClass *FitClassifierCollection::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ template <> TClass *FitClassifierCollection::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ template <> atomic_TClass_ptr FitClassifierCollection::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ template <> const char *FitClassifierCollection::Class_Name() { return "RAT::DS::FitClassifierCollection"; } //______________________________________________________________________________ template <> const char *FitClassifierCollection::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ template <> int FitClassifierCollection::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ template <> TClass *FitClassifierCollection::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ template <> TClass *FitClassifierCollection::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ template <> atomic_TClass_ptr PMT::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ template <> const char *PMT::Class_Name() { return "RAT::DS::PMT"; } //______________________________________________________________________________ template <> const char *PMT::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMT*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ template <> int PMT::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMT*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ template <> TClass *PMT::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMT*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ template <> TClass *PMT::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMT*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ template <> atomic_TClass_ptr PMT::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ template <> const char *PMT::Class_Name() { return "RAT::DS::PMT"; } //______________________________________________________________________________ template <> const char *PMT::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMT*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ template <> int PMT::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMT*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ template <> TClass *PMT::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMT*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ template <> TClass *PMT::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMT*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr PMTCal::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *PMTCal::Class_Name() { return "RAT::DS::PMTCal"; } //______________________________________________________________________________ const char *PMTCal::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMTCal*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int PMTCal::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMTCal*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *PMTCal::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMTCal*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *PMTCal::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMTCal*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr MCHit::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *MCHit::Class_Name() { return "RAT::DS::MCHit"; } //______________________________________________________________________________ const char *MCHit::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCHit*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int MCHit::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCHit*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *MCHit::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCHit*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *MCHit::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCHit*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DU { //______________________________________________________________________________ atomic_TClass_ptr PMTInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *PMTInfo::Class_Name() { return "RAT::DU::PMTInfo"; } //______________________________________________________________________________ const char *PMTInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::PMTInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int PMTInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::PMTInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *PMTInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::PMTInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *PMTInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::PMTInfo*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DU } // namespace RAT::DU namespace RAT { namespace DS { //______________________________________________________________________________ template <> atomic_TClass_ptr PMTSet >::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ template <> const char *PMTSet >::Class_Name() { return "RAT::DS::PMTSet >"; } //______________________________________________________________________________ template <> const char *PMTSet >::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet >*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ template <> int PMTSet >::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet >*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ template <> TClass *PMTSet >::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet >*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ template <> TClass *PMTSet >::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet >*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ template <> atomic_TClass_ptr PMTSet::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ template <> const char *PMTSet::Class_Name() { return "RAT::DS::PMTSet"; } //______________________________________________________________________________ template <> const char *PMTSet::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ template <> int PMTSet::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ template <> TClass *PMTSet::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ template <> TClass *PMTSet::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ template <> atomic_TClass_ptr PMTSet::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ template <> const char *PMTSet::Class_Name() { return "RAT::DS::PMTSet"; } //______________________________________________________________________________ template <> const char *PMTSet::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ template <> int PMTSet::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ template <> TClass *PMTSet::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ template <> TClass *PMTSet::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr EV::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *EV::Class_Name() { return "RAT::DS::EV"; } //______________________________________________________________________________ const char *EV::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::EV*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int EV::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::EV*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *EV::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::EV*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *EV::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::EV*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr TrigHeader::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *TrigHeader::Class_Name() { return "RAT::DS::TrigHeader"; } //______________________________________________________________________________ const char *TrigHeader::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::TrigHeader*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int TrigHeader::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::TrigHeader*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *TrigHeader::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::TrigHeader*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *TrigHeader::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::TrigHeader*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr HeaderInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *HeaderInfo::Class_Name() { return "RAT::DS::HeaderInfo"; } //______________________________________________________________________________ const char *HeaderInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::HeaderInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int HeaderInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::HeaderInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *HeaderInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::HeaderInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *HeaderInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::HeaderInfo*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr MetaDB::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *MetaDB::Class_Name() { return "RAT::DS::MetaDB"; } //______________________________________________________________________________ const char *MetaDB::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MetaDB*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int MetaDB::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MetaDB*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *MetaDB::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MetaDB*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *MetaDB::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MetaDB*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr Meta::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *Meta::Class_Name() { return "RAT::DS::Meta"; } //______________________________________________________________________________ const char *Meta::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::Meta*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int Meta::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::Meta*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *Meta::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::Meta*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *Meta::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::Meta*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr MCParticle::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *MCParticle::Class_Name() { return "RAT::DS::MCParticle"; } //______________________________________________________________________________ const char *MCParticle::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCParticle*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int MCParticle::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCParticle*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *MCParticle::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCParticle*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *MCParticle::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCParticle*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr MCTrackStep::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *MCTrackStep::Class_Name() { return "RAT::DS::MCTrackStep"; } //______________________________________________________________________________ const char *MCTrackStep::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCTrackStep*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int MCTrackStep::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCTrackStep*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *MCTrackStep::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCTrackStep*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *MCTrackStep::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCTrackStep*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr MCTrack::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *MCTrack::Class_Name() { return "RAT::DS::MCTrack"; } //______________________________________________________________________________ const char *MCTrack::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCTrack*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int MCTrack::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCTrack*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *MCTrack::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCTrack*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *MCTrack::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCTrack*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr MCPhoton::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *MCPhoton::Class_Name() { return "RAT::DS::MCPhoton"; } //______________________________________________________________________________ const char *MCPhoton::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCPhoton*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int MCPhoton::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCPhoton*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *MCPhoton::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCPhoton*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *MCPhoton::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCPhoton*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr MCPE::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *MCPE::Class_Name() { return "RAT::DS::MCPE"; } //______________________________________________________________________________ const char *MCPE::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCPE*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int MCPE::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCPE*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *MCPE::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCPE*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *MCPE::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCPE*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr MCPMT::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *MCPMT::Class_Name() { return "RAT::DS::MCPMT"; } //______________________________________________________________________________ const char *MCPMT::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCPMT*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int MCPMT::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCPMT*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *MCPMT::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCPMT*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *MCPMT::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCPMT*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr MC::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *MC::Class_Name() { return "RAT::DS::MC"; } //______________________________________________________________________________ const char *MC::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MC*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int MC::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MC*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *MC::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MC*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *MC::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MC*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr MCEV::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *MCEV::Class_Name() { return "RAT::DS::MCEV"; } //______________________________________________________________________________ const char *MCEV::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCEV*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int MCEV::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCEV*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *MCEV::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCEV*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *MCEV::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::MCEV*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr Entry::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *Entry::Class_Name() { return "RAT::DS::Entry"; } //______________________________________________________________________________ const char *Entry::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::Entry*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int Entry::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::Entry*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *Entry::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::Entry*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *Entry::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::Entry*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr SOCPMT::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *SOCPMT::Class_Name() { return "RAT::DS::SOCPMT"; } //______________________________________________________________________________ const char *SOCPMT::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::SOCPMT*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int SOCPMT::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::SOCPMT*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *SOCPMT::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::SOCPMT*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *SOCPMT::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::SOCPMT*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr SOC::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *SOC::Class_Name() { return "RAT::DS::SOC"; } //______________________________________________________________________________ const char *SOC::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::SOC*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int SOC::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::SOC*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *SOC::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::SOC*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *SOC::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::SOC*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DS { //______________________________________________________________________________ atomic_TClass_ptr Run::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *Run::Class_Name() { return "RAT::DS::Run"; } //______________________________________________________________________________ const char *Run::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::Run*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int Run::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::Run*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *Run::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::Run*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *Run::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DS::Run*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DS } // namespace RAT::DS namespace RAT { namespace DU { //______________________________________________________________________________ atomic_TClass_ptr DataCleaningBits::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *DataCleaningBits::Class_Name() { return "RAT::DU::DataCleaningBits"; } //______________________________________________________________________________ const char *DataCleaningBits::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::DataCleaningBits*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int DataCleaningBits::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::DataCleaningBits*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *DataCleaningBits::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::DataCleaningBits*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *DataCleaningBits::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::DataCleaningBits*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DU } // namespace RAT::DU namespace RAT { namespace DU { //______________________________________________________________________________ atomic_TClass_ptr DataQualityBits::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *DataQualityBits::Class_Name() { return "RAT::DU::DataQualityBits"; } //______________________________________________________________________________ const char *DataQualityBits::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::DataQualityBits*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int DataQualityBits::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::DataQualityBits*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *DataQualityBits::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::DataQualityBits*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *DataQualityBits::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::DataQualityBits*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DU } // namespace RAT::DU namespace RAT { namespace DU { //______________________________________________________________________________ atomic_TClass_ptr ChanSWStatus::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *ChanSWStatus::Class_Name() { return "RAT::DU::ChanSWStatus"; } //______________________________________________________________________________ const char *ChanSWStatus::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::ChanSWStatus*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int ChanSWStatus::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::ChanSWStatus*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *ChanSWStatus::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::ChanSWStatus*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *ChanSWStatus::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::ChanSWStatus*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DU } // namespace RAT::DU namespace RAT { namespace DU { //______________________________________________________________________________ atomic_TClass_ptr TrigBits::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *TrigBits::Class_Name() { return "RAT::DU::TrigBits"; } //______________________________________________________________________________ const char *TrigBits::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::TrigBits*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int TrigBits::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::TrigBits*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *TrigBits::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::TrigBits*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *TrigBits::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::TrigBits*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DU } // namespace RAT::DU namespace RAT { namespace DU { //______________________________________________________________________________ atomic_TClass_ptr DSReader::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *DSReader::Class_Name() { return "RAT::DU::DSReader"; } //______________________________________________________________________________ const char *DSReader::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::DSReader*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int DSReader::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::DSReader*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *DSReader::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::DSReader*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *DSReader::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::DSReader*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DU } // namespace RAT::DU namespace RAT { namespace DU { //______________________________________________________________________________ atomic_TClass_ptr EffectiveVelocity::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *EffectiveVelocity::Class_Name() { return "RAT::DU::EffectiveVelocity"; } //______________________________________________________________________________ const char *EffectiveVelocity::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::EffectiveVelocity*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int EffectiveVelocity::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::EffectiveVelocity*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *EffectiveVelocity::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::EffectiveVelocity*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *EffectiveVelocity::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::EffectiveVelocity*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DU } // namespace RAT::DU namespace RAT { //______________________________________________________________________________ atomic_TClass_ptr DB::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *DB::Class_Name() { return "RAT::DB"; } //______________________________________________________________________________ const char *DB::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DB*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int DB::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DB*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *DB::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DB*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *DB::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DB*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT namespace RAT { namespace DU { //______________________________________________________________________________ atomic_TClass_ptr GroupVelocity::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *GroupVelocity::Class_Name() { return "RAT::DU::GroupVelocity"; } //______________________________________________________________________________ const char *GroupVelocity::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::GroupVelocity*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int GroupVelocity::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::GroupVelocity*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *GroupVelocity::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::GroupVelocity*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *GroupVelocity::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::GroupVelocity*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DU } // namespace RAT::DU namespace RAT { namespace DU { //______________________________________________________________________________ atomic_TClass_ptr Point3D::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *Point3D::Class_Name() { return "RAT::DU::Point3D"; } //______________________________________________________________________________ const char *Point3D::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::Point3D*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int Point3D::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::Point3D*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *Point3D::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::Point3D*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *Point3D::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::Point3D*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DU } // namespace RAT::DU namespace RAT { namespace DU { //______________________________________________________________________________ atomic_TClass_ptr LightPathCalculator::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *LightPathCalculator::Class_Name() { return "RAT::DU::LightPathCalculator"; } //______________________________________________________________________________ const char *LightPathCalculator::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::LightPathCalculator*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int LightPathCalculator::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::LightPathCalculator*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *LightPathCalculator::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::LightPathCalculator*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *LightPathCalculator::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::LightPathCalculator*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DU } // namespace RAT::DU namespace RAT { namespace DU { //______________________________________________________________________________ atomic_TClass_ptr PanelInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *PanelInfo::Class_Name() { return "RAT::DU::PanelInfo"; } //______________________________________________________________________________ const char *PanelInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::PanelInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int PanelInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::PanelInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *PanelInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::PanelInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *PanelInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::PanelInfo*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DU } // namespace RAT::DU namespace RAT { namespace DU { //______________________________________________________________________________ atomic_TClass_ptr ChanHWStatus::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *ChanHWStatus::Class_Name() { return "RAT::DU::ChanHWStatus"; } //______________________________________________________________________________ const char *ChanHWStatus::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::ChanHWStatus*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int ChanHWStatus::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::ChanHWStatus*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *ChanHWStatus::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::ChanHWStatus*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *ChanHWStatus::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::ChanHWStatus*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DU } // namespace RAT::DU namespace RAT { namespace DU { //______________________________________________________________________________ atomic_TClass_ptr PMTCalStatus::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *PMTCalStatus::Class_Name() { return "RAT::DU::PMTCalStatus"; } //______________________________________________________________________________ const char *PMTCalStatus::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::PMTCalStatus*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int PMTCalStatus::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::PMTCalStatus*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *PMTCalStatus::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::PMTCalStatus*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *PMTCalStatus::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::PMTCalStatus*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DU } // namespace RAT::DU namespace RAT { namespace DU { //______________________________________________________________________________ atomic_TClass_ptr Segmentor::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *Segmentor::Class_Name() { return "RAT::DU::Segmentor"; } //______________________________________________________________________________ const char *Segmentor::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::Segmentor*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int Segmentor::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::Segmentor*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *Segmentor::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::Segmentor*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *Segmentor::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::Segmentor*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DU } // namespace RAT::DU namespace RAT { namespace DU { //______________________________________________________________________________ atomic_TClass_ptr SOCReader::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *SOCReader::Class_Name() { return "RAT::DU::SOCReader"; } //______________________________________________________________________________ const char *SOCReader::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::SOCReader*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int SOCReader::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::SOCReader*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *SOCReader::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::SOCReader*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *SOCReader::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::SOCReader*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DU } // namespace RAT::DU namespace RAT { namespace DU { //______________________________________________________________________________ atomic_TClass_ptr TimeResidualCalculator::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *TimeResidualCalculator::Class_Name() { return "RAT::DU::TimeResidualCalculator"; } //______________________________________________________________________________ const char *TimeResidualCalculator::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::TimeResidualCalculator*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int TimeResidualCalculator::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::TimeResidualCalculator*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *TimeResidualCalculator::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::TimeResidualCalculator*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *TimeResidualCalculator::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::TimeResidualCalculator*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DU } // namespace RAT::DU namespace RAT { namespace DU { //______________________________________________________________________________ atomic_TClass_ptr DetectorStateCorrection::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *DetectorStateCorrection::Class_Name() { return "RAT::DU::DetectorStateCorrection"; } //______________________________________________________________________________ const char *DetectorStateCorrection::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::DetectorStateCorrection*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int DetectorStateCorrection::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::DetectorStateCorrection*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *DetectorStateCorrection::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::DetectorStateCorrection*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *DetectorStateCorrection::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::DetectorStateCorrection*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DU } // namespace RAT::DU namespace RAT { namespace DU { //______________________________________________________________________________ atomic_TClass_ptr Utility::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *Utility::Class_Name() { return "RAT::DU::Utility"; } //______________________________________________________________________________ const char *Utility::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::Utility*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int Utility::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::Utility*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *Utility::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::Utility*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *Utility::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::Utility*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DU } // namespace RAT::DU namespace RAT { //______________________________________________________________________________ atomic_TClass_ptr TrackNode::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *TrackNode::Class_Name() { return "RAT::TrackNode"; } //______________________________________________________________________________ const char *TrackNode::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::TrackNode*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int TrackNode::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::TrackNode*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *TrackNode::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::TrackNode*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *TrackNode::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::TrackNode*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT namespace RAT { namespace DU { //______________________________________________________________________________ atomic_TClass_ptr EnergySystematics::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *EnergySystematics::Class_Name() { return "RAT::DU::EnergySystematics"; } //______________________________________________________________________________ const char *EnergySystematics::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::EnergySystematics*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int EnergySystematics::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::EnergySystematics*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *EnergySystematics::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::EnergySystematics*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *EnergySystematics::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RAT::DU::EnergySystematics*)nullptr)->GetClass(); } return fgIsA; } } // namespace RAT::DU } // namespace RAT::DU namespace ROOT { // Wrappers around operator new static void *new_exception(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::exception : new ::exception; } static void *newArray_exception(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::exception[nElements] : new ::exception[nElements]; } // Wrapper around operator delete static void delete_exception(void *p) { delete (static_cast<::exception*>(p)); } static void deleteArray_exception(void *p) { delete [] (static_cast<::exception*>(p)); } static void destruct_exception(void *p) { typedef ::exception current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::exception namespace ROOT { // Wrappers around operator new static void *new_pairlEstringcOstringgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) pair : new pair; } static void *newArray_pairlEstringcOstringgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) pair[nElements] : new pair[nElements]; } // Wrapper around operator delete static void delete_pairlEstringcOstringgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_pairlEstringcOstringgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_pairlEstringcOstringgR(void *p) { typedef pair current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class pair namespace ROOT { // Wrappers around operator new static void *new_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) pair : new pair; } static void *newArray_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) pair[nElements] : new pair[nElements]; } // Wrapper around operator delete static void delete_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p) { typedef pair current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class pair namespace ROOT { // Wrappers around operator new static void *new_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) pair > : new pair >; } static void *newArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) pair >[nElements] : new pair >[nElements]; } // Wrapper around operator delete static void delete_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p) { delete (static_cast >*>(p)); } static void deleteArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p) { delete [] (static_cast >*>(p)); } static void destruct_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p) { typedef pair > current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class pair > namespace ROOT { // Wrappers around operator new static void *new_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) pair > : new pair >; } static void *newArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) pair >[nElements] : new pair >[nElements]; } // Wrapper around operator delete static void delete_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p) { delete (static_cast >*>(p)); } static void deleteArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p) { delete [] (static_cast >*>(p)); } static void destruct_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p) { typedef pair > current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class pair > namespace ROOT { // Wrappers around operator new static void *new_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) pair > : new pair >; } static void *newArray_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) pair >[nElements] : new pair >[nElements]; } // Wrapper around operator delete static void delete_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p) { delete (static_cast >*>(p)); } static void deleteArray_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p) { delete [] (static_cast >*>(p)); } static void destruct_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p) { typedef pair > current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class pair > namespace ROOT { // Wrappers around operator new static void *new_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) pair : new pair; } static void *newArray_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) pair[nElements] : new pair[nElements]; } // Wrapper around operator delete static void delete_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p) { typedef pair current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class pair namespace RAT { namespace DS { //______________________________________________________________________________ void BitMask::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::BitMask. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::BitMask::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::BitMask::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLBitMask(void *p) { return p ? new(p) ::RAT::DS::BitMask : new ::RAT::DS::BitMask; } static void *newArray_RATcLcLDScLcLBitMask(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::BitMask[nElements] : new ::RAT::DS::BitMask[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLBitMask(void *p) { delete (static_cast<::RAT::DS::BitMask*>(p)); } static void deleteArray_RATcLcLDScLcLBitMask(void *p) { delete [] (static_cast<::RAT::DS::BitMask*>(p)); } static void destruct_RATcLcLDScLcLBitMask(void *p) { typedef ::RAT::DS::BitMask current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::BitMask namespace RAT { namespace DS { //______________________________________________________________________________ void Calib::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::Calib. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::Calib::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::Calib::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLCalib(void *p) { return p ? new(p) ::RAT::DS::Calib : new ::RAT::DS::Calib; } static void *newArray_RATcLcLDScLcLCalib(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::Calib[nElements] : new ::RAT::DS::Calib[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLCalib(void *p) { delete (static_cast<::RAT::DS::Calib*>(p)); } static void deleteArray_RATcLcLDScLcLCalib(void *p) { delete [] (static_cast<::RAT::DS::Calib*>(p)); } static void destruct_RATcLcLDScLcLCalib(void *p) { typedef ::RAT::DS::Calib current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::Calib namespace ROOT { // Wrapper around operator delete static void delete_RATcLcLDScLcLDataNotFound(void *p) { delete (static_cast<::RAT::DS::DataNotFound*>(p)); } static void deleteArray_RATcLcLDScLcLDataNotFound(void *p) { delete [] (static_cast<::RAT::DS::DataNotFound*>(p)); } static void destruct_RATcLcLDScLcLDataNotFound(void *p) { typedef ::RAT::DS::DataNotFound current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::DataNotFound namespace RAT { namespace DS { //______________________________________________________________________________ void ClassifierResult::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::ClassifierResult. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::ClassifierResult::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::ClassifierResult::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLClassifierResult(void *p) { return p ? new(p) ::RAT::DS::ClassifierResult : new ::RAT::DS::ClassifierResult; } static void *newArray_RATcLcLDScLcLClassifierResult(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::ClassifierResult[nElements] : new ::RAT::DS::ClassifierResult[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLClassifierResult(void *p) { delete (static_cast<::RAT::DS::ClassifierResult*>(p)); } static void deleteArray_RATcLcLDScLcLClassifierResult(void *p) { delete [] (static_cast<::RAT::DS::ClassifierResult*>(p)); } static void destruct_RATcLcLDScLcLClassifierResult(void *p) { typedef ::RAT::DS::ClassifierResult current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::ClassifierResult namespace RAT { namespace DS { //______________________________________________________________________________ void DataQCFlags::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::DataQCFlags. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::DataQCFlags::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::DataQCFlags::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLDataQCFlags(void *p) { return p ? new(p) ::RAT::DS::DataQCFlags : new ::RAT::DS::DataQCFlags; } static void *newArray_RATcLcLDScLcLDataQCFlags(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::DataQCFlags[nElements] : new ::RAT::DS::DataQCFlags[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLDataQCFlags(void *p) { delete (static_cast<::RAT::DS::DataQCFlags*>(p)); } static void deleteArray_RATcLcLDScLcLDataQCFlags(void *p) { delete [] (static_cast<::RAT::DS::DataQCFlags*>(p)); } static void destruct_RATcLcLDScLcLDataQCFlags(void *p) { typedef ::RAT::DS::DataQCFlags current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::DataQCFlags namespace RAT { namespace DS { //______________________________________________________________________________ void Digitiser::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::Digitiser. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::Digitiser::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::Digitiser::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLDigitiser(void *p) { return p ? new(p) ::RAT::DS::Digitiser : new ::RAT::DS::Digitiser; } static void *newArray_RATcLcLDScLcLDigitiser(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::Digitiser[nElements] : new ::RAT::DS::Digitiser[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLDigitiser(void *p) { delete (static_cast<::RAT::DS::Digitiser*>(p)); } static void deleteArray_RATcLcLDScLcLDigitiser(void *p) { delete [] (static_cast<::RAT::DS::Digitiser*>(p)); } static void destruct_RATcLcLDScLcLDigitiser(void *p) { typedef ::RAT::DS::Digitiser current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::Digitiser namespace RAT { namespace DS { //______________________________________________________________________________ void ECAHeader::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::ECAHeader. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::ECAHeader::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::ECAHeader::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLECAHeader(void *p) { return p ? new(p) ::RAT::DS::ECAHeader : new ::RAT::DS::ECAHeader; } static void *newArray_RATcLcLDScLcLECAHeader(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::ECAHeader[nElements] : new ::RAT::DS::ECAHeader[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLECAHeader(void *p) { delete (static_cast<::RAT::DS::ECAHeader*>(p)); } static void deleteArray_RATcLcLDScLcLECAHeader(void *p) { delete [] (static_cast<::RAT::DS::ECAHeader*>(p)); } static void destruct_RATcLcLDScLcLECAHeader(void *p) { typedef ::RAT::DS::ECAHeader current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::ECAHeader namespace RAT { namespace DS { //______________________________________________________________________________ void UniversalTime::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::UniversalTime. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::UniversalTime::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::UniversalTime::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLUniversalTime(void *p) { return p ? new(p) ::RAT::DS::UniversalTime : new ::RAT::DS::UniversalTime; } static void *newArray_RATcLcLDScLcLUniversalTime(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::UniversalTime[nElements] : new ::RAT::DS::UniversalTime[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLUniversalTime(void *p) { delete (static_cast<::RAT::DS::UniversalTime*>(p)); } static void deleteArray_RATcLcLDScLcLUniversalTime(void *p) { delete [] (static_cast<::RAT::DS::UniversalTime*>(p)); } static void destruct_RATcLcLDScLcLUniversalTime(void *p) { typedef ::RAT::DS::UniversalTime current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::UniversalTime namespace ROOT { // Wrappers around operator new static void *new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag> : new ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>; } static void *newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>[nElements] : new ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>[nElements]; } // Wrapper around operator delete static void delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) { delete (static_cast<::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>*>(p)); } static void deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) { delete [] (static_cast<::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>*>(p)); } static void destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) { typedef ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag> current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag> namespace ROOT { // Wrappers around operator new static void *new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag> : new ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>; } static void *newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>[nElements] : new ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>[nElements]; } // Wrapper around operator delete static void delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) { delete (static_cast<::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>*>(p)); } static void deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) { delete [] (static_cast<::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>*>(p)); } static void destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) { typedef ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag> current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag> namespace ROOT { // Wrappers around operator new static void *new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag> : new ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>; } static void *newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>[nElements] : new ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>[nElements]; } // Wrapper around operator delete static void delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) { delete (static_cast<::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>*>(p)); } static void deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) { delete [] (static_cast<::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>*>(p)); } static void destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) { typedef ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag> current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag> namespace ROOT { // Wrappers around operator new static void *new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag> : new ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>; } static void *newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>[nElements] : new ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>[nElements]; } // Wrapper around operator delete static void delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) { delete (static_cast<::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>*>(p)); } static void deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) { delete [] (static_cast<::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>*>(p)); } static void destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) { typedef ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag> current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag> namespace ROOT { // Wrappers around operator new static void *new_ROOTcLcLMathcLcLCartesian3DlEfloatgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::Cartesian3D : new ::ROOT::Math::Cartesian3D; } static void *newArray_ROOTcLcLMathcLcLCartesian3DlEfloatgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::Cartesian3D[nElements] : new ::ROOT::Math::Cartesian3D[nElements]; } // Wrapper around operator delete static void delete_ROOTcLcLMathcLcLCartesian3DlEfloatgR(void *p) { delete (static_cast<::ROOT::Math::Cartesian3D*>(p)); } static void deleteArray_ROOTcLcLMathcLcLCartesian3DlEfloatgR(void *p) { delete [] (static_cast<::ROOT::Math::Cartesian3D*>(p)); } static void destruct_ROOTcLcLMathcLcLCartesian3DlEfloatgR(void *p) { typedef ::ROOT::Math::Cartesian3D current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::ROOT::Math::Cartesian3D namespace ROOT { // Wrappers around operator new static void *new_ROOTcLcLMathcLcLPolar3DlEfloatgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::Polar3D : new ::ROOT::Math::Polar3D; } static void *newArray_ROOTcLcLMathcLcLPolar3DlEfloatgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::Polar3D[nElements] : new ::ROOT::Math::Polar3D[nElements]; } // Wrapper around operator delete static void delete_ROOTcLcLMathcLcLPolar3DlEfloatgR(void *p) { delete (static_cast<::ROOT::Math::Polar3D*>(p)); } static void deleteArray_ROOTcLcLMathcLcLPolar3DlEfloatgR(void *p) { delete [] (static_cast<::ROOT::Math::Polar3D*>(p)); } static void destruct_ROOTcLcLMathcLcLPolar3DlEfloatgR(void *p) { typedef ::ROOT::Math::Polar3D current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::ROOT::Math::Polar3D namespace RAT { namespace DS { //______________________________________________________________________________ void FitVertex::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::FitVertex. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::FitVertex::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::FitVertex::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLFitVertex(void *p) { return p ? new(p) ::RAT::DS::FitVertex : new ::RAT::DS::FitVertex; } static void *newArray_RATcLcLDScLcLFitVertex(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::FitVertex[nElements] : new ::RAT::DS::FitVertex[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLFitVertex(void *p) { delete (static_cast<::RAT::DS::FitVertex*>(p)); } static void deleteArray_RATcLcLDScLcLFitVertex(void *p) { delete [] (static_cast<::RAT::DS::FitVertex*>(p)); } static void destruct_RATcLcLDScLcLFitVertex(void *p) { typedef ::RAT::DS::FitVertex current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::FitVertex namespace RAT { namespace DS { //______________________________________________________________________________ void FitResult::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::FitResult. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::FitResult::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::FitResult::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLFitResult(void *p) { return p ? new(p) ::RAT::DS::FitResult : new ::RAT::DS::FitResult; } static void *newArray_RATcLcLDScLcLFitResult(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::FitResult[nElements] : new ::RAT::DS::FitResult[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLFitResult(void *p) { delete (static_cast<::RAT::DS::FitResult*>(p)); } static void deleteArray_RATcLcLDScLcLFitResult(void *p) { delete [] (static_cast<::RAT::DS::FitResult*>(p)); } static void destruct_RATcLcLDScLcLFitResult(void *p) { typedef ::RAT::DS::FitResult current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::FitResult namespace RAT { namespace DS { //______________________________________________________________________________ template <> void FitClassifierCollection::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::FitClassifierCollection. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::FitClassifierCollection::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::FitClassifierCollection::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(void *p) { return p ? new(p) ::RAT::DS::FitClassifierCollection : new ::RAT::DS::FitClassifierCollection; } static void *newArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::FitClassifierCollection[nElements] : new ::RAT::DS::FitClassifierCollection[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(void *p) { delete (static_cast<::RAT::DS::FitClassifierCollection*>(p)); } static void deleteArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(void *p) { delete [] (static_cast<::RAT::DS::FitClassifierCollection*>(p)); } static void destruct_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(void *p) { typedef ::RAT::DS::FitClassifierCollection current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::FitClassifierCollection namespace RAT { namespace DS { //______________________________________________________________________________ template <> void FitClassifierCollection::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::FitClassifierCollection. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::FitClassifierCollection::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::FitClassifierCollection::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(void *p) { return p ? new(p) ::RAT::DS::FitClassifierCollection : new ::RAT::DS::FitClassifierCollection; } static void *newArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::FitClassifierCollection[nElements] : new ::RAT::DS::FitClassifierCollection[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(void *p) { delete (static_cast<::RAT::DS::FitClassifierCollection*>(p)); } static void deleteArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(void *p) { delete [] (static_cast<::RAT::DS::FitClassifierCollection*>(p)); } static void destruct_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(void *p) { typedef ::RAT::DS::FitClassifierCollection current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::FitClassifierCollection namespace ROOT { // Wrappers around operator new static void *new_jsoncLcLValue(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::json::Value : new ::json::Value; } static void *newArray_jsoncLcLValue(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::json::Value[nElements] : new ::json::Value[nElements]; } // Wrapper around operator delete static void delete_jsoncLcLValue(void *p) { delete (static_cast<::json::Value*>(p)); } static void deleteArray_jsoncLcLValue(void *p) { delete [] (static_cast<::json::Value*>(p)); } static void destruct_jsoncLcLValue(void *p) { typedef ::json::Value current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::json::Value namespace ROOT { // Wrappers around operator new static void *new_RATcLcLLog(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::Log( (TRootIOCtor *)nullptr ) : new ::RAT::Log( (TRootIOCtor *)nullptr ); } // Wrapper around operator delete static void delete_RATcLcLLog(void *p) { delete (static_cast<::RAT::Log*>(p)); } static void deleteArray_RATcLcLLog(void *p) { delete [] (static_cast<::RAT::Log*>(p)); } static void destruct_RATcLcLLog(void *p) { typedef ::RAT::Log current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::Log namespace ROOT { // Wrappers around operator new static void *new_RATcLcLBitManip(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::BitManip : new ::RAT::BitManip; } static void *newArray_RATcLcLBitManip(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::BitManip[nElements] : new ::RAT::BitManip[nElements]; } // Wrapper around operator delete static void delete_RATcLcLBitManip(void *p) { delete (static_cast<::RAT::BitManip*>(p)); } static void deleteArray_RATcLcLBitManip(void *p) { delete [] (static_cast<::RAT::BitManip*>(p)); } static void destruct_RATcLcLBitManip(void *p) { typedef ::RAT::BitManip current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::BitManip namespace RAT { namespace DS { //______________________________________________________________________________ template <> void PMT::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::PMT. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::PMT::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::PMT::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLPMTlEDouble32_tgR(void *p) { return p ? new(p) ::RAT::DS::PMT : new ::RAT::DS::PMT; } static void *newArray_RATcLcLDScLcLPMTlEDouble32_tgR(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::PMT[nElements] : new ::RAT::DS::PMT[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLPMTlEDouble32_tgR(void *p) { delete (static_cast<::RAT::DS::PMT*>(p)); } static void deleteArray_RATcLcLDScLcLPMTlEDouble32_tgR(void *p) { delete [] (static_cast<::RAT::DS::PMT*>(p)); } static void destruct_RATcLcLDScLcLPMTlEDouble32_tgR(void *p) { typedef ::RAT::DS::PMT current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::PMT namespace RAT { namespace DS { //______________________________________________________________________________ template <> void PMT::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::PMT. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::PMT::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::PMT::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLPMTlEunsignedsPshortgR(void *p) { return p ? new(p) ::RAT::DS::PMT : new ::RAT::DS::PMT; } static void *newArray_RATcLcLDScLcLPMTlEunsignedsPshortgR(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::PMT[nElements] : new ::RAT::DS::PMT[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLPMTlEunsignedsPshortgR(void *p) { delete (static_cast<::RAT::DS::PMT*>(p)); } static void deleteArray_RATcLcLDScLcLPMTlEunsignedsPshortgR(void *p) { delete [] (static_cast<::RAT::DS::PMT*>(p)); } static void destruct_RATcLcLDScLcLPMTlEunsignedsPshortgR(void *p) { typedef ::RAT::DS::PMT current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::PMT namespace RAT { namespace DS { //______________________________________________________________________________ void PMTCal::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::PMTCal. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::PMTCal::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::PMTCal::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLPMTCal(void *p) { return p ? new(p) ::RAT::DS::PMTCal : new ::RAT::DS::PMTCal; } static void *newArray_RATcLcLDScLcLPMTCal(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::PMTCal[nElements] : new ::RAT::DS::PMTCal[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLPMTCal(void *p) { delete (static_cast<::RAT::DS::PMTCal*>(p)); } static void deleteArray_RATcLcLDScLcLPMTCal(void *p) { delete [] (static_cast<::RAT::DS::PMTCal*>(p)); } static void destruct_RATcLcLDScLcLPMTCal(void *p) { typedef ::RAT::DS::PMTCal current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::PMTCal namespace RAT { namespace DS { //______________________________________________________________________________ void MCHit::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::MCHit. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::MCHit::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::MCHit::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLMCHit(void *p) { return p ? new(p) ::RAT::DS::MCHit : new ::RAT::DS::MCHit; } static void *newArray_RATcLcLDScLcLMCHit(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::MCHit[nElements] : new ::RAT::DS::MCHit[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLMCHit(void *p) { delete (static_cast<::RAT::DS::MCHit*>(p)); } static void deleteArray_RATcLcLDScLcLMCHit(void *p) { delete [] (static_cast<::RAT::DS::MCHit*>(p)); } static void destruct_RATcLcLDScLcLMCHit(void *p) { typedef ::RAT::DS::MCHit current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::MCHit namespace RAT { namespace DU { //______________________________________________________________________________ void PMTInfo::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DU::PMTInfo. TObject::Streamer(R__b); } } // namespace RAT::DU } // namespace RAT::DU namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDUcLcLPMTInfo(void *p) { return p ? new(p) ::RAT::DU::PMTInfo : new ::RAT::DU::PMTInfo; } static void *newArray_RATcLcLDUcLcLPMTInfo(Long_t nElements, void *p) { return p ? new(p) ::RAT::DU::PMTInfo[nElements] : new ::RAT::DU::PMTInfo[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDUcLcLPMTInfo(void *p) { delete (static_cast<::RAT::DU::PMTInfo*>(p)); } static void deleteArray_RATcLcLDUcLcLPMTInfo(void *p) { delete [] (static_cast<::RAT::DU::PMTInfo*>(p)); } static void destruct_RATcLcLDUcLcLPMTInfo(void *p) { typedef ::RAT::DU::PMTInfo current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_RATcLcLDUcLcLPMTInfo(TBuffer &buf, void *obj) { ((::RAT::DU::PMTInfo*)obj)->::RAT::DU::PMTInfo::Streamer(buf); } } // end of namespace ROOT for class ::RAT::DU::PMTInfo namespace RAT { namespace DS { //______________________________________________________________________________ template <> void PMTSet >::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::PMTSet >. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::PMTSet >::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::PMTSet >::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p) { return p ? new(p) ::RAT::DS::PMTSet > : new ::RAT::DS::PMTSet >; } static void *newArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::PMTSet >[nElements] : new ::RAT::DS::PMTSet >[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p) { delete (static_cast<::RAT::DS::PMTSet >*>(p)); } static void deleteArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p) { delete [] (static_cast<::RAT::DS::PMTSet >*>(p)); } static void destruct_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p) { typedef ::RAT::DS::PMTSet > current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::PMTSet > namespace RAT { namespace DS { //______________________________________________________________________________ template <> void PMTSet::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::PMTSet. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::PMTSet::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::PMTSet::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(void *p) { return p ? new(p) ::RAT::DS::PMTSet : new ::RAT::DS::PMTSet; } static void *newArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::PMTSet[nElements] : new ::RAT::DS::PMTSet[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(void *p) { delete (static_cast<::RAT::DS::PMTSet*>(p)); } static void deleteArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(void *p) { delete [] (static_cast<::RAT::DS::PMTSet*>(p)); } static void destruct_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(void *p) { typedef ::RAT::DS::PMTSet current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::PMTSet namespace RAT { namespace DS { //______________________________________________________________________________ template <> void PMTSet::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::PMTSet. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::PMTSet::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::PMTSet::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(void *p) { return p ? new(p) ::RAT::DS::PMTSet : new ::RAT::DS::PMTSet; } static void *newArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::PMTSet[nElements] : new ::RAT::DS::PMTSet[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(void *p) { delete (static_cast<::RAT::DS::PMTSet*>(p)); } static void deleteArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(void *p) { delete [] (static_cast<::RAT::DS::PMTSet*>(p)); } static void destruct_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(void *p) { typedef ::RAT::DS::PMTSet current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::PMTSet namespace RAT { namespace DS { //______________________________________________________________________________ void EV::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::EV. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::EV::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::EV::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLEV(void *p) { return p ? new(p) ::RAT::DS::EV : new ::RAT::DS::EV; } static void *newArray_RATcLcLDScLcLEV(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::EV[nElements] : new ::RAT::DS::EV[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLEV(void *p) { delete (static_cast<::RAT::DS::EV*>(p)); } static void deleteArray_RATcLcLDScLcLEV(void *p) { delete [] (static_cast<::RAT::DS::EV*>(p)); } static void destruct_RATcLcLDScLcLEV(void *p) { typedef ::RAT::DS::EV current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::EV namespace RAT { namespace DS { //______________________________________________________________________________ void TrigHeader::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::TrigHeader. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::TrigHeader::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::TrigHeader::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLTrigHeader(void *p) { return p ? new(p) ::RAT::DS::TrigHeader : new ::RAT::DS::TrigHeader; } static void *newArray_RATcLcLDScLcLTrigHeader(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::TrigHeader[nElements] : new ::RAT::DS::TrigHeader[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLTrigHeader(void *p) { delete (static_cast<::RAT::DS::TrigHeader*>(p)); } static void deleteArray_RATcLcLDScLcLTrigHeader(void *p) { delete [] (static_cast<::RAT::DS::TrigHeader*>(p)); } static void destruct_RATcLcLDScLcLTrigHeader(void *p) { typedef ::RAT::DS::TrigHeader current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::TrigHeader namespace RAT { namespace DS { //______________________________________________________________________________ void HeaderInfo::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::HeaderInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::HeaderInfo::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::HeaderInfo::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLHeaderInfo(void *p) { return p ? new(p) ::RAT::DS::HeaderInfo : new ::RAT::DS::HeaderInfo; } static void *newArray_RATcLcLDScLcLHeaderInfo(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::HeaderInfo[nElements] : new ::RAT::DS::HeaderInfo[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLHeaderInfo(void *p) { delete (static_cast<::RAT::DS::HeaderInfo*>(p)); } static void deleteArray_RATcLcLDScLcLHeaderInfo(void *p) { delete [] (static_cast<::RAT::DS::HeaderInfo*>(p)); } static void destruct_RATcLcLDScLcLHeaderInfo(void *p) { typedef ::RAT::DS::HeaderInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::HeaderInfo namespace RAT { namespace DS { //______________________________________________________________________________ void MetaDB::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::MetaDB. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::MetaDB::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::MetaDB::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLMetaDB(void *p) { return p ? new(p) ::RAT::DS::MetaDB : new ::RAT::DS::MetaDB; } static void *newArray_RATcLcLDScLcLMetaDB(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::MetaDB[nElements] : new ::RAT::DS::MetaDB[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLMetaDB(void *p) { delete (static_cast<::RAT::DS::MetaDB*>(p)); } static void deleteArray_RATcLcLDScLcLMetaDB(void *p) { delete [] (static_cast<::RAT::DS::MetaDB*>(p)); } static void destruct_RATcLcLDScLcLMetaDB(void *p) { typedef ::RAT::DS::MetaDB current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::MetaDB namespace RAT { namespace DS { //______________________________________________________________________________ void Meta::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::Meta. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::Meta::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::Meta::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLMeta(void *p) { return p ? new(p) ::RAT::DS::Meta : new ::RAT::DS::Meta; } static void *newArray_RATcLcLDScLcLMeta(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::Meta[nElements] : new ::RAT::DS::Meta[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLMeta(void *p) { delete (static_cast<::RAT::DS::Meta*>(p)); } static void deleteArray_RATcLcLDScLcLMeta(void *p) { delete [] (static_cast<::RAT::DS::Meta*>(p)); } static void destruct_RATcLcLDScLcLMeta(void *p) { typedef ::RAT::DS::Meta current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::Meta namespace RAT { namespace DS { //______________________________________________________________________________ void MCParticle::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::MCParticle. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::MCParticle::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::MCParticle::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLMCParticle(void *p) { return p ? new(p) ::RAT::DS::MCParticle : new ::RAT::DS::MCParticle; } static void *newArray_RATcLcLDScLcLMCParticle(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::MCParticle[nElements] : new ::RAT::DS::MCParticle[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLMCParticle(void *p) { delete (static_cast<::RAT::DS::MCParticle*>(p)); } static void deleteArray_RATcLcLDScLcLMCParticle(void *p) { delete [] (static_cast<::RAT::DS::MCParticle*>(p)); } static void destruct_RATcLcLDScLcLMCParticle(void *p) { typedef ::RAT::DS::MCParticle current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::MCParticle namespace RAT { namespace DS { //______________________________________________________________________________ void MCTrackStep::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::MCTrackStep. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::MCTrackStep::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::MCTrackStep::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLMCTrackStep(void *p) { return p ? new(p) ::RAT::DS::MCTrackStep : new ::RAT::DS::MCTrackStep; } static void *newArray_RATcLcLDScLcLMCTrackStep(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::MCTrackStep[nElements] : new ::RAT::DS::MCTrackStep[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLMCTrackStep(void *p) { delete (static_cast<::RAT::DS::MCTrackStep*>(p)); } static void deleteArray_RATcLcLDScLcLMCTrackStep(void *p) { delete [] (static_cast<::RAT::DS::MCTrackStep*>(p)); } static void destruct_RATcLcLDScLcLMCTrackStep(void *p) { typedef ::RAT::DS::MCTrackStep current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::MCTrackStep namespace RAT { namespace DS { //______________________________________________________________________________ void MCTrack::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::MCTrack. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::MCTrack::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::MCTrack::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLMCTrack(void *p) { return p ? new(p) ::RAT::DS::MCTrack : new ::RAT::DS::MCTrack; } static void *newArray_RATcLcLDScLcLMCTrack(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::MCTrack[nElements] : new ::RAT::DS::MCTrack[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLMCTrack(void *p) { delete (static_cast<::RAT::DS::MCTrack*>(p)); } static void deleteArray_RATcLcLDScLcLMCTrack(void *p) { delete [] (static_cast<::RAT::DS::MCTrack*>(p)); } static void destruct_RATcLcLDScLcLMCTrack(void *p) { typedef ::RAT::DS::MCTrack current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::MCTrack namespace RAT { namespace DS { //______________________________________________________________________________ void MCPhoton::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::MCPhoton. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::MCPhoton::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::MCPhoton::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLMCPhoton(void *p) { return p ? new(p) ::RAT::DS::MCPhoton : new ::RAT::DS::MCPhoton; } static void *newArray_RATcLcLDScLcLMCPhoton(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::MCPhoton[nElements] : new ::RAT::DS::MCPhoton[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLMCPhoton(void *p) { delete (static_cast<::RAT::DS::MCPhoton*>(p)); } static void deleteArray_RATcLcLDScLcLMCPhoton(void *p) { delete [] (static_cast<::RAT::DS::MCPhoton*>(p)); } static void destruct_RATcLcLDScLcLMCPhoton(void *p) { typedef ::RAT::DS::MCPhoton current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::MCPhoton namespace RAT { namespace DS { //______________________________________________________________________________ void MCPE::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::MCPE. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::MCPE::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::MCPE::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLMCPE(void *p) { return p ? new(p) ::RAT::DS::MCPE : new ::RAT::DS::MCPE; } static void *newArray_RATcLcLDScLcLMCPE(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::MCPE[nElements] : new ::RAT::DS::MCPE[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLMCPE(void *p) { delete (static_cast<::RAT::DS::MCPE*>(p)); } static void deleteArray_RATcLcLDScLcLMCPE(void *p) { delete [] (static_cast<::RAT::DS::MCPE*>(p)); } static void destruct_RATcLcLDScLcLMCPE(void *p) { typedef ::RAT::DS::MCPE current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::MCPE namespace RAT { namespace DS { //______________________________________________________________________________ void MCPMT::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::MCPMT. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::MCPMT::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::MCPMT::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLMCPMT(void *p) { return p ? new(p) ::RAT::DS::MCPMT : new ::RAT::DS::MCPMT; } static void *newArray_RATcLcLDScLcLMCPMT(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::MCPMT[nElements] : new ::RAT::DS::MCPMT[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLMCPMT(void *p) { delete (static_cast<::RAT::DS::MCPMT*>(p)); } static void deleteArray_RATcLcLDScLcLMCPMT(void *p) { delete [] (static_cast<::RAT::DS::MCPMT*>(p)); } static void destruct_RATcLcLDScLcLMCPMT(void *p) { typedef ::RAT::DS::MCPMT current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::MCPMT namespace RAT { namespace DS { //______________________________________________________________________________ void MC::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::MC. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::MC::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::MC::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLMC(void *p) { return p ? new(p) ::RAT::DS::MC : new ::RAT::DS::MC; } static void *newArray_RATcLcLDScLcLMC(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::MC[nElements] : new ::RAT::DS::MC[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLMC(void *p) { delete (static_cast<::RAT::DS::MC*>(p)); } static void deleteArray_RATcLcLDScLcLMC(void *p) { delete [] (static_cast<::RAT::DS::MC*>(p)); } static void destruct_RATcLcLDScLcLMC(void *p) { typedef ::RAT::DS::MC current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::MC namespace RAT { namespace DS { //______________________________________________________________________________ void MCEV::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::MCEV. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::MCEV::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::MCEV::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLMCEV(void *p) { return p ? new(p) ::RAT::DS::MCEV : new ::RAT::DS::MCEV; } static void *newArray_RATcLcLDScLcLMCEV(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::MCEV[nElements] : new ::RAT::DS::MCEV[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLMCEV(void *p) { delete (static_cast<::RAT::DS::MCEV*>(p)); } static void deleteArray_RATcLcLDScLcLMCEV(void *p) { delete [] (static_cast<::RAT::DS::MCEV*>(p)); } static void destruct_RATcLcLDScLcLMCEV(void *p) { typedef ::RAT::DS::MCEV current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::MCEV namespace RAT { namespace DS { //______________________________________________________________________________ void Entry::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::Entry. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::Entry::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::Entry::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLEntry(void *p) { return p ? new(p) ::RAT::DS::Entry : new ::RAT::DS::Entry; } static void *newArray_RATcLcLDScLcLEntry(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::Entry[nElements] : new ::RAT::DS::Entry[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLEntry(void *p) { delete (static_cast<::RAT::DS::Entry*>(p)); } static void deleteArray_RATcLcLDScLcLEntry(void *p) { delete [] (static_cast<::RAT::DS::Entry*>(p)); } static void destruct_RATcLcLDScLcLEntry(void *p) { typedef ::RAT::DS::Entry current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::Entry namespace RAT { namespace DS { //______________________________________________________________________________ void SOCPMT::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::SOCPMT. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::SOCPMT::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::SOCPMT::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLSOCPMT(void *p) { return p ? new(p) ::RAT::DS::SOCPMT : new ::RAT::DS::SOCPMT; } static void *newArray_RATcLcLDScLcLSOCPMT(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::SOCPMT[nElements] : new ::RAT::DS::SOCPMT[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLSOCPMT(void *p) { delete (static_cast<::RAT::DS::SOCPMT*>(p)); } static void deleteArray_RATcLcLDScLcLSOCPMT(void *p) { delete [] (static_cast<::RAT::DS::SOCPMT*>(p)); } static void destruct_RATcLcLDScLcLSOCPMT(void *p) { typedef ::RAT::DS::SOCPMT current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::SOCPMT namespace RAT { namespace DS { //______________________________________________________________________________ void SOC::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::SOC. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::SOC::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::SOC::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLSOC(void *p) { return p ? new(p) ::RAT::DS::SOC : new ::RAT::DS::SOC; } static void *newArray_RATcLcLDScLcLSOC(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::SOC[nElements] : new ::RAT::DS::SOC[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLSOC(void *p) { delete (static_cast<::RAT::DS::SOC*>(p)); } static void deleteArray_RATcLcLDScLcLSOC(void *p) { delete [] (static_cast<::RAT::DS::SOC*>(p)); } static void destruct_RATcLcLDScLcLSOC(void *p) { typedef ::RAT::DS::SOC current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::SOC namespace RAT { namespace DS { //______________________________________________________________________________ void Run::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DS::Run. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DS::Run::Class(),this); } else { R__b.WriteClassBuffer(RAT::DS::Run::Class(),this); } } } // namespace RAT::DS } // namespace RAT::DS namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDScLcLRun(void *p) { return p ? new(p) ::RAT::DS::Run : new ::RAT::DS::Run; } static void *newArray_RATcLcLDScLcLRun(Long_t nElements, void *p) { return p ? new(p) ::RAT::DS::Run[nElements] : new ::RAT::DS::Run[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDScLcLRun(void *p) { delete (static_cast<::RAT::DS::Run*>(p)); } static void deleteArray_RATcLcLDScLcLRun(void *p) { delete [] (static_cast<::RAT::DS::Run*>(p)); } static void destruct_RATcLcLDScLcLRun(void *p) { typedef ::RAT::DS::Run current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DS::Run namespace RAT { namespace DU { //______________________________________________________________________________ void DataCleaningBits::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DU::DataCleaningBits. TObject::Streamer(R__b); } } // namespace RAT::DU } // namespace RAT::DU namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDUcLcLDataCleaningBits(void *p) { return p ? new(p) ::RAT::DU::DataCleaningBits : new ::RAT::DU::DataCleaningBits; } static void *newArray_RATcLcLDUcLcLDataCleaningBits(Long_t nElements, void *p) { return p ? new(p) ::RAT::DU::DataCleaningBits[nElements] : new ::RAT::DU::DataCleaningBits[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDUcLcLDataCleaningBits(void *p) { delete (static_cast<::RAT::DU::DataCleaningBits*>(p)); } static void deleteArray_RATcLcLDUcLcLDataCleaningBits(void *p) { delete [] (static_cast<::RAT::DU::DataCleaningBits*>(p)); } static void destruct_RATcLcLDUcLcLDataCleaningBits(void *p) { typedef ::RAT::DU::DataCleaningBits current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_RATcLcLDUcLcLDataCleaningBits(TBuffer &buf, void *obj) { ((::RAT::DU::DataCleaningBits*)obj)->::RAT::DU::DataCleaningBits::Streamer(buf); } } // end of namespace ROOT for class ::RAT::DU::DataCleaningBits namespace RAT { namespace DU { //______________________________________________________________________________ void DataQualityBits::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DU::DataQualityBits. TObject::Streamer(R__b); } } // namespace RAT::DU } // namespace RAT::DU namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDUcLcLDataQualityBits(void *p) { return p ? new(p) ::RAT::DU::DataQualityBits : new ::RAT::DU::DataQualityBits; } static void *newArray_RATcLcLDUcLcLDataQualityBits(Long_t nElements, void *p) { return p ? new(p) ::RAT::DU::DataQualityBits[nElements] : new ::RAT::DU::DataQualityBits[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDUcLcLDataQualityBits(void *p) { delete (static_cast<::RAT::DU::DataQualityBits*>(p)); } static void deleteArray_RATcLcLDUcLcLDataQualityBits(void *p) { delete [] (static_cast<::RAT::DU::DataQualityBits*>(p)); } static void destruct_RATcLcLDUcLcLDataQualityBits(void *p) { typedef ::RAT::DU::DataQualityBits current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_RATcLcLDUcLcLDataQualityBits(TBuffer &buf, void *obj) { ((::RAT::DU::DataQualityBits*)obj)->::RAT::DU::DataQualityBits::Streamer(buf); } } // end of namespace ROOT for class ::RAT::DU::DataQualityBits namespace RAT { namespace DU { //______________________________________________________________________________ void ChanSWStatus::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DU::ChanSWStatus. TObject::Streamer(R__b); } } // namespace RAT::DU } // namespace RAT::DU namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDUcLcLChanSWStatus(void *p) { return p ? new(p) ::RAT::DU::ChanSWStatus : new ::RAT::DU::ChanSWStatus; } static void *newArray_RATcLcLDUcLcLChanSWStatus(Long_t nElements, void *p) { return p ? new(p) ::RAT::DU::ChanSWStatus[nElements] : new ::RAT::DU::ChanSWStatus[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDUcLcLChanSWStatus(void *p) { delete (static_cast<::RAT::DU::ChanSWStatus*>(p)); } static void deleteArray_RATcLcLDUcLcLChanSWStatus(void *p) { delete [] (static_cast<::RAT::DU::ChanSWStatus*>(p)); } static void destruct_RATcLcLDUcLcLChanSWStatus(void *p) { typedef ::RAT::DU::ChanSWStatus current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_RATcLcLDUcLcLChanSWStatus(TBuffer &buf, void *obj) { ((::RAT::DU::ChanSWStatus*)obj)->::RAT::DU::ChanSWStatus::Streamer(buf); } } // end of namespace ROOT for class ::RAT::DU::ChanSWStatus namespace RAT { namespace DU { //______________________________________________________________________________ void TrigBits::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DU::TrigBits. TObject::Streamer(R__b); } } // namespace RAT::DU } // namespace RAT::DU namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDUcLcLTrigBits(void *p) { return p ? new(p) ::RAT::DU::TrigBits : new ::RAT::DU::TrigBits; } static void *newArray_RATcLcLDUcLcLTrigBits(Long_t nElements, void *p) { return p ? new(p) ::RAT::DU::TrigBits[nElements] : new ::RAT::DU::TrigBits[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDUcLcLTrigBits(void *p) { delete (static_cast<::RAT::DU::TrigBits*>(p)); } static void deleteArray_RATcLcLDUcLcLTrigBits(void *p) { delete [] (static_cast<::RAT::DU::TrigBits*>(p)); } static void destruct_RATcLcLDUcLcLTrigBits(void *p) { typedef ::RAT::DU::TrigBits current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_RATcLcLDUcLcLTrigBits(TBuffer &buf, void *obj) { ((::RAT::DU::TrigBits*)obj)->::RAT::DU::TrigBits::Streamer(buf); } } // end of namespace ROOT for class ::RAT::DU::TrigBits namespace RAT { namespace DU { //______________________________________________________________________________ void DSReader::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DU::DSReader. //This works around a msvc bug and should be harmless on other platforms typedef ::RAT::DU::DSReader thisClass; UInt_t R__s, R__c; if (R__b.IsReading()) { Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { } TObject::Streamer(R__b); R__b >> fT; R__b >> fRunT; R__b >> fDS; R__b >> fRun; R__b >> fMeta; R__b >> fCurrentEntry; R__b >> fTotalEntries; R__b >> fCurrentRun; R__b >> fTotalRuns; R__b >> fUseMeta; R__b.CheckByteCount(R__s, R__c, thisClass::IsA()); } else { R__c = R__b.WriteVersion(thisClass::IsA(), kTRUE); TObject::Streamer(R__b); R__b << fT; R__b << fRunT; R__b << fDS; R__b << fRun; R__b << fMeta; R__b << fCurrentEntry; R__b << fTotalEntries; R__b << fCurrentRun; R__b << fTotalRuns; R__b << fUseMeta; R__b.SetByteCount(R__c, kTRUE); } } } // namespace RAT::DU } // namespace RAT::DU namespace ROOT { // Wrapper around operator delete static void delete_RATcLcLDUcLcLDSReader(void *p) { delete (static_cast<::RAT::DU::DSReader*>(p)); } static void deleteArray_RATcLcLDUcLcLDSReader(void *p) { delete [] (static_cast<::RAT::DU::DSReader*>(p)); } static void destruct_RATcLcLDUcLcLDSReader(void *p) { typedef ::RAT::DU::DSReader current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_RATcLcLDUcLcLDSReader(TBuffer &buf, void *obj) { ((::RAT::DU::DSReader*)obj)->::RAT::DU::DSReader::Streamer(buf); } } // end of namespace ROOT for class ::RAT::DU::DSReader namespace RAT { namespace DU { //______________________________________________________________________________ void EffectiveVelocity::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DU::EffectiveVelocity. TObject::Streamer(R__b); } } // namespace RAT::DU } // namespace RAT::DU namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDUcLcLEffectiveVelocity(void *p) { return p ? new(p) ::RAT::DU::EffectiveVelocity : new ::RAT::DU::EffectiveVelocity; } static void *newArray_RATcLcLDUcLcLEffectiveVelocity(Long_t nElements, void *p) { return p ? new(p) ::RAT::DU::EffectiveVelocity[nElements] : new ::RAT::DU::EffectiveVelocity[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDUcLcLEffectiveVelocity(void *p) { delete (static_cast<::RAT::DU::EffectiveVelocity*>(p)); } static void deleteArray_RATcLcLDUcLcLEffectiveVelocity(void *p) { delete [] (static_cast<::RAT::DU::EffectiveVelocity*>(p)); } static void destruct_RATcLcLDUcLcLEffectiveVelocity(void *p) { typedef ::RAT::DU::EffectiveVelocity current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_RATcLcLDUcLcLEffectiveVelocity(TBuffer &buf, void *obj) { ((::RAT::DU::EffectiveVelocity*)obj)->::RAT::DU::EffectiveVelocity::Streamer(buf); } } // end of namespace ROOT for class ::RAT::DU::EffectiveVelocity namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDBTable(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::DBTable : new ::RAT::DBTable; } static void *newArray_RATcLcLDBTable(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::DBTable[nElements] : new ::RAT::DBTable[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDBTable(void *p) { delete (static_cast<::RAT::DBTable*>(p)); } static void deleteArray_RATcLcLDBTable(void *p) { delete [] (static_cast<::RAT::DBTable*>(p)); } static void destruct_RATcLcLDBTable(void *p) { typedef ::RAT::DBTable current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DBTable namespace ROOT { // Wrapper around operator delete static void delete_RATcLcLDBLink(void *p) { delete (static_cast<::RAT::DBLink*>(p)); } static void deleteArray_RATcLcLDBLink(void *p) { delete [] (static_cast<::RAT::DBLink*>(p)); } static void destruct_RATcLcLDBLink(void *p) { typedef ::RAT::DBLink current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DBLink namespace ROOT { // Wrappers around operator new static void *new_stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::stlplus::simple_ptr_nocopy : new ::stlplus::simple_ptr_nocopy; } static void *newArray_stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::stlplus::simple_ptr_nocopy[nElements] : new ::stlplus::simple_ptr_nocopy[nElements]; } // Wrapper around operator delete static void delete_stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR(void *p) { delete (static_cast<::stlplus::simple_ptr_nocopy*>(p)); } static void deleteArray_stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR(void *p) { delete [] (static_cast<::stlplus::simple_ptr_nocopy*>(p)); } static void destruct_stlpluscLcLsimple_ptr_nocopylERATcLcLDBLinkgR(void *p) { typedef ::stlplus::simple_ptr_nocopy current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::stlplus::simple_ptr_nocopy namespace RAT { //______________________________________________________________________________ void DB::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DB. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DB::Class(),this); } else { R__b.WriteClassBuffer(RAT::DB::Class(),this); } } } // namespace RAT namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDB(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::DB : new ::RAT::DB; } static void *newArray_RATcLcLDB(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::DB[nElements] : new ::RAT::DB[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDB(void *p) { delete (static_cast<::RAT::DB*>(p)); } static void deleteArray_RATcLcLDB(void *p) { delete [] (static_cast<::RAT::DB*>(p)); } static void destruct_RATcLcLDB(void *p) { typedef ::RAT::DB current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DB namespace RAT { namespace DU { //______________________________________________________________________________ void GroupVelocity::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DU::GroupVelocity. TObject::Streamer(R__b); } } // namespace RAT::DU } // namespace RAT::DU namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDUcLcLGroupVelocity(void *p) { return p ? new(p) ::RAT::DU::GroupVelocity : new ::RAT::DU::GroupVelocity; } static void *newArray_RATcLcLDUcLcLGroupVelocity(Long_t nElements, void *p) { return p ? new(p) ::RAT::DU::GroupVelocity[nElements] : new ::RAT::DU::GroupVelocity[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDUcLcLGroupVelocity(void *p) { delete (static_cast<::RAT::DU::GroupVelocity*>(p)); } static void deleteArray_RATcLcLDUcLcLGroupVelocity(void *p) { delete [] (static_cast<::RAT::DU::GroupVelocity*>(p)); } static void destruct_RATcLcLDUcLcLGroupVelocity(void *p) { typedef ::RAT::DU::GroupVelocity current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_RATcLcLDUcLcLGroupVelocity(TBuffer &buf, void *obj) { ((::RAT::DU::GroupVelocity*)obj)->::RAT::DU::GroupVelocity::Streamer(buf); } } // end of namespace ROOT for class ::RAT::DU::GroupVelocity namespace RAT { namespace DU { //______________________________________________________________________________ void Point3D::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DU::Point3D. TObject::Streamer(R__b); } } // namespace RAT::DU } // namespace RAT::DU namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDUcLcLPoint3D(void *p) { return p ? new(p) ::RAT::DU::Point3D : new ::RAT::DU::Point3D; } static void *newArray_RATcLcLDUcLcLPoint3D(Long_t nElements, void *p) { return p ? new(p) ::RAT::DU::Point3D[nElements] : new ::RAT::DU::Point3D[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDUcLcLPoint3D(void *p) { delete (static_cast<::RAT::DU::Point3D*>(p)); } static void deleteArray_RATcLcLDUcLcLPoint3D(void *p) { delete [] (static_cast<::RAT::DU::Point3D*>(p)); } static void destruct_RATcLcLDUcLcLPoint3D(void *p) { typedef ::RAT::DU::Point3D current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_RATcLcLDUcLcLPoint3D(TBuffer &buf, void *obj) { ((::RAT::DU::Point3D*)obj)->::RAT::DU::Point3D::Streamer(buf); } } // end of namespace ROOT for class ::RAT::DU::Point3D namespace RAT { namespace DU { //______________________________________________________________________________ void LightPathCalculator::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DU::LightPathCalculator. TObject::Streamer(R__b); } } // namespace RAT::DU } // namespace RAT::DU namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDUcLcLLightPathCalculator(void *p) { return p ? new(p) ::RAT::DU::LightPathCalculator : new ::RAT::DU::LightPathCalculator; } static void *newArray_RATcLcLDUcLcLLightPathCalculator(Long_t nElements, void *p) { return p ? new(p) ::RAT::DU::LightPathCalculator[nElements] : new ::RAT::DU::LightPathCalculator[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDUcLcLLightPathCalculator(void *p) { delete (static_cast<::RAT::DU::LightPathCalculator*>(p)); } static void deleteArray_RATcLcLDUcLcLLightPathCalculator(void *p) { delete [] (static_cast<::RAT::DU::LightPathCalculator*>(p)); } static void destruct_RATcLcLDUcLcLLightPathCalculator(void *p) { typedef ::RAT::DU::LightPathCalculator current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_RATcLcLDUcLcLLightPathCalculator(TBuffer &buf, void *obj) { ((::RAT::DU::LightPathCalculator*)obj)->::RAT::DU::LightPathCalculator::Streamer(buf); } } // end of namespace ROOT for class ::RAT::DU::LightPathCalculator namespace RAT { namespace DU { //______________________________________________________________________________ void PanelInfo::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DU::PanelInfo. TObject::Streamer(R__b); } } // namespace RAT::DU } // namespace RAT::DU namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDUcLcLPanelInfo(void *p) { return p ? new(p) ::RAT::DU::PanelInfo : new ::RAT::DU::PanelInfo; } static void *newArray_RATcLcLDUcLcLPanelInfo(Long_t nElements, void *p) { return p ? new(p) ::RAT::DU::PanelInfo[nElements] : new ::RAT::DU::PanelInfo[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDUcLcLPanelInfo(void *p) { delete (static_cast<::RAT::DU::PanelInfo*>(p)); } static void deleteArray_RATcLcLDUcLcLPanelInfo(void *p) { delete [] (static_cast<::RAT::DU::PanelInfo*>(p)); } static void destruct_RATcLcLDUcLcLPanelInfo(void *p) { typedef ::RAT::DU::PanelInfo current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_RATcLcLDUcLcLPanelInfo(TBuffer &buf, void *obj) { ((::RAT::DU::PanelInfo*)obj)->::RAT::DU::PanelInfo::Streamer(buf); } } // end of namespace ROOT for class ::RAT::DU::PanelInfo namespace RAT { namespace DU { //______________________________________________________________________________ void ChanHWStatus::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DU::ChanHWStatus. TObject::Streamer(R__b); } } // namespace RAT::DU } // namespace RAT::DU namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDUcLcLChanHWStatus(void *p) { return p ? new(p) ::RAT::DU::ChanHWStatus : new ::RAT::DU::ChanHWStatus; } static void *newArray_RATcLcLDUcLcLChanHWStatus(Long_t nElements, void *p) { return p ? new(p) ::RAT::DU::ChanHWStatus[nElements] : new ::RAT::DU::ChanHWStatus[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDUcLcLChanHWStatus(void *p) { delete (static_cast<::RAT::DU::ChanHWStatus*>(p)); } static void deleteArray_RATcLcLDUcLcLChanHWStatus(void *p) { delete [] (static_cast<::RAT::DU::ChanHWStatus*>(p)); } static void destruct_RATcLcLDUcLcLChanHWStatus(void *p) { typedef ::RAT::DU::ChanHWStatus current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_RATcLcLDUcLcLChanHWStatus(TBuffer &buf, void *obj) { ((::RAT::DU::ChanHWStatus*)obj)->::RAT::DU::ChanHWStatus::Streamer(buf); } } // end of namespace ROOT for class ::RAT::DU::ChanHWStatus namespace RAT { namespace DU { //______________________________________________________________________________ void PMTCalStatus::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DU::PMTCalStatus. TObject::Streamer(R__b); } } // namespace RAT::DU } // namespace RAT::DU namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDUcLcLPMTCalStatus(void *p) { return p ? new(p) ::RAT::DU::PMTCalStatus : new ::RAT::DU::PMTCalStatus; } static void *newArray_RATcLcLDUcLcLPMTCalStatus(Long_t nElements, void *p) { return p ? new(p) ::RAT::DU::PMTCalStatus[nElements] : new ::RAT::DU::PMTCalStatus[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDUcLcLPMTCalStatus(void *p) { delete (static_cast<::RAT::DU::PMTCalStatus*>(p)); } static void deleteArray_RATcLcLDUcLcLPMTCalStatus(void *p) { delete [] (static_cast<::RAT::DU::PMTCalStatus*>(p)); } static void destruct_RATcLcLDUcLcLPMTCalStatus(void *p) { typedef ::RAT::DU::PMTCalStatus current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_RATcLcLDUcLcLPMTCalStatus(TBuffer &buf, void *obj) { ((::RAT::DU::PMTCalStatus*)obj)->::RAT::DU::PMTCalStatus::Streamer(buf); } } // end of namespace ROOT for class ::RAT::DU::PMTCalStatus namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDUcLcLReactorNuOsc(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::DU::ReactorNuOsc : new ::RAT::DU::ReactorNuOsc; } static void *newArray_RATcLcLDUcLcLReactorNuOsc(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::DU::ReactorNuOsc[nElements] : new ::RAT::DU::ReactorNuOsc[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDUcLcLReactorNuOsc(void *p) { delete (static_cast<::RAT::DU::ReactorNuOsc*>(p)); } static void deleteArray_RATcLcLDUcLcLReactorNuOsc(void *p) { delete [] (static_cast<::RAT::DU::ReactorNuOsc*>(p)); } static void destruct_RATcLcLDUcLcLReactorNuOsc(void *p) { typedef ::RAT::DU::ReactorNuOsc current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DU::ReactorNuOsc namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDUcLcLShadowingCalculator(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::DU::ShadowingCalculator : new ::RAT::DU::ShadowingCalculator; } static void *newArray_RATcLcLDUcLcLShadowingCalculator(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::DU::ShadowingCalculator[nElements] : new ::RAT::DU::ShadowingCalculator[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDUcLcLShadowingCalculator(void *p) { delete (static_cast<::RAT::DU::ShadowingCalculator*>(p)); } static void deleteArray_RATcLcLDUcLcLShadowingCalculator(void *p) { delete [] (static_cast<::RAT::DU::ShadowingCalculator*>(p)); } static void destruct_RATcLcLDUcLcLShadowingCalculator(void *p) { typedef ::RAT::DU::ShadowingCalculator current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DU::ShadowingCalculator namespace RAT { namespace DU { //______________________________________________________________________________ void Segmentor::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DU::Segmentor. TObject::Streamer(R__b); } } // namespace RAT::DU } // namespace RAT::DU namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDUcLcLSegmentor(void *p) { return p ? new(p) ::RAT::DU::Segmentor : new ::RAT::DU::Segmentor; } static void *newArray_RATcLcLDUcLcLSegmentor(Long_t nElements, void *p) { return p ? new(p) ::RAT::DU::Segmentor[nElements] : new ::RAT::DU::Segmentor[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDUcLcLSegmentor(void *p) { delete (static_cast<::RAT::DU::Segmentor*>(p)); } static void deleteArray_RATcLcLDUcLcLSegmentor(void *p) { delete [] (static_cast<::RAT::DU::Segmentor*>(p)); } static void destruct_RATcLcLDUcLcLSegmentor(void *p) { typedef ::RAT::DU::Segmentor current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_RATcLcLDUcLcLSegmentor(TBuffer &buf, void *obj) { ((::RAT::DU::Segmentor*)obj)->::RAT::DU::Segmentor::Streamer(buf); } } // end of namespace ROOT for class ::RAT::DU::Segmentor namespace RAT { namespace DU { //______________________________________________________________________________ void SOCReader::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DU::SOCReader. TObject::Streamer(R__b); } } // namespace RAT::DU } // namespace RAT::DU namespace ROOT { // Wrapper around operator delete static void delete_RATcLcLDUcLcLSOCReader(void *p) { delete (static_cast<::RAT::DU::SOCReader*>(p)); } static void deleteArray_RATcLcLDUcLcLSOCReader(void *p) { delete [] (static_cast<::RAT::DU::SOCReader*>(p)); } static void destruct_RATcLcLDUcLcLSOCReader(void *p) { typedef ::RAT::DU::SOCReader current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_RATcLcLDUcLcLSOCReader(TBuffer &buf, void *obj) { ((::RAT::DU::SOCReader*)obj)->::RAT::DU::SOCReader::Streamer(buf); } } // end of namespace ROOT for class ::RAT::DU::SOCReader namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDUcLcLReconCorrector(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::DU::ReconCorrector : new ::RAT::DU::ReconCorrector; } static void *newArray_RATcLcLDUcLcLReconCorrector(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::DU::ReconCorrector[nElements] : new ::RAT::DU::ReconCorrector[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDUcLcLReconCorrector(void *p) { delete (static_cast<::RAT::DU::ReconCorrector*>(p)); } static void deleteArray_RATcLcLDUcLcLReconCorrector(void *p) { delete [] (static_cast<::RAT::DU::ReconCorrector*>(p)); } static void destruct_RATcLcLDUcLcLReconCorrector(void *p) { typedef ::RAT::DU::ReconCorrector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DU::ReconCorrector namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDUcLcLReconCalibrator(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::DU::ReconCalibrator : new ::RAT::DU::ReconCalibrator; } static void *newArray_RATcLcLDUcLcLReconCalibrator(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::DU::ReconCalibrator[nElements] : new ::RAT::DU::ReconCalibrator[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDUcLcLReconCalibrator(void *p) { delete (static_cast<::RAT::DU::ReconCalibrator*>(p)); } static void deleteArray_RATcLcLDUcLcLReconCalibrator(void *p) { delete [] (static_cast<::RAT::DU::ReconCalibrator*>(p)); } static void destruct_RATcLcLDUcLcLReconCalibrator(void *p) { typedef ::RAT::DU::ReconCalibrator current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DU::ReconCalibrator namespace ROOT { // Wrappers around operator new static void *new_RATcLcLFitterPMT(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::FitterPMT : new ::RAT::FitterPMT; } static void *newArray_RATcLcLFitterPMT(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::FitterPMT[nElements] : new ::RAT::FitterPMT[nElements]; } // Wrapper around operator delete static void delete_RATcLcLFitterPMT(void *p) { delete (static_cast<::RAT::FitterPMT*>(p)); } static void deleteArray_RATcLcLFitterPMT(void *p) { delete [] (static_cast<::RAT::FitterPMT*>(p)); } static void destruct_RATcLcLFitterPMT(void *p) { typedef ::RAT::FitterPMT current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::FitterPMT namespace RAT { namespace DU { //______________________________________________________________________________ void TimeResidualCalculator::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DU::TimeResidualCalculator. TObject::Streamer(R__b); } } // namespace RAT::DU } // namespace RAT::DU namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDUcLcLTimeResidualCalculator(void *p) { return p ? new(p) ::RAT::DU::TimeResidualCalculator : new ::RAT::DU::TimeResidualCalculator; } static void *newArray_RATcLcLDUcLcLTimeResidualCalculator(Long_t nElements, void *p) { return p ? new(p) ::RAT::DU::TimeResidualCalculator[nElements] : new ::RAT::DU::TimeResidualCalculator[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDUcLcLTimeResidualCalculator(void *p) { delete (static_cast<::RAT::DU::TimeResidualCalculator*>(p)); } static void deleteArray_RATcLcLDUcLcLTimeResidualCalculator(void *p) { delete [] (static_cast<::RAT::DU::TimeResidualCalculator*>(p)); } static void destruct_RATcLcLDUcLcLTimeResidualCalculator(void *p) { typedef ::RAT::DU::TimeResidualCalculator current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_RATcLcLDUcLcLTimeResidualCalculator(TBuffer &buf, void *obj) { ((::RAT::DU::TimeResidualCalculator*)obj)->::RAT::DU::TimeResidualCalculator::Streamer(buf); } } // end of namespace ROOT for class ::RAT::DU::TimeResidualCalculator namespace RAT { namespace DU { //______________________________________________________________________________ void DetectorStateCorrection::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DU::DetectorStateCorrection. TObject::Streamer(R__b); } } // namespace RAT::DU } // namespace RAT::DU namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDUcLcLDetectorStateCorrection(void *p) { return p ? new(p) ::RAT::DU::DetectorStateCorrection : new ::RAT::DU::DetectorStateCorrection; } static void *newArray_RATcLcLDUcLcLDetectorStateCorrection(Long_t nElements, void *p) { return p ? new(p) ::RAT::DU::DetectorStateCorrection[nElements] : new ::RAT::DU::DetectorStateCorrection[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDUcLcLDetectorStateCorrection(void *p) { delete (static_cast<::RAT::DU::DetectorStateCorrection*>(p)); } static void deleteArray_RATcLcLDUcLcLDetectorStateCorrection(void *p) { delete [] (static_cast<::RAT::DU::DetectorStateCorrection*>(p)); } static void destruct_RATcLcLDUcLcLDetectorStateCorrection(void *p) { typedef ::RAT::DU::DetectorStateCorrection current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_RATcLcLDUcLcLDetectorStateCorrection(TBuffer &buf, void *obj) { ((::RAT::DU::DetectorStateCorrection*)obj)->::RAT::DU::DetectorStateCorrection::Streamer(buf); } } // end of namespace ROOT for class ::RAT::DU::DetectorStateCorrection namespace RAT { namespace DU { //______________________________________________________________________________ void Utility::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DU::Utility. TObject::Streamer(R__b); } } // namespace RAT::DU } // namespace RAT::DU namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDUcLcLUtility(void *p) { return p ? new(p) ::RAT::DU::Utility( (TRootIOCtor *)nullptr ) : new ::RAT::DU::Utility( (TRootIOCtor *)nullptr ); } // Wrapper around operator delete static void delete_RATcLcLDUcLcLUtility(void *p) { delete (static_cast<::RAT::DU::Utility*>(p)); } static void deleteArray_RATcLcLDUcLcLUtility(void *p) { delete [] (static_cast<::RAT::DU::Utility*>(p)); } static void destruct_RATcLcLDUcLcLUtility(void *p) { typedef ::RAT::DU::Utility current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_RATcLcLDUcLcLUtility(TBuffer &buf, void *obj) { ((::RAT::DU::Utility*)obj)->::RAT::DU::Utility::Streamer(buf); } } // end of namespace ROOT for class ::RAT::DU::Utility namespace RAT { //______________________________________________________________________________ void TrackNode::Streamer(TBuffer &R__b) { // Stream an object of class RAT::TrackNode. //This works around a msvc bug and should be harmless on other platforms typedef ::RAT::TrackNode thisClass; UInt_t R__s, R__c; if (R__b.IsReading()) { Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { } //This works around a msvc bug and should be harmless on other platforms typedef RAT::DS::MCTrackStep baseClass0; baseClass0::Streamer(R__b); { vector &R__stl = fChild; R__stl.clear(); TClass *R__tcl1 = TBuffer::GetClass(typeid(class RAT::TrackNode *)); if (R__tcl1==0) { Error("fChild streamer","Missing the TClass object for class RAT::TrackNode *!"); return; } int R__i, R__n; R__b >> R__n; R__stl.reserve(R__n); for (R__i = 0; R__i < R__n; R__i++) { RAT::TrackNode* R__t; R__t = (RAT::TrackNode*)R__b.ReadObjectAny(R__tcl1); R__stl.push_back(R__t); } } R__b >> fIsTrackStart; R__b >> fTrackID; R__b >> fStepID; R__b >> fPDGCode; { TString R__str; R__str.Streamer(R__b); fParticleName = R__str.Data(); } R__b >> fPrev; R__b >> fNext; R__b.CheckByteCount(R__s, R__c, thisClass::IsA()); } else { R__c = R__b.WriteVersion(thisClass::IsA(), kTRUE); //This works around a msvc bug and should be harmless on other platforms typedef RAT::DS::MCTrackStep baseClass0; baseClass0::Streamer(R__b); { vector &R__stl = fChild; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } R__b << fIsTrackStart; R__b << fTrackID; R__b << fStepID; R__b << fPDGCode; { TString R__str = fParticleName.c_str(); R__str.Streamer(R__b);} R__b << fPrev; R__b << fNext; R__b.SetByteCount(R__c, kTRUE); } } } // namespace RAT namespace ROOT { // Wrappers around operator new static void *new_RATcLcLTrackNode(void *p) { return p ? new(p) ::RAT::TrackNode : new ::RAT::TrackNode; } static void *newArray_RATcLcLTrackNode(Long_t nElements, void *p) { return p ? new(p) ::RAT::TrackNode[nElements] : new ::RAT::TrackNode[nElements]; } // Wrapper around operator delete static void delete_RATcLcLTrackNode(void *p) { delete (static_cast<::RAT::TrackNode*>(p)); } static void deleteArray_RATcLcLTrackNode(void *p) { delete [] (static_cast<::RAT::TrackNode*>(p)); } static void destruct_RATcLcLTrackNode(void *p) { typedef ::RAT::TrackNode current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_RATcLcLTrackNode(TBuffer &buf, void *obj) { ((::RAT::TrackNode*)obj)->::RAT::TrackNode::Streamer(buf); } } // end of namespace ROOT for class ::RAT::TrackNode namespace ROOT { // Wrapper around operator delete static void delete_RATcLcLTrackCursor(void *p) { delete (static_cast<::RAT::TrackCursor*>(p)); } static void deleteArray_RATcLcLTrackCursor(void *p) { delete [] (static_cast<::RAT::TrackCursor*>(p)); } static void destruct_RATcLcLTrackCursor(void *p) { typedef ::RAT::TrackCursor current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::TrackCursor namespace ROOT { // Wrapper around operator delete static void delete_RATcLcLTrackNav(void *p) { delete (static_cast<::RAT::TrackNav*>(p)); } static void deleteArray_RATcLcLTrackNav(void *p) { delete [] (static_cast<::RAT::TrackNav*>(p)); } static void destruct_RATcLcLTrackNav(void *p) { typedef ::RAT::TrackNav current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::TrackNav namespace ROOT { // Wrappers around operator new static void *new_RATcLcLPgSQLBackend(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::PgSQLBackend : new ::RAT::PgSQLBackend; } static void *newArray_RATcLcLPgSQLBackend(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::PgSQLBackend[nElements] : new ::RAT::PgSQLBackend[nElements]; } // Wrapper around operator delete static void delete_RATcLcLPgSQLBackend(void *p) { delete (static_cast<::RAT::PgSQLBackend*>(p)); } static void deleteArray_RATcLcLPgSQLBackend(void *p) { delete [] (static_cast<::RAT::PgSQLBackend*>(p)); } static void destruct_RATcLcLPgSQLBackend(void *p) { typedef ::RAT::PgSQLBackend current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::PgSQLBackend namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDBCommandLoader(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::DBCommandLoader : new ::RAT::DBCommandLoader; } static void *newArray_RATcLcLDBCommandLoader(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::DBCommandLoader[nElements] : new ::RAT::DBCommandLoader[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDBCommandLoader(void *p) { delete (static_cast<::RAT::DBCommandLoader*>(p)); } static void deleteArray_RATcLcLDBCommandLoader(void *p) { delete [] (static_cast<::RAT::DBCommandLoader*>(p)); } static void destruct_RATcLcLDBCommandLoader(void *p) { typedef ::RAT::DBCommandLoader current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DBCommandLoader namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDBTextLoader(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::DBTextLoader : new ::RAT::DBTextLoader; } static void *newArray_RATcLcLDBTextLoader(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::DBTextLoader[nElements] : new ::RAT::DBTextLoader[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDBTextLoader(void *p) { delete (static_cast<::RAT::DBTextLoader*>(p)); } static void deleteArray_RATcLcLDBTextLoader(void *p) { delete [] (static_cast<::RAT::DBTextLoader*>(p)); } static void destruct_RATcLcLDBTextLoader(void *p) { typedef ::RAT::DBTextLoader current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DBTextLoader namespace ROOT { // Wrappers around operator new static void *new_RATcLcLDBJsonLoader(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::DBJsonLoader : new ::RAT::DBJsonLoader; } static void *newArray_RATcLcLDBJsonLoader(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::DBJsonLoader[nElements] : new ::RAT::DBJsonLoader[nElements]; } // Wrapper around operator delete static void delete_RATcLcLDBJsonLoader(void *p) { delete (static_cast<::RAT::DBJsonLoader*>(p)); } static void deleteArray_RATcLcLDBJsonLoader(void *p) { delete [] (static_cast<::RAT::DBJsonLoader*>(p)); } static void destruct_RATcLcLDBJsonLoader(void *p) { typedef ::RAT::DBJsonLoader current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DBJsonLoader namespace ROOT { // Wrappers around operator new static void *new_RATcLcLHTTPDownloader(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::HTTPDownloader : new ::RAT::HTTPDownloader; } static void *newArray_RATcLcLHTTPDownloader(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::HTTPDownloader[nElements] : new ::RAT::HTTPDownloader[nElements]; } // Wrapper around operator delete static void delete_RATcLcLHTTPDownloader(void *p) { delete (static_cast<::RAT::HTTPDownloader*>(p)); } static void deleteArray_RATcLcLHTTPDownloader(void *p) { delete [] (static_cast<::RAT::HTTPDownloader*>(p)); } static void destruct_RATcLcLHTTPDownloader(void *p) { typedef ::RAT::HTTPDownloader current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::HTTPDownloader namespace ROOT { // Wrappers around operator new static void *new_RATcLcLMetaInformation(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::MetaInformation( (TRootIOCtor *)nullptr ) : new ::RAT::MetaInformation( (TRootIOCtor *)nullptr ); } // Wrapper around operator delete static void delete_RATcLcLMetaInformation(void *p) { delete (static_cast<::RAT::MetaInformation*>(p)); } static void deleteArray_RATcLcLMetaInformation(void *p) { delete [] (static_cast<::RAT::MetaInformation*>(p)); } static void destruct_RATcLcLMetaInformation(void *p) { typedef ::RAT::MetaInformation current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::MetaInformation namespace ROOT { // Wrappers around operator new static void *new_ratzdabcLcLunknown_record_error(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ratzdab::unknown_record_error : new ::ratzdab::unknown_record_error; } static void *newArray_ratzdabcLcLunknown_record_error(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ratzdab::unknown_record_error[nElements] : new ::ratzdab::unknown_record_error[nElements]; } // Wrapper around operator delete static void delete_ratzdabcLcLunknown_record_error(void *p) { delete (static_cast<::ratzdab::unknown_record_error*>(p)); } static void deleteArray_ratzdabcLcLunknown_record_error(void *p) { delete [] (static_cast<::ratzdab::unknown_record_error*>(p)); } static void destruct_ratzdabcLcLunknown_record_error(void *p) { typedef ::ratzdab::unknown_record_error current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::ratzdab::unknown_record_error namespace ROOT { // Wrapper around operator delete static void delete_ratzdabcLcLzdabfile(void *p) { delete (static_cast<::ratzdab::zdabfile*>(p)); } static void deleteArray_ratzdabcLcLzdabfile(void *p) { delete [] (static_cast<::ratzdab::zdabfile*>(p)); } static void destruct_ratzdabcLcLzdabfile(void *p) { typedef ::ratzdab::zdabfile current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::ratzdab::zdabfile namespace ROOT { // Wrappers around operator new static void *new_ratzdabcLcLzdabfilecLcLzdab_file_read_error(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ratzdab::zdabfile::zdab_file_read_error : new ::ratzdab::zdabfile::zdab_file_read_error; } static void *newArray_ratzdabcLcLzdabfilecLcLzdab_file_read_error(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ratzdab::zdabfile::zdab_file_read_error[nElements] : new ::ratzdab::zdabfile::zdab_file_read_error[nElements]; } // Wrapper around operator delete static void delete_ratzdabcLcLzdabfilecLcLzdab_file_read_error(void *p) { delete (static_cast<::ratzdab::zdabfile::zdab_file_read_error*>(p)); } static void deleteArray_ratzdabcLcLzdabfilecLcLzdab_file_read_error(void *p) { delete [] (static_cast<::ratzdab::zdabfile::zdab_file_read_error*>(p)); } static void destruct_ratzdabcLcLzdabfilecLcLzdab_file_read_error(void *p) { typedef ::ratzdab::zdabfile::zdab_file_read_error current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::ratzdab::zdabfile::zdab_file_read_error namespace ROOT { // Wrappers around operator new static void *new_RunRecord(void *p) { return p ? new(p) ::RunRecord : new ::RunRecord; } static void *newArray_RunRecord(Long_t nElements, void *p) { return p ? new(p) ::RunRecord[nElements] : new ::RunRecord[nElements]; } // Wrapper around operator delete static void delete_RunRecord(void *p) { delete (static_cast<::RunRecord*>(p)); } static void deleteArray_RunRecord(void *p) { delete [] (static_cast<::RunRecord*>(p)); } static void destruct_RunRecord(void *p) { typedef ::RunRecord current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RunRecord namespace ROOT { // Wrappers around operator new static void *new_TriggerInfo(void *p) { return p ? new(p) ::TriggerInfo : new ::TriggerInfo; } static void *newArray_TriggerInfo(Long_t nElements, void *p) { return p ? new(p) ::TriggerInfo[nElements] : new ::TriggerInfo[nElements]; } // Wrapper around operator delete static void delete_TriggerInfo(void *p) { delete (static_cast<::TriggerInfo*>(p)); } static void deleteArray_TriggerInfo(void *p) { delete [] (static_cast<::TriggerInfo*>(p)); } static void destruct_TriggerInfo(void *p) { typedef ::TriggerInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::TriggerInfo namespace ROOT { // Wrappers around operator new static void *new_EpedRecord(void *p) { return p ? new(p) ::EpedRecord : new ::EpedRecord; } static void *newArray_EpedRecord(Long_t nElements, void *p) { return p ? new(p) ::EpedRecord[nElements] : new ::EpedRecord[nElements]; } // Wrapper around operator delete static void delete_EpedRecord(void *p) { delete (static_cast<::EpedRecord*>(p)); } static void deleteArray_EpedRecord(void *p) { delete [] (static_cast<::EpedRecord*>(p)); } static void destruct_EpedRecord(void *p) { typedef ::EpedRecord current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::EpedRecord namespace ROOT { // Wrappers around operator new static void *new_ManipRopeStatus(void *p) { return p ? new(p) ::ManipRopeStatus : new ::ManipRopeStatus; } static void *newArray_ManipRopeStatus(Long_t nElements, void *p) { return p ? new(p) ::ManipRopeStatus[nElements] : new ::ManipRopeStatus[nElements]; } // Wrapper around operator delete static void delete_ManipRopeStatus(void *p) { delete (static_cast<::ManipRopeStatus*>(p)); } static void deleteArray_ManipRopeStatus(void *p) { delete [] (static_cast<::ManipRopeStatus*>(p)); } static void destruct_ManipRopeStatus(void *p) { typedef ::ManipRopeStatus current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::ManipRopeStatus namespace ROOT { // Wrappers around operator new static void *new_MTCReadoutData(void *p) { return p ? new(p) ::MTCReadoutData : new ::MTCReadoutData; } static void *newArray_MTCReadoutData(Long_t nElements, void *p) { return p ? new(p) ::MTCReadoutData[nElements] : new ::MTCReadoutData[nElements]; } // Wrapper around operator delete static void delete_MTCReadoutData(void *p) { delete (static_cast<::MTCReadoutData*>(p)); } static void deleteArray_MTCReadoutData(void *p) { delete [] (static_cast<::MTCReadoutData*>(p)); } static void destruct_MTCReadoutData(void *p) { typedef ::MTCReadoutData current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::MTCReadoutData namespace ROOT { // Wrappers around operator new static void *new_PmtEventRecord(void *p) { return p ? new(p) ::PmtEventRecord : new ::PmtEventRecord; } static void *newArray_PmtEventRecord(Long_t nElements, void *p) { return p ? new(p) ::PmtEventRecord[nElements] : new ::PmtEventRecord[nElements]; } // Wrapper around operator delete static void delete_PmtEventRecord(void *p) { delete (static_cast<::PmtEventRecord*>(p)); } static void deleteArray_PmtEventRecord(void *p) { delete [] (static_cast<::PmtEventRecord*>(p)); } static void destruct_PmtEventRecord(void *p) { typedef ::PmtEventRecord current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::PmtEventRecord namespace ROOT { // Wrappers around operator new static void *new_PZdabFile(void *p) { return p ? new(p) ::PZdabFile : new ::PZdabFile; } static void *newArray_PZdabFile(Long_t nElements, void *p) { return p ? new(p) ::PZdabFile[nElements] : new ::PZdabFile[nElements]; } // Wrapper around operator delete static void delete_PZdabFile(void *p) { delete (static_cast<::PZdabFile*>(p)); } static void deleteArray_PZdabFile(void *p) { delete [] (static_cast<::PZdabFile*>(p)); } static void destruct_PZdabFile(void *p) { typedef ::PZdabFile current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::PZdabFile namespace RAT { namespace DU { //______________________________________________________________________________ void EnergySystematics::Streamer(TBuffer &R__b) { // Stream an object of class RAT::DU::EnergySystematics. if (R__b.IsReading()) { R__b.ReadClassBuffer(RAT::DU::EnergySystematics::Class(),this); } else { R__b.WriteClassBuffer(RAT::DU::EnergySystematics::Class(),this); } } } // namespace RAT::DU } // namespace RAT::DU namespace ROOT { // Wrapper around operator delete static void delete_RATcLcLDUcLcLEnergySystematics(void *p) { delete (static_cast<::RAT::DU::EnergySystematics*>(p)); } static void deleteArray_RATcLcLDUcLcLEnergySystematics(void *p) { delete [] (static_cast<::RAT::DU::EnergySystematics*>(p)); } static void destruct_RATcLcLDUcLcLEnergySystematics(void *p) { typedef ::RAT::DU::EnergySystematics current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::DU::EnergySystematics namespace ROOT { // Wrappers around operator new static void *new_RATcLcLLPcLcLLightPath(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::LP::LightPath : new ::RAT::LP::LightPath; } static void *newArray_RATcLcLLPcLcLLightPath(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::LP::LightPath[nElements] : new ::RAT::LP::LightPath[nElements]; } // Wrapper around operator delete static void delete_RATcLcLLPcLcLLightPath(void *p) { delete (static_cast<::RAT::LP::LightPath*>(p)); } static void deleteArray_RATcLcLLPcLcLLightPath(void *p) { delete [] (static_cast<::RAT::LP::LightPath*>(p)); } static void destruct_RATcLcLLPcLcLLightPath(void *p) { typedef ::RAT::LP::LightPath current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::LP::LightPath namespace ROOT { // Wrapper around operator delete static void delete_RATcLcLLPcLcLLightPathFitter(void *p) { delete (static_cast<::RAT::LP::LightPathFitter*>(p)); } static void deleteArray_RATcLcLLPcLcLLightPathFitter(void *p) { delete [] (static_cast<::RAT::LP::LightPathFitter*>(p)); } static void destruct_RATcLcLLPcLcLLightPathFitter(void *p) { typedef ::RAT::LP::LightPathFitter current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::LP::LightPathFitter namespace ROOT { // Wrappers around operator new static void *new_RATcLcLLPcLcLLightPathStraightFitter(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::LP::LightPathStraightFitter : new ::RAT::LP::LightPathStraightFitter; } static void *newArray_RATcLcLLPcLcLLightPathStraightFitter(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::LP::LightPathStraightFitter[nElements] : new ::RAT::LP::LightPathStraightFitter[nElements]; } // Wrapper around operator delete static void delete_RATcLcLLPcLcLLightPathStraightFitter(void *p) { delete (static_cast<::RAT::LP::LightPathStraightFitter*>(p)); } static void deleteArray_RATcLcLLPcLcLLightPathStraightFitter(void *p) { delete [] (static_cast<::RAT::LP::LightPathStraightFitter*>(p)); } static void destruct_RATcLcLLPcLcLLightPathStraightFitter(void *p) { typedef ::RAT::LP::LightPathStraightFitter current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::LP::LightPathStraightFitter namespace ROOT { // Wrappers around operator new static void *new_RATcLcLLPcLcLLightPathStraightScint(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::LP::LightPathStraightScint : new ::RAT::LP::LightPathStraightScint; } static void *newArray_RATcLcLLPcLcLLightPathStraightScint(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::LP::LightPathStraightScint[nElements] : new ::RAT::LP::LightPathStraightScint[nElements]; } // Wrapper around operator delete static void delete_RATcLcLLPcLcLLightPathStraightScint(void *p) { delete (static_cast<::RAT::LP::LightPathStraightScint*>(p)); } static void deleteArray_RATcLcLLPcLcLLightPathStraightScint(void *p) { delete [] (static_cast<::RAT::LP::LightPathStraightScint*>(p)); } static void destruct_RATcLcLLPcLcLLightPathStraightScint(void *p) { typedef ::RAT::LP::LightPathStraightScint current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::LP::LightPathStraightScint namespace ROOT { // Wrappers around operator new static void *new_RATcLcLLPcLcLLightPathStraightScintWater(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::LP::LightPathStraightScintWater : new ::RAT::LP::LightPathStraightScintWater; } static void *newArray_RATcLcLLPcLcLLightPathStraightScintWater(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::RAT::LP::LightPathStraightScintWater[nElements] : new ::RAT::LP::LightPathStraightScintWater[nElements]; } // Wrapper around operator delete static void delete_RATcLcLLPcLcLLightPathStraightScintWater(void *p) { delete (static_cast<::RAT::LP::LightPathStraightScintWater*>(p)); } static void deleteArray_RATcLcLLPcLcLLightPathStraightScintWater(void *p) { delete [] (static_cast<::RAT::LP::LightPathStraightScintWater*>(p)); } static void destruct_RATcLcLLPcLcLLightPathStraightScintWater(void *p) { typedef ::RAT::LP::LightPathStraightScintWater current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RAT::LP::LightPathStraightScintWater namespace ROOT { static TClass *vectorlEunsignedsPshortgR_Dictionary(); static void vectorlEunsignedsPshortgR_TClassManip(TClass*); static void *new_vectorlEunsignedsPshortgR(void *p = nullptr); static void *newArray_vectorlEunsignedsPshortgR(Long_t size, void *p); static void delete_vectorlEunsignedsPshortgR(void *p); static void deleteArray_vectorlEunsignedsPshortgR(void *p); static void destruct_vectorlEunsignedsPshortgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEunsignedsPshortgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEunsignedsPshortgR); instance.SetNewArray(&newArray_vectorlEunsignedsPshortgR); instance.SetDelete(&delete_vectorlEunsignedsPshortgR); instance.SetDeleteArray(&deleteArray_vectorlEunsignedsPshortgR); instance.SetDestructor(&destruct_vectorlEunsignedsPshortgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEunsignedsPshortgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlEunsignedsPshortgR_TClassManip(theClass); return theClass; } static void vectorlEunsignedsPshortgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEunsignedsPshortgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlEunsignedsPshortgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEunsignedsPshortgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEunsignedsPshortgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEunsignedsPshortgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEunsignedsPintgR_Dictionary(); static void vectorlEunsignedsPintgR_TClassManip(TClass*); static void *new_vectorlEunsignedsPintgR(void *p = nullptr); static void *newArray_vectorlEunsignedsPintgR(Long_t size, void *p); static void delete_vectorlEunsignedsPintgR(void *p); static void deleteArray_vectorlEunsignedsPintgR(void *p); static void destruct_vectorlEunsignedsPintgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEunsignedsPintgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEunsignedsPintgR); instance.SetNewArray(&newArray_vectorlEunsignedsPintgR); instance.SetDelete(&delete_vectorlEunsignedsPintgR); instance.SetDeleteArray(&deleteArray_vectorlEunsignedsPintgR); instance.SetDestructor(&destruct_vectorlEunsignedsPintgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEunsignedsPintgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlEunsignedsPintgR_TClassManip(theClass); return theClass; } static void vectorlEunsignedsPintgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEunsignedsPintgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlEunsignedsPintgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEunsignedsPintgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEunsignedsPintgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEunsignedsPintgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEstringgR_Dictionary(); static void vectorlEstringgR_TClassManip(TClass*); static void *new_vectorlEstringgR(void *p = nullptr); static void *newArray_vectorlEstringgR(Long_t size, void *p); static void delete_vectorlEstringgR(void *p); static void deleteArray_vectorlEstringgR(void *p); static void destruct_vectorlEstringgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEstringgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEstringgR); instance.SetNewArray(&newArray_vectorlEstringgR); instance.SetDelete(&delete_vectorlEstringgR); instance.SetDeleteArray(&deleteArray_vectorlEstringgR); instance.SetDestructor(&destruct_vectorlEstringgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::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(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEstringgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlEstringgR_TClassManip(theClass); return theClass; } static void vectorlEstringgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEstringgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlEstringgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEstringgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEstringgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEstringgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEpairlEstringcOstringgRsPgR_Dictionary(); static void vectorlEpairlEstringcOstringgRsPgR_TClassManip(TClass*); static void *new_vectorlEpairlEstringcOstringgRsPgR(void *p = nullptr); static void *newArray_vectorlEpairlEstringcOstringgRsPgR(Long_t size, void *p); static void delete_vectorlEpairlEstringcOstringgRsPgR(void *p); static void deleteArray_vectorlEpairlEstringcOstringgRsPgR(void *p); static void destruct_vectorlEpairlEstringcOstringgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector >*) { vector > *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector >)); static ::ROOT::TGenericClassInfo instance("vector >", -2, "vector", 423, typeid(vector >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEpairlEstringcOstringgRsPgR_Dictionary, isa_proxy, 0, sizeof(vector >) ); instance.SetNew(&new_vectorlEpairlEstringcOstringgRsPgR); instance.SetNewArray(&newArray_vectorlEpairlEstringcOstringgRsPgR); instance.SetDelete(&delete_vectorlEpairlEstringcOstringgRsPgR); instance.SetDeleteArray(&deleteArray_vectorlEpairlEstringcOstringgRsPgR); instance.SetDestructor(&destruct_vectorlEpairlEstringcOstringgRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector > >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector >","std::vector, std::allocator >, std::__cxx11::basic_string, std::allocator > >, std::allocator, std::allocator >, std::__cxx11::basic_string, std::allocator > > > >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEpairlEstringcOstringgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast >*>(nullptr))->GetClass(); vectorlEpairlEstringcOstringgRsPgR_TClassManip(theClass); return theClass; } static void vectorlEpairlEstringcOstringgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEpairlEstringcOstringgRsPgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector > : new vector >; } static void *newArray_vectorlEpairlEstringcOstringgRsPgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector >[nElements] : new vector >[nElements]; } // Wrapper around operator delete static void delete_vectorlEpairlEstringcOstringgRsPgR(void *p) { delete (static_cast >*>(p)); } static void deleteArray_vectorlEpairlEstringcOstringgRsPgR(void *p) { delete [] (static_cast >*>(p)); } static void destruct_vectorlEpairlEstringcOstringgRsPgR(void *p) { typedef vector > current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector > namespace ROOT { static TClass *vectorlEintgR_Dictionary(); static void vectorlEintgR_TClassManip(TClass*); static void *new_vectorlEintgR(void *p = nullptr); static void *newArray_vectorlEintgR(Long_t size, void *p); static void delete_vectorlEintgR(void *p); static void deleteArray_vectorlEintgR(void *p); static void destruct_vectorlEintgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEintgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEintgR); instance.SetNewArray(&newArray_vectorlEintgR); instance.SetDelete(&delete_vectorlEintgR); instance.SetDeleteArray(&deleteArray_vectorlEintgR); instance.SetDestructor(&destruct_vectorlEintgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEintgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlEintgR_TClassManip(theClass); return theClass; } static void vectorlEintgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEintgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlEintgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEintgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEintgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEintgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEfloatgR_Dictionary(); static void vectorlEfloatgR_TClassManip(TClass*); static void *new_vectorlEfloatgR(void *p = nullptr); static void *newArray_vectorlEfloatgR(Long_t size, void *p); static void delete_vectorlEfloatgR(void *p); static void deleteArray_vectorlEfloatgR(void *p); static void destruct_vectorlEfloatgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEfloatgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEfloatgR); instance.SetNewArray(&newArray_vectorlEfloatgR); instance.SetDelete(&delete_vectorlEfloatgR); instance.SetDeleteArray(&deleteArray_vectorlEfloatgR); instance.SetDestructor(&destruct_vectorlEfloatgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEfloatgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlEfloatgR_TClassManip(theClass); return theClass; } static void vectorlEfloatgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEfloatgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlEfloatgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEfloatgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEfloatgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEfloatgR(void *p) { typedef vector current_t; (static_cast(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 = nullptr); 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 = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, 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 >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEdoublegR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->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(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEdoublegR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEdoublegR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEdoublegR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEULong64_tgR_Dictionary(); static void vectorlEULong64_tgR_TClassManip(TClass*); static void *new_vectorlEULong64_tgR(void *p = nullptr); static void *newArray_vectorlEULong64_tgR(Long_t size, void *p); static void delete_vectorlEULong64_tgR(void *p); static void deleteArray_vectorlEULong64_tgR(void *p); static void destruct_vectorlEULong64_tgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEULong64_tgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEULong64_tgR); instance.SetNewArray(&newArray_vectorlEULong64_tgR); instance.SetDelete(&delete_vectorlEULong64_tgR); instance.SetDeleteArray(&deleteArray_vectorlEULong64_tgR); instance.SetDestructor(&destruct_vectorlEULong64_tgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEULong64_tgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlEULong64_tgR_TClassManip(theClass); return theClass; } static void vectorlEULong64_tgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEULong64_tgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlEULong64_tgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEULong64_tgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEULong64_tgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEULong64_tgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlETVector3gR_Dictionary(); static void vectorlETVector3gR_TClassManip(TClass*); static void *new_vectorlETVector3gR(void *p = nullptr); static void *newArray_vectorlETVector3gR(Long_t size, void *p); static void delete_vectorlETVector3gR(void *p); static void deleteArray_vectorlETVector3gR(void *p); static void destruct_vectorlETVector3gR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlETVector3gR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlETVector3gR); instance.SetNewArray(&newArray_vectorlETVector3gR); instance.SetDelete(&delete_vectorlETVector3gR); instance.SetDeleteArray(&deleteArray_vectorlETVector3gR); instance.SetDestructor(&destruct_vectorlETVector3gR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlETVector3gR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlETVector3gR_TClassManip(theClass); return theClass; } static void vectorlETVector3gR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlETVector3gR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlETVector3gR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlETVector3gR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlETVector3gR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlETVector3gR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLTrackNodegR_Dictionary(); static void vectorlERATcLcLTrackNodegR_TClassManip(TClass*); static void *new_vectorlERATcLcLTrackNodegR(void *p = nullptr); static void *newArray_vectorlERATcLcLTrackNodegR(Long_t size, void *p); static void delete_vectorlERATcLcLTrackNodegR(void *p); static void deleteArray_vectorlERATcLcLTrackNodegR(void *p); static void destruct_vectorlERATcLcLTrackNodegR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLTrackNodegR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLTrackNodegR); instance.SetNewArray(&newArray_vectorlERATcLcLTrackNodegR); instance.SetDelete(&delete_vectorlERATcLcLTrackNodegR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLTrackNodegR); instance.SetDestructor(&destruct_vectorlERATcLcLTrackNodegR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLTrackNodegR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLTrackNodegR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLTrackNodegR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLTrackNodegR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLTrackNodegR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLTrackNodegR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLTrackNodegR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLTrackNodegR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLTrackNodemUgR_Dictionary(); static void vectorlERATcLcLTrackNodemUgR_TClassManip(TClass*); static void *new_vectorlERATcLcLTrackNodemUgR(void *p = nullptr); static void *newArray_vectorlERATcLcLTrackNodemUgR(Long_t size, void *p); static void delete_vectorlERATcLcLTrackNodemUgR(void *p); static void deleteArray_vectorlERATcLcLTrackNodemUgR(void *p); static void destruct_vectorlERATcLcLTrackNodemUgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLTrackNodemUgR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLTrackNodemUgR); instance.SetNewArray(&newArray_vectorlERATcLcLTrackNodemUgR); instance.SetDelete(&delete_vectorlERATcLcLTrackNodemUgR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLTrackNodemUgR); instance.SetDestructor(&destruct_vectorlERATcLcLTrackNodemUgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLTrackNodemUgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLTrackNodemUgR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLTrackNodemUgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLTrackNodemUgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLTrackNodemUgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLTrackNodemUgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLTrackNodemUgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLTrackNodemUgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR_Dictionary(); static void vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR_TClassManip(TClass*); static void *new_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR(void *p = nullptr); static void *newArray_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR(Long_t size, void *p); static void delete_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR(void *p); static void deleteArray_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR(void *p); static void destruct_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR); instance.SetNewArray(&newArray_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR); instance.SetDelete(&delete_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR); instance.SetDestructor(&destruct_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLDUcLcLPoint3DgR_Dictionary(); static void vectorlERATcLcLDUcLcLPoint3DgR_TClassManip(TClass*); static void *new_vectorlERATcLcLDUcLcLPoint3DgR(void *p = nullptr); static void *newArray_vectorlERATcLcLDUcLcLPoint3DgR(Long_t size, void *p); static void delete_vectorlERATcLcLDUcLcLPoint3DgR(void *p); static void deleteArray_vectorlERATcLcLDUcLcLPoint3DgR(void *p); static void destruct_vectorlERATcLcLDUcLcLPoint3DgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDUcLcLPoint3DgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLDUcLcLPoint3DgR); instance.SetNewArray(&newArray_vectorlERATcLcLDUcLcLPoint3DgR); instance.SetDelete(&delete_vectorlERATcLcLDUcLcLPoint3DgR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDUcLcLPoint3DgR); instance.SetDestructor(&destruct_vectorlERATcLcLDUcLcLPoint3DgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDUcLcLPoint3DgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLDUcLcLPoint3DgR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDUcLcLPoint3DgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDUcLcLPoint3DgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLDUcLcLPoint3DgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDUcLcLPoint3DgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLDUcLcLPoint3DgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLDUcLcLPoint3DgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLDScLcLTrigHeadergR_Dictionary(); static void vectorlERATcLcLDScLcLTrigHeadergR_TClassManip(TClass*); static void *new_vectorlERATcLcLDScLcLTrigHeadergR(void *p = nullptr); static void *newArray_vectorlERATcLcLDScLcLTrigHeadergR(Long_t size, void *p); static void delete_vectorlERATcLcLDScLcLTrigHeadergR(void *p); static void deleteArray_vectorlERATcLcLDScLcLTrigHeadergR(void *p); static void destruct_vectorlERATcLcLDScLcLTrigHeadergR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDScLcLTrigHeadergR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLDScLcLTrigHeadergR); instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLTrigHeadergR); instance.SetDelete(&delete_vectorlERATcLcLDScLcLTrigHeadergR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLTrigHeadergR); instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLTrigHeadergR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDScLcLTrigHeadergR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLDScLcLTrigHeadergR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDScLcLTrigHeadergR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDScLcLTrigHeadergR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLDScLcLTrigHeadergR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDScLcLTrigHeadergR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLDScLcLTrigHeadergR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLDScLcLTrigHeadergR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLDScLcLPMTCalgR_Dictionary(); static void vectorlERATcLcLDScLcLPMTCalgR_TClassManip(TClass*); static void *new_vectorlERATcLcLDScLcLPMTCalgR(void *p = nullptr); static void *newArray_vectorlERATcLcLDScLcLPMTCalgR(Long_t size, void *p); static void delete_vectorlERATcLcLDScLcLPMTCalgR(void *p); static void deleteArray_vectorlERATcLcLDScLcLPMTCalgR(void *p); static void destruct_vectorlERATcLcLDScLcLPMTCalgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDScLcLPMTCalgR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLDScLcLPMTCalgR); instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLPMTCalgR); instance.SetDelete(&delete_vectorlERATcLcLDScLcLPMTCalgR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLPMTCalgR); instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLPMTCalgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDScLcLPMTCalgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLDScLcLPMTCalgR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDScLcLPMTCalgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDScLcLPMTCalgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLDScLcLPMTCalgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDScLcLPMTCalgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLDScLcLPMTCalgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLDScLcLPMTCalgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_Dictionary(); static void vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_TClassManip(TClass*); static void *new_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p = nullptr); static void *newArray_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(Long_t size, void *p); static void delete_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p); static void deleteArray_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p); static void destruct_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector >*) { vector > *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector >)); static ::ROOT::TGenericClassInfo instance("vector >", -2, "vector", 423, typeid(vector >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_Dictionary, isa_proxy, 0, sizeof(vector >) ); instance.SetNew(&new_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR); instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR); instance.SetDelete(&delete_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR); instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector > >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector >","std::vector, std::allocator > >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast >*>(nullptr))->GetClass(); vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector > : new vector >; } static void *newArray_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector >[nElements] : new vector >[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p) { delete (static_cast >*>(p)); } static void deleteArray_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p) { delete [] (static_cast >*>(p)); } static void destruct_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p) { typedef vector > current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector > namespace ROOT { static TClass *vectorlERATcLcLDScLcLMetaDBgR_Dictionary(); static void vectorlERATcLcLDScLcLMetaDBgR_TClassManip(TClass*); static void *new_vectorlERATcLcLDScLcLMetaDBgR(void *p = nullptr); static void *newArray_vectorlERATcLcLDScLcLMetaDBgR(Long_t size, void *p); static void delete_vectorlERATcLcLDScLcLMetaDBgR(void *p); static void deleteArray_vectorlERATcLcLDScLcLMetaDBgR(void *p); static void destruct_vectorlERATcLcLDScLcLMetaDBgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDScLcLMetaDBgR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLDScLcLMetaDBgR); instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLMetaDBgR); instance.SetDelete(&delete_vectorlERATcLcLDScLcLMetaDBgR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLMetaDBgR); instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLMetaDBgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDScLcLMetaDBgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLDScLcLMetaDBgR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDScLcLMetaDBgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDScLcLMetaDBgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLDScLcLMetaDBgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDScLcLMetaDBgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLDScLcLMetaDBgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLDScLcLMetaDBgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLDScLcLMCTrackStepgR_Dictionary(); static void vectorlERATcLcLDScLcLMCTrackStepgR_TClassManip(TClass*); static void *new_vectorlERATcLcLDScLcLMCTrackStepgR(void *p = nullptr); static void *newArray_vectorlERATcLcLDScLcLMCTrackStepgR(Long_t size, void *p); static void delete_vectorlERATcLcLDScLcLMCTrackStepgR(void *p); static void deleteArray_vectorlERATcLcLDScLcLMCTrackStepgR(void *p); static void destruct_vectorlERATcLcLDScLcLMCTrackStepgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDScLcLMCTrackStepgR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLDScLcLMCTrackStepgR); instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLMCTrackStepgR); instance.SetDelete(&delete_vectorlERATcLcLDScLcLMCTrackStepgR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLMCTrackStepgR); instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLMCTrackStepgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDScLcLMCTrackStepgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLDScLcLMCTrackStepgR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDScLcLMCTrackStepgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDScLcLMCTrackStepgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLDScLcLMCTrackStepgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDScLcLMCTrackStepgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLDScLcLMCTrackStepgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLDScLcLMCTrackStepgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLDScLcLMCTrackgR_Dictionary(); static void vectorlERATcLcLDScLcLMCTrackgR_TClassManip(TClass*); static void *new_vectorlERATcLcLDScLcLMCTrackgR(void *p = nullptr); static void *newArray_vectorlERATcLcLDScLcLMCTrackgR(Long_t size, void *p); static void delete_vectorlERATcLcLDScLcLMCTrackgR(void *p); static void deleteArray_vectorlERATcLcLDScLcLMCTrackgR(void *p); static void destruct_vectorlERATcLcLDScLcLMCTrackgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDScLcLMCTrackgR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLDScLcLMCTrackgR); instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLMCTrackgR); instance.SetDelete(&delete_vectorlERATcLcLDScLcLMCTrackgR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLMCTrackgR); instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLMCTrackgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDScLcLMCTrackgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLDScLcLMCTrackgR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDScLcLMCTrackgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDScLcLMCTrackgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLDScLcLMCTrackgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDScLcLMCTrackgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLDScLcLMCTrackgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLDScLcLMCTrackgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLDScLcLMCPhotongR_Dictionary(); static void vectorlERATcLcLDScLcLMCPhotongR_TClassManip(TClass*); static void *new_vectorlERATcLcLDScLcLMCPhotongR(void *p = nullptr); static void *newArray_vectorlERATcLcLDScLcLMCPhotongR(Long_t size, void *p); static void delete_vectorlERATcLcLDScLcLMCPhotongR(void *p); static void deleteArray_vectorlERATcLcLDScLcLMCPhotongR(void *p); static void destruct_vectorlERATcLcLDScLcLMCPhotongR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDScLcLMCPhotongR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLDScLcLMCPhotongR); instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLMCPhotongR); instance.SetDelete(&delete_vectorlERATcLcLDScLcLMCPhotongR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLMCPhotongR); instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLMCPhotongR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDScLcLMCPhotongR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLDScLcLMCPhotongR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDScLcLMCPhotongR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDScLcLMCPhotongR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLDScLcLMCPhotongR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDScLcLMCPhotongR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLDScLcLMCPhotongR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLDScLcLMCPhotongR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLDScLcLMCParticlegR_Dictionary(); static void vectorlERATcLcLDScLcLMCParticlegR_TClassManip(TClass*); static void *new_vectorlERATcLcLDScLcLMCParticlegR(void *p = nullptr); static void *newArray_vectorlERATcLcLDScLcLMCParticlegR(Long_t size, void *p); static void delete_vectorlERATcLcLDScLcLMCParticlegR(void *p); static void deleteArray_vectorlERATcLcLDScLcLMCParticlegR(void *p); static void destruct_vectorlERATcLcLDScLcLMCParticlegR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDScLcLMCParticlegR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLDScLcLMCParticlegR); instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLMCParticlegR); instance.SetDelete(&delete_vectorlERATcLcLDScLcLMCParticlegR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLMCParticlegR); instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLMCParticlegR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDScLcLMCParticlegR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLDScLcLMCParticlegR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDScLcLMCParticlegR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDScLcLMCParticlegR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLDScLcLMCParticlegR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDScLcLMCParticlegR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLDScLcLMCParticlegR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLDScLcLMCParticlegR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLDScLcLMCPMTgR_Dictionary(); static void vectorlERATcLcLDScLcLMCPMTgR_TClassManip(TClass*); static void *new_vectorlERATcLcLDScLcLMCPMTgR(void *p = nullptr); static void *newArray_vectorlERATcLcLDScLcLMCPMTgR(Long_t size, void *p); static void delete_vectorlERATcLcLDScLcLMCPMTgR(void *p); static void deleteArray_vectorlERATcLcLDScLcLMCPMTgR(void *p); static void destruct_vectorlERATcLcLDScLcLMCPMTgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDScLcLMCPMTgR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLDScLcLMCPMTgR); instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLMCPMTgR); instance.SetDelete(&delete_vectorlERATcLcLDScLcLMCPMTgR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLMCPMTgR); instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLMCPMTgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDScLcLMCPMTgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLDScLcLMCPMTgR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDScLcLMCPMTgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDScLcLMCPMTgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLDScLcLMCPMTgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDScLcLMCPMTgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLDScLcLMCPMTgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLDScLcLMCPMTgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLDScLcLMCPEgR_Dictionary(); static void vectorlERATcLcLDScLcLMCPEgR_TClassManip(TClass*); static void *new_vectorlERATcLcLDScLcLMCPEgR(void *p = nullptr); static void *newArray_vectorlERATcLcLDScLcLMCPEgR(Long_t size, void *p); static void delete_vectorlERATcLcLDScLcLMCPEgR(void *p); static void deleteArray_vectorlERATcLcLDScLcLMCPEgR(void *p); static void destruct_vectorlERATcLcLDScLcLMCPEgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDScLcLMCPEgR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLDScLcLMCPEgR); instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLMCPEgR); instance.SetDelete(&delete_vectorlERATcLcLDScLcLMCPEgR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLMCPEgR); instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLMCPEgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDScLcLMCPEgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLDScLcLMCPEgR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDScLcLMCPEgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDScLcLMCPEgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLDScLcLMCPEgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDScLcLMCPEgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLDScLcLMCPEgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLDScLcLMCPEgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLDScLcLMCHitgR_Dictionary(); static void vectorlERATcLcLDScLcLMCHitgR_TClassManip(TClass*); static void *new_vectorlERATcLcLDScLcLMCHitgR(void *p = nullptr); static void *newArray_vectorlERATcLcLDScLcLMCHitgR(Long_t size, void *p); static void delete_vectorlERATcLcLDScLcLMCHitgR(void *p); static void deleteArray_vectorlERATcLcLDScLcLMCHitgR(void *p); static void destruct_vectorlERATcLcLDScLcLMCHitgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDScLcLMCHitgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLDScLcLMCHitgR); instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLMCHitgR); instance.SetDelete(&delete_vectorlERATcLcLDScLcLMCHitgR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLMCHitgR); instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLMCHitgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDScLcLMCHitgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLDScLcLMCHitgR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDScLcLMCHitgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDScLcLMCHitgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLDScLcLMCHitgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDScLcLMCHitgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLDScLcLMCHitgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLDScLcLMCHitgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLDScLcLMCEVgR_Dictionary(); static void vectorlERATcLcLDScLcLMCEVgR_TClassManip(TClass*); static void *new_vectorlERATcLcLDScLcLMCEVgR(void *p = nullptr); static void *newArray_vectorlERATcLcLDScLcLMCEVgR(Long_t size, void *p); static void delete_vectorlERATcLcLDScLcLMCEVgR(void *p); static void deleteArray_vectorlERATcLcLDScLcLMCEVgR(void *p); static void destruct_vectorlERATcLcLDScLcLMCEVgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDScLcLMCEVgR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLDScLcLMCEVgR); instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLMCEVgR); instance.SetDelete(&delete_vectorlERATcLcLDScLcLMCEVgR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLMCEVgR); instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLMCEVgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDScLcLMCEVgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLDScLcLMCEVgR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDScLcLMCEVgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDScLcLMCEVgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLDScLcLMCEVgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDScLcLMCEVgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLDScLcLMCEVgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLDScLcLMCEVgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLDScLcLMCgR_Dictionary(); static void vectorlERATcLcLDScLcLMCgR_TClassManip(TClass*); static void *new_vectorlERATcLcLDScLcLMCgR(void *p = nullptr); static void *newArray_vectorlERATcLcLDScLcLMCgR(Long_t size, void *p); static void delete_vectorlERATcLcLDScLcLMCgR(void *p); static void deleteArray_vectorlERATcLcLDScLcLMCgR(void *p); static void destruct_vectorlERATcLcLDScLcLMCgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDScLcLMCgR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLDScLcLMCgR); instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLMCgR); instance.SetDelete(&delete_vectorlERATcLcLDScLcLMCgR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLMCgR); instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLMCgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDScLcLMCgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLDScLcLMCgR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDScLcLMCgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDScLcLMCgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLDScLcLMCgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDScLcLMCgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLDScLcLMCgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLDScLcLMCgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLDScLcLHeaderInfogR_Dictionary(); static void vectorlERATcLcLDScLcLHeaderInfogR_TClassManip(TClass*); static void *new_vectorlERATcLcLDScLcLHeaderInfogR(void *p = nullptr); static void *newArray_vectorlERATcLcLDScLcLHeaderInfogR(Long_t size, void *p); static void delete_vectorlERATcLcLDScLcLHeaderInfogR(void *p); static void deleteArray_vectorlERATcLcLDScLcLHeaderInfogR(void *p); static void destruct_vectorlERATcLcLDScLcLHeaderInfogR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDScLcLHeaderInfogR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLDScLcLHeaderInfogR); instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLHeaderInfogR); instance.SetDelete(&delete_vectorlERATcLcLDScLcLHeaderInfogR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLHeaderInfogR); instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLHeaderInfogR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDScLcLHeaderInfogR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLDScLcLHeaderInfogR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDScLcLHeaderInfogR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDScLcLHeaderInfogR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLDScLcLHeaderInfogR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDScLcLHeaderInfogR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLDScLcLHeaderInfogR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLDScLcLHeaderInfogR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLDScLcLFitVertexgR_Dictionary(); static void vectorlERATcLcLDScLcLFitVertexgR_TClassManip(TClass*); static void *new_vectorlERATcLcLDScLcLFitVertexgR(void *p = nullptr); static void *newArray_vectorlERATcLcLDScLcLFitVertexgR(Long_t size, void *p); static void delete_vectorlERATcLcLDScLcLFitVertexgR(void *p); static void deleteArray_vectorlERATcLcLDScLcLFitVertexgR(void *p); static void destruct_vectorlERATcLcLDScLcLFitVertexgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDScLcLFitVertexgR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLDScLcLFitVertexgR); instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLFitVertexgR); instance.SetDelete(&delete_vectorlERATcLcLDScLcLFitVertexgR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLFitVertexgR); instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLFitVertexgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDScLcLFitVertexgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLDScLcLFitVertexgR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDScLcLFitVertexgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDScLcLFitVertexgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLDScLcLFitVertexgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDScLcLFitVertexgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLDScLcLFitVertexgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLDScLcLFitVertexgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLDScLcLEVgR_Dictionary(); static void vectorlERATcLcLDScLcLEVgR_TClassManip(TClass*); static void *new_vectorlERATcLcLDScLcLEVgR(void *p = nullptr); static void *newArray_vectorlERATcLcLDScLcLEVgR(Long_t size, void *p); static void delete_vectorlERATcLcLDScLcLEVgR(void *p); static void deleteArray_vectorlERATcLcLDScLcLEVgR(void *p); static void destruct_vectorlERATcLcLDScLcLEVgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDScLcLEVgR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLDScLcLEVgR); instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLEVgR); instance.SetDelete(&delete_vectorlERATcLcLDScLcLEVgR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLEVgR); instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLEVgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDScLcLEVgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLDScLcLEVgR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDScLcLEVgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDScLcLEVgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLDScLcLEVgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDScLcLEVgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLDScLcLEVgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLDScLcLEVgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLDScLcLECAHeadergR_Dictionary(); static void vectorlERATcLcLDScLcLECAHeadergR_TClassManip(TClass*); static void *new_vectorlERATcLcLDScLcLECAHeadergR(void *p = nullptr); static void *newArray_vectorlERATcLcLDScLcLECAHeadergR(Long_t size, void *p); static void delete_vectorlERATcLcLDScLcLECAHeadergR(void *p); static void deleteArray_vectorlERATcLcLDScLcLECAHeadergR(void *p); static void destruct_vectorlERATcLcLDScLcLECAHeadergR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDScLcLECAHeadergR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLDScLcLECAHeadergR); instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLECAHeadergR); instance.SetDelete(&delete_vectorlERATcLcLDScLcLECAHeadergR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLECAHeadergR); instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLECAHeadergR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDScLcLECAHeadergR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLDScLcLECAHeadergR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDScLcLECAHeadergR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDScLcLECAHeadergR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLDScLcLECAHeadergR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDScLcLECAHeadergR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLDScLcLECAHeadergR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLDScLcLECAHeadergR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLDScLcLDigitisergR_Dictionary(); static void vectorlERATcLcLDScLcLDigitisergR_TClassManip(TClass*); static void *new_vectorlERATcLcLDScLcLDigitisergR(void *p = nullptr); static void *newArray_vectorlERATcLcLDScLcLDigitisergR(Long_t size, void *p); static void delete_vectorlERATcLcLDScLcLDigitisergR(void *p); static void deleteArray_vectorlERATcLcLDScLcLDigitisergR(void *p); static void destruct_vectorlERATcLcLDScLcLDigitisergR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDScLcLDigitisergR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLDScLcLDigitisergR); instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLDigitisergR); instance.SetDelete(&delete_vectorlERATcLcLDScLcLDigitisergR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLDigitisergR); instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLDigitisergR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDScLcLDigitisergR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLDScLcLDigitisergR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDScLcLDigitisergR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDScLcLDigitisergR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLDScLcLDigitisergR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDScLcLDigitisergR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLDScLcLDigitisergR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLDScLcLDigitisergR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLDBTablegR_Dictionary(); static void vectorlERATcLcLDBTablegR_TClassManip(TClass*); static void *new_vectorlERATcLcLDBTablegR(void *p = nullptr); static void *newArray_vectorlERATcLcLDBTablegR(Long_t size, void *p); static void delete_vectorlERATcLcLDBTablegR(void *p); static void deleteArray_vectorlERATcLcLDBTablegR(void *p); static void destruct_vectorlERATcLcLDBTablegR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDBTablegR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLDBTablegR); instance.SetNewArray(&newArray_vectorlERATcLcLDBTablegR); instance.SetDelete(&delete_vectorlERATcLcLDBTablegR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDBTablegR); instance.SetDestructor(&destruct_vectorlERATcLcLDBTablegR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDBTablegR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLDBTablegR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDBTablegR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDBTablegR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLDBTablegR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDBTablegR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLDBTablegR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLDBTablegR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlERATcLcLDBTablemUgR_Dictionary(); static void vectorlERATcLcLDBTablemUgR_TClassManip(TClass*); static void *new_vectorlERATcLcLDBTablemUgR(void *p = nullptr); static void *newArray_vectorlERATcLcLDBTablemUgR(Long_t size, void *p); static void delete_vectorlERATcLcLDBTablemUgR(void *p); static void deleteArray_vectorlERATcLcLDBTablemUgR(void *p); static void destruct_vectorlERATcLcLDBTablemUgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlERATcLcLDBTablemUgR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlERATcLcLDBTablemUgR); instance.SetNewArray(&newArray_vectorlERATcLcLDBTablemUgR); instance.SetDelete(&delete_vectorlERATcLcLDBTablemUgR); instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDBTablemUgR); instance.SetDestructor(&destruct_vectorlERATcLcLDBTablemUgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("vector","std::vector >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlERATcLcLDBTablemUgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlERATcLcLDBTablemUgR_TClassManip(theClass); return theClass; } static void vectorlERATcLcLDBTablemUgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlERATcLcLDBTablemUgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector : new vector; } static void *newArray_vectorlERATcLcLDBTablemUgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlERATcLcLDBTablemUgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlERATcLcLDBTablemUgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlERATcLcLDBTablemUgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *setlEstringgR_Dictionary(); static void setlEstringgR_TClassManip(TClass*); static void *new_setlEstringgR(void *p = nullptr); static void *newArray_setlEstringgR(Long_t size, void *p); static void delete_setlEstringgR(void *p); static void deleteArray_setlEstringgR(void *p); static void destruct_setlEstringgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const set*) { set *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(set)); static ::ROOT::TGenericClassInfo instance("set", -2, "set", 94, typeid(set), ::ROOT::Internal::DefineBehavior(ptr, ptr), &setlEstringgR_Dictionary, isa_proxy, 0, sizeof(set) ); instance.SetNew(&new_setlEstringgR); instance.SetNewArray(&newArray_setlEstringgR); instance.SetDelete(&delete_setlEstringgR); instance.SetDeleteArray(&deleteArray_setlEstringgR); instance.SetDestructor(&destruct_setlEstringgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Insert< set >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("set","std::set, std::allocator >, std::less, std::allocator > >, std::allocator, std::allocator > > >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *setlEstringgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); setlEstringgR_TClassManip(theClass); return theClass; } static void setlEstringgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_setlEstringgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) set : new set; } static void *newArray_setlEstringgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) set[nElements] : new set[nElements]; } // Wrapper around operator delete static void delete_setlEstringgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_setlEstringgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_setlEstringgR(void *p) { typedef set current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class set namespace ROOT { static TClass *setlERATcLcLDBTableKeygR_Dictionary(); static void setlERATcLcLDBTableKeygR_TClassManip(TClass*); static void *new_setlERATcLcLDBTableKeygR(void *p = nullptr); static void *newArray_setlERATcLcLDBTableKeygR(Long_t size, void *p); static void delete_setlERATcLcLDBTableKeygR(void *p); static void deleteArray_setlERATcLcLDBTableKeygR(void *p); static void destruct_setlERATcLcLDBTableKeygR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const set*) { set *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(set)); static ::ROOT::TGenericClassInfo instance("set", -2, "set", 94, typeid(set), ::ROOT::Internal::DefineBehavior(ptr, ptr), &setlERATcLcLDBTableKeygR_Dictionary, isa_proxy, 0, sizeof(set) ); instance.SetNew(&new_setlERATcLcLDBTableKeygR); instance.SetNewArray(&newArray_setlERATcLcLDBTableKeygR); instance.SetDelete(&delete_setlERATcLcLDBTableKeygR); instance.SetDeleteArray(&deleteArray_setlERATcLcLDBTableKeygR); instance.SetDestructor(&destruct_setlERATcLcLDBTableKeygR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Insert< set >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("set","std::set, std::allocator >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *setlERATcLcLDBTableKeygR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); setlERATcLcLDBTableKeygR_TClassManip(theClass); return theClass; } static void setlERATcLcLDBTableKeygR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_setlERATcLcLDBTableKeygR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) set : new set; } static void *newArray_setlERATcLcLDBTableKeygR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) set[nElements] : new set[nElements]; } // Wrapper around operator delete static void delete_setlERATcLcLDBTableKeygR(void *p) { delete (static_cast*>(p)); } static void deleteArray_setlERATcLcLDBTableKeygR(void *p) { delete [] (static_cast*>(p)); } static void destruct_setlERATcLcLDBTableKeygR(void *p) { typedef set current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class set namespace ROOT { static TClass *maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR_Dictionary(); static void maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR_TClassManip(TClass*); static void *new_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR(void *p = nullptr); static void *newArray_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR(Long_t size, void *p); static void delete_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR(void *p); static void deleteArray_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR(void *p); static void destruct_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map >*) { map > *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map >)); static ::ROOT::TGenericClassInfo instance("map >", -2, "map", 100, typeid(map >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR_Dictionary, isa_proxy, 0, sizeof(map >) ); instance.SetNew(&new_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR); instance.SetNewArray(&newArray_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR); instance.SetDelete(&delete_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR); instance.SetDeleteArray(&deleteArray_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR); instance.SetDestructor(&destruct_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map > >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("map >","std::map >, std::less, std::allocator > > > >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast >*>(nullptr))->GetClass(); maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR_TClassManip(theClass); return theClass; } static void maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map > : new map >; } static void *newArray_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map >[nElements] : new map >[nElements]; } // Wrapper around operator delete static void delete_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR(void *p) { delete (static_cast >*>(p)); } static void deleteArray_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR(void *p) { delete [] (static_cast >*>(p)); } static void destruct_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR(void *p) { typedef map > current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map > namespace ROOT { static TClass *maplEunsignedsPshortcOunsignedsPshortgR_Dictionary(); static void maplEunsignedsPshortcOunsignedsPshortgR_TClassManip(TClass*); static void *new_maplEunsignedsPshortcOunsignedsPshortgR(void *p = nullptr); static void *newArray_maplEunsignedsPshortcOunsignedsPshortgR(Long_t size, void *p); static void delete_maplEunsignedsPshortcOunsignedsPshortgR(void *p); static void deleteArray_maplEunsignedsPshortcOunsignedsPshortgR(void *p); static void destruct_maplEunsignedsPshortcOunsignedsPshortgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map*) { map *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map)); static ::ROOT::TGenericClassInfo instance("map", -2, "map", 100, typeid(map), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEunsignedsPshortcOunsignedsPshortgR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEunsignedsPshortcOunsignedsPshortgR); instance.SetNewArray(&newArray_maplEunsignedsPshortcOunsignedsPshortgR); instance.SetDelete(&delete_maplEunsignedsPshortcOunsignedsPshortgR); instance.SetDeleteArray(&deleteArray_maplEunsignedsPshortcOunsignedsPshortgR); instance.SetDestructor(&destruct_maplEunsignedsPshortcOunsignedsPshortgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("map","std::map, std::allocator > >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEunsignedsPshortcOunsignedsPshortgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); maplEunsignedsPshortcOunsignedsPshortgR_TClassManip(theClass); return theClass; } static void maplEunsignedsPshortcOunsignedsPshortgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEunsignedsPshortcOunsignedsPshortgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map : new map; } static void *newArray_maplEunsignedsPshortcOunsignedsPshortgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEunsignedsPshortcOunsignedsPshortgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_maplEunsignedsPshortcOunsignedsPshortgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_maplEunsignedsPshortcOunsignedsPshortgR(void *p) { typedef map current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR_Dictionary(); static void maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR_TClassManip(TClass*); static void *new_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p = nullptr); static void *newArray_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR(Long_t size, void *p); static void delete_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p); static void deleteArray_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p); static void destruct_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map*) { map *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map)); static ::ROOT::TGenericClassInfo instance("map", -2, "map", 100, typeid(map), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR_Dictionary, isa_proxy, 4, sizeof(map) ); instance.SetNew(&new_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR); instance.SetNewArray(&newArray_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR); instance.SetDelete(&delete_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR); instance.SetDeleteArray(&deleteArray_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR); instance.SetDestructor(&destruct_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("map","std::map, std::allocator > >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR_TClassManip(theClass); return theClass; } static void maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map : new map; } static void *newArray_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p) { typedef map current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_Dictionary(); static void maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_TClassManip(TClass*); static void *new_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p = nullptr); static void *newArray_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(Long_t size, void *p); static void delete_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p); static void deleteArray_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p); static void destruct_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map >*) { map > *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map >)); static ::ROOT::TGenericClassInfo instance("map >", -2, "map", 100, typeid(map >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_Dictionary, isa_proxy, 4, sizeof(map >) ); instance.SetNew(&new_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR); instance.SetNewArray(&newArray_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR); instance.SetDelete(&delete_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR); instance.SetDeleteArray(&deleteArray_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR); instance.SetDestructor(&destruct_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map > >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("map >","std::map, std::less, std::allocator > > >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast >*>(nullptr))->GetClass(); maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_TClassManip(theClass); return theClass; } static void maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map > : new map >; } static void *newArray_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map >[nElements] : new map >[nElements]; } // Wrapper around operator delete static void delete_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p) { delete (static_cast >*>(p)); } static void deleteArray_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p) { delete [] (static_cast >*>(p)); } static void destruct_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p) { typedef map > current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map > namespace ROOT { static TClass *maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_Dictionary(); static void maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_TClassManip(TClass*); static void *new_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p = nullptr); static void *newArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(Long_t size, void *p); static void delete_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p); static void deleteArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p); static void destruct_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map >*) { map > *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map >)); static ::ROOT::TGenericClassInfo instance("map >", -2, "map", 100, typeid(map >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_Dictionary, isa_proxy, 4, sizeof(map >) ); instance.SetNew(&new_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR); instance.SetNewArray(&newArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR); instance.SetDelete(&delete_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR); instance.SetDeleteArray(&deleteArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR); instance.SetDestructor(&destruct_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map > >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("map >","std::map, std::less, std::allocator > > >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast >*>(nullptr))->GetClass(); maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_TClassManip(theClass); return theClass; } static void maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map > : new map >; } static void *newArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map >[nElements] : new map >[nElements]; } // Wrapper around operator delete static void delete_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p) { delete (static_cast >*>(p)); } static void deleteArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p) { delete [] (static_cast >*>(p)); } static void destruct_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p) { typedef map > current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map > namespace ROOT { static TClass *maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_Dictionary(); static void maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_TClassManip(TClass*); static void *new_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p = nullptr); static void *newArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(Long_t size, void *p); static void delete_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p); static void deleteArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p); static void destruct_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map >*) { map > *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map >)); static ::ROOT::TGenericClassInfo instance("map >", -2, "map", 100, typeid(map >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_Dictionary, isa_proxy, 4, sizeof(map >) ); instance.SetNew(&new_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR); instance.SetNewArray(&newArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR); instance.SetDelete(&delete_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR); instance.SetDeleteArray(&deleteArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR); instance.SetDestructor(&destruct_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map > >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("map >","std::map, std::less, std::allocator > > >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast >*>(nullptr))->GetClass(); maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_TClassManip(theClass); return theClass; } static void maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map > : new map >; } static void *newArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map >[nElements] : new map >[nElements]; } // Wrapper around operator delete static void delete_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p) { delete (static_cast >*>(p)); } static void deleteArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p) { delete [] (static_cast >*>(p)); } static void destruct_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p) { typedef map > current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map > namespace ROOT { static TClass *maplEunsignedsPintcORATcLcLDScLcLBitMaskgR_Dictionary(); static void maplEunsignedsPintcORATcLcLDScLcLBitMaskgR_TClassManip(TClass*); static void *new_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p = nullptr); static void *newArray_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR(Long_t size, void *p); static void delete_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p); static void deleteArray_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p); static void destruct_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map*) { map *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map)); static ::ROOT::TGenericClassInfo instance("map", -2, "map", 100, typeid(map), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEunsignedsPintcORATcLcLDScLcLBitMaskgR_Dictionary, isa_proxy, 4, sizeof(map) ); instance.SetNew(&new_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR); instance.SetNewArray(&newArray_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR); instance.SetDelete(&delete_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR); instance.SetDeleteArray(&deleteArray_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR); instance.SetDestructor(&destruct_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("map","std::map, std::allocator > >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEunsignedsPintcORATcLcLDScLcLBitMaskgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); maplEunsignedsPintcORATcLcLDScLcLBitMaskgR_TClassManip(theClass); return theClass; } static void maplEunsignedsPintcORATcLcLDScLcLBitMaskgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map : new map; } static void *newArray_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p) { typedef map current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *maplEstringcOstringgR_Dictionary(); static void maplEstringcOstringgR_TClassManip(TClass*); static void *new_maplEstringcOstringgR(void *p = nullptr); static void *newArray_maplEstringcOstringgR(Long_t size, void *p); static void delete_maplEstringcOstringgR(void *p); static void deleteArray_maplEstringcOstringgR(void *p); static void destruct_maplEstringcOstringgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map*) { map *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map)); static ::ROOT::TGenericClassInfo instance("map", -2, "map", 100, typeid(map), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEstringcOstringgR_Dictionary, isa_proxy, 4, sizeof(map) ); instance.SetNew(&new_maplEstringcOstringgR); instance.SetNewArray(&newArray_maplEstringcOstringgR); instance.SetDelete(&delete_maplEstringcOstringgR); instance.SetDeleteArray(&deleteArray_maplEstringcOstringgR); instance.SetDestructor(&destruct_maplEstringcOstringgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("map","std::map, std::allocator >, std::__cxx11::basic_string, std::allocator >, std::less, std::allocator > >, std::allocator, std::allocator > const, std::__cxx11::basic_string, std::allocator > > > >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEstringcOstringgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); maplEstringcOstringgR_TClassManip(theClass); return theClass; } static void maplEstringcOstringgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEstringcOstringgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map : new map; } static void *newArray_maplEstringcOstringgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEstringcOstringgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_maplEstringcOstringgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_maplEstringcOstringgR(void *p) { typedef map current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *maplEstringcORATcLcLDScLcLFitResultgR_Dictionary(); static void maplEstringcORATcLcLDScLcLFitResultgR_TClassManip(TClass*); static void *new_maplEstringcORATcLcLDScLcLFitResultgR(void *p = nullptr); static void *newArray_maplEstringcORATcLcLDScLcLFitResultgR(Long_t size, void *p); static void delete_maplEstringcORATcLcLDScLcLFitResultgR(void *p); static void deleteArray_maplEstringcORATcLcLDScLcLFitResultgR(void *p); static void destruct_maplEstringcORATcLcLDScLcLFitResultgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map*) { map *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map)); static ::ROOT::TGenericClassInfo instance("map", -2, "map", 100, typeid(map), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEstringcORATcLcLDScLcLFitResultgR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEstringcORATcLcLDScLcLFitResultgR); instance.SetNewArray(&newArray_maplEstringcORATcLcLDScLcLFitResultgR); instance.SetDelete(&delete_maplEstringcORATcLcLDScLcLFitResultgR); instance.SetDeleteArray(&deleteArray_maplEstringcORATcLcLDScLcLFitResultgR); instance.SetDestructor(&destruct_maplEstringcORATcLcLDScLcLFitResultgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("map","std::map, std::allocator >, RAT::DS::FitResult, std::less, std::allocator > >, std::allocator, std::allocator > const, RAT::DS::FitResult> > >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEstringcORATcLcLDScLcLFitResultgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); maplEstringcORATcLcLDScLcLFitResultgR_TClassManip(theClass); return theClass; } static void maplEstringcORATcLcLDScLcLFitResultgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEstringcORATcLcLDScLcLFitResultgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map : new map; } static void *newArray_maplEstringcORATcLcLDScLcLFitResultgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEstringcORATcLcLDScLcLFitResultgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_maplEstringcORATcLcLDScLcLFitResultgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_maplEstringcORATcLcLDScLcLFitResultgR(void *p) { typedef map current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *maplEstringcORATcLcLDScLcLClassifierResultgR_Dictionary(); static void maplEstringcORATcLcLDScLcLClassifierResultgR_TClassManip(TClass*); static void *new_maplEstringcORATcLcLDScLcLClassifierResultgR(void *p = nullptr); static void *newArray_maplEstringcORATcLcLDScLcLClassifierResultgR(Long_t size, void *p); static void delete_maplEstringcORATcLcLDScLcLClassifierResultgR(void *p); static void deleteArray_maplEstringcORATcLcLDScLcLClassifierResultgR(void *p); static void destruct_maplEstringcORATcLcLDScLcLClassifierResultgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map*) { map *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map)); static ::ROOT::TGenericClassInfo instance("map", -2, "map", 100, typeid(map), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEstringcORATcLcLDScLcLClassifierResultgR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEstringcORATcLcLDScLcLClassifierResultgR); instance.SetNewArray(&newArray_maplEstringcORATcLcLDScLcLClassifierResultgR); instance.SetDelete(&delete_maplEstringcORATcLcLDScLcLClassifierResultgR); instance.SetDeleteArray(&deleteArray_maplEstringcORATcLcLDScLcLClassifierResultgR); instance.SetDestructor(&destruct_maplEstringcORATcLcLDScLcLClassifierResultgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("map","std::map, std::allocator >, RAT::DS::ClassifierResult, std::less, std::allocator > >, std::allocator, std::allocator > const, RAT::DS::ClassifierResult> > >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEstringcORATcLcLDScLcLClassifierResultgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); maplEstringcORATcLcLDScLcLClassifierResultgR_TClassManip(theClass); return theClass; } static void maplEstringcORATcLcLDScLcLClassifierResultgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEstringcORATcLcLDScLcLClassifierResultgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map : new map; } static void *newArray_maplEstringcORATcLcLDScLcLClassifierResultgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEstringcORATcLcLDScLcLClassifierResultgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_maplEstringcORATcLcLDScLcLClassifierResultgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_maplEstringcORATcLcLDScLcLClassifierResultgR(void *p) { typedef map current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *maplEstringcODouble32_tgR_Dictionary(); static void maplEstringcODouble32_tgR_TClassManip(TClass*); static void *new_maplEstringcODouble32_tgR(void *p = nullptr); static void *newArray_maplEstringcODouble32_tgR(Long_t size, void *p); static void delete_maplEstringcODouble32_tgR(void *p); static void deleteArray_maplEstringcODouble32_tgR(void *p); static void destruct_maplEstringcODouble32_tgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map*) { map *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map)); static ::ROOT::TGenericClassInfo instance("map", -2, "map", 100, typeid(map), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEstringcODouble32_tgR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEstringcODouble32_tgR); instance.SetNewArray(&newArray_maplEstringcODouble32_tgR); instance.SetDelete(&delete_maplEstringcODouble32_tgR); instance.SetDeleteArray(&deleteArray_maplEstringcODouble32_tgR); instance.SetDestructor(&destruct_maplEstringcODouble32_tgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map >())); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEstringcODouble32_tgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); maplEstringcODouble32_tgR_TClassManip(theClass); return theClass; } static void maplEstringcODouble32_tgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEstringcODouble32_tgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map : new map; } static void *newArray_maplEstringcODouble32_tgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEstringcODouble32_tgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_maplEstringcODouble32_tgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_maplEstringcODouble32_tgR(void *p) { typedef map current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *maplEpairlEstringcOstringgRcOintgR_Dictionary(); static void maplEpairlEstringcOstringgRcOintgR_TClassManip(TClass*); static void *new_maplEpairlEstringcOstringgRcOintgR(void *p = nullptr); static void *newArray_maplEpairlEstringcOstringgRcOintgR(Long_t size, void *p); static void delete_maplEpairlEstringcOstringgRcOintgR(void *p); static void deleteArray_maplEpairlEstringcOstringgRcOintgR(void *p); static void destruct_maplEpairlEstringcOstringgRcOintgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map,int>*) { map,int> *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map,int>)); static ::ROOT::TGenericClassInfo instance("map,int>", -2, "map", 100, typeid(map,int>), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEpairlEstringcOstringgRcOintgR_Dictionary, isa_proxy, 0, sizeof(map,int>) ); instance.SetNew(&new_maplEpairlEstringcOstringgRcOintgR); instance.SetNewArray(&newArray_maplEpairlEstringcOstringgRcOintgR); instance.SetDelete(&delete_maplEpairlEstringcOstringgRcOintgR); instance.SetDeleteArray(&deleteArray_maplEpairlEstringcOstringgRcOintgR); instance.SetDestructor(&destruct_maplEpairlEstringcOstringgRcOintgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map,int> >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("map,int>","std::map, std::allocator >, std::__cxx11::basic_string, std::allocator > >, int, std::less, std::allocator >, std::__cxx11::basic_string, std::allocator > > >, std::allocator, std::allocator >, std::__cxx11::basic_string, std::allocator > > const, int> > >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast,int>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEpairlEstringcOstringgRcOintgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast,int>*>(nullptr))->GetClass(); maplEpairlEstringcOstringgRcOintgR_TClassManip(theClass); return theClass; } static void maplEpairlEstringcOstringgRcOintgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEpairlEstringcOstringgRcOintgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map,int> : new map,int>; } static void *newArray_maplEpairlEstringcOstringgRcOintgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map,int>[nElements] : new map,int>[nElements]; } // Wrapper around operator delete static void delete_maplEpairlEstringcOstringgRcOintgR(void *p) { delete (static_cast,int>*>(p)); } static void deleteArray_maplEpairlEstringcOstringgRcOintgR(void *p) { delete [] (static_cast,int>*>(p)); } static void destruct_maplEpairlEstringcOstringgRcOintgR(void *p) { typedef map,int> current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map,int> namespace ROOT { static TClass *maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR_Dictionary(); static void maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR_TClassManip(TClass*); static void *new_maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR(void *p = nullptr); static void *newArray_maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR(Long_t size, void *p); static void delete_maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR(void *p); static void deleteArray_maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR(void *p); static void destruct_maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map >*) { map > *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map >)); static ::ROOT::TGenericClassInfo instance("map >", -2, "map", 100, typeid(map >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR_Dictionary, isa_proxy, 0, sizeof(map >) ); instance.SetNew(&new_maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR); instance.SetNewArray(&newArray_maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR); instance.SetDelete(&delete_maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR); instance.SetDeleteArray(&deleteArray_maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR); instance.SetDestructor(&destruct_maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map > >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("map >","std::map, std::less, std::allocator > > >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast >*>(nullptr))->GetClass(); maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR_TClassManip(theClass); return theClass; } static void maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map > : new map >; } static void *newArray_maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map >[nElements] : new map >[nElements]; } // Wrapper around operator delete static void delete_maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR(void *p) { delete (static_cast >*>(p)); } static void deleteArray_maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR(void *p) { delete [] (static_cast >*>(p)); } static void destruct_maplERATcLcLDBTableKeycOstlpluscLcLsimple_ptr_nocopylERATcLcLDBTablegRsPgR(void *p) { typedef map > current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map > namespace ROOT { static TClass *listlERATcLcLDBLinkmUgR_Dictionary(); static void listlERATcLcLDBLinkmUgR_TClassManip(TClass*); static void *new_listlERATcLcLDBLinkmUgR(void *p = nullptr); static void *newArray_listlERATcLcLDBLinkmUgR(Long_t size, void *p); static void delete_listlERATcLcLDBLinkmUgR(void *p); static void deleteArray_listlERATcLcLDBLinkmUgR(void *p); static void destruct_listlERATcLcLDBLinkmUgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const list*) { list *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(list)); static ::ROOT::TGenericClassInfo instance("list", -2, "list", 632, typeid(list), ::ROOT::Internal::DefineBehavior(ptr, ptr), &listlERATcLcLDBLinkmUgR_Dictionary, isa_proxy, 0, sizeof(list) ); instance.SetNew(&new_listlERATcLcLDBLinkmUgR); instance.SetNewArray(&newArray_listlERATcLcLDBLinkmUgR); instance.SetDelete(&delete_listlERATcLcLDBLinkmUgR); instance.SetDeleteArray(&deleteArray_listlERATcLcLDBLinkmUgR); instance.SetDestructor(&destruct_listlERATcLcLDBLinkmUgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< list >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("list","std::__cxx11::list >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *listlERATcLcLDBLinkmUgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); listlERATcLcLDBLinkmUgR_TClassManip(theClass); return theClass; } static void listlERATcLcLDBLinkmUgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_listlERATcLcLDBLinkmUgR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) list : new list; } static void *newArray_listlERATcLcLDBLinkmUgR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) list[nElements] : new list[nElements]; } // Wrapper around operator delete static void delete_listlERATcLcLDBLinkmUgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_listlERATcLcLDBLinkmUgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_listlERATcLcLDBLinkmUgR(void *p) { typedef list current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class list namespace ROOT { static TClass *dequelERATcLcLDBTableKeygR_Dictionary(); static void dequelERATcLcLDBTableKeygR_TClassManip(TClass*); static void *new_dequelERATcLcLDBTableKeygR(void *p = nullptr); static void *newArray_dequelERATcLcLDBTableKeygR(Long_t size, void *p); static void delete_dequelERATcLcLDBTableKeygR(void *p); static void deleteArray_dequelERATcLcLDBTableKeygR(void *p); static void destruct_dequelERATcLcLDBTableKeygR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const deque*) { deque *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(deque)); static ::ROOT::TGenericClassInfo instance("deque", -2, "deque", 788, typeid(deque), ::ROOT::Internal::DefineBehavior(ptr, ptr), &dequelERATcLcLDBTableKeygR_Dictionary, isa_proxy, 0, sizeof(deque) ); instance.SetNew(&new_dequelERATcLcLDBTableKeygR); instance.SetNewArray(&newArray_dequelERATcLcLDBTableKeygR); instance.SetDelete(&delete_dequelERATcLcLDBTableKeygR); instance.SetDeleteArray(&deleteArray_dequelERATcLcLDBTableKeygR); instance.SetDestructor(&destruct_dequelERATcLcLDBTableKeygR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< deque >())); instance.AdoptAlternate(::ROOT::AddClassAlternate("deque","std::deque >")); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *dequelERATcLcLDBTableKeygR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); dequelERATcLcLDBTableKeygR_TClassManip(theClass); return theClass; } static void dequelERATcLcLDBTableKeygR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_dequelERATcLcLDBTableKeygR(void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) deque : new deque; } static void *newArray_dequelERATcLcLDBTableKeygR(Long_t nElements, void *p) { return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) deque[nElements] : new deque[nElements]; } // Wrapper around operator delete static void delete_dequelERATcLcLDBTableKeygR(void *p) { delete (static_cast*>(p)); } static void deleteArray_dequelERATcLcLDBTableKeygR(void *p) { delete [] (static_cast*>(p)); } static void destruct_dequelERATcLcLDBTableKeygR(void *p) { typedef deque current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class deque namespace { void TriggerDictionaryInitialization_RAT_Dict_Impl() { static const char* headers[] = { "RAT/DS/BitMask.hh", "RAT/DS/Calib.hh", "RAT/DS/ClassifierResult.hh", "RAT/DS/DataQCFlags.hh", "RAT/DS/DataNotFound.hh", "RAT/DS/Digitiser.hh", "RAT/DS/ECAHeader.hh", "RAT/DS/EV.hh", "RAT/DS/FitResult.hh", "RAT/DS/FitVertex.hh", "RAT/DS/HeaderInfo.hh", "RAT/DS/Meta.hh", "RAT/DS/MetaDB.hh", "RAT/DS/MC.hh", "RAT/DS/MCEV.hh", "RAT/DS/MCHit.hh", "RAT/DS/MCPMT.hh", "RAT/DS/MCParticle.hh", "RAT/DS/MCPE.hh", "RAT/DS/MCPhoton.hh", "RAT/DS/MCTrack.hh", "RAT/DS/MCTrackStep.hh", "RAT/DS/PMT.hh", "RAT/DS/PMTSet.hh", "RAT/DS/Entry.hh", "RAT/DS/Run.hh", "RAT/DS/SOC.hh", "RAT/DS/SOCPMT.hh", "RAT/DS/TrigHeader.hh", "RAT/DS/UniversalTime.hh", "RAT/DU/DataCleaningBits.hh", "RAT/DU/DataQualityBits.hh", "RAT/DU/ChanSWStatus.hh", "RAT/DU/TrigBits.hh", "RAT/DU/DSReader.hh", "RAT/DU/EffectiveVelocity.hh", "RAT/DU/GroupVelocity.hh", "RAT/DU/LightPathCalculator.hh", "RAT/DU/PMTInfo.hh", "RAT/DU/PanelInfo.hh", "RAT/DU/ChanHWStatus.hh", "RAT/DU/PMTCalStatus.hh", "RAT/DU/ReactorNuOsc.hh", "RAT/DU/ShadowingCalculator.hh", "RAT/DU/Segmentor.hh", "RAT/DU/SOCReader.hh", "RAT/DU/Utility.hh", "RAT/PeakFinder.hh", "RAT/TrackNav.hh", "RAT/TrackNode.hh", "RAT/TrackCursor.hh", "RAT/PgSQLBackend.hh", "RAT/DB.hh", "RAT/DBLink.hh", "RAT/DBTable.hh", "RAT/DBCommandLoader.hh", "RAT/DBTextLoader.hh", "RAT/DBJsonLoader.hh", "RAT/HTTPDownloader.hh", "RAT/Log.hh", "RAT/MetaInformation.hh", "RAT/zdab_file.hh", "RAT/zdab_convert.hh", "RAT/Record_Info.hh", "RAT/PZdabFile.hh", "RAT/BitManip.hh", "RAT/FlatMap.hh", "RAT/DataCleaningUtility.hh", "RAT/SunUtil.hh", "RAT/Version.hh", "RAT/DataCleaningUtility.hh", "RAT/GLG4StringUtil.hh", "RAT/PhysicsUtil.hh", "RAT/QuadraticRoots.hh", "RAT/VectorTools.hh", "RAT/FitterPMT.hh", "RAT/DU/ReconCorrector.hh", "RAT/DU/EnergySystematics.hh", "RAT/DU/ReconCalibrator.hh", "RAT/DU/TimeResidualCalculator.hh", "RAT/DU/Point3D.hh", "RAT/LightPath.hh", "RAT/LightPathFitter.hh", "RAT/LightPathStraightFitter.hh", "RAT/LightPathStraightScint.hh", "RAT/LightPathStraightScintWater.hh", "RAT/DU/DetectorStateCorrection.hh", nullptr }; static const char* includePaths[] = { "include/libpq", "include/external", "/cvmfs/snoplus.egi.eu/el9/sw/dependencies/root-6.30.06/obj/include", "/cvmfs/snoplus.egi.eu/el9/sw/dependencies/geant4.10.00.p04/include/Geant4", "/cvmfs/snoplus.egi.eu/el9/sw/dependencies/bzip2-1.0.8/include", "/cvmfs/snoplus.egi.eu/el9/sw/dependencies/root-6.30.06/obj/include/", "/home/snoprod/temp_Will/cvmfs_pusher/rat/", nullptr }; static const char* fwdDeclCode = R"DICTFWDDCLS( #line 1 "RAT_Dict 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; extern "C++" {namespace std{class __attribute__((annotate("$clingAutoload$bits/exception.h"))) __attribute__((annotate("$clingAutoload$new"))) exception;}} namespace std{template struct __attribute__((annotate("$clingAutoload$bits/char_traits.h"))) __attribute__((annotate("$clingAutoload$string"))) char_traits; } namespace std{template class __attribute__((annotate("$clingAutoload$bits/memoryfwd.h"))) __attribute__((annotate("$clingAutoload$string"))) allocator; } namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/SOCPMT.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/Run.hh"))) SOCPMT;}} namespace std{template struct __attribute__((annotate("$clingAutoload$bits/stl_pair.h"))) __attribute__((annotate("$clingAutoload$string"))) pair; } namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/ClassifierResult.hh"))) ClassifierResult;}} namespace RAT{namespace DS{template class __attribute__((annotate("$clingAutoload$RAT/DS/FitClassifierCollection.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) FitClassifierCollection; }} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/FitResult.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) FitResult;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/PMT.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) PMTCal;}} namespace RAT{namespace DS{template class __attribute__((annotate("$clingAutoload$RAT/DS/PMTSet.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) PMTSet; }} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/BitMask.hh"))) BitMask;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/FitVertex.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) FitVertex;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/ECAHeader.hh"))) ECAHeader;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/TrigHeader.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/HeaderInfo.hh"))) TrigHeader;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/MetaDB.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/Meta.hh"))) MetaDB;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/MCTrackStep.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/MC.hh"))) MCTrackStep;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/MCPhoton.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/MC.hh"))) MCPhoton;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/MCPE.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/MC.hh"))) MCPE;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/MCParticle.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/MC.hh"))) MCParticle;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/MCTrack.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/MC.hh"))) MCTrack;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/MCPMT.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/MC.hh"))) MCPMT;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/MC.hh"))) MC;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/MCEV.hh"))) MCEV;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) EV;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/HeaderInfo.hh"))) HeaderInfo;}} namespace RAT{class __attribute__((annotate("$clingAutoload$RAT/DBTable.hh"))) __attribute__((annotate("$clingAutoload$RAT/DU/GroupVelocity.hh"))) DBTable;} namespace RAT{class __attribute__((annotate("$clingAutoload$RAT/TrackNode.hh"))) __attribute__((annotate("$clingAutoload$RAT/TrackNav.hh"))) TrackNode;} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/Calib.hh"))) Calib;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/DataNotFound.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/ClassifierResult.hh"))) DataNotFound;}} namespace std{template struct __attribute__((annotate("$clingAutoload$bits/stl_function.h"))) __attribute__((annotate("$clingAutoload$string"))) less; } namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/DataQCFlags.hh"))) DataQCFlags;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/Digitiser.hh"))) Digitiser;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/UniversalTime.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) UniversalTime;}} namespace ROOT{namespace Math{template class __attribute__((annotate("$clingAutoload$Math/GenVector/Cartesian3D.h"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) Cartesian3D; }} namespace ROOT{namespace Math{class __attribute__((annotate("$clingAutoload$Math/GenVector/CoordinateSystemTags.h"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) DefaultCoordinateSystemTag;}} namespace ROOT{namespace Math{template class __attribute__((annotate("$clingAutoload$Math/GenVector/DisplacementVector3D.h"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) DisplacementVector3D; }} namespace ROOT{namespace Math{template class __attribute__((annotate("$clingAutoload$Math/Vector3Dfwd.h"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) Polar3D; }} namespace json{class __attribute__((annotate("$clingAutoload$RAT/json.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) Value;} namespace RAT{class __attribute__((annotate("$clingAutoload$RAT/Log.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) Log;} namespace RAT{class __attribute__((annotate("$clingAutoload$RAT/BitManip.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) BitManip;} namespace RAT{namespace DS{template class __attribute__((annotate("$clingAutoload$RAT/DS/PMT.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) PMT; }} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/MCHit.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) MCHit;}} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/PMTInfo.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) PMTInfo;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/Meta.hh"))) Meta;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/Entry.hh"))) Entry;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/SOC.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/Run.hh"))) SOC;}} namespace RAT{namespace DS{class __attribute__((annotate("$clingAutoload$RAT/DS/Run.hh"))) Run;}} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/DataCleaningBits.hh"))) DataCleaningBits;}} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/DataQualityBits.hh"))) DataQualityBits;}} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/ChanSWStatus.hh"))) ChanSWStatus;}} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/TrigBits.hh"))) TrigBits;}} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/DSReader.hh"))) DSReader;}} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/EffectiveVelocity.hh"))) EffectiveVelocity;}} namespace RAT{class __attribute__((annotate("$clingAutoload$RAT/DBLink.hh"))) __attribute__((annotate("$clingAutoload$RAT/DU/GroupVelocity.hh"))) DBLink;} namespace stlplus{template class __attribute__((annotate("$clingAutoload$stlplus3/containers/simple_ptr.hpp"))) __attribute__((annotate("$clingAutoload$RAT/DU/GroupVelocity.hh"))) simple_ptr_nocopy; } namespace RAT{class __attribute__((annotate("$clingAutoload$RAT/DB.hh"))) __attribute__((annotate("$clingAutoload$RAT/DU/GroupVelocity.hh"))) DB;} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/GroupVelocity.hh"))) GroupVelocity;}} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/Point3D.hh"))) __attribute__((annotate("$clingAutoload$RAT/DU/LightPathCalculator.hh"))) Point3D;}} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/LightPathCalculator.hh"))) LightPathCalculator;}} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/PanelInfo.hh"))) PanelInfo;}} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/ChanHWStatus.hh"))) ChanHWStatus;}} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/PMTCalStatus.hh"))) PMTCalStatus;}} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/ReactorNuOsc.hh"))) ReactorNuOsc;}} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/ShadowingCalculator.hh"))) ShadowingCalculator;}} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/Segmentor.hh"))) Segmentor;}} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/SOCReader.hh"))) SOCReader;}} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/ReconCorrector.hh"))) __attribute__((annotate("$clingAutoload$RAT/DU/Utility.hh"))) ReconCorrector;}} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/ReconCalibrator.hh"))) __attribute__((annotate("$clingAutoload$RAT/DU/Utility.hh"))) ReconCalibrator;}} namespace RAT{class __attribute__((annotate("$clingAutoload$RAT/FitterPMT.hh"))) __attribute__((annotate("$clingAutoload$RAT/DU/Utility.hh"))) FitterPMT;} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/TimeResidualCalculator.hh"))) __attribute__((annotate("$clingAutoload$RAT/DU/Utility.hh"))) TimeResidualCalculator;}} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/DetectorStateCorrection.hh"))) __attribute__((annotate("$clingAutoload$RAT/DU/Utility.hh"))) DetectorStateCorrection;}} namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/Utility.hh"))) Utility;}} namespace RAT{class __attribute__((annotate("$clingAutoload$RAT/TrackCursor.hh"))) __attribute__((annotate("$clingAutoload$RAT/TrackNav.hh"))) TrackCursor;} namespace RAT{class __attribute__((annotate("$clingAutoload$RAT/TrackNav.hh"))) TrackNav;} namespace RAT{class __attribute__((annotate("$clingAutoload$RAT/PgSQLBackend.hh"))) PgSQLBackend;} namespace RAT{class __attribute__((annotate("$clingAutoload$RAT/DBCommandLoader.hh"))) DBCommandLoader;} namespace RAT{class __attribute__((annotate("$clingAutoload$RAT/DBTextLoader.hh"))) DBTextLoader;} namespace RAT{class __attribute__((annotate("$clingAutoload$RAT/DBJsonLoader.hh"))) DBJsonLoader;} namespace RAT{class __attribute__((annotate("$clingAutoload$RAT/HTTPDownloader.hh"))) HTTPDownloader;} namespace RAT{class __attribute__((annotate("$clingAutoload$RAT/MetaInformation.hh"))) MetaInformation;} namespace ratzdab{class __attribute__((annotate("$clingAutoload$RAT/zdab_convert.hh"))) __attribute__((annotate("$clingAutoload$RAT/zdab_file.hh"))) unknown_record_error;} namespace ratzdab{class __attribute__((annotate("$clingAutoload$RAT/zdab_file.hh"))) zdabfile;} struct __attribute__((annotate("$clingAutoload$RAT/Record_Info.hh"))) RunRecord; struct __attribute__((annotate("$clingAutoload$RAT/Record_Info.hh"))) TriggerInfo; struct __attribute__((annotate("$clingAutoload$RAT/Record_Info.hh"))) EpedRecord; struct __attribute__((annotate("$clingAutoload$RAT/Record_Info.hh"))) ManipRopeStatus; struct __attribute__((annotate("$clingAutoload$RAT/Record_Info.hh"))) MTCReadoutData; struct __attribute__((annotate("$clingAutoload$RAT/Record_Info.hh"))) PmtEventRecord; class __attribute__((annotate("$clingAutoload$RAT/PZdabFile.hh"))) PZdabFile; namespace RAT{namespace DU{class __attribute__((annotate("$clingAutoload$RAT/DU/EnergySystematics.hh"))) EnergySystematics;}} namespace RAT{namespace LP{class __attribute__((annotate("$clingAutoload$RAT/LightPath.hh"))) LightPath;}} namespace RAT{namespace LP{class __attribute__((annotate("$clingAutoload$RAT/LightPathFitter.hh"))) LightPathFitter;}} namespace RAT{namespace LP{class __attribute__((annotate("$clingAutoload$RAT/LightPathStraightFitter.hh"))) LightPathStraightFitter;}} namespace RAT{namespace LP{class __attribute__((annotate("$clingAutoload$RAT/LightPathStraightScint.hh"))) LightPathStraightScint;}} namespace RAT{namespace LP{class __attribute__((annotate("$clingAutoload$RAT/LightPathStraightScintWater.hh"))) LightPathStraightScintWater;}} namespace ROOT{namespace Math{typedef DisplacementVector3D, ROOT::Math::DefaultCoordinateSystemTag> XYZVector __attribute__((annotate("$clingAutoload$Math/Vector3Dfwd.h"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) ;}} namespace ROOT{namespace Math{typedef DisplacementVector3D, ROOT::Math::DefaultCoordinateSystemTag> XYZVectorF __attribute__((annotate("$clingAutoload$Math/Vector3Dfwd.h"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) ;}} namespace ROOT{namespace Math{typedef DisplacementVector3D, ROOT::Math::DefaultCoordinateSystemTag> Polar3DVector __attribute__((annotate("$clingAutoload$Math/Vector3Dfwd.h"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) ;}} namespace ROOT{namespace Math{typedef DisplacementVector3D, ROOT::Math::DefaultCoordinateSystemTag> Polar3DVectorF __attribute__((annotate("$clingAutoload$Math/Vector3Dfwd.h"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) ;}} namespace RAT{namespace DS{typedef FitClassifierCollection FitCollection __attribute__((annotate("$clingAutoload$RAT/DS/FitClassifierCollection.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) ;}} namespace RAT{namespace DS{typedef FitClassifierCollection ClassifierCollection __attribute__((annotate("$clingAutoload$RAT/DS/FitClassifierCollection.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) ;}} typedef double Double32_t __attribute__((annotate("$clingAutoload$RtypesCore.h"))) ; namespace RAT{namespace DS{typedef PMT PMTFloat __attribute__((annotate("$clingAutoload$RAT/DS/PMT.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) ;}} typedef unsigned short UShort_t __attribute__((annotate("$clingAutoload$RtypesCore.h"))) ; namespace RAT{namespace DS{typedef PMT PMTUncal __attribute__((annotate("$clingAutoload$RAT/DS/PMT.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) ;}} namespace RAT{namespace DS{typedef PMTSet UncalPMTs __attribute__((annotate("$clingAutoload$RAT/DS/PMTSet.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) ;}} namespace RAT{namespace DS{typedef PMTSet CalPMTs __attribute__((annotate("$clingAutoload$RAT/DS/PMTSet.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) ;}} namespace RAT{namespace DS{typedef PMTSet MCHits __attribute__((annotate("$clingAutoload$RAT/DS/PMTSet.hh"))) __attribute__((annotate("$clingAutoload$RAT/DS/EV.hh"))) ;}} namespace RAT{typedef stlplus::simple_ptr_nocopy DBLinkPtr __attribute__((annotate("$clingAutoload$RAT/DB.hh"))) __attribute__((annotate("$clingAutoload$RAT/DU/GroupVelocity.hh"))) ;} )DICTFWDDCLS"; static const char* payloadCode = R"DICTPAYLOAD( #line 1 "RAT_Dict dictionary payload" #ifndef _REENTRANT #define _REENTRANT 1 #endif #ifndef _THREAD_SAFE #define _THREAD_SAFE 1 #endif #ifndef _POSIX_PTHREAD_SEMANTICS #define _POSIX_PTHREAD_SEMANTICS 1 #endif #ifndef FRONTEND #define FRONTEND 1 #endif #ifndef UNSAFE_STAT_OK #define UNSAFE_STAT_OK 1 #endif #ifndef SO_MAJOR_VERSION #define SO_MAJOR_VERSION 5 #endif #ifndef REFINT_VERBOSE #define REFINT_VERBOSE 1 #endif #ifndef _GNU_SOURCE #define _GNU_SOURCE 1 #endif #ifndef G4UI_USE_TCSH #define G4UI_USE_TCSH 1 #endif #ifndef G4VIS_USE #define G4VIS_USE 1 #endif #define _BACKWARD_BACKWARD_WARNING_H // Inline headers #include "RAT/DS/BitMask.hh" #include "RAT/DS/Calib.hh" #include "RAT/DS/ClassifierResult.hh" #include "RAT/DS/DataQCFlags.hh" #include "RAT/DS/DataNotFound.hh" #include "RAT/DS/Digitiser.hh" #include "RAT/DS/ECAHeader.hh" #include "RAT/DS/EV.hh" #include "RAT/DS/FitResult.hh" #include "RAT/DS/FitVertex.hh" #include "RAT/DS/HeaderInfo.hh" #include "RAT/DS/Meta.hh" #include "RAT/DS/MetaDB.hh" #include "RAT/DS/MC.hh" #include "RAT/DS/MCEV.hh" #include "RAT/DS/MCHit.hh" #include "RAT/DS/MCPMT.hh" #include "RAT/DS/MCParticle.hh" #include "RAT/DS/MCPE.hh" #include "RAT/DS/MCPhoton.hh" #include "RAT/DS/MCTrack.hh" #include "RAT/DS/MCTrackStep.hh" #include "RAT/DS/PMT.hh" #include "RAT/DS/PMTSet.hh" #include "RAT/DS/Entry.hh" #include "RAT/DS/Run.hh" #include "RAT/DS/SOC.hh" #include "RAT/DS/SOCPMT.hh" #include "RAT/DS/TrigHeader.hh" #include "RAT/DS/UniversalTime.hh" #include "RAT/DU/DataCleaningBits.hh" #include "RAT/DU/DataQualityBits.hh" #include "RAT/DU/ChanSWStatus.hh" #include "RAT/DU/TrigBits.hh" #include "RAT/DU/DSReader.hh" #include "RAT/DU/EffectiveVelocity.hh" #include "RAT/DU/GroupVelocity.hh" #include "RAT/DU/LightPathCalculator.hh" #include "RAT/DU/PMTInfo.hh" #include "RAT/DU/PanelInfo.hh" #include "RAT/DU/ChanHWStatus.hh" #include "RAT/DU/PMTCalStatus.hh" #include "RAT/DU/ReactorNuOsc.hh" #include "RAT/DU/ShadowingCalculator.hh" #include "RAT/DU/Segmentor.hh" #include "RAT/DU/SOCReader.hh" #include "RAT/DU/Utility.hh" #include "RAT/PeakFinder.hh" #include "RAT/TrackNav.hh" #include "RAT/TrackNode.hh" #include "RAT/TrackCursor.hh" #include "RAT/PgSQLBackend.hh" #include "RAT/DB.hh" #include "RAT/DBLink.hh" #include "RAT/DBTable.hh" #include "RAT/DBCommandLoader.hh" #include "RAT/DBTextLoader.hh" #include "RAT/DBJsonLoader.hh" #include "RAT/HTTPDownloader.hh" #include "RAT/Log.hh" #include "RAT/MetaInformation.hh" #include "RAT/zdab_file.hh" #include "RAT/zdab_convert.hh" #include "RAT/Record_Info.hh" #include "RAT/PZdabFile.hh" #include "RAT/BitManip.hh" #include "RAT/FlatMap.hh" #include "RAT/DataCleaningUtility.hh" #include "RAT/SunUtil.hh" #include "RAT/Version.hh" #include "RAT/DataCleaningUtility.hh" #include "RAT/GLG4StringUtil.hh" #include "RAT/PhysicsUtil.hh" #include "RAT/QuadraticRoots.hh" #include "RAT/VectorTools.hh" #include "RAT/FitterPMT.hh" #include "RAT/DU/ReconCorrector.hh" #include "RAT/DU/EnergySystematics.hh" #include "RAT/DU/ReconCalibrator.hh" #include "RAT/DU/TimeResidualCalculator.hh" #include "RAT/DU/Point3D.hh" #include "RAT/LightPath.hh" #include "RAT/LightPathFitter.hh" #include "RAT/LightPathStraightFitter.hh" #include "RAT/LightPathStraightScint.hh" #include "RAT/LightPathStraightScintWater.hh" #include "RAT/DU/DetectorStateCorrection.hh" #undef _BACKWARD_BACKWARD_WARNING_H )DICTPAYLOAD"; static const char* classesHeaders[] = { "EpedRecord", payloadCode, "@", "MTCReadoutData", payloadCode, "@", "ManipRopeStatus", payloadCode, "@", "PZdabFile", payloadCode, "@", "PmtEventRecord", payloadCode, "@", "RAT::BitManip", payloadCode, "@", "RAT::CheckMask", payloadCode, "@", "RAT::DB", payloadCode, "@", "RAT::DBCommandLoader", payloadCode, "@", "RAT::DBJsonLoader", payloadCode, "@", "RAT::DBLink", payloadCode, "@", "RAT::DBLinkPtr", payloadCode, "@", "RAT::DBTable", payloadCode, "@", "RAT::DBTextLoader", payloadCode, "@", "RAT::DS::BitMask", payloadCode, "@", "RAT::DS::CalPMTs", payloadCode, "@", "RAT::DS::Calib", payloadCode, "@", "RAT::DS::ClassifierCollection", payloadCode, "@", "RAT::DS::ClassifierResult", payloadCode, "@", "RAT::DS::DataNotFound", payloadCode, "@", "RAT::DS::DataQCFlags", payloadCode, "@", "RAT::DS::Digitiser", payloadCode, "@", "RAT::DS::ECAHeader", payloadCode, "@", "RAT::DS::EV", payloadCode, "@", "RAT::DS::Entry", payloadCode, "@", "RAT::DS::FitClassifierCollection", payloadCode, "@", "RAT::DS::FitClassifierCollection", payloadCode, "@", "RAT::DS::FitCollection", payloadCode, "@", "RAT::DS::FitResult", payloadCode, "@", "RAT::DS::FitVertex", payloadCode, "@", "RAT::DS::HeaderInfo", payloadCode, "@", "RAT::DS::MC", payloadCode, "@", "RAT::DS::MCEV", payloadCode, "@", "RAT::DS::MCHit", payloadCode, "@", "RAT::DS::MCHits", payloadCode, "@", "RAT::DS::MCPE", payloadCode, "@", "RAT::DS::MCPMT", payloadCode, "@", "RAT::DS::MCParticle", payloadCode, "@", "RAT::DS::MCPhoton", payloadCode, "@", "RAT::DS::MCTrack", payloadCode, "@", "RAT::DS::MCTrackStep", payloadCode, "@", "RAT::DS::Meta", payloadCode, "@", "RAT::DS::MetaDB", payloadCode, "@", "RAT::DS::PMT", payloadCode, "@", "RAT::DS::PMT", payloadCode, "@", "RAT::DS::PMTCal", payloadCode, "@", "RAT::DS::PMTFloat", payloadCode, "@", "RAT::DS::PMTSet", payloadCode, "@", "RAT::DS::PMTSet >", payloadCode, "@", "RAT::DS::PMTSet", payloadCode, "@", "RAT::DS::PMTUncal", payloadCode, "@", "RAT::DS::Run", payloadCode, "@", "RAT::DS::SOC", payloadCode, "@", "RAT::DS::SOCPMT", payloadCode, "@", "RAT::DS::TrigHeader", payloadCode, "@", "RAT::DS::UncalPMTs", payloadCode, "@", "RAT::DS::UniversalTime", payloadCode, "@", "RAT::DU::ChanHWStatus", payloadCode, "@", "RAT::DU::ChanSWStatus", payloadCode, "@", "RAT::DU::DSReader", payloadCode, "@", "RAT::DU::DataCleaningBits", payloadCode, "@", "RAT::DU::DataQualityBits", payloadCode, "@", "RAT::DU::DetectorStateCorrection", payloadCode, "@", "RAT::DU::EffectiveVelocity", payloadCode, "@", "RAT::DU::EnergySystematics", payloadCode, "@", "RAT::DU::GroupVelocity", payloadCode, "@", "RAT::DU::LightPathCalculator", payloadCode, "@", "RAT::DU::PMTCalStatus", payloadCode, "@", "RAT::DU::PMTInfo", payloadCode, "@", "RAT::DU::PanelInfo", payloadCode, "@", "RAT::DU::Point3D", payloadCode, "@", "RAT::DU::ReactorNuOsc", payloadCode, "@", "RAT::DU::ReconCalibrator", payloadCode, "@", "RAT::DU::ReconCorrector", payloadCode, "@", "RAT::DU::SOCReader", payloadCode, "@", "RAT::DU::Segmentor", payloadCode, "@", "RAT::DU::ShadowingCalculator", payloadCode, "@", "RAT::DU::TimeResidualCalculator", payloadCode, "@", "RAT::DU::TrigBits", payloadCode, "@", "RAT::DU::Utility", payloadCode, "@", "RAT::EventIsClean", payloadCode, "@", "RAT::FitterPMT", payloadCode, "@", "RAT::HTTPDownloader", payloadCode, "@", "RAT::LP::LightPath", payloadCode, "@", "RAT::LP::LightPathFitter", payloadCode, "@", "RAT::LP::LightPathStraightFitter", payloadCode, "@", "RAT::LP::LightPathStraightScint", payloadCode, "@", "RAT::LP::LightPathStraightScintWater", payloadCode, "@", "RAT::Log", payloadCode, "@", "RAT::MetaInformation", payloadCode, "@", "RAT::MissingBits", payloadCode, "@", "RAT::PgSQLBackend", payloadCode, "@", "RAT::SphereToIcosahedron", payloadCode, "@", "RAT::SunDirection", payloadCode, "@", "RAT::TrackCursor", payloadCode, "@", "RAT::TrackNav", payloadCode, "@", "RAT::TrackNode", payloadCode, "@", "RAT::TransformCoord", payloadCode, "@", "RAT::util::EnergyToWavelength", payloadCode, "@", "RAT::util::WavelengthToEnergy", payloadCode, "@", "ROOT::Math::Cartesian3D", payloadCode, "@", "ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>", payloadCode, "@", "ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>", payloadCode, "@", "ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>", payloadCode, "@", "ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag>", payloadCode, "@", "ROOT::Math::Polar3D", payloadCode, "@", "ROOT::Math::Polar3DVector", payloadCode, "@", "ROOT::Math::Polar3DVectorF", payloadCode, "@", "ROOT::Math::XYZVector", payloadCode, "@", "ROOT::Math::XYZVectorF", payloadCode, "@", "RunRecord", payloadCode, "@", "TriggerInfo", payloadCode, "@", "exception", "@", "json::Value", payloadCode, "@", "ratzdab::get_pdg_to_mass_map", payloadCode, "@", "ratzdab::get_pdg_to_snoman_map", payloadCode, "@", "ratzdab::pack::event", payloadCode, "@", "ratzdab::unknown_record_error", payloadCode, "@", "ratzdab::zdabfile", payloadCode, "@", "ratzdab::zdabfile::zdab_file_read_error", payloadCode, "@", "stlplus::simple_ptr_nocopy", payloadCode, "@", nullptr }; static bool isInitialized = false; if (!isInitialized) { TROOT::RegisterModule("RAT_Dict", headers, includePaths, payloadCode, fwdDeclCode, TriggerDictionaryInitialization_RAT_Dict_Impl, {}, classesHeaders, /*hasCxxModule*/false); isInitialized = true; } } static struct DictInit { DictInit() { TriggerDictionaryInitialization_RAT_Dict_Impl(); } } __TheDictionaryInitializer; } void TriggerDictionaryInitialization_RAT_Dict() { TriggerDictionaryInitialization_RAT_Dict_Impl(); }