EventDisplayCint.cc

Go to the documentation of this file.

// Do NOT change. Changes will be lost next time file is generated

#define R__DICTIONARY_FILENAME dIscratchdIworkspacedIbuildmIlarsoftdIBUILDTYPEdIdebugdIQUALdIs131mIc14dIlabel1dIswarmdIlabel2dISLF7dIbuilddIlareventdisplaydIv09_11_05mIbuildFWdIbuilddIlareventdisplaydIEventDisplaydIEventDisplayCint
#define R__NO_DEPRECATION

/*******************************************************************/
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#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 <algorithm>
#include "TCollectionProxyInfo.h"
/*******************************************************************/

#include "TDataMember.h"

// Header files passed as explicit arguments
#include "lareventdisplay/EventDisplay/TWireProjPad.h"
#include "lareventdisplay/EventDisplay/TWQProjectionView.h"
#include "lareventdisplay/EventDisplay/TWQMultiTPCProjection.h"
#include "lareventdisplay/EventDisplay/TQPad.h"
#include "lareventdisplay/EventDisplay/Style.h"
#include "lareventdisplay/EventDisplay/SimulationDrawer.h"
#include "lareventdisplay/EventDisplay/RecoBaseDrawer.h"
#include "lareventdisplay/EventDisplay/RawDataDrawer.h"
#include "lareventdisplay/EventDisplay/Ortho3DView.h"
#include "lareventdisplay/EventDisplay/Ortho3DPad.h"
#include "lareventdisplay/EventDisplay/MCBriefPad.h"
#include "lareventdisplay/EventDisplay/HitSelector.h"
#include "lareventdisplay/EventDisplay/HeaderPad.h"
#include "lareventdisplay/EventDisplay/HeaderDrawer.h"
#include "lareventdisplay/EventDisplay/GraphClusterAlg.h"
#include "lareventdisplay/EventDisplay/DrawingPad.h"
#include "lareventdisplay/EventDisplay/Display3DView.h"
#include "lareventdisplay/EventDisplay/Display3DPad.h"
#include "lareventdisplay/EventDisplay/CalorView.h"
#include "lareventdisplay/EventDisplay/CalorPad.h"
#include "lareventdisplay/EventDisplay/AnalysisBaseDrawer.h"

// Header files passed via #pragma extra_include

// The generated code does not explicitly qualify STL entities
namespace std {} using namespace std;

namespace evd {
   namespace ROOTDict {
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
      static TClass *evd_Dictionary();

      // Function generating the singleton type initializer
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
      {
         static ::ROOT::TGenericClassInfo 
            instance("evd", 0 /*version*/, "DrawingPad.h", 17,
                     ::ROOT::Internal::DefineBehavior((void*)nullptr,(void*)nullptr),
                     &evd_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 *evd_Dictionary() {
         return GenerateInitInstance()->GetClass();
      }

   }
}

namespace ROOT {
   static TClass *evdcLcLDrawingPad_Dictionary();
   static void evdcLcLDrawingPad_TClassManip(TClass*);
   static void delete_evdcLcLDrawingPad(void *p);
   static void deleteArray_evdcLcLDrawingPad(void *p);
   static void destruct_evdcLcLDrawingPad(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evd::DrawingPad*)
   {
      ::evd::DrawingPad *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::evd::DrawingPad));
      static ::ROOT::TGenericClassInfo 
         instance("evd::DrawingPad", "DrawingPad.h", 27,
                  typeid(::evd::DrawingPad), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &evdcLcLDrawingPad_Dictionary, isa_proxy, 1,
                  sizeof(::evd::DrawingPad) );
      instance.SetDelete(&delete_evdcLcLDrawingPad);
      instance.SetDeleteArray(&deleteArray_evdcLcLDrawingPad);
      instance.SetDestructor(&destruct_evdcLcLDrawingPad);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evd::DrawingPad*)
   {
      return GenerateInitInstanceLocal(static_cast<::evd::DrawingPad*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::evd::DrawingPad*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *evdcLcLDrawingPad_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::evd::DrawingPad*>(nullptr))->GetClass();
      evdcLcLDrawingPad_TClassManip(theClass);
   return theClass;
   }

   static void evdcLcLDrawingPad_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *evdcLcLTWQProjectionView_Dictionary();
   static void evdcLcLTWQProjectionView_TClassManip(TClass*);
   static void delete_evdcLcLTWQProjectionView(void *p);
   static void deleteArray_evdcLcLTWQProjectionView(void *p);
   static void destruct_evdcLcLTWQProjectionView(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evd::TWQProjectionView*)
   {
      ::evd::TWQProjectionView *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::evd::TWQProjectionView));
      static ::ROOT::TGenericClassInfo 
         instance("evd::TWQProjectionView", "TWQProjectionView.h", 55,
                  typeid(::evd::TWQProjectionView), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &evdcLcLTWQProjectionView_Dictionary, isa_proxy, 1,
                  sizeof(::evd::TWQProjectionView) );
      instance.SetDelete(&delete_evdcLcLTWQProjectionView);
      instance.SetDeleteArray(&deleteArray_evdcLcLTWQProjectionView);
      instance.SetDestructor(&destruct_evdcLcLTWQProjectionView);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evd::TWQProjectionView*)
   {
      return GenerateInitInstanceLocal(static_cast<::evd::TWQProjectionView*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::evd::TWQProjectionView*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *evdcLcLTWQProjectionView_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::evd::TWQProjectionView*>(nullptr))->GetClass();
      evdcLcLTWQProjectionView_TClassManip(theClass);
   return theClass;
   }

   static void evdcLcLTWQProjectionView_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *evdcLcLTWQMultiTPCProjectionView_Dictionary();
   static void evdcLcLTWQMultiTPCProjectionView_TClassManip(TClass*);
   static void delete_evdcLcLTWQMultiTPCProjectionView(void *p);
   static void deleteArray_evdcLcLTWQMultiTPCProjectionView(void *p);
   static void destruct_evdcLcLTWQMultiTPCProjectionView(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evd::TWQMultiTPCProjectionView*)
   {
      ::evd::TWQMultiTPCProjectionView *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::evd::TWQMultiTPCProjectionView));
      static ::ROOT::TGenericClassInfo 
         instance("evd::TWQMultiTPCProjectionView", "TWQMultiTPCProjection.h", 56,
                  typeid(::evd::TWQMultiTPCProjectionView), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &evdcLcLTWQMultiTPCProjectionView_Dictionary, isa_proxy, 1,
                  sizeof(::evd::TWQMultiTPCProjectionView) );
      instance.SetDelete(&delete_evdcLcLTWQMultiTPCProjectionView);
      instance.SetDeleteArray(&deleteArray_evdcLcLTWQMultiTPCProjectionView);
      instance.SetDestructor(&destruct_evdcLcLTWQMultiTPCProjectionView);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evd::TWQMultiTPCProjectionView*)
   {
      return GenerateInitInstanceLocal(static_cast<::evd::TWQMultiTPCProjectionView*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::evd::TWQMultiTPCProjectionView*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *evdcLcLTWQMultiTPCProjectionView_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::evd::TWQMultiTPCProjectionView*>(nullptr))->GetClass();
      evdcLcLTWQMultiTPCProjectionView_TClassManip(theClass);
   return theClass;
   }

   static void evdcLcLTWQMultiTPCProjectionView_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *evdcLcLOrtho3DView_Dictionary();
   static void evdcLcLOrtho3DView_TClassManip(TClass*);
   static void delete_evdcLcLOrtho3DView(void *p);
   static void deleteArray_evdcLcLOrtho3DView(void *p);
   static void destruct_evdcLcLOrtho3DView(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evd::Ortho3DView*)
   {
      ::evd::Ortho3DView *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::evd::Ortho3DView));
      static ::ROOT::TGenericClassInfo 
         instance("evd::Ortho3DView", "Ortho3DView.h", 21,
                  typeid(::evd::Ortho3DView), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &evdcLcLOrtho3DView_Dictionary, isa_proxy, 1,
                  sizeof(::evd::Ortho3DView) );
      instance.SetDelete(&delete_evdcLcLOrtho3DView);
      instance.SetDeleteArray(&deleteArray_evdcLcLOrtho3DView);
      instance.SetDestructor(&destruct_evdcLcLOrtho3DView);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evd::Ortho3DView*)
   {
      return GenerateInitInstanceLocal(static_cast<::evd::Ortho3DView*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::evd::Ortho3DView*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *evdcLcLOrtho3DView_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::evd::Ortho3DView*>(nullptr))->GetClass();
      evdcLcLOrtho3DView_TClassManip(theClass);
   return theClass;
   }

   static void evdcLcLOrtho3DView_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *evdcLcLOrtho3DPad_Dictionary();
   static void evdcLcLOrtho3DPad_TClassManip(TClass*);
   static void delete_evdcLcLOrtho3DPad(void *p);
   static void deleteArray_evdcLcLOrtho3DPad(void *p);
   static void destruct_evdcLcLOrtho3DPad(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evd::Ortho3DPad*)
   {
      ::evd::Ortho3DPad *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::evd::Ortho3DPad));
      static ::ROOT::TGenericClassInfo 
         instance("evd::Ortho3DPad", "Ortho3DPad.h", 28,
                  typeid(::evd::Ortho3DPad), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &evdcLcLOrtho3DPad_Dictionary, isa_proxy, 1,
                  sizeof(::evd::Ortho3DPad) );
      instance.SetDelete(&delete_evdcLcLOrtho3DPad);
      instance.SetDeleteArray(&deleteArray_evdcLcLOrtho3DPad);
      instance.SetDestructor(&destruct_evdcLcLOrtho3DPad);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evd::Ortho3DPad*)
   {
      return GenerateInitInstanceLocal(static_cast<::evd::Ortho3DPad*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::evd::Ortho3DPad*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *evdcLcLOrtho3DPad_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::evd::Ortho3DPad*>(nullptr))->GetClass();
      evdcLcLOrtho3DPad_TClassManip(theClass);
   return theClass;
   }

   static void evdcLcLOrtho3DPad_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *evdcLcLDisplay3DView_Dictionary();
   static void evdcLcLDisplay3DView_TClassManip(TClass*);
   static void delete_evdcLcLDisplay3DView(void *p);
   static void deleteArray_evdcLcLDisplay3DView(void *p);
   static void destruct_evdcLcLDisplay3DView(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evd::Display3DView*)
   {
      ::evd::Display3DView *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::evd::Display3DView));
      static ::ROOT::TGenericClassInfo 
         instance("evd::Display3DView", "Display3DView.h", 16,
                  typeid(::evd::Display3DView), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &evdcLcLDisplay3DView_Dictionary, isa_proxy, 1,
                  sizeof(::evd::Display3DView) );
      instance.SetDelete(&delete_evdcLcLDisplay3DView);
      instance.SetDeleteArray(&deleteArray_evdcLcLDisplay3DView);
      instance.SetDestructor(&destruct_evdcLcLDisplay3DView);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evd::Display3DView*)
   {
      return GenerateInitInstanceLocal(static_cast<::evd::Display3DView*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::evd::Display3DView*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *evdcLcLDisplay3DView_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::evd::Display3DView*>(nullptr))->GetClass();
      evdcLcLDisplay3DView_TClassManip(theClass);
   return theClass;
   }

   static void evdcLcLDisplay3DView_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *evdcLcLCalorView_Dictionary();
   static void evdcLcLCalorView_TClassManip(TClass*);
   static void delete_evdcLcLCalorView(void *p);
   static void deleteArray_evdcLcLCalorView(void *p);
   static void destruct_evdcLcLCalorView(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::evd::CalorView*)
   {
      ::evd::CalorView *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::evd::CalorView));
      static ::ROOT::TGenericClassInfo 
         instance("evd::CalorView", "CalorView.h", 20,
                  typeid(::evd::CalorView), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &evdcLcLCalorView_Dictionary, isa_proxy, 1,
                  sizeof(::evd::CalorView) );
      instance.SetDelete(&delete_evdcLcLCalorView);
      instance.SetDeleteArray(&deleteArray_evdcLcLCalorView);
      instance.SetDestructor(&destruct_evdcLcLCalorView);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::evd::CalorView*)
   {
      return GenerateInitInstanceLocal(static_cast<::evd::CalorView*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::evd::CalorView*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *evdcLcLCalorView_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::evd::CalorView*>(nullptr))->GetClass();
      evdcLcLCalorView_TClassManip(theClass);
   return theClass;
   }

   static void evdcLcLCalorView_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrapper around operator delete
   static void delete_evdcLcLDrawingPad(void *p) {
      delete (static_cast<::evd::DrawingPad*>(p));
   }
   static void deleteArray_evdcLcLDrawingPad(void *p) {
      delete [] (static_cast<::evd::DrawingPad*>(p));
   }
   static void destruct_evdcLcLDrawingPad(void *p) {
      typedef ::evd::DrawingPad current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::evd::DrawingPad

namespace ROOT {
   // Wrapper around operator delete
   static void delete_evdcLcLTWQProjectionView(void *p) {
      delete (static_cast<::evd::TWQProjectionView*>(p));
   }
   static void deleteArray_evdcLcLTWQProjectionView(void *p) {
      delete [] (static_cast<::evd::TWQProjectionView*>(p));
   }
   static void destruct_evdcLcLTWQProjectionView(void *p) {
      typedef ::evd::TWQProjectionView current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::evd::TWQProjectionView

namespace ROOT {
   // Wrapper around operator delete
   static void delete_evdcLcLTWQMultiTPCProjectionView(void *p) {
      delete (static_cast<::evd::TWQMultiTPCProjectionView*>(p));
   }
   static void deleteArray_evdcLcLTWQMultiTPCProjectionView(void *p) {
      delete [] (static_cast<::evd::TWQMultiTPCProjectionView*>(p));
   }
   static void destruct_evdcLcLTWQMultiTPCProjectionView(void *p) {
      typedef ::evd::TWQMultiTPCProjectionView current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::evd::TWQMultiTPCProjectionView

namespace ROOT {
   // Wrapper around operator delete
   static void delete_evdcLcLOrtho3DView(void *p) {
      delete (static_cast<::evd::Ortho3DView*>(p));
   }
   static void deleteArray_evdcLcLOrtho3DView(void *p) {
      delete [] (static_cast<::evd::Ortho3DView*>(p));
   }
   static void destruct_evdcLcLOrtho3DView(void *p) {
      typedef ::evd::Ortho3DView current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::evd::Ortho3DView

namespace ROOT {
   // Wrapper around operator delete
   static void delete_evdcLcLOrtho3DPad(void *p) {
      delete (static_cast<::evd::Ortho3DPad*>(p));
   }
   static void deleteArray_evdcLcLOrtho3DPad(void *p) {
      delete [] (static_cast<::evd::Ortho3DPad*>(p));
   }
   static void destruct_evdcLcLOrtho3DPad(void *p) {
      typedef ::evd::Ortho3DPad current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::evd::Ortho3DPad

namespace ROOT {
   // Wrapper around operator delete
   static void delete_evdcLcLDisplay3DView(void *p) {
      delete (static_cast<::evd::Display3DView*>(p));
   }
   static void deleteArray_evdcLcLDisplay3DView(void *p) {
      delete [] (static_cast<::evd::Display3DView*>(p));
   }
   static void destruct_evdcLcLDisplay3DView(void *p) {
      typedef ::evd::Display3DView current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::evd::Display3DView

namespace ROOT {
   // Wrapper around operator delete
   static void delete_evdcLcLCalorView(void *p) {
      delete (static_cast<::evd::CalorView*>(p));
   }
   static void deleteArray_evdcLcLCalorView(void *p) {
      delete [] (static_cast<::evd::CalorView*>(p));
   }
   static void destruct_evdcLcLCalorView(void *p) {
      typedef ::evd::CalorView current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::evd::CalorView

namespace {
  void TriggerDictionaryInitialization_libEventDisplay_Impl() {
    static const char* headers[] = {
"lareventdisplay/EventDisplay/TWireProjPad.h",
"lareventdisplay/EventDisplay/TWQProjectionView.h",
"lareventdisplay/EventDisplay/TWQMultiTPCProjection.h",
"lareventdisplay/EventDisplay/TQPad.h",
"lareventdisplay/EventDisplay/Style.h",
"lareventdisplay/EventDisplay/SimulationDrawer.h",
"lareventdisplay/EventDisplay/RecoBaseDrawer.h",
"lareventdisplay/EventDisplay/RawDataDrawer.h",
"lareventdisplay/EventDisplay/Ortho3DView.h",
"lareventdisplay/EventDisplay/Ortho3DPad.h",
"lareventdisplay/EventDisplay/MCBriefPad.h",
"lareventdisplay/EventDisplay/HitSelector.h",
"lareventdisplay/EventDisplay/HeaderPad.h",
"lareventdisplay/EventDisplay/HeaderDrawer.h",
"lareventdisplay/EventDisplay/GraphClusterAlg.h",
"lareventdisplay/EventDisplay/DrawingPad.h",
"lareventdisplay/EventDisplay/Display3DView.h",
"lareventdisplay/EventDisplay/Display3DPad.h",
"lareventdisplay/EventDisplay/CalorView.h",
"lareventdisplay/EventDisplay/CalorPad.h",
"lareventdisplay/EventDisplay/AnalysisBaseDrawer.h",
nullptr
    };
    static const char* includePaths[] = {
nullptr
    };
    static const char* fwdDeclCode = R"DICTFWDDCLS(
#line 1 "libEventDisplay dictionary forward declarations' payload"
#pragma clang diagnostic ignored "-Wkeyword-compat"
#pragma clang diagnostic ignored "-Wignored-attributes"
#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
extern int __Cling_AutoLoading_Map;
namespace evd{class __attribute__((annotate("$clingAutoload$lareventdisplay/EventDisplay/DrawingPad.h")))  __attribute__((annotate("$clingAutoload$lareventdisplay/EventDisplay/TWireProjPad.h")))  DrawingPad;}
namespace evd{class __attribute__((annotate("$clingAutoload$lareventdisplay/EventDisplay/TWQProjectionView.h")))  TWQProjectionView;}
namespace evd{class __attribute__((annotate("$clingAutoload$lareventdisplay/EventDisplay/TWQMultiTPCProjection.h")))  TWQMultiTPCProjectionView;}
namespace evd{class __attribute__((annotate("$clingAutoload$lareventdisplay/EventDisplay/Ortho3DView.h")))  Ortho3DView;}
namespace evd{class __attribute__((annotate("$clingAutoload$lareventdisplay/EventDisplay/Ortho3DPad.h")))  Ortho3DPad;}
namespace evd{class __attribute__((annotate("$clingAutoload$lareventdisplay/EventDisplay/Display3DView.h")))  Display3DView;}
namespace evd{class __attribute__((annotate("$clingAutoload$lareventdisplay/EventDisplay/CalorView.h")))  CalorView;}
)DICTFWDDCLS";
    static const char* payloadCode = R"DICTPAYLOAD(
#line 1 "libEventDisplay dictionary payload"

#ifndef USE_ROOT
  #define USE_ROOT 1
#endif

#define _BACKWARD_BACKWARD_WARNING_H
// Inline headers
#include "lareventdisplay/EventDisplay/TWireProjPad.h"
#include "lareventdisplay/EventDisplay/TWQProjectionView.h"
#include "lareventdisplay/EventDisplay/TWQMultiTPCProjection.h"
#include "lareventdisplay/EventDisplay/TQPad.h"
#include "lareventdisplay/EventDisplay/Style.h"
#include "lareventdisplay/EventDisplay/SimulationDrawer.h"
#include "lareventdisplay/EventDisplay/RecoBaseDrawer.h"
#include "lareventdisplay/EventDisplay/RawDataDrawer.h"
#include "lareventdisplay/EventDisplay/Ortho3DView.h"
#include "lareventdisplay/EventDisplay/Ortho3DPad.h"
#include "lareventdisplay/EventDisplay/MCBriefPad.h"
#include "lareventdisplay/EventDisplay/HitSelector.h"
#include "lareventdisplay/EventDisplay/HeaderPad.h"
#include "lareventdisplay/EventDisplay/HeaderDrawer.h"
#include "lareventdisplay/EventDisplay/GraphClusterAlg.h"
#include "lareventdisplay/EventDisplay/DrawingPad.h"
#include "lareventdisplay/EventDisplay/Display3DView.h"
#include "lareventdisplay/EventDisplay/Display3DPad.h"
#include "lareventdisplay/EventDisplay/CalorView.h"
#include "lareventdisplay/EventDisplay/CalorPad.h"
#include "lareventdisplay/EventDisplay/AnalysisBaseDrawer.h"

#undef  _BACKWARD_BACKWARD_WARNING_H
)DICTPAYLOAD";
    static const char* classesHeaders[] = {
"evd::CalorView", payloadCode, "@",
"evd::Display3DView", payloadCode, "@",
"evd::DrawingPad", payloadCode, "@",
"evd::Ortho3DPad", payloadCode, "@",
"evd::Ortho3DView", payloadCode, "@",
"evd::TWQMultiTPCProjectionView", payloadCode, "@",
"evd::TWQProjectionView", payloadCode, "@",
nullptr
};
    static bool isInitialized = false;
    if (!isInitialized) {
      TROOT::RegisterModule("libEventDisplay",
        headers, includePaths, payloadCode, fwdDeclCode,
        TriggerDictionaryInitialization_libEventDisplay_Impl, {}, classesHeaders, /*hasCxxModule*/false);
      isInitialized = true;
    }
  }
  static struct DictInit {
    DictInit() {
      TriggerDictionaryInitialization_libEventDisplay_Impl();
    }
  } __TheDictionaryInitializer;
}
void TriggerDictionaryInitialization_libEventDisplay() {
  TriggerDictionaryInitialization_libEventDisplay_Impl();
}