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

#define R__DICTIONARY_FILENAME fluxdict
#define R__NO_DEPRECATION

/*******************************************************************/
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#define G__DICTIONARY
#include "RConfig.h"
#include "TClass.h"
#include "TDictAttributeMap.h"
#include "TInterpreter.h"
#include "TROOT.h"
#include "TBuffer.h"
#include "TMemberInspector.h"
#include "TInterpreter.h"
#include "TVirtualMutex.h"
#include "TError.h"

#ifndef G__ROOT
#define G__ROOT
#endif

#include "RtypesImp.h"
#include "TIsAProxy.h"
#include "TFileMergeInfo.h"
#include <algorithm>
#include "TCollectionProxyInfo.h"
/*******************************************************************/

#include "TDataMember.h"

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

// Header files passed as explicit arguments
#include "Flux.hh"

// Header files passed via #pragma extra_include

namespace KM3NET_FLUX {
   namespace ROOT {
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
      static TClass *KM3NET_FLUX_Dictionary();

      // Function generating the singleton type initializer
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
      {
         static ::ROOT::TGenericClassInfo 
            instance("KM3NET_FLUX", 0 /*version*/, "Flux.hh", 230,
                     ::ROOT::Internal::DefineBehavior((void*)0,(void*)0),
                     &KM3NET_FLUX_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 *KM3NET_FLUX_Dictionary() {
         return GenerateInitInstance()->GetClass();
      }

   }
}

namespace ROOT {
   static void delete_Flux(void *p);
   static void deleteArray_Flux(void *p);
   static void destruct_Flux(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Flux*)
   {
      ::Flux *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Flux >(0);
      static ::ROOT::TGenericClassInfo 
         instance("Flux", ::Flux::Class_Version(), "Flux.hh", 20,
                  typeid(::Flux), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::Flux::Dictionary, isa_proxy, 4,
                  sizeof(::Flux) );
      instance.SetDelete(&delete_Flux);
      instance.SetDeleteArray(&deleteArray_Flux);
      instance.SetDestructor(&destruct_Flux);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Flux*)
   {
      return GenerateInitInstanceLocal((::Flux*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Flux*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void delete_DiffuseFlux(void *p);
   static void deleteArray_DiffuseFlux(void *p);
   static void destruct_DiffuseFlux(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::DiffuseFlux*)
   {
      ::DiffuseFlux *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::DiffuseFlux >(0);
      static ::ROOT::TGenericClassInfo 
         instance("DiffuseFlux", ::DiffuseFlux::Class_Version(), "Flux.hh", 38,
                  typeid(::DiffuseFlux), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::DiffuseFlux::Dictionary, isa_proxy, 4,
                  sizeof(::DiffuseFlux) );
      instance.SetDelete(&delete_DiffuseFlux);
      instance.SetDeleteArray(&deleteArray_DiffuseFlux);
      instance.SetDestructor(&destruct_DiffuseFlux);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::DiffuseFlux*)
   {
      return GenerateInitInstanceLocal((::DiffuseFlux*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::DiffuseFlux*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void delete_ScalableFlux(void *p);
   static void deleteArray_ScalableFlux(void *p);
   static void destruct_ScalableFlux(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ScalableFlux*)
   {
      ::ScalableFlux *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::ScalableFlux >(0);
      static ::ROOT::TGenericClassInfo 
         instance("ScalableFlux", ::ScalableFlux::Class_Version(), "Flux.hh", 78,
                  typeid(::ScalableFlux), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::ScalableFlux::Dictionary, isa_proxy, 4,
                  sizeof(::ScalableFlux) );
      instance.SetDelete(&delete_ScalableFlux);
      instance.SetDeleteArray(&deleteArray_ScalableFlux);
      instance.SetDestructor(&destruct_ScalableFlux);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ScalableFlux*)
   {
      return GenerateInitInstanceLocal((::ScalableFlux*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ScalableFlux*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_PowerLawFlux(void *p = 0);
   static void *newArray_PowerLawFlux(Long_t size, void *p);
   static void delete_PowerLawFlux(void *p);
   static void deleteArray_PowerLawFlux(void *p);
   static void destruct_PowerLawFlux(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::PowerLawFlux*)
   {
      ::PowerLawFlux *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::PowerLawFlux >(0);
      static ::ROOT::TGenericClassInfo 
         instance("PowerLawFlux", ::PowerLawFlux::Class_Version(), "Flux.hh", 88,
                  typeid(::PowerLawFlux), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::PowerLawFlux::Dictionary, isa_proxy, 4,
                  sizeof(::PowerLawFlux) );
      instance.SetNew(&new_PowerLawFlux);
      instance.SetNewArray(&newArray_PowerLawFlux);
      instance.SetDelete(&delete_PowerLawFlux);
      instance.SetDeleteArray(&deleteArray_PowerLawFlux);
      instance.SetDestructor(&destruct_PowerLawFlux);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::PowerLawFlux*)
   {
      return GenerateInitInstanceLocal((::PowerLawFlux*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::PowerLawFlux*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_NuExprFlux(void *p = 0);
   static void *newArray_NuExprFlux(Long_t size, void *p);
   static void delete_NuExprFlux(void *p);
   static void deleteArray_NuExprFlux(void *p);
   static void destruct_NuExprFlux(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::NuExprFlux*)
   {
      ::NuExprFlux *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::NuExprFlux >(0);
      static ::ROOT::TGenericClassInfo 
         instance("NuExprFlux", ::NuExprFlux::Class_Version(), "Flux.hh", 123,
                  typeid(::NuExprFlux), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::NuExprFlux::Dictionary, isa_proxy, 4,
                  sizeof(::NuExprFlux) );
      instance.SetNew(&new_NuExprFlux);
      instance.SetNewArray(&newArray_NuExprFlux);
      instance.SetDelete(&delete_NuExprFlux);
      instance.SetDeleteArray(&deleteArray_NuExprFlux);
      instance.SetDestructor(&destruct_NuExprFlux);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::NuExprFlux*)
   {
      return GenerateInitInstanceLocal((::NuExprFlux*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NuExprFlux*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_NuFromGammaFlux(void *p = 0);
   static void *newArray_NuFromGammaFlux(Long_t size, void *p);
   static void delete_NuFromGammaFlux(void *p);
   static void deleteArray_NuFromGammaFlux(void *p);
   static void destruct_NuFromGammaFlux(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::NuFromGammaFlux*)
   {
      ::NuFromGammaFlux *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::NuFromGammaFlux >(0);
      static ::ROOT::TGenericClassInfo 
         instance("NuFromGammaFlux", ::NuFromGammaFlux::Class_Version(), "Flux.hh", 176,
                  typeid(::NuFromGammaFlux), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::NuFromGammaFlux::Dictionary, isa_proxy, 4,
                  sizeof(::NuFromGammaFlux) );
      instance.SetNew(&new_NuFromGammaFlux);
      instance.SetNewArray(&newArray_NuFromGammaFlux);
      instance.SetDelete(&delete_NuFromGammaFlux);
      instance.SetDeleteArray(&deleteArray_NuFromGammaFlux);
      instance.SetDestructor(&destruct_NuFromGammaFlux);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::NuFromGammaFlux*)
   {
      return GenerateInitInstanceLocal((::NuFromGammaFlux*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::NuFromGammaFlux*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void delete_IsotropicFlux(void *p);
   static void deleteArray_IsotropicFlux(void *p);
   static void destruct_IsotropicFlux(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::IsotropicFlux*)
   {
      ::IsotropicFlux *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::IsotropicFlux >(0);
      static ::ROOT::TGenericClassInfo 
         instance("IsotropicFlux", ::IsotropicFlux::Class_Version(), "Flux.hh", 258,
                  typeid(::IsotropicFlux), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::IsotropicFlux::Dictionary, isa_proxy, 4,
                  sizeof(::IsotropicFlux) );
      instance.SetDelete(&delete_IsotropicFlux);
      instance.SetDeleteArray(&deleteArray_IsotropicFlux);
      instance.SetDestructor(&destruct_IsotropicFlux);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::IsotropicFlux*)
   {
      return GenerateInitInstanceLocal((::IsotropicFlux*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IsotropicFlux*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_Flux_Honda2006(void *p = 0);
   static void *newArray_Flux_Honda2006(Long_t size, void *p);
   static void delete_Flux_Honda2006(void *p);
   static void deleteArray_Flux_Honda2006(void *p);
   static void destruct_Flux_Honda2006(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Flux_Honda2006*)
   {
      ::Flux_Honda2006 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Flux_Honda2006 >(0);
      static ::ROOT::TGenericClassInfo 
         instance("Flux_Honda2006", ::Flux_Honda2006::Class_Version(), "Flux.hh", 364,
                  typeid(::Flux_Honda2006), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::Flux_Honda2006::Dictionary, isa_proxy, 4,
                  sizeof(::Flux_Honda2006) );
      instance.SetNew(&new_Flux_Honda2006);
      instance.SetNewArray(&newArray_Flux_Honda2006);
      instance.SetDelete(&delete_Flux_Honda2006);
      instance.SetDeleteArray(&deleteArray_Flux_Honda2006);
      instance.SetDestructor(&destruct_Flux_Honda2006);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Flux_Honda2006*)
   {
      return GenerateInitInstanceLocal((::Flux_Honda2006*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Flux_Honda2006*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_Flux_prompt_Sarsevic_std(void *p = 0);
   static void *newArray_Flux_prompt_Sarsevic_std(Long_t size, void *p);
   static void delete_Flux_prompt_Sarsevic_std(void *p);
   static void deleteArray_Flux_prompt_Sarsevic_std(void *p);
   static void destruct_Flux_prompt_Sarsevic_std(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Flux_prompt_Sarsevic_std*)
   {
      ::Flux_prompt_Sarsevic_std *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Flux_prompt_Sarsevic_std >(0);
      static ::ROOT::TGenericClassInfo 
         instance("Flux_prompt_Sarsevic_std", ::Flux_prompt_Sarsevic_std::Class_Version(), "Flux.hh", 516,
                  typeid(::Flux_prompt_Sarsevic_std), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::Flux_prompt_Sarsevic_std::Dictionary, isa_proxy, 4,
                  sizeof(::Flux_prompt_Sarsevic_std) );
      instance.SetNew(&new_Flux_prompt_Sarsevic_std);
      instance.SetNewArray(&newArray_Flux_prompt_Sarsevic_std);
      instance.SetDelete(&delete_Flux_prompt_Sarsevic_std);
      instance.SetDeleteArray(&deleteArray_Flux_prompt_Sarsevic_std);
      instance.SetDestructor(&destruct_Flux_prompt_Sarsevic_std);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Flux_prompt_Sarsevic_std*)
   {
      return GenerateInitInstanceLocal((::Flux_prompt_Sarsevic_std*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Flux_prompt_Sarsevic_std*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_Flux_Atmospheric(void *p = 0);
   static void *newArray_Flux_Atmospheric(Long_t size, void *p);
   static void delete_Flux_Atmospheric(void *p);
   static void deleteArray_Flux_Atmospheric(void *p);
   static void destruct_Flux_Atmospheric(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Flux_Atmospheric*)
   {
      ::Flux_Atmospheric *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Flux_Atmospheric >(0);
      static ::ROOT::TGenericClassInfo 
         instance("Flux_Atmospheric", ::Flux_Atmospheric::Class_Version(), "Flux.hh", 690,
                  typeid(::Flux_Atmospheric), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::Flux_Atmospheric::Dictionary, isa_proxy, 4,
                  sizeof(::Flux_Atmospheric) );
      instance.SetNew(&new_Flux_Atmospheric);
      instance.SetNewArray(&newArray_Flux_Atmospheric);
      instance.SetDelete(&delete_Flux_Atmospheric);
      instance.SetDeleteArray(&deleteArray_Flux_Atmospheric);
      instance.SetDestructor(&destruct_Flux_Atmospheric);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Flux_Atmospheric*)
   {
      return GenerateInitInstanceLocal((::Flux_Atmospheric*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Flux_Atmospheric*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void delete_Flux_Bartol2004(void *p);
   static void deleteArray_Flux_Bartol2004(void *p);
   static void destruct_Flux_Bartol2004(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Flux_Bartol2004*)
   {
      ::Flux_Bartol2004 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Flux_Bartol2004 >(0);
      static ::ROOT::TGenericClassInfo 
         instance("Flux_Bartol2004", ::Flux_Bartol2004::Class_Version(), "Flux.hh", 711,
                  typeid(::Flux_Bartol2004), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::Flux_Bartol2004::Dictionary, isa_proxy, 4,
                  sizeof(::Flux_Bartol2004) );
      instance.SetDelete(&delete_Flux_Bartol2004);
      instance.SetDeleteArray(&deleteArray_Flux_Bartol2004);
      instance.SetDestructor(&destruct_Flux_Bartol2004);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Flux_Bartol2004*)
   {
      return GenerateInitInstanceLocal((::Flux_Bartol2004*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Flux_Bartol2004*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

//______________________________________________________________________________
atomic_TClass_ptr Flux::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *Flux::Class_Name()
{
   return "Flux";
}

//______________________________________________________________________________
const char *Flux::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::Flux*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int Flux::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::Flux*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *Flux::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Flux*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *Flux::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Flux*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
atomic_TClass_ptr DiffuseFlux::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *DiffuseFlux::Class_Name()
{
   return "DiffuseFlux";
}

//______________________________________________________________________________
const char *DiffuseFlux::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::DiffuseFlux*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int DiffuseFlux::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::DiffuseFlux*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *DiffuseFlux::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::DiffuseFlux*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *DiffuseFlux::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::DiffuseFlux*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
atomic_TClass_ptr ScalableFlux::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *ScalableFlux::Class_Name()
{
   return "ScalableFlux";
}

//______________________________________________________________________________
const char *ScalableFlux::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::ScalableFlux*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int ScalableFlux::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::ScalableFlux*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *ScalableFlux::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ScalableFlux*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *ScalableFlux::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ScalableFlux*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
atomic_TClass_ptr PowerLawFlux::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PowerLawFlux::Class_Name()
{
   return "PowerLawFlux";
}

//______________________________________________________________________________
const char *PowerLawFlux::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::PowerLawFlux*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PowerLawFlux::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::PowerLawFlux*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *PowerLawFlux::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::PowerLawFlux*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *PowerLawFlux::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::PowerLawFlux*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
atomic_TClass_ptr NuExprFlux::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *NuExprFlux::Class_Name()
{
   return "NuExprFlux";
}

//______________________________________________________________________________
const char *NuExprFlux::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::NuExprFlux*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int NuExprFlux::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::NuExprFlux*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *NuExprFlux::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::NuExprFlux*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *NuExprFlux::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::NuExprFlux*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
atomic_TClass_ptr NuFromGammaFlux::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *NuFromGammaFlux::Class_Name()
{
   return "NuFromGammaFlux";
}

//______________________________________________________________________________
const char *NuFromGammaFlux::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::NuFromGammaFlux*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int NuFromGammaFlux::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::NuFromGammaFlux*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *NuFromGammaFlux::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::NuFromGammaFlux*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *NuFromGammaFlux::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::NuFromGammaFlux*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
atomic_TClass_ptr IsotropicFlux::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *IsotropicFlux::Class_Name()
{
   return "IsotropicFlux";
}

//______________________________________________________________________________
const char *IsotropicFlux::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::IsotropicFlux*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int IsotropicFlux::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::IsotropicFlux*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *IsotropicFlux::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::IsotropicFlux*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *IsotropicFlux::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::IsotropicFlux*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
atomic_TClass_ptr Flux_Honda2006::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *Flux_Honda2006::Class_Name()
{
   return "Flux_Honda2006";
}

//______________________________________________________________________________
const char *Flux_Honda2006::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::Flux_Honda2006*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int Flux_Honda2006::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::Flux_Honda2006*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *Flux_Honda2006::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Flux_Honda2006*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *Flux_Honda2006::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Flux_Honda2006*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
atomic_TClass_ptr Flux_prompt_Sarsevic_std::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *Flux_prompt_Sarsevic_std::Class_Name()
{
   return "Flux_prompt_Sarsevic_std";
}

//______________________________________________________________________________
const char *Flux_prompt_Sarsevic_std::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::Flux_prompt_Sarsevic_std*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int Flux_prompt_Sarsevic_std::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::Flux_prompt_Sarsevic_std*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *Flux_prompt_Sarsevic_std::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Flux_prompt_Sarsevic_std*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *Flux_prompt_Sarsevic_std::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Flux_prompt_Sarsevic_std*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
atomic_TClass_ptr Flux_Atmospheric::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *Flux_Atmospheric::Class_Name()
{
   return "Flux_Atmospheric";
}

//______________________________________________________________________________
const char *Flux_Atmospheric::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::Flux_Atmospheric*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int Flux_Atmospheric::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::Flux_Atmospheric*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *Flux_Atmospheric::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Flux_Atmospheric*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *Flux_Atmospheric::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Flux_Atmospheric*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
atomic_TClass_ptr Flux_Bartol2004::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *Flux_Bartol2004::Class_Name()
{
   return "Flux_Bartol2004";
}

//______________________________________________________________________________
const char *Flux_Bartol2004::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::Flux_Bartol2004*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int Flux_Bartol2004::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::Flux_Bartol2004*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *Flux_Bartol2004::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Flux_Bartol2004*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *Flux_Bartol2004::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Flux_Bartol2004*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
void Flux::Streamer(TBuffer &R__b)
{
   // Stream an object of class Flux.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(Flux::Class(),this);
   } else {
      R__b.WriteClassBuffer(Flux::Class(),this);
   }
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_Flux(void *p) {
      delete ((::Flux*)p);
   }
   static void deleteArray_Flux(void *p) {
      delete [] ((::Flux*)p);
   }
   static void destruct_Flux(void *p) {
      typedef ::Flux current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Flux

//______________________________________________________________________________
void DiffuseFlux::Streamer(TBuffer &R__b)
{
   // Stream an object of class DiffuseFlux.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(DiffuseFlux::Class(),this);
   } else {
      R__b.WriteClassBuffer(DiffuseFlux::Class(),this);
   }
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_DiffuseFlux(void *p) {
      delete ((::DiffuseFlux*)p);
   }
   static void deleteArray_DiffuseFlux(void *p) {
      delete [] ((::DiffuseFlux*)p);
   }
   static void destruct_DiffuseFlux(void *p) {
      typedef ::DiffuseFlux current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::DiffuseFlux

//______________________________________________________________________________
void ScalableFlux::Streamer(TBuffer &R__b)
{
   // Stream an object of class ScalableFlux.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(ScalableFlux::Class(),this);
   } else {
      R__b.WriteClassBuffer(ScalableFlux::Class(),this);
   }
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ScalableFlux(void *p) {
      delete ((::ScalableFlux*)p);
   }
   static void deleteArray_ScalableFlux(void *p) {
      delete [] ((::ScalableFlux*)p);
   }
   static void destruct_ScalableFlux(void *p) {
      typedef ::ScalableFlux current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ScalableFlux

//______________________________________________________________________________
void PowerLawFlux::Streamer(TBuffer &R__b)
{
   // Stream an object of class PowerLawFlux.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(PowerLawFlux::Class(),this);
   } else {
      R__b.WriteClassBuffer(PowerLawFlux::Class(),this);
   }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_PowerLawFlux(void *p) {
      return  p ? new(p) ::PowerLawFlux : new ::PowerLawFlux;
   }
   static void *newArray_PowerLawFlux(Long_t nElements, void *p) {
      return p ? new(p) ::PowerLawFlux[nElements] : new ::PowerLawFlux[nElements];
   }
   // Wrapper around operator delete
   static void delete_PowerLawFlux(void *p) {
      delete ((::PowerLawFlux*)p);
   }
   static void deleteArray_PowerLawFlux(void *p) {
      delete [] ((::PowerLawFlux*)p);
   }
   static void destruct_PowerLawFlux(void *p) {
      typedef ::PowerLawFlux current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PowerLawFlux

//______________________________________________________________________________
void NuExprFlux::Streamer(TBuffer &R__b)
{
   // Stream an object of class NuExprFlux.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(NuExprFlux::Class(),this);
   } else {
      R__b.WriteClassBuffer(NuExprFlux::Class(),this);
   }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_NuExprFlux(void *p) {
      return  p ? new(p) ::NuExprFlux : new ::NuExprFlux;
   }
   static void *newArray_NuExprFlux(Long_t nElements, void *p) {
      return p ? new(p) ::NuExprFlux[nElements] : new ::NuExprFlux[nElements];
   }
   // Wrapper around operator delete
   static void delete_NuExprFlux(void *p) {
      delete ((::NuExprFlux*)p);
   }
   static void deleteArray_NuExprFlux(void *p) {
      delete [] ((::NuExprFlux*)p);
   }
   static void destruct_NuExprFlux(void *p) {
      typedef ::NuExprFlux current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::NuExprFlux

//______________________________________________________________________________
void NuFromGammaFlux::Streamer(TBuffer &R__b)
{
   // Stream an object of class NuFromGammaFlux.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(NuFromGammaFlux::Class(),this);
   } else {
      R__b.WriteClassBuffer(NuFromGammaFlux::Class(),this);
   }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_NuFromGammaFlux(void *p) {
      return  p ? new(p) ::NuFromGammaFlux : new ::NuFromGammaFlux;
   }
   static void *newArray_NuFromGammaFlux(Long_t nElements, void *p) {
      return p ? new(p) ::NuFromGammaFlux[nElements] : new ::NuFromGammaFlux[nElements];
   }
   // Wrapper around operator delete
   static void delete_NuFromGammaFlux(void *p) {
      delete ((::NuFromGammaFlux*)p);
   }
   static void deleteArray_NuFromGammaFlux(void *p) {
      delete [] ((::NuFromGammaFlux*)p);
   }
   static void destruct_NuFromGammaFlux(void *p) {
      typedef ::NuFromGammaFlux current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::NuFromGammaFlux

//______________________________________________________________________________
void IsotropicFlux::Streamer(TBuffer &R__b)
{
   // Stream an object of class IsotropicFlux.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(IsotropicFlux::Class(),this);
   } else {
      R__b.WriteClassBuffer(IsotropicFlux::Class(),this);
   }
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_IsotropicFlux(void *p) {
      delete ((::IsotropicFlux*)p);
   }
   static void deleteArray_IsotropicFlux(void *p) {
      delete [] ((::IsotropicFlux*)p);
   }
   static void destruct_IsotropicFlux(void *p) {
      typedef ::IsotropicFlux current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::IsotropicFlux

//______________________________________________________________________________
void Flux_Honda2006::Streamer(TBuffer &R__b)
{
   // Stream an object of class Flux_Honda2006.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(Flux_Honda2006::Class(),this);
   } else {
      R__b.WriteClassBuffer(Flux_Honda2006::Class(),this);
   }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_Flux_Honda2006(void *p) {
      return  p ? new(p) ::Flux_Honda2006 : new ::Flux_Honda2006;
   }
   static void *newArray_Flux_Honda2006(Long_t nElements, void *p) {
      return p ? new(p) ::Flux_Honda2006[nElements] : new ::Flux_Honda2006[nElements];
   }
   // Wrapper around operator delete
   static void delete_Flux_Honda2006(void *p) {
      delete ((::Flux_Honda2006*)p);
   }
   static void deleteArray_Flux_Honda2006(void *p) {
      delete [] ((::Flux_Honda2006*)p);
   }
   static void destruct_Flux_Honda2006(void *p) {
      typedef ::Flux_Honda2006 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Flux_Honda2006

//______________________________________________________________________________
void Flux_prompt_Sarsevic_std::Streamer(TBuffer &R__b)
{
   // Stream an object of class Flux_prompt_Sarsevic_std.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(Flux_prompt_Sarsevic_std::Class(),this);
   } else {
      R__b.WriteClassBuffer(Flux_prompt_Sarsevic_std::Class(),this);
   }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_Flux_prompt_Sarsevic_std(void *p) {
      return  p ? new(p) ::Flux_prompt_Sarsevic_std : new ::Flux_prompt_Sarsevic_std;
   }
   static void *newArray_Flux_prompt_Sarsevic_std(Long_t nElements, void *p) {
      return p ? new(p) ::Flux_prompt_Sarsevic_std[nElements] : new ::Flux_prompt_Sarsevic_std[nElements];
   }
   // Wrapper around operator delete
   static void delete_Flux_prompt_Sarsevic_std(void *p) {
      delete ((::Flux_prompt_Sarsevic_std*)p);
   }
   static void deleteArray_Flux_prompt_Sarsevic_std(void *p) {
      delete [] ((::Flux_prompt_Sarsevic_std*)p);
   }
   static void destruct_Flux_prompt_Sarsevic_std(void *p) {
      typedef ::Flux_prompt_Sarsevic_std current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Flux_prompt_Sarsevic_std

//______________________________________________________________________________
void Flux_Atmospheric::Streamer(TBuffer &R__b)
{
   // Stream an object of class Flux_Atmospheric.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(Flux_Atmospheric::Class(),this);
   } else {
      R__b.WriteClassBuffer(Flux_Atmospheric::Class(),this);
   }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_Flux_Atmospheric(void *p) {
      return  p ? new(p) ::Flux_Atmospheric : new ::Flux_Atmospheric;
   }
   static void *newArray_Flux_Atmospheric(Long_t nElements, void *p) {
      return p ? new(p) ::Flux_Atmospheric[nElements] : new ::Flux_Atmospheric[nElements];
   }
   // Wrapper around operator delete
   static void delete_Flux_Atmospheric(void *p) {
      delete ((::Flux_Atmospheric*)p);
   }
   static void deleteArray_Flux_Atmospheric(void *p) {
      delete [] ((::Flux_Atmospheric*)p);
   }
   static void destruct_Flux_Atmospheric(void *p) {
      typedef ::Flux_Atmospheric current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Flux_Atmospheric

//______________________________________________________________________________
void Flux_Bartol2004::Streamer(TBuffer &R__b)
{
   // Stream an object of class Flux_Bartol2004.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(Flux_Bartol2004::Class(),this);
   } else {
      R__b.WriteClassBuffer(Flux_Bartol2004::Class(),this);
   }
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_Flux_Bartol2004(void *p) {
      delete ((::Flux_Bartol2004*)p);
   }
   static void deleteArray_Flux_Bartol2004(void *p) {
      delete [] ((::Flux_Bartol2004*)p);
   }
   static void destruct_Flux_Bartol2004(void *p) {
      typedef ::Flux_Bartol2004 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Flux_Bartol2004

namespace ROOT {
   static TClass *maplEstringcOTH2FgR_Dictionary();
   static void maplEstringcOTH2FgR_TClassManip(TClass*);
   static void *new_maplEstringcOTH2FgR(void *p = 0);
   static void *newArray_maplEstringcOTH2FgR(Long_t size, void *p);
   static void delete_maplEstringcOTH2FgR(void *p);
   static void deleteArray_maplEstringcOTH2FgR(void *p);
   static void destruct_maplEstringcOTH2FgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const map<string,TH2F>*)
   {
      map<string,TH2F> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<string,TH2F>));
      static ::ROOT::TGenericClassInfo 
         instance("map<string,TH2F>", -2, "map", 96,
                  typeid(map<string,TH2F>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &maplEstringcOTH2FgR_Dictionary, isa_proxy, 0,
                  sizeof(map<string,TH2F>) );
      instance.SetNew(&new_maplEstringcOTH2FgR);
      instance.SetNewArray(&newArray_maplEstringcOTH2FgR);
      instance.SetDelete(&delete_maplEstringcOTH2FgR);
      instance.SetDeleteArray(&deleteArray_maplEstringcOTH2FgR);
      instance.SetDestructor(&destruct_maplEstringcOTH2FgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<string,TH2F> >()));

      ::ROOT::AddClassAlternate("map<string,TH2F>","std::map<std::string, TH2F, std::less<std::string>, std::allocator<std::pair<std::string const, TH2F> > >");
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const map<string,TH2F>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *maplEstringcOTH2FgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const map<string,TH2F>*)0x0)->GetClass();
      maplEstringcOTH2FgR_TClassManip(theClass);
   return theClass;
   }

   static void maplEstringcOTH2FgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_maplEstringcOTH2FgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map<string,TH2F> : new map<string,TH2F>;
   }
   static void *newArray_maplEstringcOTH2FgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map<string,TH2F>[nElements] : new map<string,TH2F>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEstringcOTH2FgR(void *p) {
      delete ((map<string,TH2F>*)p);
   }
   static void deleteArray_maplEstringcOTH2FgR(void *p) {
      delete [] ((map<string,TH2F>*)p);
   }
   static void destruct_maplEstringcOTH2FgR(void *p) {
      typedef map<string,TH2F> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class map<string,TH2F>

namespace {
  void TriggerDictionaryInitialization_fluxdict_Impl() {
    static const char* headers[] = {
"Flux.hh",
0
    };
    static const char* includePaths[] = {
"/builds/common/jpp/externals/km3net-dataformat/..",
"/usr/local/include/",
"/builds/common/jpp/externals/flux/",
0
    };
    static const char* fwdDeclCode = R"DICTFWDDCLS(
#line 1 "fluxdict dictionary forward declarations' payload"
#pragma clang diagnostic ignored "-Wkeyword-compat"
#pragma clang diagnostic ignored "-Wignored-attributes"
#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
extern int __Cling_AutoLoading_Map;
struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Flux.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Flux.hh")))  Flux;
struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Flux.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Flux.hh")))  DiffuseFlux;
struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Flux.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Flux.hh")))  ScalableFlux;
struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Flux.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Flux.hh")))  PowerLawFlux;
struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Flux.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Flux.hh")))  NuExprFlux;
struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Flux.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Flux.hh")))  NuFromGammaFlux;
struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Flux.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Flux.hh")))  IsotropicFlux;
struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Flux.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Flux.hh")))  Flux_Honda2006;
struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Flux.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Flux.hh")))  Flux_prompt_Sarsevic_std;
struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Flux.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Flux.hh")))  Flux_Atmospheric;
struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Flux.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Flux.hh")))  Flux_Bartol2004;
)DICTFWDDCLS";
    static const char* payloadCode = R"DICTPAYLOAD(
#line 1 "fluxdict dictionary payload"


#define _BACKWARD_BACKWARD_WARNING_H
// Inline headers
#include "Flux.hh"

#undef  _BACKWARD_BACKWARD_WARNING_H
)DICTPAYLOAD";
    static const char* classesHeaders[] = {
"", payloadCode, "@",
"DiffuseFlux", payloadCode, "@",
"DiffuseFlux::fgIsA", payloadCode, "@",
"Flux", payloadCode, "@",
"Flux::fgIsA", payloadCode, "@",
"Flux_Atmospheric", payloadCode, "@",
"Flux_Atmospheric::fgIsA", payloadCode, "@",
"Flux_Bartol2004", payloadCode, "@",
"Flux_Bartol2004::fgIsA", payloadCode, "@",
"Flux_Honda2006", payloadCode, "@",
"Flux_Honda2006::fgIsA", payloadCode, "@",
"Flux_prompt_Sarsevic_std", payloadCode, "@",
"Flux_prompt_Sarsevic_std::fgIsA", payloadCode, "@",
"IsotropicFlux", payloadCode, "@",
"IsotropicFlux::fgIsA", payloadCode, "@",
"KM3NET_FLUX::simple_hash", payloadCode, "@",
"NuExprFlux", payloadCode, "@",
"NuExprFlux::fgIsA", payloadCode, "@",
"NuFromGammaFlux", payloadCode, "@",
"NuFromGammaFlux::fgIsA", payloadCode, "@",
"PowerLawFlux", payloadCode, "@",
"PowerLawFlux::fgIsA", payloadCode, "@",
"ScalableFlux", payloadCode, "@",
"ScalableFlux::fgIsA", payloadCode, "@",
"correctKnee", payloadCode, "@",
"correctKneeFit1", payloadCode, "@",
"correctKneeFit2", payloadCode, "@",
"operator<<", payloadCode, "@",
nullptr
};
    static bool isInitialized = false;
    if (!isInitialized) {
      TROOT::RegisterModule("fluxdict",
        headers, includePaths, payloadCode, fwdDeclCode,
        TriggerDictionaryInitialization_fluxdict_Impl, {}, classesHeaders, /*hasCxxModule*/false);
      isInitialized = true;
    }
  }
  static struct DictInit {
    DictInit() {
      TriggerDictionaryInitialization_fluxdict_Impl();
    }
  } __TheDictionaryInitializer;
}
void TriggerDictionaryInitialization_fluxdict() {
  TriggerDictionaryInitialization_fluxdict_Impl();
}