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

#define R__DICTIONARY_FILENAME KM3NeTDictionary
#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 "/builds/common/jpp/externals/km3net-dataformat/online/JDAQ.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQAbstractPreamble.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQChronometer.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQClock.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQDataTypes.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQEvent.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQEventHeader.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQException.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQFrame.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQFrameStatus.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQHeader.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQHit.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQKeyHit.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQModuleIdentifier.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQPMTIdentifier.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQPreamble.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQPrint.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQRoot.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQSummaryFrame.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQSummaryslice.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQSummarysliceHeader.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQSuperFrame.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQSuperFrameHeader.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQTimeslice.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQTimesliceHeader.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQTriggerCounter.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQTriggerMask.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQTriggeredHit.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/online/JDAQUTCExtended.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/offline/AAObject.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/offline/Evt.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/offline/Exception.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/offline/Head.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/offline/Hit.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/offline/MultiHead.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/offline/Trk.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/offline/Vec.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/offline/io_ascii.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/offline/io_online.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/tools/multiplicity.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/tools/reconstruction.hh"
#include "/builds/common/jpp/externals/km3net-dataformat/tools/time_converter.hh"

// Header files passed via #pragma extra_include

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

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQAbstractPreamble(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQAbstractPreamble(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQAbstractPreamble(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQAbstractPreamble(void *p);
   static void destruct_KM3NETDAQcLcLJDAQAbstractPreamble(void *p);
   static void streamer_KM3NETDAQcLcLJDAQAbstractPreamble(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQAbstractPreamble*)
   {
      ::KM3NETDAQ::JDAQAbstractPreamble *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQAbstractPreamble >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQAbstractPreamble", ::KM3NETDAQ::JDAQAbstractPreamble::Class_Version(), "", 309,
                  typeid(::KM3NETDAQ::JDAQAbstractPreamble), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQAbstractPreamble::Dictionary, isa_proxy, 17,
                  sizeof(::KM3NETDAQ::JDAQAbstractPreamble) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQAbstractPreamble);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQAbstractPreamble);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQAbstractPreamble);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQAbstractPreamble);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQAbstractPreamble);
      instance.SetStreamerFunc(&streamer_KM3NETDAQcLcLJDAQAbstractPreamble);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQAbstractPreamble*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQAbstractPreamble*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQAbstractPreamble*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQUTCExtended(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQUTCExtended(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQUTCExtended(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQUTCExtended(void *p);
   static void destruct_KM3NETDAQcLcLJDAQUTCExtended(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQUTCExtended*)
   {
      ::KM3NETDAQ::JDAQUTCExtended *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQUTCExtended >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQUTCExtended", ::KM3NETDAQ::JDAQUTCExtended::Class_Version(), "JDAQUTCExtended.hh", 22,
                  typeid(::KM3NETDAQ::JDAQUTCExtended), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQUTCExtended::Dictionary, isa_proxy, 4,
                  sizeof(::KM3NETDAQ::JDAQUTCExtended) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQUTCExtended);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQUTCExtended);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQUTCExtended);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQUTCExtended);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQUTCExtended);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQUTCExtended*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQUTCExtended*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQUTCExtended*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQChronometer(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQChronometer(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQChronometer(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQChronometer(void *p);
   static void destruct_KM3NETDAQcLcLJDAQChronometer(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQChronometer*)
   {
      ::KM3NETDAQ::JDAQChronometer *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQChronometer >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQChronometer", ::KM3NETDAQ::JDAQChronometer::Class_Version(), "", 384,
                  typeid(::KM3NETDAQ::JDAQChronometer), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQChronometer::Dictionary, isa_proxy, 4,
                  sizeof(::KM3NETDAQ::JDAQChronometer) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQChronometer);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQChronometer);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQChronometer);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQChronometer);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQChronometer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQChronometer*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQChronometer*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQChronometer*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQPreamble(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQPreamble(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQPreamble(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQPreamble(void *p);
   static void destruct_KM3NETDAQcLcLJDAQPreamble(void *p);
   static void streamer_KM3NETDAQcLcLJDAQPreamble(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQPreamble*)
   {
      ::KM3NETDAQ::JDAQPreamble *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQPreamble >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQPreamble", ::KM3NETDAQ::JDAQPreamble::Class_Version(), "JDAQPreamble.hh", 26,
                  typeid(::KM3NETDAQ::JDAQPreamble), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQPreamble::Dictionary, isa_proxy, 17,
                  sizeof(::KM3NETDAQ::JDAQPreamble) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQPreamble);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQPreamble);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQPreamble);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQPreamble);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQPreamble);
      instance.SetStreamerFunc(&streamer_KM3NETDAQcLcLJDAQPreamble);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQPreamble*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQPreamble*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQPreamble*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQHeader(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQHeader(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQHeader(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQHeader(void *p);
   static void destruct_KM3NETDAQcLcLJDAQHeader(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQHeader*)
   {
      ::KM3NETDAQ::JDAQHeader *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQHeader >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQHeader", ::KM3NETDAQ::JDAQHeader::Class_Version(), "JDAQHeader.hh", 17,
                  typeid(::KM3NETDAQ::JDAQHeader), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQHeader::Dictionary, isa_proxy, 4,
                  sizeof(::KM3NETDAQ::JDAQHeader) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQHeader);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQHeader);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQHeader);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQHeader);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQHeader);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQHeader*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQHeader*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQHeader*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQTriggerCounter(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQTriggerCounter(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQTriggerCounter(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQTriggerCounter(void *p);
   static void destruct_KM3NETDAQcLcLJDAQTriggerCounter(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQTriggerCounter*)
   {
      ::KM3NETDAQ::JDAQTriggerCounter *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQTriggerCounter >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQTriggerCounter", ::KM3NETDAQ::JDAQTriggerCounter::Class_Version(), "JDAQTriggerCounter.hh", 23,
                  typeid(::KM3NETDAQ::JDAQTriggerCounter), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQTriggerCounter::Dictionary, isa_proxy, 4,
                  sizeof(::KM3NETDAQ::JDAQTriggerCounter) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQTriggerCounter);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQTriggerCounter);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQTriggerCounter);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQTriggerCounter);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQTriggerCounter);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQTriggerCounter*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQTriggerCounter*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQTriggerCounter*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQTriggerMask(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQTriggerMask(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQTriggerMask(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQTriggerMask(void *p);
   static void destruct_KM3NETDAQcLcLJDAQTriggerMask(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQTriggerMask*)
   {
      ::KM3NETDAQ::JDAQTriggerMask *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQTriggerMask >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQTriggerMask", ::KM3NETDAQ::JDAQTriggerMask::Class_Version(), "JDAQTriggerMask.hh", 48,
                  typeid(::KM3NETDAQ::JDAQTriggerMask), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQTriggerMask::Dictionary, isa_proxy, 4,
                  sizeof(::KM3NETDAQ::JDAQTriggerMask) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQTriggerMask);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQTriggerMask);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQTriggerMask);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQTriggerMask);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQTriggerMask);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQTriggerMask*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQTriggerMask*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQTriggerMask*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQEventHeader(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQEventHeader(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQEventHeader(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQEventHeader(void *p);
   static void destruct_KM3NETDAQcLcLJDAQEventHeader(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQEventHeader*)
   {
      ::KM3NETDAQ::JDAQEventHeader *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQEventHeader >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQEventHeader", ::KM3NETDAQ::JDAQEventHeader::Class_Version(), "JDAQEventHeader.hh", 19,
                  typeid(::KM3NETDAQ::JDAQEventHeader), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQEventHeader::Dictionary, isa_proxy, 4,
                  sizeof(::KM3NETDAQ::JDAQEventHeader) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQEventHeader);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQEventHeader);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQEventHeader);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQEventHeader);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQEventHeader);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQEventHeader*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQEventHeader*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQEventHeader*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQHit(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQHit(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQHit(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQHit(void *p);
   static void destruct_KM3NETDAQcLcLJDAQHit(void *p);
   static void streamer_KM3NETDAQcLcLJDAQHit(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQHit*)
   {
      ::KM3NETDAQ::JDAQHit *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQHit >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQHit", ::KM3NETDAQ::JDAQHit::Class_Version(), "JDAQHit.hh", 34,
                  typeid(::KM3NETDAQ::JDAQHit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQHit::Dictionary, isa_proxy, 17,
                  sizeof(::KM3NETDAQ::JDAQHit) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQHit);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQHit);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQHit);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQHit);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQHit);
      instance.SetStreamerFunc(&streamer_KM3NETDAQcLcLJDAQHit);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQHit*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQHit*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQHit*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQModuleIdentifier(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQModuleIdentifier(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQModuleIdentifier(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQModuleIdentifier(void *p);
   static void destruct_KM3NETDAQcLcLJDAQModuleIdentifier(void *p);
   static void streamer_KM3NETDAQcLcLJDAQModuleIdentifier(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQModuleIdentifier*)
   {
      ::KM3NETDAQ::JDAQModuleIdentifier *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQModuleIdentifier >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQModuleIdentifier", ::KM3NETDAQ::JDAQModuleIdentifier::Class_Version(), "JDAQModuleIdentifier.hh", 19,
                  typeid(::KM3NETDAQ::JDAQModuleIdentifier), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQModuleIdentifier::Dictionary, isa_proxy, 17,
                  sizeof(::KM3NETDAQ::JDAQModuleIdentifier) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQModuleIdentifier);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQModuleIdentifier);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQModuleIdentifier);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQModuleIdentifier);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQModuleIdentifier);
      instance.SetStreamerFunc(&streamer_KM3NETDAQcLcLJDAQModuleIdentifier);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQModuleIdentifier*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQModuleIdentifier*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQModuleIdentifier*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQPMTIdentifier(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQPMTIdentifier(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQPMTIdentifier(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQPMTIdentifier(void *p);
   static void destruct_KM3NETDAQcLcLJDAQPMTIdentifier(void *p);
   static void streamer_KM3NETDAQcLcLJDAQPMTIdentifier(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQPMTIdentifier*)
   {
      ::KM3NETDAQ::JDAQPMTIdentifier *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQPMTIdentifier >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQPMTIdentifier", ::KM3NETDAQ::JDAQPMTIdentifier::Class_Version(), "JDAQPMTIdentifier.hh", 20,
                  typeid(::KM3NETDAQ::JDAQPMTIdentifier), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQPMTIdentifier::Dictionary, isa_proxy, 17,
                  sizeof(::KM3NETDAQ::JDAQPMTIdentifier) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQPMTIdentifier);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQPMTIdentifier);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQPMTIdentifier);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQPMTIdentifier);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQPMTIdentifier);
      instance.SetStreamerFunc(&streamer_KM3NETDAQcLcLJDAQPMTIdentifier);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQPMTIdentifier*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQPMTIdentifier*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQPMTIdentifier*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQKeyHit(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQKeyHit(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQKeyHit(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQKeyHit(void *p);
   static void destruct_KM3NETDAQcLcLJDAQKeyHit(void *p);
   static void streamer_KM3NETDAQcLcLJDAQKeyHit(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQKeyHit*)
   {
      ::KM3NETDAQ::JDAQKeyHit *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQKeyHit >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQKeyHit", ::KM3NETDAQ::JDAQKeyHit::Class_Version(), "JDAQKeyHit.hh", 19,
                  typeid(::KM3NETDAQ::JDAQKeyHit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQKeyHit::Dictionary, isa_proxy, 17,
                  sizeof(::KM3NETDAQ::JDAQKeyHit) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQKeyHit);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQKeyHit);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQKeyHit);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQKeyHit);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQKeyHit);
      instance.SetStreamerFunc(&streamer_KM3NETDAQcLcLJDAQKeyHit);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQKeyHit*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQKeyHit*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQKeyHit*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQTriggeredHit(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQTriggeredHit(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQTriggeredHit(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQTriggeredHit(void *p);
   static void destruct_KM3NETDAQcLcLJDAQTriggeredHit(void *p);
   static void streamer_KM3NETDAQcLcLJDAQTriggeredHit(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQTriggeredHit*)
   {
      ::KM3NETDAQ::JDAQTriggeredHit *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQTriggeredHit >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQTriggeredHit", ::KM3NETDAQ::JDAQTriggeredHit::Class_Version(), "JDAQTriggeredHit.hh", 20,
                  typeid(::KM3NETDAQ::JDAQTriggeredHit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQTriggeredHit::Dictionary, isa_proxy, 17,
                  sizeof(::KM3NETDAQ::JDAQTriggeredHit) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQTriggeredHit);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQTriggeredHit);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQTriggeredHit);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQTriggeredHit);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQTriggeredHit);
      instance.SetStreamerFunc(&streamer_KM3NETDAQcLcLJDAQTriggeredHit);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQTriggeredHit*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQTriggeredHit*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQTriggeredHit*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQEvent(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQEvent(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQEvent(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQEvent(void *p);
   static void destruct_KM3NETDAQcLcLJDAQEvent(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQEvent*)
   {
      ::KM3NETDAQ::JDAQEvent *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQEvent >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQEvent", ::KM3NETDAQ::JDAQEvent::Class_Version(), "", 1062,
                  typeid(::KM3NETDAQ::JDAQEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQEvent::Dictionary, isa_proxy, 4,
                  sizeof(::KM3NETDAQ::JDAQEvent) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQEvent);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQEvent);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQEvent);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQEvent);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQEvent);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQEvent*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQEvent*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQEvent*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQFrame(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQFrame(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQFrame(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQFrame(void *p);
   static void destruct_KM3NETDAQcLcLJDAQFrame(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQFrame*)
   {
      ::KM3NETDAQ::JDAQFrame *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQFrame >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQFrame", ::KM3NETDAQ::JDAQFrame::Class_Version(), "", 1598,
                  typeid(::KM3NETDAQ::JDAQFrame), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQFrame::Dictionary, isa_proxy, 4,
                  sizeof(::KM3NETDAQ::JDAQFrame) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQFrame);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQFrame);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQFrame);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQFrame);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQFrame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQFrame*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQFrame*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQFrame*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQFrameStatus(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQFrameStatus(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQFrameStatus(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQFrameStatus(void *p);
   static void destruct_KM3NETDAQcLcLJDAQFrameStatus(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQFrameStatus*)
   {
      ::KM3NETDAQ::JDAQFrameStatus *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQFrameStatus >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQFrameStatus", ::KM3NETDAQ::JDAQFrameStatus::Class_Version(), "", 1886,
                  typeid(::KM3NETDAQ::JDAQFrameStatus), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQFrameStatus::Dictionary, isa_proxy, 4,
                  sizeof(::KM3NETDAQ::JDAQFrameStatus) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQFrameStatus);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQFrameStatus);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQFrameStatus);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQFrameStatus);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQFrameStatus);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQFrameStatus*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQFrameStatus*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQFrameStatus*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQSuperFrameHeader(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQSuperFrameHeader(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQSuperFrameHeader(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQSuperFrameHeader(void *p);
   static void destruct_KM3NETDAQcLcLJDAQSuperFrameHeader(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQSuperFrameHeader*)
   {
      ::KM3NETDAQ::JDAQSuperFrameHeader *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQSuperFrameHeader >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQSuperFrameHeader", ::KM3NETDAQ::JDAQSuperFrameHeader::Class_Version(), "JDAQSuperFrameHeader.hh", 19,
                  typeid(::KM3NETDAQ::JDAQSuperFrameHeader), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQSuperFrameHeader::Dictionary, isa_proxy, 4,
                  sizeof(::KM3NETDAQ::JDAQSuperFrameHeader) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQSuperFrameHeader);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQSuperFrameHeader);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQSuperFrameHeader);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQSuperFrameHeader);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQSuperFrameHeader);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQSuperFrameHeader*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQSuperFrameHeader*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQSuperFrameHeader*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQSuperFrame(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQSuperFrame(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQSuperFrame(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQSuperFrame(void *p);
   static void destruct_KM3NETDAQcLcLJDAQSuperFrame(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQSuperFrame*)
   {
      ::KM3NETDAQ::JDAQSuperFrame *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQSuperFrame >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQSuperFrame", ::KM3NETDAQ::JDAQSuperFrame::Class_Version(), "JDAQSuperFrame.hh", 22,
                  typeid(::KM3NETDAQ::JDAQSuperFrame), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQSuperFrame::Dictionary, isa_proxy, 4,
                  sizeof(::KM3NETDAQ::JDAQSuperFrame) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQSuperFrame);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQSuperFrame);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQSuperFrame);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQSuperFrame);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQSuperFrame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQSuperFrame*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQSuperFrame*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQSuperFrame*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static TClass *KM3NETDAQcLcLJDAQRate_Dictionary();
   static void KM3NETDAQcLcLJDAQRate_TClassManip(TClass*);
   static void *new_KM3NETDAQcLcLJDAQRate(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQRate(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQRate(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQRate(void *p);
   static void destruct_KM3NETDAQcLcLJDAQRate(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQRate*)
   {
      ::KM3NETDAQ::JDAQRate *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::KM3NETDAQ::JDAQRate));
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQRate", "", 3320,
                  typeid(::KM3NETDAQ::JDAQRate), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &KM3NETDAQcLcLJDAQRate_Dictionary, isa_proxy, 4,
                  sizeof(::KM3NETDAQ::JDAQRate) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQRate);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQRate);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQRate);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQRate);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQRate);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQRate*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQRate*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQRate*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *KM3NETDAQcLcLJDAQRate_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQRate*>(nullptr))->GetClass();
      KM3NETDAQcLcLJDAQRate_TClassManip(theClass);
   return theClass;
   }

   static void KM3NETDAQcLcLJDAQRate_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQSummaryFrame(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQSummaryFrame(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQSummaryFrame(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQSummaryFrame(void *p);
   static void destruct_KM3NETDAQcLcLJDAQSummaryFrame(void *p);
   static void streamer_KM3NETDAQcLcLJDAQSummaryFrame(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQSummaryFrame*)
   {
      ::KM3NETDAQ::JDAQSummaryFrame *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQSummaryFrame >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQSummaryFrame", ::KM3NETDAQ::JDAQSummaryFrame::Class_Version(), "", 3616,
                  typeid(::KM3NETDAQ::JDAQSummaryFrame), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQSummaryFrame::Dictionary, isa_proxy, 17,
                  sizeof(::KM3NETDAQ::JDAQSummaryFrame) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQSummaryFrame);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQSummaryFrame);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQSummaryFrame);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQSummaryFrame);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQSummaryFrame);
      instance.SetStreamerFunc(&streamer_KM3NETDAQcLcLJDAQSummaryFrame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQSummaryFrame*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQSummaryFrame*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQSummaryFrame*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQSummarysliceHeader(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQSummarysliceHeader(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQSummarysliceHeader(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQSummarysliceHeader(void *p);
   static void destruct_KM3NETDAQcLcLJDAQSummarysliceHeader(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQSummarysliceHeader*)
   {
      ::KM3NETDAQ::JDAQSummarysliceHeader *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQSummarysliceHeader >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQSummarysliceHeader", ::KM3NETDAQ::JDAQSummarysliceHeader::Class_Version(), "JDAQSummarysliceHeader.hh", 17,
                  typeid(::KM3NETDAQ::JDAQSummarysliceHeader), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQSummarysliceHeader::Dictionary, isa_proxy, 4,
                  sizeof(::KM3NETDAQ::JDAQSummarysliceHeader) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQSummarysliceHeader);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQSummarysliceHeader);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQSummarysliceHeader);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQSummarysliceHeader);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQSummarysliceHeader);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQSummarysliceHeader*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQSummarysliceHeader*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQSummarysliceHeader*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQTimesliceHeader(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQTimesliceHeader(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQTimesliceHeader(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQTimesliceHeader(void *p);
   static void destruct_KM3NETDAQcLcLJDAQTimesliceHeader(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQTimesliceHeader*)
   {
      ::KM3NETDAQ::JDAQTimesliceHeader *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQTimesliceHeader >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQTimesliceHeader", ::KM3NETDAQ::JDAQTimesliceHeader::Class_Version(), "JDAQTimesliceHeader.hh", 16,
                  typeid(::KM3NETDAQ::JDAQTimesliceHeader), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQTimesliceHeader::Dictionary, isa_proxy, 4,
                  sizeof(::KM3NETDAQ::JDAQTimesliceHeader) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQTimesliceHeader);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQTimesliceHeader);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQTimesliceHeader);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQTimesliceHeader);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQTimesliceHeader);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQTimesliceHeader*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQTimesliceHeader*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQTimesliceHeader*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQTimeslice(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQTimeslice(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQTimeslice(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQTimeslice(void *p);
   static void destruct_KM3NETDAQcLcLJDAQTimeslice(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQTimeslice*)
   {
      ::KM3NETDAQ::JDAQTimeslice *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQTimeslice >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQTimeslice", ::KM3NETDAQ::JDAQTimeslice::Class_Version(), "JDAQTimeslice.hh", 30,
                  typeid(::KM3NETDAQ::JDAQTimeslice), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQTimeslice::Dictionary, isa_proxy, 4,
                  sizeof(::KM3NETDAQ::JDAQTimeslice) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQTimeslice);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQTimeslice);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQTimeslice);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQTimeslice);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQTimeslice);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQTimeslice*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQTimeslice*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQTimeslice*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQTimesliceL0(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQTimesliceL0(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQTimesliceL0(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQTimesliceL0(void *p);
   static void destruct_KM3NETDAQcLcLJDAQTimesliceL0(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQTimesliceL0*)
   {
      ::KM3NETDAQ::JDAQTimesliceL0 *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQTimesliceL0 >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQTimesliceL0", ::KM3NETDAQ::JDAQTimesliceL0::Class_Version(), "JDAQTimeslice.hh", 259,
                  typeid(::KM3NETDAQ::JDAQTimesliceL0), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQTimesliceL0::Dictionary, isa_proxy, 4,
                  sizeof(::KM3NETDAQ::JDAQTimesliceL0) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQTimesliceL0);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQTimesliceL0);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQTimesliceL0);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQTimesliceL0);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQTimesliceL0);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQTimesliceL0*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQTimesliceL0*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQTimesliceL0*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQTimesliceL1(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQTimesliceL1(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQTimesliceL1(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQTimesliceL1(void *p);
   static void destruct_KM3NETDAQcLcLJDAQTimesliceL1(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQTimesliceL1*)
   {
      ::KM3NETDAQ::JDAQTimesliceL1 *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQTimesliceL1 >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQTimesliceL1", ::KM3NETDAQ::JDAQTimesliceL1::Class_Version(), "JDAQTimeslice.hh", 265,
                  typeid(::KM3NETDAQ::JDAQTimesliceL1), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQTimesliceL1::Dictionary, isa_proxy, 4,
                  sizeof(::KM3NETDAQ::JDAQTimesliceL1) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQTimesliceL1);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQTimesliceL1);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQTimesliceL1);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQTimesliceL1);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQTimesliceL1);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQTimesliceL1*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQTimesliceL1*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQTimesliceL1*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQTimesliceL2(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQTimesliceL2(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQTimesliceL2(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQTimesliceL2(void *p);
   static void destruct_KM3NETDAQcLcLJDAQTimesliceL2(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQTimesliceL2*)
   {
      ::KM3NETDAQ::JDAQTimesliceL2 *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQTimesliceL2 >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQTimesliceL2", ::KM3NETDAQ::JDAQTimesliceL2::Class_Version(), "JDAQTimeslice.hh", 271,
                  typeid(::KM3NETDAQ::JDAQTimesliceL2), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQTimesliceL2::Dictionary, isa_proxy, 4,
                  sizeof(::KM3NETDAQ::JDAQTimesliceL2) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQTimesliceL2);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQTimesliceL2);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQTimesliceL2);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQTimesliceL2);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQTimesliceL2);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQTimesliceL2*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQTimesliceL2*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQTimesliceL2*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQTimesliceSN(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQTimesliceSN(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQTimesliceSN(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQTimesliceSN(void *p);
   static void destruct_KM3NETDAQcLcLJDAQTimesliceSN(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQTimesliceSN*)
   {
      ::KM3NETDAQ::JDAQTimesliceSN *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQTimesliceSN >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQTimesliceSN", ::KM3NETDAQ::JDAQTimesliceSN::Class_Version(), "JDAQTimeslice.hh", 277,
                  typeid(::KM3NETDAQ::JDAQTimesliceSN), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQTimesliceSN::Dictionary, isa_proxy, 4,
                  sizeof(::KM3NETDAQ::JDAQTimesliceSN) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQTimesliceSN);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQTimesliceSN);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQTimesliceSN);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQTimesliceSN);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQTimesliceSN);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQTimesliceSN*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQTimesliceSN*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQTimesliceSN*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_KM3NETDAQcLcLJDAQSummaryslice(void *p = nullptr);
   static void *newArray_KM3NETDAQcLcLJDAQSummaryslice(Long_t size, void *p);
   static void delete_KM3NETDAQcLcLJDAQSummaryslice(void *p);
   static void deleteArray_KM3NETDAQcLcLJDAQSummaryslice(void *p);
   static void destruct_KM3NETDAQcLcLJDAQSummaryslice(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQSummaryslice*)
   {
      ::KM3NETDAQ::JDAQSummaryslice *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQSummaryslice >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("KM3NETDAQ::JDAQSummaryslice", ::KM3NETDAQ::JDAQSummaryslice::Class_Version(), "", 3863,
                  typeid(::KM3NETDAQ::JDAQSummaryslice), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::KM3NETDAQ::JDAQSummaryslice::Dictionary, isa_proxy, 4,
                  sizeof(::KM3NETDAQ::JDAQSummaryslice) );
      instance.SetNew(&new_KM3NETDAQcLcLJDAQSummaryslice);
      instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQSummaryslice);
      instance.SetDelete(&delete_KM3NETDAQcLcLJDAQSummaryslice);
      instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQSummaryslice);
      instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQSummaryslice);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQSummaryslice*)
   {
      return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQSummaryslice*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQSummaryslice*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_AAObject(void *p = nullptr);
   static void *newArray_AAObject(Long_t size, void *p);
   static void delete_AAObject(void *p);
   static void deleteArray_AAObject(void *p);
   static void destruct_AAObject(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::AAObject*)
   {
      ::AAObject *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::AAObject >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("AAObject", ::AAObject::Class_Version(), "", 5699,
                  typeid(::AAObject), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::AAObject::Dictionary, isa_proxy, 4,
                  sizeof(::AAObject) );
      instance.SetNew(&new_AAObject);
      instance.SetNewArray(&newArray_AAObject);
      instance.SetDelete(&delete_AAObject);
      instance.SetDeleteArray(&deleteArray_AAObject);
      instance.SetDestructor(&destruct_AAObject);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::AAObject*)
   {
      return GenerateInitInstanceLocal(static_cast<::AAObject*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::AAObject*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_Vec(void *p = nullptr);
   static void *newArray_Vec(Long_t size, void *p);
   static void delete_Vec(void *p);
   static void deleteArray_Vec(void *p);
   static void destruct_Vec(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Vec*)
   {
      ::Vec *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Vec >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("Vec", ::Vec::Class_Version(), "Vec.hh", 12,
                  typeid(::Vec), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::Vec::Dictionary, isa_proxy, 4,
                  sizeof(::Vec) );
      instance.SetNew(&new_Vec);
      instance.SetNewArray(&newArray_Vec);
      instance.SetDelete(&delete_Vec);
      instance.SetDeleteArray(&deleteArray_Vec);
      instance.SetDestructor(&destruct_Vec);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Vec*)
   {
      return GenerateInitInstanceLocal(static_cast<::Vec*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::Vec*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_Hit(void *p = nullptr);
   static void *newArray_Hit(Long_t size, void *p);
   static void delete_Hit(void *p);
   static void deleteArray_Hit(void *p);
   static void destruct_Hit(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Hit*)
   {
      ::Hit *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Hit >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("Hit", ::Hit::Class_Version(), "Hit.hh", 8,
                  typeid(::Hit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::Hit::Dictionary, isa_proxy, 4,
                  sizeof(::Hit) );
      instance.SetNew(&new_Hit);
      instance.SetNewArray(&newArray_Hit);
      instance.SetDelete(&delete_Hit);
      instance.SetDeleteArray(&deleteArray_Hit);
      instance.SetDestructor(&destruct_Hit);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Hit*)
   {
      return GenerateInitInstanceLocal(static_cast<::Hit*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::Hit*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_Trk(void *p = nullptr);
   static void *newArray_Trk(Long_t size, void *p);
   static void delete_Trk(void *p);
   static void deleteArray_Trk(void *p);
   static void destruct_Trk(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Trk*)
   {
      ::Trk *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Trk >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("Trk", ::Trk::Class_Version(), "Trk.hh", 14,
                  typeid(::Trk), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::Trk::Dictionary, isa_proxy, 4,
                  sizeof(::Trk) );
      instance.SetNew(&new_Trk);
      instance.SetNewArray(&newArray_Trk);
      instance.SetDelete(&delete_Trk);
      instance.SetDeleteArray(&deleteArray_Trk);
      instance.SetDestructor(&destruct_Trk);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Trk*)
   {
      return GenerateInitInstanceLocal(static_cast<::Trk*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::Trk*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_Evt(void *p = nullptr);
   static void *newArray_Evt(Long_t size, void *p);
   static void delete_Evt(void *p);
   static void deleteArray_Evt(void *p);
   static void destruct_Evt(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Evt*)
   {
      ::Evt *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Evt >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("Evt", ::Evt::Class_Version(), "", 5878,
                  typeid(::Evt), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::Evt::Dictionary, isa_proxy, 4,
                  sizeof(::Evt) );
      instance.SetNew(&new_Evt);
      instance.SetNewArray(&newArray_Evt);
      instance.SetDelete(&delete_Evt);
      instance.SetDeleteArray(&deleteArray_Evt);
      instance.SetDestructor(&destruct_Evt);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Evt*)
   {
      return GenerateInitInstanceLocal(static_cast<::Evt*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::Evt*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_Head(void *p = nullptr);
   static void *newArray_Head(Long_t size, void *p);
   static void delete_Head(void *p);
   static void deleteArray_Head(void *p);
   static void destruct_Head(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Head*)
   {
      ::Head *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Head >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("Head", ::Head::Class_Version(), "", 6290,
                  typeid(::Head), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::Head::Dictionary, isa_proxy, 4,
                  sizeof(::Head) );
      instance.SetNew(&new_Head);
      instance.SetNewArray(&newArray_Head);
      instance.SetDelete(&delete_Head);
      instance.SetDeleteArray(&deleteArray_Head);
      instance.SetDestructor(&destruct_Head);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Head*)
   {
      return GenerateInitInstanceLocal(static_cast<::Head*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::Head*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_MultiHead(void *p = nullptr);
   static void *newArray_MultiHead(Long_t size, void *p);
   static void delete_MultiHead(void *p);
   static void deleteArray_MultiHead(void *p);
   static void destruct_MultiHead(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::MultiHead*)
   {
      ::MultiHead *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::MultiHead >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("MultiHead", ::MultiHead::Class_Version(), "", 6764,
                  typeid(::MultiHead), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::MultiHead::Dictionary, isa_proxy, 4,
                  sizeof(::MultiHead) );
      instance.SetNew(&new_MultiHead);
      instance.SetNewArray(&newArray_MultiHead);
      instance.SetDelete(&delete_MultiHead);
      instance.SetDeleteArray(&deleteArray_MultiHead);
      instance.SetDestructor(&destruct_MultiHead);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::MultiHead*)
   {
      return GenerateInitInstanceLocal(static_cast<::MultiHead*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::MultiHead*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQAbstractPreamble::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQAbstractPreamble::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQAbstractPreamble*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQAbstractPreamble::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQAbstractPreamble*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQAbstractPreamble::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQAbstractPreamble*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQUTCExtended::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQUTCExtended::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQUTCExtended*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQUTCExtended::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQUTCExtended*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQUTCExtended::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQUTCExtended*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQChronometer::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQChronometer::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQChronometer*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQChronometer::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQChronometer*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQChronometer::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQChronometer*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQPreamble::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQPreamble::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQPreamble*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQPreamble::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQPreamble*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQPreamble::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQPreamble*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQHeader::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQHeader::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQHeader*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQHeader::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQHeader*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQHeader::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQHeader*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQTriggerCounter::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQTriggerCounter::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggerCounter*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQTriggerCounter::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggerCounter*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQTriggerCounter::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggerCounter*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQTriggerMask::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQTriggerMask::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggerMask*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQTriggerMask::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggerMask*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQTriggerMask::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggerMask*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQEventHeader::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQEventHeader::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQEventHeader*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQEventHeader::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQEventHeader*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQEventHeader::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQEventHeader*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQHit::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQHit::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQHit*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQHit::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQHit*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQHit::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQHit*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQModuleIdentifier::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQModuleIdentifier::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQModuleIdentifier*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQModuleIdentifier::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQModuleIdentifier*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQModuleIdentifier::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQModuleIdentifier*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQPMTIdentifier::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQPMTIdentifier::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQPMTIdentifier*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQPMTIdentifier::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQPMTIdentifier*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQPMTIdentifier::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQPMTIdentifier*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQKeyHit::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQKeyHit::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQKeyHit*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQKeyHit::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQKeyHit*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQKeyHit::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQKeyHit*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQTriggeredHit::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQTriggeredHit::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggeredHit*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQTriggeredHit::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggeredHit*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQTriggeredHit::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggeredHit*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQEvent::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQEvent::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQEvent*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQEvent::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQEvent*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQEvent::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQEvent*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQFrame::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQFrame::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQFrame*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQFrame::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQFrame*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQFrame::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQFrame*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQFrameStatus::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQFrameStatus::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQFrameStatus*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQFrameStatus::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQFrameStatus*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQFrameStatus::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQFrameStatus*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQSuperFrameHeader::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQSuperFrameHeader::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSuperFrameHeader*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQSuperFrameHeader::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSuperFrameHeader*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQSuperFrameHeader::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSuperFrameHeader*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQSuperFrame::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQSuperFrame::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSuperFrame*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQSuperFrame::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSuperFrame*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQSuperFrame::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSuperFrame*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQSummaryFrame::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQSummaryFrame::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummaryFrame*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQSummaryFrame::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummaryFrame*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQSummaryFrame::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummaryFrame*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQSummarysliceHeader::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQSummarysliceHeader::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummarysliceHeader*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQSummarysliceHeader::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummarysliceHeader*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQSummarysliceHeader::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummarysliceHeader*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQTimesliceHeader::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQTimesliceHeader::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceHeader*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQTimesliceHeader::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceHeader*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQTimesliceHeader::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceHeader*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQTimeslice::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQTimeslice::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimeslice*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQTimeslice::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimeslice*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQTimeslice::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimeslice*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQTimesliceL0::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQTimesliceL0::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL0*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQTimesliceL0::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL0*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQTimesliceL0::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL0*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQTimesliceL1::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQTimesliceL1::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL1*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQTimesliceL1::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL1*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQTimesliceL1::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL1*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQTimesliceL2::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQTimesliceL2::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL2*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQTimesliceL2::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL2*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQTimesliceL2::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL2*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQTimesliceSN::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQTimesliceSN::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceSN*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQTimesliceSN::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceSN*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQTimesliceSN::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceSN*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
namespace KM3NETDAQ {
//______________________________________________________________________________
atomic_TClass_ptr JDAQSummaryslice::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *JDAQSummaryslice::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummaryslice*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int JDAQSummaryslice::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummaryslice*)nullptr)->GetImplFileLine();
}

//______________________________________________________________________________
TClass *JDAQSummaryslice::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummaryslice*)nullptr)->GetClass();
   return fgIsA;
}

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

} // namespace KM3NETDAQ
//______________________________________________________________________________
atomic_TClass_ptr AAObject::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *AAObject::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::AAObject*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int AAObject::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::AAObject*)nullptr)->GetImplFileLine();
}

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

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

//______________________________________________________________________________
atomic_TClass_ptr Vec::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *Vec::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::Vec*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int Vec::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::Vec*)nullptr)->GetImplFileLine();
}

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

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

//______________________________________________________________________________
atomic_TClass_ptr Hit::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *Hit::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::Hit*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int Hit::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::Hit*)nullptr)->GetImplFileLine();
}

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

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

//______________________________________________________________________________
atomic_TClass_ptr Trk::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *Trk::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::Trk*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int Trk::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::Trk*)nullptr)->GetImplFileLine();
}

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

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

//______________________________________________________________________________
atomic_TClass_ptr Evt::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *Evt::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::Evt*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int Evt::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::Evt*)nullptr)->GetImplFileLine();
}

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

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

//______________________________________________________________________________
atomic_TClass_ptr Head::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *Head::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::Head*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int Head::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::Head*)nullptr)->GetImplFileLine();
}

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

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

//______________________________________________________________________________
atomic_TClass_ptr MultiHead::fgIsA(nullptr);  // static to hold class pointer

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

//______________________________________________________________________________
const char *MultiHead::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::MultiHead*)nullptr)->GetImplFileName();
}

//______________________________________________________________________________
int MultiHead::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::MultiHead*)nullptr)->GetImplFileLine();
}

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQAbstractPreamble(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQAbstractPreamble : new ::KM3NETDAQ::JDAQAbstractPreamble;
   }
   static void *newArray_KM3NETDAQcLcLJDAQAbstractPreamble(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQAbstractPreamble[nElements] : new ::KM3NETDAQ::JDAQAbstractPreamble[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQAbstractPreamble(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQAbstractPreamble*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQAbstractPreamble(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQAbstractPreamble*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQAbstractPreamble(void *p) {
      typedef ::KM3NETDAQ::JDAQAbstractPreamble current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_KM3NETDAQcLcLJDAQAbstractPreamble(TBuffer &buf, void *obj) {
      ((::KM3NETDAQ::JDAQAbstractPreamble*)obj)->::KM3NETDAQ::JDAQAbstractPreamble::Streamer(buf);
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQAbstractPreamble

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

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

} // namespace KM3NETDAQ
namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQUTCExtended(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQUTCExtended : new ::KM3NETDAQ::JDAQUTCExtended;
   }
   static void *newArray_KM3NETDAQcLcLJDAQUTCExtended(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQUTCExtended[nElements] : new ::KM3NETDAQ::JDAQUTCExtended[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQUTCExtended(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQUTCExtended*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQUTCExtended(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQUTCExtended*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQUTCExtended(void *p) {
      typedef ::KM3NETDAQ::JDAQUTCExtended current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQUTCExtended

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

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

} // namespace KM3NETDAQ
namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQChronometer(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQChronometer : new ::KM3NETDAQ::JDAQChronometer;
   }
   static void *newArray_KM3NETDAQcLcLJDAQChronometer(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQChronometer[nElements] : new ::KM3NETDAQ::JDAQChronometer[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQChronometer(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQChronometer*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQChronometer(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQChronometer*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQChronometer(void *p) {
      typedef ::KM3NETDAQ::JDAQChronometer current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQChronometer

namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQPreamble(void *p) {
      return  p ? new(p) ::KM3NETDAQ::JDAQPreamble : new ::KM3NETDAQ::JDAQPreamble;
   }
   static void *newArray_KM3NETDAQcLcLJDAQPreamble(Long_t nElements, void *p) {
      return p ? new(p) ::KM3NETDAQ::JDAQPreamble[nElements] : new ::KM3NETDAQ::JDAQPreamble[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQPreamble(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQPreamble*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQPreamble(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQPreamble*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQPreamble(void *p) {
      typedef ::KM3NETDAQ::JDAQPreamble current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_KM3NETDAQcLcLJDAQPreamble(TBuffer &buf, void *obj) {
      ((::KM3NETDAQ::JDAQPreamble*)obj)->::KM3NETDAQ::JDAQPreamble::Streamer(buf);
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQPreamble

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

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

} // namespace KM3NETDAQ
namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQHeader(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQHeader : new ::KM3NETDAQ::JDAQHeader;
   }
   static void *newArray_KM3NETDAQcLcLJDAQHeader(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQHeader[nElements] : new ::KM3NETDAQ::JDAQHeader[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQHeader(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQHeader*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQHeader(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQHeader*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQHeader(void *p) {
      typedef ::KM3NETDAQ::JDAQHeader current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQHeader

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

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

} // namespace KM3NETDAQ
namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQTriggerCounter(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQTriggerCounter : new ::KM3NETDAQ::JDAQTriggerCounter;
   }
   static void *newArray_KM3NETDAQcLcLJDAQTriggerCounter(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQTriggerCounter[nElements] : new ::KM3NETDAQ::JDAQTriggerCounter[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQTriggerCounter(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQTriggerCounter*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQTriggerCounter(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQTriggerCounter*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQTriggerCounter(void *p) {
      typedef ::KM3NETDAQ::JDAQTriggerCounter current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQTriggerCounter

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

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

} // namespace KM3NETDAQ
namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQTriggerMask(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQTriggerMask : new ::KM3NETDAQ::JDAQTriggerMask;
   }
   static void *newArray_KM3NETDAQcLcLJDAQTriggerMask(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQTriggerMask[nElements] : new ::KM3NETDAQ::JDAQTriggerMask[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQTriggerMask(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQTriggerMask*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQTriggerMask(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQTriggerMask*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQTriggerMask(void *p) {
      typedef ::KM3NETDAQ::JDAQTriggerMask current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQTriggerMask

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

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

} // namespace KM3NETDAQ
namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQEventHeader(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQEventHeader : new ::KM3NETDAQ::JDAQEventHeader;
   }
   static void *newArray_KM3NETDAQcLcLJDAQEventHeader(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQEventHeader[nElements] : new ::KM3NETDAQ::JDAQEventHeader[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQEventHeader(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQEventHeader*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQEventHeader(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQEventHeader*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQEventHeader(void *p) {
      typedef ::KM3NETDAQ::JDAQEventHeader current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQEventHeader

namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQHit(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQHit : new ::KM3NETDAQ::JDAQHit;
   }
   static void *newArray_KM3NETDAQcLcLJDAQHit(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQHit[nElements] : new ::KM3NETDAQ::JDAQHit[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQHit(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQHit*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQHit(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQHit*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQHit(void *p) {
      typedef ::KM3NETDAQ::JDAQHit current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_KM3NETDAQcLcLJDAQHit(TBuffer &buf, void *obj) {
      ((::KM3NETDAQ::JDAQHit*)obj)->::KM3NETDAQ::JDAQHit::Streamer(buf);
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQHit

namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQModuleIdentifier(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQModuleIdentifier : new ::KM3NETDAQ::JDAQModuleIdentifier;
   }
   static void *newArray_KM3NETDAQcLcLJDAQModuleIdentifier(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQModuleIdentifier[nElements] : new ::KM3NETDAQ::JDAQModuleIdentifier[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQModuleIdentifier(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQModuleIdentifier*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQModuleIdentifier(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQModuleIdentifier*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQModuleIdentifier(void *p) {
      typedef ::KM3NETDAQ::JDAQModuleIdentifier current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_KM3NETDAQcLcLJDAQModuleIdentifier(TBuffer &buf, void *obj) {
      ((::KM3NETDAQ::JDAQModuleIdentifier*)obj)->::KM3NETDAQ::JDAQModuleIdentifier::Streamer(buf);
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQModuleIdentifier

namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQPMTIdentifier(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQPMTIdentifier : new ::KM3NETDAQ::JDAQPMTIdentifier;
   }
   static void *newArray_KM3NETDAQcLcLJDAQPMTIdentifier(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQPMTIdentifier[nElements] : new ::KM3NETDAQ::JDAQPMTIdentifier[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQPMTIdentifier(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQPMTIdentifier*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQPMTIdentifier(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQPMTIdentifier*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQPMTIdentifier(void *p) {
      typedef ::KM3NETDAQ::JDAQPMTIdentifier current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_KM3NETDAQcLcLJDAQPMTIdentifier(TBuffer &buf, void *obj) {
      ((::KM3NETDAQ::JDAQPMTIdentifier*)obj)->::KM3NETDAQ::JDAQPMTIdentifier::Streamer(buf);
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQPMTIdentifier

namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQKeyHit(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQKeyHit : new ::KM3NETDAQ::JDAQKeyHit;
   }
   static void *newArray_KM3NETDAQcLcLJDAQKeyHit(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQKeyHit[nElements] : new ::KM3NETDAQ::JDAQKeyHit[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQKeyHit(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQKeyHit*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQKeyHit(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQKeyHit*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQKeyHit(void *p) {
      typedef ::KM3NETDAQ::JDAQKeyHit current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_KM3NETDAQcLcLJDAQKeyHit(TBuffer &buf, void *obj) {
      ((::KM3NETDAQ::JDAQKeyHit*)obj)->::KM3NETDAQ::JDAQKeyHit::Streamer(buf);
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQKeyHit

namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQTriggeredHit(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQTriggeredHit : new ::KM3NETDAQ::JDAQTriggeredHit;
   }
   static void *newArray_KM3NETDAQcLcLJDAQTriggeredHit(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQTriggeredHit[nElements] : new ::KM3NETDAQ::JDAQTriggeredHit[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQTriggeredHit(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQTriggeredHit*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQTriggeredHit(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQTriggeredHit*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQTriggeredHit(void *p) {
      typedef ::KM3NETDAQ::JDAQTriggeredHit current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_KM3NETDAQcLcLJDAQTriggeredHit(TBuffer &buf, void *obj) {
      ((::KM3NETDAQ::JDAQTriggeredHit*)obj)->::KM3NETDAQ::JDAQTriggeredHit::Streamer(buf);
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQTriggeredHit

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

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

} // namespace KM3NETDAQ
namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQEvent(void *p) {
      return  p ? new(p) ::KM3NETDAQ::JDAQEvent : new ::KM3NETDAQ::JDAQEvent;
   }
   static void *newArray_KM3NETDAQcLcLJDAQEvent(Long_t nElements, void *p) {
      return p ? new(p) ::KM3NETDAQ::JDAQEvent[nElements] : new ::KM3NETDAQ::JDAQEvent[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQEvent(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQEvent*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQEvent(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQEvent*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQEvent(void *p) {
      typedef ::KM3NETDAQ::JDAQEvent current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQEvent

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

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

} // namespace KM3NETDAQ
namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQFrame(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQFrame : new ::KM3NETDAQ::JDAQFrame;
   }
   static void *newArray_KM3NETDAQcLcLJDAQFrame(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQFrame[nElements] : new ::KM3NETDAQ::JDAQFrame[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQFrame(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQFrame*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQFrame(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQFrame*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQFrame(void *p) {
      typedef ::KM3NETDAQ::JDAQFrame current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQFrame

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

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

} // namespace KM3NETDAQ
namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQFrameStatus(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQFrameStatus : new ::KM3NETDAQ::JDAQFrameStatus;
   }
   static void *newArray_KM3NETDAQcLcLJDAQFrameStatus(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQFrameStatus[nElements] : new ::KM3NETDAQ::JDAQFrameStatus[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQFrameStatus(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQFrameStatus*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQFrameStatus(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQFrameStatus*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQFrameStatus(void *p) {
      typedef ::KM3NETDAQ::JDAQFrameStatus current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQFrameStatus

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

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

} // namespace KM3NETDAQ
namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQSuperFrameHeader(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQSuperFrameHeader : new ::KM3NETDAQ::JDAQSuperFrameHeader;
   }
   static void *newArray_KM3NETDAQcLcLJDAQSuperFrameHeader(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQSuperFrameHeader[nElements] : new ::KM3NETDAQ::JDAQSuperFrameHeader[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQSuperFrameHeader(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQSuperFrameHeader*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQSuperFrameHeader(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQSuperFrameHeader*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQSuperFrameHeader(void *p) {
      typedef ::KM3NETDAQ::JDAQSuperFrameHeader current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQSuperFrameHeader

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

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

} // namespace KM3NETDAQ
namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQSuperFrame(void *p) {
      return  p ? new(p) ::KM3NETDAQ::JDAQSuperFrame : new ::KM3NETDAQ::JDAQSuperFrame;
   }
   static void *newArray_KM3NETDAQcLcLJDAQSuperFrame(Long_t nElements, void *p) {
      return p ? new(p) ::KM3NETDAQ::JDAQSuperFrame[nElements] : new ::KM3NETDAQ::JDAQSuperFrame[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQSuperFrame(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQSuperFrame*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQSuperFrame(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQSuperFrame*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQSuperFrame(void *p) {
      typedef ::KM3NETDAQ::JDAQSuperFrame current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQSuperFrame

namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQRate(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQRate : new ::KM3NETDAQ::JDAQRate;
   }
   static void *newArray_KM3NETDAQcLcLJDAQRate(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQRate[nElements] : new ::KM3NETDAQ::JDAQRate[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQRate(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQRate*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQRate(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQRate*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQRate(void *p) {
      typedef ::KM3NETDAQ::JDAQRate current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQRate

namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQSummaryFrame(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQSummaryFrame : new ::KM3NETDAQ::JDAQSummaryFrame;
   }
   static void *newArray_KM3NETDAQcLcLJDAQSummaryFrame(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQSummaryFrame[nElements] : new ::KM3NETDAQ::JDAQSummaryFrame[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQSummaryFrame(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQSummaryFrame*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQSummaryFrame(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQSummaryFrame*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQSummaryFrame(void *p) {
      typedef ::KM3NETDAQ::JDAQSummaryFrame current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_KM3NETDAQcLcLJDAQSummaryFrame(TBuffer &buf, void *obj) {
      ((::KM3NETDAQ::JDAQSummaryFrame*)obj)->::KM3NETDAQ::JDAQSummaryFrame::Streamer(buf);
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQSummaryFrame

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

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

} // namespace KM3NETDAQ
namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQSummarysliceHeader(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQSummarysliceHeader : new ::KM3NETDAQ::JDAQSummarysliceHeader;
   }
   static void *newArray_KM3NETDAQcLcLJDAQSummarysliceHeader(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQSummarysliceHeader[nElements] : new ::KM3NETDAQ::JDAQSummarysliceHeader[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQSummarysliceHeader(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQSummarysliceHeader*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQSummarysliceHeader(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQSummarysliceHeader*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQSummarysliceHeader(void *p) {
      typedef ::KM3NETDAQ::JDAQSummarysliceHeader current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQSummarysliceHeader

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

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

} // namespace KM3NETDAQ
namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQTimesliceHeader(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQTimesliceHeader : new ::KM3NETDAQ::JDAQTimesliceHeader;
   }
   static void *newArray_KM3NETDAQcLcLJDAQTimesliceHeader(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQTimesliceHeader[nElements] : new ::KM3NETDAQ::JDAQTimesliceHeader[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQTimesliceHeader(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQTimesliceHeader*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQTimesliceHeader(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQTimesliceHeader*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQTimesliceHeader(void *p) {
      typedef ::KM3NETDAQ::JDAQTimesliceHeader current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQTimesliceHeader

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

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

} // namespace KM3NETDAQ
namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQTimeslice(void *p) {
      return  p ? new(p) ::KM3NETDAQ::JDAQTimeslice : new ::KM3NETDAQ::JDAQTimeslice;
   }
   static void *newArray_KM3NETDAQcLcLJDAQTimeslice(Long_t nElements, void *p) {
      return p ? new(p) ::KM3NETDAQ::JDAQTimeslice[nElements] : new ::KM3NETDAQ::JDAQTimeslice[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQTimeslice(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQTimeslice*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQTimeslice(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQTimeslice*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQTimeslice(void *p) {
      typedef ::KM3NETDAQ::JDAQTimeslice current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQTimeslice

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

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

} // namespace KM3NETDAQ
namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQTimesliceL0(void *p) {
      return  p ? new(p) ::KM3NETDAQ::JDAQTimesliceL0 : new ::KM3NETDAQ::JDAQTimesliceL0;
   }
   static void *newArray_KM3NETDAQcLcLJDAQTimesliceL0(Long_t nElements, void *p) {
      return p ? new(p) ::KM3NETDAQ::JDAQTimesliceL0[nElements] : new ::KM3NETDAQ::JDAQTimesliceL0[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQTimesliceL0(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQTimesliceL0*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQTimesliceL0(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQTimesliceL0*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQTimesliceL0(void *p) {
      typedef ::KM3NETDAQ::JDAQTimesliceL0 current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQTimesliceL0

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

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

} // namespace KM3NETDAQ
namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQTimesliceL1(void *p) {
      return  p ? new(p) ::KM3NETDAQ::JDAQTimesliceL1 : new ::KM3NETDAQ::JDAQTimesliceL1;
   }
   static void *newArray_KM3NETDAQcLcLJDAQTimesliceL1(Long_t nElements, void *p) {
      return p ? new(p) ::KM3NETDAQ::JDAQTimesliceL1[nElements] : new ::KM3NETDAQ::JDAQTimesliceL1[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQTimesliceL1(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQTimesliceL1*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQTimesliceL1(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQTimesliceL1*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQTimesliceL1(void *p) {
      typedef ::KM3NETDAQ::JDAQTimesliceL1 current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQTimesliceL1

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

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

} // namespace KM3NETDAQ
namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQTimesliceL2(void *p) {
      return  p ? new(p) ::KM3NETDAQ::JDAQTimesliceL2 : new ::KM3NETDAQ::JDAQTimesliceL2;
   }
   static void *newArray_KM3NETDAQcLcLJDAQTimesliceL2(Long_t nElements, void *p) {
      return p ? new(p) ::KM3NETDAQ::JDAQTimesliceL2[nElements] : new ::KM3NETDAQ::JDAQTimesliceL2[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQTimesliceL2(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQTimesliceL2*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQTimesliceL2(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQTimesliceL2*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQTimesliceL2(void *p) {
      typedef ::KM3NETDAQ::JDAQTimesliceL2 current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQTimesliceL2

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

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

} // namespace KM3NETDAQ
namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQTimesliceSN(void *p) {
      return  p ? new(p) ::KM3NETDAQ::JDAQTimesliceSN : new ::KM3NETDAQ::JDAQTimesliceSN;
   }
   static void *newArray_KM3NETDAQcLcLJDAQTimesliceSN(Long_t nElements, void *p) {
      return p ? new(p) ::KM3NETDAQ::JDAQTimesliceSN[nElements] : new ::KM3NETDAQ::JDAQTimesliceSN[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQTimesliceSN(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQTimesliceSN*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQTimesliceSN(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQTimesliceSN*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQTimesliceSN(void *p) {
      typedef ::KM3NETDAQ::JDAQTimesliceSN current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQTimesliceSN

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

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

} // namespace KM3NETDAQ
namespace ROOT {
   // Wrappers around operator new
   static void *new_KM3NETDAQcLcLJDAQSummaryslice(void *p) {
      return  p ? new(p) ::KM3NETDAQ::JDAQSummaryslice : new ::KM3NETDAQ::JDAQSummaryslice;
   }
   static void *newArray_KM3NETDAQcLcLJDAQSummaryslice(Long_t nElements, void *p) {
      return p ? new(p) ::KM3NETDAQ::JDAQSummaryslice[nElements] : new ::KM3NETDAQ::JDAQSummaryslice[nElements];
   }
   // Wrapper around operator delete
   static void delete_KM3NETDAQcLcLJDAQSummaryslice(void *p) {
      delete (static_cast<::KM3NETDAQ::JDAQSummaryslice*>(p));
   }
   static void deleteArray_KM3NETDAQcLcLJDAQSummaryslice(void *p) {
      delete [] (static_cast<::KM3NETDAQ::JDAQSummaryslice*>(p));
   }
   static void destruct_KM3NETDAQcLcLJDAQSummaryslice(void *p) {
      typedef ::KM3NETDAQ::JDAQSummaryslice current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::KM3NETDAQ::JDAQSummaryslice

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_AAObject(void *p) {
      return  p ? new(p) ::AAObject : new ::AAObject;
   }
   static void *newArray_AAObject(Long_t nElements, void *p) {
      return p ? new(p) ::AAObject[nElements] : new ::AAObject[nElements];
   }
   // Wrapper around operator delete
   static void delete_AAObject(void *p) {
      delete (static_cast<::AAObject*>(p));
   }
   static void deleteArray_AAObject(void *p) {
      delete [] (static_cast<::AAObject*>(p));
   }
   static void destruct_AAObject(void *p) {
      typedef ::AAObject current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::AAObject

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_Vec(void *p) {
      return  p ? new(p) ::Vec : new ::Vec;
   }
   static void *newArray_Vec(Long_t nElements, void *p) {
      return p ? new(p) ::Vec[nElements] : new ::Vec[nElements];
   }
   // Wrapper around operator delete
   static void delete_Vec(void *p) {
      delete (static_cast<::Vec*>(p));
   }
   static void deleteArray_Vec(void *p) {
      delete [] (static_cast<::Vec*>(p));
   }
   static void destruct_Vec(void *p) {
      typedef ::Vec current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::Vec

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_Hit(void *p) {
      return  p ? new(p) ::Hit : new ::Hit;
   }
   static void *newArray_Hit(Long_t nElements, void *p) {
      return p ? new(p) ::Hit[nElements] : new ::Hit[nElements];
   }
   // Wrapper around operator delete
   static void delete_Hit(void *p) {
      delete (static_cast<::Hit*>(p));
   }
   static void deleteArray_Hit(void *p) {
      delete [] (static_cast<::Hit*>(p));
   }
   static void destruct_Hit(void *p) {
      typedef ::Hit current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::Hit

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_Trk(void *p) {
      return  p ? new(p) ::Trk : new ::Trk;
   }
   static void *newArray_Trk(Long_t nElements, void *p) {
      return p ? new(p) ::Trk[nElements] : new ::Trk[nElements];
   }
   // Wrapper around operator delete
   static void delete_Trk(void *p) {
      delete (static_cast<::Trk*>(p));
   }
   static void deleteArray_Trk(void *p) {
      delete [] (static_cast<::Trk*>(p));
   }
   static void destruct_Trk(void *p) {
      typedef ::Trk current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::Trk

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_Evt(void *p) {
      return  p ? new(p) ::Evt : new ::Evt;
   }
   static void *newArray_Evt(Long_t nElements, void *p) {
      return p ? new(p) ::Evt[nElements] : new ::Evt[nElements];
   }
   // Wrapper around operator delete
   static void delete_Evt(void *p) {
      delete (static_cast<::Evt*>(p));
   }
   static void deleteArray_Evt(void *p) {
      delete [] (static_cast<::Evt*>(p));
   }
   static void destruct_Evt(void *p) {
      typedef ::Evt current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::Evt

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_Head(void *p) {
      return  p ? new(p) ::Head : new ::Head;
   }
   static void *newArray_Head(Long_t nElements, void *p) {
      return p ? new(p) ::Head[nElements] : new ::Head[nElements];
   }
   // Wrapper around operator delete
   static void delete_Head(void *p) {
      delete (static_cast<::Head*>(p));
   }
   static void deleteArray_Head(void *p) {
      delete [] (static_cast<::Head*>(p));
   }
   static void destruct_Head(void *p) {
      typedef ::Head current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::Head

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_MultiHead(void *p) {
      return  p ? new(p) ::MultiHead : new ::MultiHead;
   }
   static void *newArray_MultiHead(Long_t nElements, void *p) {
      return p ? new(p) ::MultiHead[nElements] : new ::MultiHead[nElements];
   }
   // Wrapper around operator delete
   static void delete_MultiHead(void *p) {
      delete (static_cast<::MultiHead*>(p));
   }
   static void deleteArray_MultiHead(void *p) {
      delete [] (static_cast<::MultiHead*>(p));
   }
   static void destruct_MultiHead(void *p) {
      typedef ::MultiHead current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::MultiHead

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<string>*)
   {
      vector<string> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<string>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<string>", -2, "vector", 389,
                  typeid(vector<string>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEstringgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<string>) );
      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<string> >()));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<string>","std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >"));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<string>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEstringgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<string>*>(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<string> : new vector<string>;
   }
   static void *newArray_vectorlEstringgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<string>[nElements] : new vector<string>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEstringgR(void *p) {
      delete (static_cast<vector<string>*>(p));
   }
   static void deleteArray_vectorlEstringgR(void *p) {
      delete [] (static_cast<vector<string>*>(p));
   }
   static void destruct_vectorlEstringgR(void *p) {
      typedef vector<string> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class vector<string>

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<int>*)
   {
      vector<int> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<int>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<int>", -2, "vector", 389,
                  typeid(vector<int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEintgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<int>) );
      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<int> >()));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<int>","std::vector<int, std::allocator<int> >"));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<int>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEintgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<int>*>(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<int> : new vector<int>;
   }
   static void *newArray_vectorlEintgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<int>[nElements] : new vector<int>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEintgR(void *p) {
      delete (static_cast<vector<int>*>(p));
   }
   static void deleteArray_vectorlEintgR(void *p) {
      delete [] (static_cast<vector<int>*>(p));
   }
   static void destruct_vectorlEintgR(void *p) {
      typedef vector<int> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class vector<int>

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<double>*)
   {
      vector<double> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<double>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<double>", -2, "vector", 389,
                  typeid(vector<double>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(vector<double>) );
      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<double> >()));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<double>","std::vector<double, std::allocator<double> >"));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<double>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEdoublegR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<double>*>(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<double> : new vector<double>;
   }
   static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<double>[nElements] : new vector<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEdoublegR(void *p) {
      delete (static_cast<vector<double>*>(p));
   }
   static void deleteArray_vectorlEdoublegR(void *p) {
      delete [] (static_cast<vector<double>*>(p));
   }
   static void destruct_vectorlEdoublegR(void *p) {
      typedef vector<double> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class vector<double>

namespace ROOT {
   static TClass *vectorlETrkgR_Dictionary();
   static void vectorlETrkgR_TClassManip(TClass*);
   static void *new_vectorlETrkgR(void *p = nullptr);
   static void *newArray_vectorlETrkgR(Long_t size, void *p);
   static void delete_vectorlETrkgR(void *p);
   static void deleteArray_vectorlETrkgR(void *p);
   static void destruct_vectorlETrkgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<Trk>*)
   {
      vector<Trk> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<Trk>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<Trk>", -2, "vector", 389,
                  typeid(vector<Trk>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlETrkgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<Trk>) );
      instance.SetNew(&new_vectorlETrkgR);
      instance.SetNewArray(&newArray_vectorlETrkgR);
      instance.SetDelete(&delete_vectorlETrkgR);
      instance.SetDeleteArray(&deleteArray_vectorlETrkgR);
      instance.SetDestructor(&destruct_vectorlETrkgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<Trk> >()));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<Trk>","std::vector<Trk, std::allocator<Trk> >"));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<Trk>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlETrkgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<Trk>*>(nullptr))->GetClass();
      vectorlETrkgR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlETrkgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlETrkgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<Trk> : new vector<Trk>;
   }
   static void *newArray_vectorlETrkgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<Trk>[nElements] : new vector<Trk>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlETrkgR(void *p) {
      delete (static_cast<vector<Trk>*>(p));
   }
   static void deleteArray_vectorlETrkgR(void *p) {
      delete [] (static_cast<vector<Trk>*>(p));
   }
   static void destruct_vectorlETrkgR(void *p) {
      typedef vector<Trk> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class vector<Trk>

namespace ROOT {
   static TClass *vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR_Dictionary();
   static void vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR_TClassManip(TClass*);
   static void *new_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p = nullptr);
   static void *newArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(Long_t size, void *p);
   static void delete_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p);
   static void deleteArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p);
   static void destruct_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<KM3NETDAQ::JDAQTriggeredHit>*)
   {
      vector<KM3NETDAQ::JDAQTriggeredHit> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<KM3NETDAQ::JDAQTriggeredHit>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<KM3NETDAQ::JDAQTriggeredHit>", -2, "vector", 389,
                  typeid(vector<KM3NETDAQ::JDAQTriggeredHit>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<KM3NETDAQ::JDAQTriggeredHit>) );
      instance.SetNew(&new_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR);
      instance.SetNewArray(&newArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR);
      instance.SetDelete(&delete_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR);
      instance.SetDeleteArray(&deleteArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR);
      instance.SetDestructor(&destruct_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<KM3NETDAQ::JDAQTriggeredHit> >()));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<KM3NETDAQ::JDAQTriggeredHit>","std::vector<KM3NETDAQ::JDAQTriggeredHit, std::allocator<KM3NETDAQ::JDAQTriggeredHit> >"));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<KM3NETDAQ::JDAQTriggeredHit>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<KM3NETDAQ::JDAQTriggeredHit>*>(nullptr))->GetClass();
      vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQTriggeredHit> : new vector<KM3NETDAQ::JDAQTriggeredHit>;
   }
   static void *newArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQTriggeredHit>[nElements] : new vector<KM3NETDAQ::JDAQTriggeredHit>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p) {
      delete (static_cast<vector<KM3NETDAQ::JDAQTriggeredHit>*>(p));
   }
   static void deleteArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p) {
      delete [] (static_cast<vector<KM3NETDAQ::JDAQTriggeredHit>*>(p));
   }
   static void destruct_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p) {
      typedef vector<KM3NETDAQ::JDAQTriggeredHit> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class vector<KM3NETDAQ::JDAQTriggeredHit>

namespace ROOT {
   static TClass *vectorlEKM3NETDAQcLcLJDAQSuperFramegR_Dictionary();
   static void vectorlEKM3NETDAQcLcLJDAQSuperFramegR_TClassManip(TClass*);
   static void *new_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p = nullptr);
   static void *newArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(Long_t size, void *p);
   static void delete_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p);
   static void deleteArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p);
   static void destruct_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<KM3NETDAQ::JDAQSuperFrame>*)
   {
      vector<KM3NETDAQ::JDAQSuperFrame> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<KM3NETDAQ::JDAQSuperFrame>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<KM3NETDAQ::JDAQSuperFrame>", -2, "vector", 389,
                  typeid(vector<KM3NETDAQ::JDAQSuperFrame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEKM3NETDAQcLcLJDAQSuperFramegR_Dictionary, isa_proxy, 0,
                  sizeof(vector<KM3NETDAQ::JDAQSuperFrame>) );
      instance.SetNew(&new_vectorlEKM3NETDAQcLcLJDAQSuperFramegR);
      instance.SetNewArray(&newArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR);
      instance.SetDelete(&delete_vectorlEKM3NETDAQcLcLJDAQSuperFramegR);
      instance.SetDeleteArray(&deleteArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR);
      instance.SetDestructor(&destruct_vectorlEKM3NETDAQcLcLJDAQSuperFramegR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<KM3NETDAQ::JDAQSuperFrame> >()));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<KM3NETDAQ::JDAQSuperFrame>","std::vector<KM3NETDAQ::JDAQSuperFrame, std::allocator<KM3NETDAQ::JDAQSuperFrame> >"));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<KM3NETDAQ::JDAQSuperFrame>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEKM3NETDAQcLcLJDAQSuperFramegR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<KM3NETDAQ::JDAQSuperFrame>*>(nullptr))->GetClass();
      vectorlEKM3NETDAQcLcLJDAQSuperFramegR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEKM3NETDAQcLcLJDAQSuperFramegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQSuperFrame> : new vector<KM3NETDAQ::JDAQSuperFrame>;
   }
   static void *newArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQSuperFrame>[nElements] : new vector<KM3NETDAQ::JDAQSuperFrame>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p) {
      delete (static_cast<vector<KM3NETDAQ::JDAQSuperFrame>*>(p));
   }
   static void deleteArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p) {
      delete [] (static_cast<vector<KM3NETDAQ::JDAQSuperFrame>*>(p));
   }
   static void destruct_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p) {
      typedef vector<KM3NETDAQ::JDAQSuperFrame> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class vector<KM3NETDAQ::JDAQSuperFrame>

namespace ROOT {
   static TClass *vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_Dictionary();
   static void vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_TClassManip(TClass*);
   static void *new_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p = nullptr);
   static void *newArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(Long_t size, void *p);
   static void delete_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p);
   static void deleteArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p);
   static void destruct_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<KM3NETDAQ::JDAQSummaryFrame>*)
   {
      vector<KM3NETDAQ::JDAQSummaryFrame> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<KM3NETDAQ::JDAQSummaryFrame>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<KM3NETDAQ::JDAQSummaryFrame>", -2, "vector", 389,
                  typeid(vector<KM3NETDAQ::JDAQSummaryFrame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_Dictionary, isa_proxy, 0,
                  sizeof(vector<KM3NETDAQ::JDAQSummaryFrame>) );
      instance.SetNew(&new_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR);
      instance.SetNewArray(&newArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR);
      instance.SetDelete(&delete_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR);
      instance.SetDeleteArray(&deleteArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR);
      instance.SetDestructor(&destruct_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<KM3NETDAQ::JDAQSummaryFrame> >()));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<KM3NETDAQ::JDAQSummaryFrame>","std::vector<KM3NETDAQ::JDAQSummaryFrame, std::allocator<KM3NETDAQ::JDAQSummaryFrame> >"));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<KM3NETDAQ::JDAQSummaryFrame>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<KM3NETDAQ::JDAQSummaryFrame>*>(nullptr))->GetClass();
      vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQSummaryFrame> : new vector<KM3NETDAQ::JDAQSummaryFrame>;
   }
   static void *newArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQSummaryFrame>[nElements] : new vector<KM3NETDAQ::JDAQSummaryFrame>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p) {
      delete (static_cast<vector<KM3NETDAQ::JDAQSummaryFrame>*>(p));
   }
   static void deleteArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p) {
      delete [] (static_cast<vector<KM3NETDAQ::JDAQSummaryFrame>*>(p));
   }
   static void destruct_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p) {
      typedef vector<KM3NETDAQ::JDAQSummaryFrame> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class vector<KM3NETDAQ::JDAQSummaryFrame>

namespace ROOT {
   static TClass *vectorlEKM3NETDAQcLcLJDAQKeyHitgR_Dictionary();
   static void vectorlEKM3NETDAQcLcLJDAQKeyHitgR_TClassManip(TClass*);
   static void *new_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p = nullptr);
   static void *newArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(Long_t size, void *p);
   static void delete_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p);
   static void deleteArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p);
   static void destruct_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<KM3NETDAQ::JDAQKeyHit>*)
   {
      vector<KM3NETDAQ::JDAQKeyHit> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<KM3NETDAQ::JDAQKeyHit>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<KM3NETDAQ::JDAQKeyHit>", -2, "vector", 389,
                  typeid(vector<KM3NETDAQ::JDAQKeyHit>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEKM3NETDAQcLcLJDAQKeyHitgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<KM3NETDAQ::JDAQKeyHit>) );
      instance.SetNew(&new_vectorlEKM3NETDAQcLcLJDAQKeyHitgR);
      instance.SetNewArray(&newArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR);
      instance.SetDelete(&delete_vectorlEKM3NETDAQcLcLJDAQKeyHitgR);
      instance.SetDeleteArray(&deleteArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR);
      instance.SetDestructor(&destruct_vectorlEKM3NETDAQcLcLJDAQKeyHitgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<KM3NETDAQ::JDAQKeyHit> >()));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<KM3NETDAQ::JDAQKeyHit>","std::vector<KM3NETDAQ::JDAQKeyHit, std::allocator<KM3NETDAQ::JDAQKeyHit> >"));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<KM3NETDAQ::JDAQKeyHit>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEKM3NETDAQcLcLJDAQKeyHitgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<KM3NETDAQ::JDAQKeyHit>*>(nullptr))->GetClass();
      vectorlEKM3NETDAQcLcLJDAQKeyHitgR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEKM3NETDAQcLcLJDAQKeyHitgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQKeyHit> : new vector<KM3NETDAQ::JDAQKeyHit>;
   }
   static void *newArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQKeyHit>[nElements] : new vector<KM3NETDAQ::JDAQKeyHit>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p) {
      delete (static_cast<vector<KM3NETDAQ::JDAQKeyHit>*>(p));
   }
   static void deleteArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p) {
      delete [] (static_cast<vector<KM3NETDAQ::JDAQKeyHit>*>(p));
   }
   static void destruct_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p) {
      typedef vector<KM3NETDAQ::JDAQKeyHit> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class vector<KM3NETDAQ::JDAQKeyHit>

namespace ROOT {
   static TClass *vectorlEHitgR_Dictionary();
   static void vectorlEHitgR_TClassManip(TClass*);
   static void *new_vectorlEHitgR(void *p = nullptr);
   static void *newArray_vectorlEHitgR(Long_t size, void *p);
   static void delete_vectorlEHitgR(void *p);
   static void deleteArray_vectorlEHitgR(void *p);
   static void destruct_vectorlEHitgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<Hit>*)
   {
      vector<Hit> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<Hit>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<Hit>", -2, "vector", 389,
                  typeid(vector<Hit>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEHitgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<Hit>) );
      instance.SetNew(&new_vectorlEHitgR);
      instance.SetNewArray(&newArray_vectorlEHitgR);
      instance.SetDelete(&delete_vectorlEHitgR);
      instance.SetDeleteArray(&deleteArray_vectorlEHitgR);
      instance.SetDestructor(&destruct_vectorlEHitgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<Hit> >()));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<Hit>","std::vector<Hit, std::allocator<Hit> >"));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<Hit>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEHitgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<Hit>*>(nullptr))->GetClass();
      vectorlEHitgR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEHitgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEHitgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<Hit> : new vector<Hit>;
   }
   static void *newArray_vectorlEHitgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<Hit>[nElements] : new vector<Hit>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEHitgR(void *p) {
      delete (static_cast<vector<Hit>*>(p));
   }
   static void deleteArray_vectorlEHitgR(void *p) {
      delete [] (static_cast<vector<Hit>*>(p));
   }
   static void destruct_vectorlEHitgR(void *p) {
      typedef vector<Hit> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class vector<Hit>

namespace ROOT {
   static TClass *vectorlEHeadgR_Dictionary();
   static void vectorlEHeadgR_TClassManip(TClass*);
   static void *new_vectorlEHeadgR(void *p = nullptr);
   static void *newArray_vectorlEHeadgR(Long_t size, void *p);
   static void delete_vectorlEHeadgR(void *p);
   static void deleteArray_vectorlEHeadgR(void *p);
   static void destruct_vectorlEHeadgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<Head>*)
   {
      vector<Head> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<Head>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<Head>", -2, "vector", 389,
                  typeid(vector<Head>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEHeadgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<Head>) );
      instance.SetNew(&new_vectorlEHeadgR);
      instance.SetNewArray(&newArray_vectorlEHeadgR);
      instance.SetDelete(&delete_vectorlEHeadgR);
      instance.SetDeleteArray(&deleteArray_vectorlEHeadgR);
      instance.SetDestructor(&destruct_vectorlEHeadgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<Head> >()));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<Head>","std::vector<Head, std::allocator<Head> >"));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<Head>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEHeadgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<Head>*>(nullptr))->GetClass();
      vectorlEHeadgR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEHeadgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEHeadgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<Head> : new vector<Head>;
   }
   static void *newArray_vectorlEHeadgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<Head>[nElements] : new vector<Head>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEHeadgR(void *p) {
      delete (static_cast<vector<Head>*>(p));
   }
   static void deleteArray_vectorlEHeadgR(void *p) {
      delete [] (static_cast<vector<Head>*>(p));
   }
   static void destruct_vectorlEHeadgR(void *p) {
      typedef vector<Head> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class vector<Head>

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<string,string>*)
   {
      map<string,string> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<string,string>));
      static ::ROOT::TGenericClassInfo 
         instance("map<string,string>", -2, "map", 100,
                  typeid(map<string,string>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &maplEstringcOstringgR_Dictionary, isa_proxy, 0,
                  sizeof(map<string,string>) );
      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<string,string> >()));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("map<string,string>","std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >"));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const map<string,string>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *maplEstringcOstringgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const map<string,string>*>(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<string,string> : new map<string,string>;
   }
   static void *newArray_maplEstringcOstringgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map<string,string>[nElements] : new map<string,string>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEstringcOstringgR(void *p) {
      delete (static_cast<map<string,string>*>(p));
   }
   static void deleteArray_maplEstringcOstringgR(void *p) {
      delete [] (static_cast<map<string,string>*>(p));
   }
   static void destruct_maplEstringcOstringgR(void *p) {
      typedef map<string,string> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class map<string,string>

namespace {
  void TriggerDictionaryInitialization_KM3NeTDictionary_Impl() {
    static const char* headers[] = {
"0",
nullptr
    };
    static const char* includePaths[] = {
"/builds/common/jpp/externals",
"/usr/local/include/",
"/builds/common/jpp/externals/km3net-dataformat/src/",
nullptr
    };
    static const char* fwdDeclCode = R"DICTFWDDCLS(
#line 1 "KM3NeTDictionary 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 KM3NETDAQ{class JDAQAbstractPreamble;}
namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQUTCExtended.hh")))  JDAQUTCExtended;}
namespace KM3NETDAQ{class JDAQChronometer;}
namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQPreamble.hh")))  JDAQPreamble;}
namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQHeader.hh")))  __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQEventHeader.hh")))  JDAQHeader;}
namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTriggerCounter.hh")))  __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQEventHeader.hh")))  JDAQTriggerCounter;}
namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTriggerMask.hh")))  __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQEventHeader.hh")))  JDAQTriggerMask;}
namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQEventHeader.hh")))  JDAQEventHeader;}
namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQHit.hh")))  JDAQHit;}
namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQModuleIdentifier.hh")))  __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQKeyHit.hh")))  JDAQModuleIdentifier;}
namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQPMTIdentifier.hh")))  __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQKeyHit.hh")))  JDAQPMTIdentifier;}
namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQKeyHit.hh")))  JDAQKeyHit;}
namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTriggeredHit.hh")))  JDAQTriggeredHit;}
namespace KM3NETDAQ{class JDAQEvent;}
namespace KM3NETDAQ{class JDAQFrame;}
namespace KM3NETDAQ{class JDAQFrameStatus;}
namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQSuperFrameHeader.hh")))  __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQSuperFrame.hh")))  JDAQSuperFrameHeader;}
namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQSuperFrame.hh")))  JDAQSuperFrame;}
namespace KM3NETDAQ{class JDAQRate;}
namespace KM3NETDAQ{class JDAQSummaryFrame;}
namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQSummarysliceHeader.hh")))  JDAQSummarysliceHeader;}
namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimesliceHeader.hh")))  __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimeslice.hh")))  JDAQTimesliceHeader;}
namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimeslice.hh")))  JDAQTimeslice;}
namespace KM3NETDAQ{struct __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimeslice.hh")))  JDAQTimesliceL0;}
namespace KM3NETDAQ{struct __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimeslice.hh")))  JDAQTimesliceL1;}
namespace KM3NETDAQ{struct __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimeslice.hh")))  JDAQTimesliceL2;}
namespace KM3NETDAQ{struct __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimeslice.hh")))  JDAQTimesliceSN;}
namespace KM3NETDAQ{class JDAQSummaryslice;}
struct AAObject;
struct __attribute__((annotate("$clingAutoload$km3net-dataformat/offline/Vec.hh")))  __attribute__((annotate("$clingAutoload$km3net-dataformat/offline/Hit.hh")))  Vec;
struct __attribute__((annotate("$clingAutoload$km3net-dataformat/offline/Hit.hh")))  Hit;
struct __attribute__((annotate("$clingAutoload$km3net-dataformat/offline/Trk.hh")))  Trk;
struct Evt;
struct Head;
struct MultiHead;
)DICTFWDDCLS";
    static const char* payloadCode = R"DICTPAYLOAD(
#line 1 "KM3NeTDictionary dictionary payload"

#ifndef NAMESPACE
  #define NAMESPACE KM3NET
#endif

#define _BACKWARD_BACKWARD_WARNING_H
// Inline headers
#ifndef __JDAQ__
#define __JDAQ__

#include "km3net-dataformat/online/JDAQException.hh"


/**
 * \file
 *
 * KM3NeT DAQ constants, bit handling, etc.
 * \author mdejong
 */


/**
 * %KM3NeT DAQ data structures and auxiliaries.
 */
namespace KM3NETDAQ {

#define KM3NET  1
#define ANTARES 2

#if NAMESPACE == ANTARES  
  static const int NUMBER_OF_PMTS          =  3;    //!< Total number of PMTs in module
#else
  static const int NUMBER_OF_PMTS          = 31;    //!< Total number of PMTs in module
#endif

#undef KM3NET
#undef ANTARES

  
  /**
   * Auxiliary data structure for single bit.
   */
  struct JBit {
    /**
     * Default constructor.
     */
    JBit() :
      bit(0)
    {}


    /** 
     * Constructor.
     *
     * \param  __bit        bit [0, 31]
     */
    JBit(int __bit) :
      bit(__bit)
    {
      if (bit < 0 || bit > 31) {
	throw JDAQException("JBit: illegal bit range.");
      }
    }


    /**
     * Get bit mask.
     *
     * In the returned mask, the single bit at <tt>bit</tt> set to 1.
     *
     * \return              bit mask
     */
    int get() const
    {
      return 1 << bit;
    }


    /**
     * Set bit in given bit mask.
     *
     * \param  mask         bit mask (I/O)
     */
    void set(int& mask) const
    {
      mask |=  get();
    }


    /**
     * Unset bit in given bit mask.
     *
     * \param  mask         bit mask (I/O)
     */
    void unset(int& mask) const
    {
      mask &= ~get();
    } 


    /**
     * Set bit in given bit mask.
     *
     * \param  mask         bit mask (I/0)
     * \param  value        bit status
     */
    void set(int& mask, const bool value) const
    {
      if (value)
	set  (mask);
      else
	unset(mask);
    }


    /**
     * Write given value as bit mask.
     *
     * \param  value        value
     * \return              bit mask
     */
    int write(const int value) const
    {
      return (value << bit) & get();
    }


    /**
     * Read given bit mask as value.
     *
     * \param  mask         bit mask
     * \return              value
     */
    int read(const int mask) const
    {
      return (mask & get()) >> bit;
    }


    /**
     * Test bit.
     *
     * \param  mask         bit mask
     * \return              true if bit set; else false
     */
    bool has(const int mask) const
    {
      return (mask & get()) != 0;
    } 


    int bit;        //!< bit
  };


  /**
   * Auxiliary data structure for range of bits.
   */
  struct JBits {
    /**
     * Default constructor.
     */
    JBits() :
      lsb(0),
      msb(0)
    {}


    /** 
     * Constructor.
     *
     * \param  __lsb        least significant bit [0,   31]
     * \param  __msb        most  significant bit [lsb, 31]
     */
    JBits(int __lsb, int __msb) :
      lsb(__lsb),
      msb(__msb)
    {
      if (lsb < 0   || lsb > 31 ||
	  msb < lsb || msb > 31) {
	throw JDAQException("JBits: illegal bit range.");
      }
    }


    /**
     * Get bit mask.
     *
     * In the returned mask, the bits from <tt>lsb</tt> (included) to <tt>msb</tt> (included) are set to 1.
     *
     * \return              bit mask
     */
    int get() const
    {
      static const unsigned int mask[] = { 0x00000001,
					   0x00000003,
					   0x00000007,
					   0x0000000F,
					   
					   0x0000001F,
					   0x0000003F,
					   0x0000007F,
					   0x000000FF,
				  
					   0x000001FF,
					   0x000003FF,
					   0x000007FF,
					   0x00000FFF,
					   
					   0x00001FFF,
					   0x00003FFF,
					   0x00007FFF,
					   0x0000FFFF,
					   
					   0x0001FFFF,
					   0x0003FFFF,
					   0x0007FFFF,
					   0x000FFFFF,
					   
					   0x001FFFFF,
					   0x003FFFFF,
					   0x007FFFFF,
					   0x00FFFFFF,
					   
					   0x01FFFFFF,
					   0x03FFFFFF,
					   0x07FFFFFF,
					   0x0FFFFFFF,
					   
					   0x1FFFFFFF,
					   0x3FFFFFFF,
					   0x7FFFFFFF,
					   0xFFFFFFFF };

      return (int) (mask[msb-lsb] << lsb);
    }


    /**
     * Write given value as bit mask.
     *
     * \param  value        value
     * \return              bit mask
     */
    int write(const int value) const
    {
      return (value << lsb) & get();
    }


    /**
     * Read given bit mask as value.
     *
     * \param  mask         bit mask
     * \return              value
     */
    int read(const int mask) const
    {
      return (mask & get()) >> lsb;
    }


    /**
     * Test bit mask.
     *
     * \param  mask         bit mask
     * \return              true if at least one of the bits is set; else false
     */
    bool has(const int mask) const
    {
      return (get() & mask) != 0;
    } 


    int lsb;        //!< least significant bit
    int msb;        //!< most  significant bit
  };


  static const JBit   DAQ_WHITE_RABBIT        (31);       //!< White Rabbit status
  static const JBits  DAQ_TDC                 ( 0, 30);   //!< TDC  high-rate veto status
  static const JBits  DAQ_FIFO                ( 0, 30);   //!< FIFO almost full bits

  static const JBit   DAQ_UDP_TRAILER         (31);       //!< UDP trailer
  static const JBits  DAQ_UDP_RECEIVED_PACKETS( 0, 15);   //!< Mask of UDP received packets
  static const JBits  DAQ_UDP_SEQUENCE_NUMBER (16, 31);   //!< Mask of UDP sequence number
}

#endif
#ifndef __JDAQABSTRACTPREAMBLE__
#define __JDAQABSTRACTPREAMBLE__

#include "km3net-dataformat/online/JDAQDataTypes.hh"
#include "km3net-dataformat/online/JDAQRoot.hh"


/**
 * \author rbruijn
 */

namespace KM3NETDAQ {


  /**
   * Simple data structure for the DAQ preamble required for a correct calculation 
   * of the object size for binary I/O.
   *
   * Note that JDAQPreamble derives from this and adds I/O and ROOT functionality.
   */
  class JDAQAbstractPreamble {
  protected:
    /**
     * Constructor.
     *
     * \param  type           data type of derived class
     */
    template<class T>
    JDAQAbstractPreamble(JDAQType<T> type) :
      length(0),
      type  (KM3NETDAQ::getDataType(type))
    {}
    
  public:
    /**
     * Default constuctor
     */
    JDAQAbstractPreamble() :
      length(0),
      type  (0)
    {}
    

    /**
     * Get length.
     *
     * \return                number of bytes
     */
    int getLength() const 
    { 
      return length;
    }
    

    /**
     * Get data type.
     *
     * \return                data type
     */
    int getDataType() const 
    { 
      return type; 
    }


    ClassDefNV(JDAQAbstractPreamble,1);

  protected:
    int length;
    int type;
  };
}

#endif
#ifndef __JDAQCHRONOMETER__
#define __JDAQCHRONOMETER__

#include <ostream>
#include <iomanip>

#include "km3net-dataformat/online/JDAQRoot.hh"
#include "km3net-dataformat/online/JDAQUTCExtended.hh"
#include "km3net-dataformat/online/JDAQClock.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {

  /**
   * DAQ chronometer.
   */
  class JDAQChronometer
  {
  public:

    friend size_t getSizeof<JDAQChronometer>();
    friend JReader& operator>>(JReader&, JDAQChronometer&);
    friend JWriter& operator<<(JWriter&, const JDAQChronometer&);

    /**
     * Default constructor.
     */
    JDAQChronometer() :
      detector_id(0),
      run        (0),
      frame_index(0),
      timeslice_start()
    {}


    /**
     * Constructor.
     *
     * \param  __detector_id        detector identifier
     * \param  __run                run number
     * \param  __frame_index        frame index
     */
    JDAQChronometer(const int __detector_id,
		    const int __run,
		    const int __frame_index) :
      detector_id(__detector_id),
      run        (__run),
      frame_index(__frame_index),
      timeslice_start(getTimeOfFrame(__frame_index))
    {}


    /**
     * Constructor.
     *
     * \param  __detector_id        detector identifier
     * \param  __run                run number
     * \param  __frame_index        frame index
     * \param  __timeslice_start    start of time slice
     */
    JDAQChronometer(const int __detector_id,
		    const int __run,
		    const int __frame_index,
		    const JDAQUTCExtended& __timeslice_start) :
      detector_id(__detector_id),
      run        (__run),
      frame_index(__frame_index),
      timeslice_start(__timeslice_start)
    {}


    /**
     * Virtual destructor.
     */
    virtual ~JDAQChronometer()
    {}


    /**
     * Get DAQ chronometer.
     *
     * \return                DAQ chronometer
     */
    const JDAQChronometer& getDAQChronometer() const 
    { 
      return static_cast<const JDAQChronometer&>(*this); 
    }


    /**
     * Set DAQ chronometer.
     *
     * \param chronometer     DAQ chronometer
     */
    void setDAQChronometer(const JDAQChronometer& chronometer)
    { 
      static_cast<JDAQChronometer&>(*this) = chronometer;
    }


    /**
     * Get detector identifier.
     *
     * \return                detector identifier
     */
    int getDetectorID() const 
    { 
      return detector_id; 
    }


    /**
     * Get run number.
     *
     * \return                run number
     */
    int getRunNumber() const 
    { 
      return run; 
    }


    /**
     * Get frame index.
     *
     * \return                frame index
     */
    int getFrameIndex() const 
    { 
      return frame_index; 
    }
    
    
    /**
     * Get start of timeslice
     *
     * \return                timeslice start
     */
    
    JDAQUTCExtended getTimesliceStart() const
    {
      return timeslice_start;
    }
    

    /**
     * Set run number.
     *
     * \param run             run number
     */
    void setRunNumber(const int run)
    { 
      this->run = run;
    }


    /**
     * Set frame index.
     *
     * \param frame_index     frame index
     */
    void setFrameIndex(const int frame_index)
    { 
      this->frame_index = frame_index;
    }

    
    /**
     * Set timeslice start time
     *
     * \param timeslice_start timeslice start time
     */    
    void setTimesliceStart(const JDAQUTCExtended& timeslice_start)
    {
      this->timeslice_start = timeslice_start;
    }


    ClassDef(JDAQChronometer,3);


  protected:
    int detector_id;
    int run;
    int frame_index;
    JDAQUTCExtended timeslice_start;
  };


  /**
   * Print DAQ chronometer.
   *
   * \param  out           output stream
   * \param  chronometer   JDAQChronometer
   * \return               output stream
   */
  inline std::ostream& operator<<(std::ostream& out, const JDAQChronometer& chronometer)
  {
    using namespace std;

    out << setw(8) << chronometer.getDetectorID();
    out << ' ';
    out << setw(8) << chronometer.getRunNumber();
    out << ' ';
    out << setw(8) << chronometer.getFrameIndex();
    out << ' ';
    out <<            chronometer.getTimesliceStart();
    
    return out;
  }


  /**
   * Get time of last RTS in ns since start of run for a given chronometer.
   *
   * \param  chronometer  chronometer
   * \return              time [ns]
   */
  inline double getTimeOfRTS(const JDAQChronometer& chronometer)
  {
    return getTimeOfRTS(chronometer.getFrameIndex());
  }


  /**
   * Equal operator for DAQ chronometers.
   *
   * \param  first     chronometer
   * \param  second    chronometer
   * \result           true if first chronometer equal to second; else false
   */
  inline bool operator==(const JDAQChronometer& first,
			 const JDAQChronometer& second)
  {
    return (first.getDetectorID()     == second.getDetectorID()    &&
	    first.getRunNumber()      == second.getRunNumber()     &&
	    first.getFrameIndex()     == second.getFrameIndex()    &&
	    first.getTimesliceStart() == second.getTimesliceStart());
  }


  /**
   * Not-equal operator for DAQ chronometers.
   *
   * \param  first     chronometer
   * \param  second    chronometer
   * \result           true if first chronometer not equal to second; else false
   */
  inline bool operator!=(const JDAQChronometer& first,
			 const JDAQChronometer& second)
  {
    return !(first == second);
  }


  /**
   * Get time difference between two chronometers.
   *
   * \param  first       chronometer
   * \param  second      chronometer
   * \result             time difference [s]
   */
  inline double getTimeDifference(const JDAQChronometer& first, const JDAQChronometer& second)
  {
    return getTimeDifference(first.getTimesliceStart(), second.getTimesliceStart());
  }
}

#endif
#ifndef __JDAQCLOCK__
#define __JDAQCLOCK__

#include <istream>
#include <ostream>
#include <exception>
#include <cmath>

#include "km3net-dataformat/online/JDAQException.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {

  namespace {
    static double FRAME_TIME_NS =  100000000.0;     //!< Frame time [ns]
    static double RESET_TIME_NS =  FRAME_TIME_NS;   //!< TDC dynamic range [ns]
  }


  /**
   * Auxiliary class to set DAQ system clock parameters.
   */
  class JDAQClock {
  public:
    /**
     * Clock types.
     */
    enum JDAQClock_t { KM3NET = 1, PPM_DU = 3, ANTARES = 101 };

  
    /**
     * Constructor.
     *
     * \param  clock        clock type
     */
    JDAQClock(const JDAQClock_t clock = KM3NET)
    {
      this->clock = clock;

      set();
    }


    /**
     * Get clock type.
     *
     * \return              clock type
     */
    JDAQClock_t get() const
    {
      return clock;
    }


    /**
     * Set clock type.
     *
     * \param  clock        clock type
     */
    void set(const JDAQClock_t clock)
    {
      this->clock = clock;

      set();
    }


    /**
     * Set DAQ clock parameters.
     */
    void set()
    {
      switch (this->clock) {

      case KM3NET:
	FRAME_TIME_NS =  100000000.0;
	RESET_TIME_NS =  FRAME_TIME_NS;
	break;
	
      case PPM_DU:
	FRAME_TIME_NS =  (1<<27);
	RESET_TIME_NS =  FRAME_TIME_NS;
	break;
	
      case ANTARES:
	FRAME_TIME_NS =  13107200.0 * 8;
	RESET_TIME_NS = 419430400.0;
	break;
	
      default:
	throw JDAQException("Undefined clock.");
      }
    }


    /**
     * Read clock from input.
     *
     * \param  in         input stream
     * \param  clock      JClock
     * \return            input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JDAQClock& clock)
    {
      using namespace std;

      int clk;
	
      in >> clk;

      try {
	clock.set((JDAQClock_t) clk);
      }
      catch(const std::exception& error) {
	in.setstate(ios_base::badbit);
      }

      return in;
    }


    /**
     * Write clock to output.
     *
     * \param  out        output stream
     * \param  clock      JClock
     * \return            output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JDAQClock& clock)
    {
      return out << clock.clock;
    }


  protected:
    JDAQClock_t clock;
  };


  /**
   * Equal operator for JDAQClock.
   *
   * \param  first        JDAQClock
   * \param  second       JDAQClock
   * \return              true if both clock types are equal; else false
   */
  inline bool operator==(const JDAQClock& first, const JDAQClock& second)
  {
    return first.get() == second.get();
  }


  /**
   * Get frame time duration.
   *
   * \return              frame time [ns]
   */
  inline double getFrameTime() 
  { 
    return FRAME_TIME_NS; 
  }


  /**
   * Get TDC dynamic range.
   *
   * \return              TDC dynamic range [ns]
   */
  inline double getRTS() 
  { 
    return RESET_TIME_NS; 
  }


  /**
   * Get start time of frame in ns since start of run for a given frame index.
   *
   * \param  frame_index  frame index
   * \return              time [ns]
   */
  inline double getTimeOfFrame(const int frame_index)
  {
    if (frame_index != 0)
      return (double) (frame_index - 1) * FRAME_TIME_NS;
    else
      return 0;
  }


  /**
   * Get start time of frame in ns since start of run for a given frame index.
   *
   * \param  frame_index  frame index
   * \return              time [ns]
   */
  inline double getTimeOfFrame(const unsigned int frame_index)
  {
    if (frame_index != 0)
      return (double) (frame_index - 1) * FRAME_TIME_NS;
    else
      return 0;
  }


  /**
   * Get time of last RTS in ns since start of run for a given time.
   *
   * \param  t_ns         time [ns]
   * \return              time [ns]
   */
  inline double getTimeOfRTS(const double t_ns)
  {
    return std::floor(t_ns/RESET_TIME_NS) * RESET_TIME_NS;
  }


  /**
   * Get time of last RTS in ns since start of run for a given frame index.
   *
   * \param  frame_index  frame index
   * \return              time [ns]
   */
  inline double getTimeOfRTS(const int frame_index)
  {
    return std::floor(getTimeOfFrame(frame_index)/RESET_TIME_NS) * RESET_TIME_NS;
  }


  /**
   * Get time of last RTS in ns since start of run for a given frame index.
   *
   * \param  frame_index  frame index
   * \return              time [ns]
   */
  inline double getTimeOfRTS(const unsigned int frame_index)
  {
    return std::floor(getTimeOfFrame(frame_index)/RESET_TIME_NS) * RESET_TIME_NS;
  }


  /**
   * Get frame index for a given time in ns.
   *
   * \param  t_ns         time [ns]
   * \return              frame index
   */
  inline int getFrameIndex(const double t_ns)
  {
    return (int) (t_ns / FRAME_TIME_NS) + 1;
  }


  /**
   * Get time in ns since last RTS for a given frame index.
   *
   * \param  frame_index  frame index
   * \return              time [ns]
   */
  inline double getTimeSinceRTS(const int frame_index)
  {
    return std::fmod(getTimeOfFrame(frame_index), RESET_TIME_NS);
  }


  /**
   * Get time in ns since last RTS for a given frame index.
   *
   * \param  frame_index  frame index
   * \return              time [ns]
   */
  inline double getTimeSinceRTS(const unsigned int frame_index)
  {
    return std::fmod(getTimeOfFrame(frame_index), RESET_TIME_NS);
  }


  /**
   * Get time in ns since last RTS for a given time in ns.
   *
   * \param  t_ns         time [ns]
   * \return              time [ns]
   */
  inline double getTimeSinceRTS(const double& t_ns)
  {
    return std::fmod(t_ns, RESET_TIME_NS);
  }
}

namespace ANTARES {
  /**
   * Set clock.
   */
  inline void setClock()
  {
    KM3NETDAQ::JDAQClock clock(KM3NETDAQ::JDAQClock::ANTARES);
  }

  using KM3NETDAQ::getFrameTime;
  using KM3NETDAQ::getRTS;
  using KM3NETDAQ::getTimeOfFrame;
  using KM3NETDAQ::getTimeOfRTS;
  using KM3NETDAQ::getFrameIndex;
  using KM3NETDAQ::getTimeSinceRTS;
}

namespace KM3NET {
  /**
   * Set clock.
   */
  inline void setClock()
  {
    KM3NETDAQ::JDAQClock clock(KM3NETDAQ::JDAQClock::KM3NET);
  }

  using KM3NETDAQ::getFrameTime;
  using KM3NETDAQ::getRTS;
  using KM3NETDAQ::getTimeOfFrame;
  using KM3NETDAQ::getTimeOfRTS;
  using KM3NETDAQ::getFrameIndex;
  using KM3NETDAQ::getTimeSinceRTS;
}

#endif
#ifndef __JDAQDATATYPES__
#define __JDAQDATATYPES__

#include "km3net-dataformat/definitions/daqdatatypes.hh"

/**
 * \author mdejong
 */

namespace KM3NETDAQ {

  /**
   * Auxiliary class for a DAQ type holder.\n
   * This class can be used to transfer a template class to a method argument.
   */
  template<class T>
  struct JDAQType {
    typedef T  data_type;
  };


  /**
   * Template definition for method returning data type.\n
   * The template argument refers to the data type for future I/O operations.
   */
  template<class T>
  inline int getDataType()
  {
    return getDataType(JDAQType<T>());
  }
 

  /**
   * Argument definition for method returning data type.\n
   * The method argument refers to the data type for future I/O operations.\n
   * This method should be overloaded for each corresponding class.
   *
   * \param  type          data type
   */
  template<class T>
  inline int getDataType(const JDAQType<T>& type);


  class  JDAQSuperFrame;
  class  JDAQSummaryFrame;
  class  JDAQTimeslice;
  struct JDAQTimesliceL0;
  struct JDAQTimesliceL1;
  struct JDAQTimesliceL2;
  struct JDAQTimesliceSN;
  class  JDAQSummaryslice;
  class  JDAQEvent;


  inline int getDataType(const JDAQType<JDAQSuperFrame>&)   { return DAQSUPERFRAME; }
  inline int getDataType(const JDAQType<JDAQSummaryFrame>&) { return DAQSUMMARYFRAME; }
  inline int getDataType(const JDAQType<JDAQTimeslice>&)    { return DAQTIMESLICE; }
  inline int getDataType(const JDAQType<JDAQTimesliceL0>&)  { return DAQTIMESLICEL0; }
  inline int getDataType(const JDAQType<JDAQTimesliceL1>&)  { return DAQTIMESLICEL1; }
  inline int getDataType(const JDAQType<JDAQTimesliceL2>&)  { return DAQTIMESLICEL2; }
  inline int getDataType(const JDAQType<JDAQTimesliceSN>&)  { return DAQTIMESLICESN; }
  inline int getDataType(const JDAQType<JDAQSummaryslice>&) { return DAQSUMMARYSLICE; }
  inline int getDataType(const JDAQType<JDAQEvent>&)        { return DAQEVENT; }
}

#endif
#ifndef __JDAQEVENT__
#define __JDAQEVENT__

#include <ostream>
#include <iomanip>
#include <vector>

#include "km3net-dataformat/online/JDAQRoot.hh"
#include "km3net-dataformat/online/JDAQPreamble.hh"
#include "km3net-dataformat/online/JDAQEventHeader.hh"
#include "km3net-dataformat/online/JDAQHit.hh"
#include "km3net-dataformat/online/JDAQKeyHit.hh"
#include "km3net-dataformat/online/JDAQTriggeredHit.hh"
#include "km3net-dataformat/online/JDAQPrint.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {


  typedef  JDAQKeyHit             JDAQSnapshotHit;


  /**
   * DAQ Event.
   */
  class JDAQEvent :
    public JDAQPreamble,
    public JDAQEventHeader
  {
  public:

    using JDAQTriggerMask::getTriggerMask;

    friend size_t getSizeof(const JDAQEvent&);
    friend JReader& operator>>(JReader&, JDAQEvent&);
    friend JWriter& operator<<(JWriter&, const JDAQEvent&);

    /**
     * Default constructor.
     */
    JDAQEvent() :
      JDAQPreamble(JDAQType<JDAQEvent>()),
      JDAQEventHeader()
    {}


    /**
     * Constructor.
     *
     * \param  header         header
     */
    JDAQEvent(const JDAQEventHeader& header) :
      JDAQPreamble(JDAQType<JDAQEvent>()),
      JDAQEventHeader(header)
    {}


    /**
     * Template const_iterator
     */
    template<class T> 
    class const_iterator : 
      public std::vector<T>::const_iterator
    {
    public:
      /**
       * Default constructor.
       */
      const_iterator() :
	std::vector<T>::const_iterator()
      {}

      
      /**
       * Copy constructor.
       *
       * \param  i              iterator
       */
      const_iterator(const typename std::vector<T>::const_iterator& i) :
	std::vector<T>::const_iterator(i)
      {}
    };


    /**
     * Template const_reverse_iterator
     */
    template<class T> 
    class const_reverse_iterator : 
      public std::vector<T>::const_reverse_iterator
    {
    public:
      /**
       * Default constructor.
       */
      const_reverse_iterator() :
	std::vector<T>::const_reverse_iterator()
      {}
      

      /**
       * Copy constructor.
       *
       * \param  i              iterator
       */
      const_reverse_iterator(const typename std::vector<T>::const_reverse_iterator& i) :
	std::vector<T>::const_reverse_iterator(i)
      {}
    };


    /**
     * Get container with hits.
     *
     * \return                container with hits
     */
    template<class T>
    const std::vector<T>& getHits() const;


    /**
     * Get container with hits.
     *
     * \return                container with hits
     */
    template<class T>
    std::vector<T>& getHits();


    /**
     * Get begin of data.
     *
     * \return                begin of data
     */
    template<class T>
    const_iterator<T> begin() const;


    /**
     * Get end of data.
     *
     * \return                end of data
     */
    template<class T>
    const_iterator<T> end() const;


    /**
     * Get reverse begin of data.
     *
     * \return                begin of data
     */
    template<class T>
    const_reverse_iterator<T> rbegin() const;


    /**
     * Get reverse end of data.
     *
     * \return                end of data
     */
    template<class T>
    const_reverse_iterator<T> rend() const;


    /**
     * Get number of hits.
     *
     * \return                number of hits
     */
    template<class T>
    unsigned int size() const;


    /**
     * Check emptyness of hit container.
     *
     * \return                true if empty; else false
     */
    template<class T>
    bool empty() const;


    /**
     * Clear event.
     */
    void clear()
    {
      snapshotHits .clear();
      triggeredHits.clear();
    }


    /**
     * Add hit.
     *
     * \param  hit            hit
     */
    void push_back(const JDAQKeyHit& hit)
    {
      snapshotHits.push_back(hit);
    }


    /**
     * Add hit.
     *
     * \param  hit            hit
     */
    void push_back(const JDAQTriggeredHit& hit)
    {
      triggeredHits.push_back(hit);
    }


    /**
     * Get trigger mask of given hit.
     *
     * \param  hit            hit
     * \return                trigger mask
     */
    static JTriggerMask_t getTriggerMask(const JDAQTriggeredHit& hit) 
    {
      return hit.getTriggerMask();
    }


    /**
     * Get trigger mask of given hit.
     *
     * \param  hit            hit
     * \return                trigger mask
     */
    JTriggerMask_t getTriggerMask(const JDAQSnapshotHit& hit) const
    {
      for (std::vector<JDAQTriggeredHit>::const_iterator i = triggeredHits.begin(); i != triggeredHits.end(); ++i) {
	if (*i == hit) {
	  return i->getTriggerMask();
	}
      }

      return JTriggerMask_t(0);
    }


    /**
     * Print DAQ Event.
     *
     * \param  out         output stream
     * \param  lpr         long print
     * \return             output stream
     */
    std::ostream& print(std::ostream& out, const bool lpr = false) const;


    ClassDef(JDAQEvent,4);


  protected:
    std::vector<JDAQTriggeredHit> triggeredHits;
    std::vector<JDAQSnapshotHit>  snapshotHits;
  };


  /**
   * Equal operator for DAQ events.
   *
   * \param  first     event
   * \param  second    event
   * \result           true if first event equal to second; else false
   */
  bool operator==(const JDAQEvent& first,
		  const JDAQEvent& second);
  

  /**
   * Not-equal operator for DAQ events.
   *
   * \param  first     event
   * \param  second    event
   * \result           true if first event not equal to second; else false
   */
  inline bool operator!=(const JDAQEvent& first,
			 const JDAQEvent& second)
  {
    return !(first == second);
  }

  
  /**
   * Print DAQ Event.
   *
   * \param  out         output stream
   * \param  event       event
   * \return             output stream
   */
  inline std::ostream& operator<<(std::ostream& out, const JDAQEvent& event)
  {
    return event.print(out, getDAQLongprint());
  }


  /**
   * Get time difference between two events.
   *
   * \param  first       event
   * \param  second      event
   * \result             time difference [s]
   */
  inline double getTimeDifference(const JDAQEvent& first, const JDAQEvent& second);
}

#endif
#ifndef __JDAQEVENTHEADER__
#define __JDAQEVENTHEADER__

#include "km3net-dataformat/online/JDAQRoot.hh"
#include "km3net-dataformat/online/JDAQHeader.hh"
#include "km3net-dataformat/online/JDAQTriggerCounter.hh"
#include "km3net-dataformat/online/JDAQTriggerMask.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {

  /**
   * JDAQ event header.
   */
  class JDAQEventHeader :
    public JDAQHeader,
    public JDAQTriggerCounter,
    public JDAQTriggerMask
  {
  public:

    friend size_t getSizeof<JDAQEventHeader>();
    friend JReader& operator>>(JReader&, JDAQEventHeader&);
    friend JWriter& operator<<(JWriter&, const JDAQEventHeader&);

    /**
     * Default constructor.
     */
    JDAQEventHeader() :
      JDAQHeader(),
      JDAQTriggerCounter(),
      JDAQTriggerMask(),
      overlays(0)
    {}

    
    /**
     * Get DAQ event header.
     *
     * \return                DAQ event header
     */
    const JDAQEventHeader& getDAQEventHeader() const
    {
      return static_cast<const JDAQEventHeader&>(*this);
    }


    /**
     * Check if header is same.
     *
     * \param  header         DAQ event header
     * \return                true if event headers are same; else false
     */
    inline bool is_same(const JDAQEventHeader& header) const
    {
      return (this->getDetectorID() == header.getDetectorID() &&
	      this->getRunNumber()  == header.getRunNumber()  &&
	      this->getFrameIndex() == header.getFrameIndex() &&
	      this->getCounter()    == header.getCounter());
    }
	

    /**
     * Get number of overlays.
     *
     * \return                number of overlays
     */
    unsigned int getOverlays() const
    {
      return overlays;
    }


    ClassDef(JDAQEventHeader,3);


  protected:
    unsigned int overlays;
  };


  /**
   * Equal operator for DAQ event headers.
   *
   * \param  first     event header
   * \param  second    event header
   * \result           true if first event header equal to second; else false
   */
  inline bool operator==(const JDAQEventHeader& first,
			 const JDAQEventHeader& second)
  {
    return (first.getDAQHeader()         == second.getDAQHeader()         &&
	    first.getDAQTriggerCounter() == second.getDAQTriggerCounter() &&
	    first.getDAQTriggerMask()    == second.getDAQTriggerMask());
  }


  /**
   * Not-equal operator for DAQ event headers.
   *
   * \param  first     event header
   * \param  second    event header
   * \result           true if first event header not equal to second; else false
   */
  inline bool operator!=(const JDAQEventHeader& first,
			 const JDAQEventHeader& second)
  {
    return !(first == second);
  }
}

#endif
#ifndef __JDAQEXCEPTION__
#define __JDAQEXCEPTION__

#include <exception>
#include <ostream>


/**
 * \author mdejong
 */

namespace KM3NETDAQ {


  /**
   * General exception
   */
  class JDAQException : public std::exception { 
  public:
    /**
     * Constructor.
     *
     * \param  error    error message
     */
    JDAQException(const std::string& error) :
      std::exception(),
      buffer(error)
    {}


    /**
     * Destructor.
     */
    ~JDAQException() throw()
    {}


    /**
     * Get error message.
     *
     * \return          error message
     */
    virtual const char* what() const throw() 
    { 
      return buffer.c_str();
    }


    /**
     * Print error message of JDAQException.
     *
     * \param  out        output stream
     * \param  exception  exception
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JDAQException& exception)
    {
      return out << exception.what();
    }

  private:
    const std::string buffer;
  };
}

#endif
#ifndef __JDAQFRAME__
#define __JDAQFRAME__

#include <stdlib.h>
#include <string.h>
#include <string>
#include <iterator>
#include <algorithm>

#include "km3net-dataformat/online/JDAQHit.hh"
#include "km3net-dataformat/online/JDAQRoot.hh"
#include "km3net-dataformat/online/JDAQException.hh"


/**
 * \author mdejong
 */
namespace KM3NETDAQ {

  /**
   * Subset of data frame.
   **/
  class JDAQFrameSubset
  {
  public:

    typedef  const JDAQHit*                         const_iterator;
    typedef  std::reverse_iterator<const_iterator>  const_reverse_iterator;


    /**
     * Constructor.
     *
     * \param  number_of_hits   number of hits
     * \param  data             pointer to data
     */
    JDAQFrameSubset(const int number_of_hits, const JDAQHit* data) :
      numberOfHits(number_of_hits),
      buffer(data)
    {}


    const_iterator begin() const { return buffer; }
    const_iterator end()   const { return buffer + numberOfHits; }

    const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
    const_reverse_iterator rend()   const { return const_reverse_iterator(begin()); }

    bool empty() const { return numberOfHits == 0; }

    int size() const { return numberOfHits; }

    const JDAQHit* data() const { return buffer; }


  private:
    const int      numberOfHits;
    const JDAQHit* buffer;
  };


  /**
   * Data frame.
   */
  class JDAQFrame
  {
  public:

    typedef  const JDAQHit*                         const_iterator;
    typedef  JDAQHit*                               iterator;
    typedef  std::reverse_iterator<const_iterator>  const_reverse_iterator;
    typedef  std::reverse_iterator<iterator>        reverse_iterator;

    friend size_t getSizeof(const JDAQFrame&);
    friend JReader& operator>>(JReader&, JDAQFrame&);
    friend JWriter& operator<<(JWriter&, const JDAQFrame&);

    /**
     * Default constructor.
     */
    JDAQFrame() :
      numberOfHits(0),
      buffer(NULL)
    {}


    /**
     * Copy constructor.
     *
     * \param  frame            frame
     */
    JDAQFrame(const JDAQFrame& frame) :
      numberOfHits(0),
      buffer(NULL)
    {
      add(frame);
    }


    /**
     * Move constructor.
     *
     * \param  frame            frame
     */
    JDAQFrame(JDAQFrame&& frame) :
      numberOfHits(frame.numberOfHits),
      buffer      (frame.buffer)
    {
      frame.numberOfHits = 0;
      frame.buffer       = NULL;
    }


    /**
     * Constructor.
     *
     * \param  number_of_hits   number of hits
     * \param  data             pointer to data
     */
    JDAQFrame(const int number_of_hits, const JDAQHit* data) :
      numberOfHits(0),
      buffer(NULL)
    {
      add(number_of_hits, data);
    }


    /**
     * Destructor.
     */
    virtual ~JDAQFrame()
    {
      clear();
    }


    /**
     * Assignment operator.
     *
     * \param  frame            frame
     * \return                  this frame
     */
    JDAQFrame& operator=(const JDAQFrame& frame)
    {
      add(frame);

      return *this;
    }


    /**
     * Clear data.
     */
    void clear()
    {
      if (buffer != NULL) {
	free(buffer);
      }

      numberOfHits = 0;
      buffer       = NULL;
    }


    const_iterator begin() const { return buffer; }
    const_iterator end()   const { return buffer + numberOfHits; }


    iterator begin() { return buffer; }
    iterator end()   { return buffer + numberOfHits; }


    const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
    const_reverse_iterator rend()   const { return const_reverse_iterator(begin()); }


    reverse_iterator rbegin() { return reverse_iterator(end()); }
    reverse_iterator rend()   { return reverse_iterator(begin()); }


    bool empty() const { return numberOfHits == 0; }

    int size() const { return numberOfHits; }

    const JDAQHit* data() const { return buffer; }
    JDAQHit*       data()       { return buffer; }


    /**
     * Get hit at given index.
     *
     * \param  index            index
     * \return                  hit
     */
    const JDAQHit& operator[](int index) const
    {
      return buffer[index];
    }

    /**
     * Get subset of data.
     *
     * \param  i1               first index of hit (included)
     * \param  i2               last  index of hit (excluded)
     * \return                  frame
     */
    JDAQFrameSubset subset(const int i1, const int i2) const
    {
      return JDAQFrameSubset(i2 - i1, buffer + i1);
    }


    /**
     * Add data.
     *
     * \param  frame            frame
     * \return                  this frame
     */
    JDAQFrame& add(const JDAQFrame& frame) 
    {
      return add(frame.numberOfHits, frame.buffer);
    }


    /**
     * Add data.
     *
     * \param  number_of_hits   number of hits
     * \param  data             pointer to data
     * \return                  this data frame
     */
    JDAQFrame& add(const int number_of_hits, const JDAQHit* data)
    {
      if (number_of_hits > 0) {

	resize(numberOfHits + number_of_hits);

	memcpy(buffer + numberOfHits - number_of_hits, data, number_of_hits * sizeof(JDAQHit));
      }

      return *this;
    }


    /**
     * Swap data.
     *
     * \param  frame            frame
     */
    void swap(JDAQFrame& frame) 
    {
      std::swap(numberOfHits, frame.numberOfHits);
      std::swap(buffer,       frame.buffer);
    }


    int      numberOfHits;        // following comment line is used by rootcint
    JDAQHit* buffer;              // [numberOfHits]


    ClassDef(JDAQFrame,1);


  protected:
    /**
     * Resize internal buffer.
     *
     * This method increases the size of the buffer if necessary.
     * Otherwise, the current size is maintained.
     *
     * \param  number_of_hits   total number of hits to allocate
     */
    void resize(const int number_of_hits)
    {
      if (number_of_hits > numberOfHits) {

	const int number_of_bytes = number_of_hits * sizeof(JDAQHit);

	if (buffer == NULL)
	  buffer = (JDAQHit*) malloc(number_of_bytes);
	else
	  buffer = (JDAQHit*) realloc(buffer, number_of_bytes);

	if (buffer == NULL) {
	  throw JDAQException("JDAQFrame::resize(): Memory exception - number of hits = " + std::to_string(number_of_hits));
	}

	numberOfHits = number_of_hits;
      }
    }
  };


  /**
   * Equal operator for DAQ frames.
   *
   * \param  first     frame
   * \param  second    frame
   * \result           true if first frame equal to second; else false
   */
  inline bool operator==(const JDAQFrame& first,
			 const JDAQFrame& second)
  {
    if (first.size() == second.size()) {
      
      for (JDAQFrame::const_iterator p = first.begin(), q = second.begin(); p != first.end(); ++p, ++q) {
	if (*p != *q) {
	  return false;
	}
      }
      
      return true;

    } else {

      return false;
    }
  }


  /**
   * Not-equal operator for DAQ frames.
   *
   * \param  first     frame
   * \param  second    frame
   * \result           true if first frame not equal to second; else false
   */
  inline bool operator!=(const JDAQFrame& first,
			 const JDAQFrame& second)
  {
    return !(first == second);
  }
}

#endif
#ifndef __JDAQFRAMESTATUS__
#define __JDAQFRAMESTATUS__

#include "km3net-dataformat/online/JDAQ.hh"
#include "km3net-dataformat/online/JDAQException.hh"
#include "km3net-dataformat/online/JDAQRoot.hh"


/**
 * \author mdejong
 */
namespace KM3NETDAQ {

  /**
   * DAQ frame status.
   */
  class JDAQFrameStatus {
  public:

    friend size_t getSizeof<JDAQFrameStatus>();
    friend JReader& operator>>(JReader&, JDAQFrameStatus&);
    friend JWriter& operator<<(JWriter&, const JDAQFrameStatus&);

    /**
     * Default constructor.
     */
    JDAQFrameStatus() :
      daq     (0),
      status  (0),
      fifo    (0),
      status_3(0),
      status_4(0)
    {}
    

    /**
     * Constructor.
     *
     * \param  __daq          DAQ  status
     * \param  __status       TDC  status
     * \param  __fifo         FIFO status
     * \param  __status_3     spare
     * \param  __status_4     spare
     */
    JDAQFrameStatus(const int __daq,
		    const int __status,
		    const int __fifo,
		    const int __status_3 = 0,
		    const int __status_4 = 0) :
      daq     (__daq),
      status  (__status),
      fifo    (__fifo),
      status_3(__status_3),
      status_4(__status_4)
    {}
 

    /**
     * Get reference to unique instance of this class object.
     *
     * This instance has default values which correspond to a valid DAQ frame status.
     *
     * \return                reference to this class object
     */
    static const JDAQFrameStatus& getInstance()
    {
      static const JDAQFrameStatus status(DAQ_UDP_RECEIVED_PACKETS.write(2) | DAQ_UDP_SEQUENCE_NUMBER.write(1),
					  DAQ_WHITE_RABBIT.write(1),
					  DAQ_FIFO.write(0) | DAQ_UDP_TRAILER.write(1));

      return status;
    }
  

    /**
     * Get DAQ frame status.
     *
     * \return                DAQ frame status
     */
    const JDAQFrameStatus& getDAQFrameStatus() const
    {
      return static_cast<const JDAQFrameStatus&>(*this);
    }


    /**
     * Set DAQ frame status.
     *
     * \param  status         DAQ frame status
     */
    void setDAQFrameStatus(const JDAQFrameStatus& status)
    {
      static_cast<JDAQFrameStatus&>(*this) = status;
    }


    /**
     * Get DAQ status.
     *
     * \return                DAQ status
     */
    int getDAQStatus() const 
    { 
      return this->daq;
    }


    /**
     * Get TDC and White Rabbit status.
     *
     * \return                status
     */
    int getStatus() const 
    { 
      return this->status;
    }


    /**
     * Get FIFO status.
     *
     * \return                FIFO status
     */
    int getFIFOStatus() const 
    { 
      return this->fifo;
    }


    /**
     * Test DAQ status of packets.
     *
     * \return                true if okay; else false
     */
    bool testDAQStatus() const 
    { 
      return (getUDPNumberOfReceivedPackets() == (getUDPMaximalSequenceNumber() + 1)) && hasUDPTrailer();
    }


    /**
     * Test TDC and White Rabbit status.
     *
     * \return                true if okay; else false
     */
    bool testStatus() const 
    { 
      return testWhiteRabbitStatus() && testTDCStatus();
    }


    /**
     * Get number of received UDP packets.
     *
     * \return                UDP received packets
     */
    int getUDPNumberOfReceivedPackets() const 
    { 
      return DAQ_UDP_RECEIVED_PACKETS.read(this->daq);
    }


    /**
     * Get maximal sequence number of UDP packet.
     *
     * \return                UDP sequence number
     */
    int getUDPMaximalSequenceNumber() const 
    { 
      return DAQ_UDP_SEQUENCE_NUMBER.read(this->daq);
    }


    /**
     * Test White Rabbit status.
     *
     * \return                true if okay; else false
     */
    bool testWhiteRabbitStatus() const
    {
      return DAQ_WHITE_RABBIT.has(this->status);
    }


    /**
     * Test TDC status.
     *
     * \return                true if okay; else false
     */
    bool testTDCStatus() const 
    { 
      return !testHighRateVeto();
    }


    /**
     * Test high-rate veto status.
     *
     * \return                true if one of the TDCs is high-rate vetoed; else false
     */
    bool testHighRateVeto() const
    {
      return DAQ_TDC.has(this->status);
    }


    /**
     * Test high-rate veto status.
     *
     * \param  tdc            TDC
     * \return                true if TDC is high-rate vetoed; else false
     */
    bool testHighRateVeto(const int tdc) const
    {
      return JBit(tdc).has(this->status);
    }


    /**
     * Count high-rate veto status.
     *
     * \return                number of the TDCs with high-rate veto
     */
    int countHighRateVeto() const
    {
      int n = 0;

      if (testHighRateVeto()) {
	for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
	  if (JBit(pmt).has(this->status)) {
	    ++n;
	  }
	}
      }
      
      return n;
    }


    /**
     * Test FIFO status.
     *
     * \return                true if one of the TDCs has FIFO almost full; else false
     */
    bool testFIFOStatus() const 
    { 
      return DAQ_FIFO.has(this->fifo);
    }


    /**
     * Test FIFO status.
     *
     * \param  tdc            TDC
     * \return                true if FIFO is almost full; else false
     */
    bool testFIFOStatus(const int tdc) const
    {
      return JBit(tdc).has(this->fifo);
    }


    /**
     * Count FIFO status.
     *
     * \return                number of the TDCs with FIFO almost full
     */
    int countFIFOStatus() const
    {
      int n = 0;

      if (testFIFOStatus()) {
	for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
	  if (JBit(pmt).has(this->fifo)) {
	    ++n;
	  }
	}
      }

      return n;
    }

    /**
     * Count active channels.
     * \return                number of TDCs without high rate veto or FIFO almost full
     */
    int countActiveChannels() const
    {
      int n = NUMBER_OF_PMTS;

      if (testHighRateVeto() || testFIFOStatus()) {
	for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
	  if ( JBit(pmt).has(this->status) || JBit(pmt).has(this->fifo) ) {
	    --n;
	  }
	}
      }

      return n;

    }


    /**
     * Get UDP trailer status.
     *
     * \return                true if UDP trailer present; else false
     */
    bool hasUDPTrailer() const
    {
      return DAQ_UDP_TRAILER.has(this->fifo);
    }


    /**
     * Set high-rate veto.
     *
     * \param  tdc            TDC
     * \param  value          value
     */
    void setHighRateVeto(const int tdc, const bool value)
    {
      JBit(tdc).set(this->status, value);
    }


    ClassDefNV(JDAQFrameStatus,1);

  protected:
    int  daq;         // DAQ  status
    int  status;      // TDC  status
    int  fifo;        // FIFO status
    int  status_3;    // spare
    int  status_4;    // spare
  };


  /**
   * Equal operator for DAQ frame status.
   *
   * \param  first     frame status
   * \param  second    frame status
   * \result           true if first frame status equal to second; else false
   */
  inline bool operator==(const JDAQFrameStatus& first,
			 const JDAQFrameStatus& second)
  {
    return (first.getDAQStatus()  == second.getDAQStatus()  &&
	    first.getStatus()     == second.getStatus()     &&
	    first.getFIFOStatus() == second.getFIFOStatus());
  }


  /**
   * Not-equal operator for DAQ frame status.
   *
   * \param  first     frame status
   * \param  second    frame status
   * \result           true if first frame status not equal to second; else false
   */
  inline bool operator!=(const JDAQFrameStatus& first,
			 const JDAQFrameStatus& second)
  {
    return !(first == second);
  }
}

#endif
#ifndef __JDAQHEADER__
#define __JDAQHEADER__

#include "km3net-dataformat/online/JDAQRoot.hh"
#include "km3net-dataformat/online/JDAQChronometer.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {

  /**
   * DAQ header.
   */
  class JDAQHeader :
    public JDAQChronometer
  {
  public:

    friend size_t getSizeof<JDAQHeader>();
    friend JReader& operator>>(JReader&, JDAQHeader&);
    friend JWriter& operator<<(JWriter&, const JDAQHeader&);

    /**
     * Default constructor.
     */
    JDAQHeader() :
      JDAQChronometer()
    {}


    /**
     * Constructor.
     *
     * \param  chronometer    chronometer
     */
    JDAQHeader(const JDAQChronometer& chronometer) :
      JDAQChronometer(chronometer)
    {}

    
    /**
     * Get DAQ header.
     *
     * \return                DAQ header
     */
    const JDAQHeader& getDAQHeader() const 
    { 
      return static_cast<const JDAQHeader&>(*this); 
    }


    /**
     * Set DAQ header.
     *
     * \param header          DAQ header
     */
    void setDAQHeader(const JDAQHeader& header)
    { 
      static_cast<JDAQHeader&>(*this) = header;
    }


    ClassDef(JDAQHeader,2);
  };


  /**
   * Equal operator for DAQ headers.
   *
   * \param  first     header
   * \param  second    header
   * \result           true if first header equal to second; else false
   */
  inline bool operator==(const JDAQHeader& first,
			 const JDAQHeader& second)
  {
    return (first.getDAQChronometer() == second.getDAQChronometer());
  }


  /**
   * Not-equal operator for DAQ headers.
   *
   * \param  first     header
   * \param  second    header
   * \result           true if first header not equal to second; else false
   */
  inline bool operator!=(const JDAQHeader& first,
			 const JDAQHeader& second)
  {
    return !(first == second);
  }
}

#endif
#ifndef __JDAQHIT__
#define __JDAQHIT__

#include <istream>
#include <ostream>
#include <iomanip>

#ifndef __CINT__
#include <netinet/in.h>
#endif

#include "km3net-dataformat/online/JDAQ.hh"
#include "km3net-dataformat/online/JDAQRoot.hh"
#include "km3net-dataformat/online/JDAQException.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {
  /**
   * Hit data structure.
   *
   * N.B.
   * The size of this data structure (i.e. the value obtained with the <tt>sizeof()</tt> operator 
   * should exactly match the preset number of bytes from the DAQ system. 
   * The <tt>pragma</tt> statement is necessary to ensure the correct size of this object.
   * Furthermore, this data structure should have no virtual methods and no virtual destructor.
   * Consequently, the standard ROOT <tt>CLassDef()</tt> macro is replaced by
   * the designated <tt>ClassDefNV()</tt> macro.
   */
#pragma pack(push,1)
  class JDAQHit
  {
  public:

    typedef  unsigned char             JPMT_t;    //!< PMT channel in FPGA
    typedef  unsigned int              JTDC_t;    //!< leading edge [ns]
    typedef  unsigned char             JTOT_t;    //!< time over threshold [ns]

    friend size_t getSizeof<JDAQHit>();
    friend JReader& operator>>(JReader&, JDAQHit&);
    friend JWriter& operator<<(JWriter&, const JDAQHit&);

    /**
     * Default constructor.
     */
    JDAQHit()
    {}


    /**
     * Constructor.
     *
     * \param  pmt_id         PMT channel
     * \param  tdc_ns         time of hit         [ns]
     * \param  tot_ns         time over threshold [ns]
     */
    JDAQHit(const JPMT_t pmt_id,
	    const JTDC_t tdc_ns,
	    const JTOT_t tot_ns) :
      pmt(pmt_id),
      tdc(htonl(tdc_ns)),
      //tdc(tdc_ns),
      tot(tot_ns)
    {}


    /**
     * Get PMT.
     *
     * \return                PMT
     */
    inline JPMT_t getPMT() const
    { 
      return pmt;
    }


    /**
     * Get time.
     *
     * \return                time [ns]
     */
    inline JTDC_t getT() const
    { 
      return ntohl(tdc);
    }


    /**
     * Get time-over-threshold.
     *
     * \return                time-over-threshold [ns]
     */
    inline JTOT_t getToT() const
    { 
      return tot;
    }


    /**
     * Get maximal time-over-threshold.
     *
     * \return                time-over-threshold [ns]
     */
    static JTOT_t getMaximalToT()
    {
      return 0xFF;
    }


    /**
     * Read DAQ hit from input.
     *
     * \param  in             input stream
     * \param  hit            hit
     * \return                input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JDAQHit& hit)
    {
      int pmt;
      int tdc;
      int tot;

      if (in >> pmt >> tdc >> tot) {
	hit = JDAQHit(pmt, tdc, tot);
      }

      return in;
    }


    /**
     * Write DAQ hit to output.
     *
     * \param  out           output stream
     * \param  hit           hit
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JDAQHit& hit)
    {
      using namespace std;

      out << setw(2) << (int) hit.getPMT() << ' '
	  << setw(8) << (int) hit.getT()   << ' '
	  << setw(3) << (int) hit.getToT();

      return out;
    }


    ClassDefNV(JDAQHit,1);


  protected:
    JPMT_t pmt;       //!< PMT readout channel in FPGA
    JTDC_t tdc;       //!< leading edge        [ns]
    JTOT_t tot;       //!< time over threshold [ns]
  };
#pragma pack(pop)


  /**
   * Less than operator for DAQ hits.
   *
   * The less than operator is applied first to the time and then to the PMT channel of the hits.
   *
   * \param  first     hit
   * \param  second    hit
   * \result           true if first hit earlier than second; else false
   */
  inline bool operator<(const JDAQHit& first,
			const JDAQHit& second)
  {
    if (first.getT() != second.getT())
      return first.getT()   < second.getT();
    else
      return first.getPMT() < second.getPMT();
  }


  /**
   * Equal operator for DAQ hits.
   *
   * \param  first     hit
   * \param  second    hit
   * \result           true if first hit equal to second; else false
   */
  inline bool operator==(const JDAQHit& first,
			 const JDAQHit& second)
  {
    return (first.getPMT() == second.getPMT()  &&
	    first.getT()   == second.getT()    &&
	    first.getToT() == second.getToT());
  }


  /**
   * Not-equal operator for DAQ hits.
   *
   * \param  first     hit
   * \param  second    hit
   * \result           true if first hit not equal to second; else false
   */
  inline bool operator!=(const JDAQHit& first,
			 const JDAQHit& second)
  {
    return !(first == second);
  }
}

#endif
#ifndef __JDAQKEYHIT__
#define __JDAQKEYHIT__

#include "km3net-dataformat/online/JDAQRoot.hh"
#include "km3net-dataformat/online/JDAQModuleIdentifier.hh"
#include "km3net-dataformat/online/JDAQHit.hh"
#include "km3net-dataformat/online/JDAQPMTIdentifier.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {

  /**
   * DAQ key hit
   */
  class JDAQKeyHit :
    public JDAQModuleIdentifier,
    public JDAQHit
  {
  public:

    friend size_t getSizeof<JDAQKeyHit>();
    friend JReader& operator>>(JReader&, JDAQKeyHit&);
    friend JWriter& operator<<(JWriter&, const JDAQKeyHit&);

    /**
     * Default constructor.
     */
    JDAQKeyHit() :
      JDAQModuleIdentifier(),
      JDAQHit()
    {}


    /**
     * Constructor.
     *
     * \param  id             module identifier
     * \param  hit            PMT    hit
     */
    JDAQKeyHit(const JDAQModuleIdentifier& id,
	       const JDAQHit&              hit) :
      JDAQModuleIdentifier(id),
      JDAQHit(hit)
    {}


    /**
     * Virtual destructor.
     */
    virtual ~JDAQKeyHit()
    {}


    /**
     * Type conversion operator.
     *
     * \return          axis
     */
    operator JDAQPMTIdentifier () const
    {
      return JDAQPMTIdentifier(this->getModuleID(), this->getPMT());
    }


    ClassDef(JDAQKeyHit,1);
  };



  /**
   * Less than operator for DAQ hits.
   *
   * The less than operator is applied first to the module idientifier then to the PMT channel and then to the time of the hits.
   *
   * \param  first     hit
   * \param  second    hit
   * \result           true if first hit before than second; else false
   */
  inline bool operator<(const JDAQKeyHit& first,
                        const JDAQKeyHit& second)
  {
    if (first.getModuleID() == second.getModuleID()) {
      if (first.getPMT() == second.getPMT())
	return first.getT()   < second.getT();
      else
	return first.getPMT() < second.getPMT();
    } else
      return first.getModuleID() < second.getModuleID();
  }



  /**
   * Equal operator for DAQ hits.
   *
   * The equal operator is applied to the module idientifier, to the PMT channel and to the time of the hits.
   *
   * \param  first     hit
   * \param  second    hit
   * \result         t  rue if first hit equal to second; else false
   */
  inline bool operator==(const JDAQKeyHit& first,
                         const JDAQKeyHit& second)
  {
    return (first.getModuleID() == second.getModuleID() &&
	    first.getPMT()      == second.getPMT()      &&
	    first.getT()        == second.getT());
  }


  /**
   * Not-equal operator for DAQ hits.
   *
   * \param  first     hit
   * \param  second    hit
   * \result           true if first hit not equal to second; else false
   */
  inline bool operator!=(const JDAQKeyHit& first,
			 const JDAQKeyHit& second)
  {
    return !(first == second);
  }
}

#endif
#ifndef __JDAQMODULEIDENTIFIER__
#define __JDAQMODULEIDENTIFIER__

#include <istream>
#include <ostream>

#include "km3net-dataformat/online/JDAQRoot.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {

  /**
   * Module identifier.
   */
  class JDAQModuleIdentifier
  {
  public:

    friend size_t getSizeof<JDAQModuleIdentifier>();
    friend JReader& operator>>(JReader&, JDAQModuleIdentifier&);
    friend JWriter& operator<<(JWriter&, const JDAQModuleIdentifier&);

    /**
     * Default constructor.
     */
    JDAQModuleIdentifier() :
      id(-1)
    {}
    

    /**
     * Constructor.
     *
     * \param  __id           module identifier
     */
    JDAQModuleIdentifier(const int __id) :
      id(__id)
    {}


    /**
     * Get Module identifier.
     *
     * \return                Module identifier
     */
    const JDAQModuleIdentifier& getModuleIdentifier() const 
    { 
      return *this; 
    }


    /**
     * Set Module identifier.
     *
     * \param  module         Module identifier
     */
    void setModuleIdentifier(const JDAQModuleIdentifier& module)
    { 
      *this = module;
    }

    
    /**
     * Get module identifier.
     *
     * \return                module identifier
     */
    int getModuleID() const 
    { 
      return id;
    }


    /**
     * Read DAQ ModuleIdentifier from input.
     *
     * \param  in             input stream
     * \param  module         module identifier
     * \return                input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JDAQModuleIdentifier& module)
    {
      in >> module.id;

      return in;
    }


    /**
     * Write DAQ ModuleIdentifier to output.
     *
     * \param  out           output stream
     * \param  module        module identifier
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JDAQModuleIdentifier& module)
    {
      out << module.id;

      return out;
    }


    ClassDefNV(JDAQModuleIdentifier,1);


  protected:
    int id;
  };


  /**
   * Equal operator.
   *
   * \param  first     first  module identifier
   * \param  second    second module identifier
   * \return           true if identifiers are equal; else false
   */
  inline bool operator==(const JDAQModuleIdentifier& first, const JDAQModuleIdentifier& second)
  { 
    return first.getModuleID() == second.getModuleID(); 
  }


  /**
   * Not equal operator.
   *
   * \param  first     first  module identifier
   * \param  second    second module identifier
   * \return           true if identifiers are different; else false
   */
  inline bool operator!=(const JDAQModuleIdentifier& first, const JDAQModuleIdentifier& second)
  { 
    return first.getModuleID() != second.getModuleID();
  }


  /**
   * Equal operator.
   *
   * \param  module    module identifier
   * \param  id        identifier
   * \return           true if identifiers are equal; else false
   */
  inline bool operator==(const JDAQModuleIdentifier& module, const int id)
  { 
    return module.getModuleID() == id; 
  }


  /**
   * Not equal operator.
   *
   * \param  module    module identifier
   * \param  id        identifier
   * \return           true if identifiers are different; else false
   */
  inline bool operator!=(const JDAQModuleIdentifier& module, const int id)
  { 
    return module.getModuleID() != id; 
  }
  

  /**
   * Less than operator.
   *
   * \param  first     first  module identifier
   * \param  second    second module identifier
   * \return           true if first identifier less than second eidentifier; else false
   */
  inline bool operator<(const JDAQModuleIdentifier& first, const JDAQModuleIdentifier& second)
  { 
    return first.getModuleID() < second.getModuleID();
  }


  /**
   * Less than operator.
   *
   * \param  module    module identifier
   * \param  id        identifier
   * \return           true if module identifier less than identifier; else false
   */
  inline bool operator<(const JDAQModuleIdentifier& module, const int id)
  { 
    return module.getModuleID() < id;
  }


  /**
   * Auxiliary class to compare modules.
   */
  struct JDAQModuleComparator {
    /*
     * Default constructor.
     */
    JDAQModuleComparator()
    {}

    
    /**
     * Compare modules.
     *
     * \param  first           first  module
     * \param  second          second module
     * \return                 true if first module identifier less than that of second; else false
     */
    bool operator()(const JDAQModuleIdentifier& first, const JDAQModuleIdentifier& second) const
    {
      return first.getModuleID() < second.getModuleID();
    }
  };
}

#endif
#ifndef __JDAQPMTIDENTIFIER__
#define __JDAQPMTIDENTIFIER__

#include <istream>
#include <ostream>

#include "km3net-dataformat/online/JDAQModuleIdentifier.hh"
#include "km3net-dataformat/online/JDAQRoot.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {

  /**
   * PMT identifier.
   */
  class JDAQPMTIdentifier :
    public JDAQModuleIdentifier
  {
  public:

    friend size_t getSizeof<JDAQPMTIdentifier>();
    friend JReader& operator>>(JReader&, JDAQPMTIdentifier&);
    friend JWriter& operator<<(JWriter&, const JDAQPMTIdentifier&);

    /**
     * Default constructor.
     */
    JDAQPMTIdentifier() :
      JDAQModuleIdentifier(),
      address            (0)
    {}
    

    /**
     * Constructor.
     *
     * \param  id             module identifier
     * \param  pmt_address    PMT address
     */
    JDAQPMTIdentifier(const JDAQModuleIdentifier& id,
		      const int                   pmt_address) :
      JDAQModuleIdentifier(id),
      address             (pmt_address)
    {}


    /**
     * Get PMT identifier.
     *
     * \return                PMT identifier
     */
    const JDAQPMTIdentifier& getPMTIdentifier() const 
    { 
      return *this; 
    }


    /**
     * Set PMT identifier.
     *
     * \param  pmt            PMT identifier
     */
    void setPMTIdentifier(const JDAQPMTIdentifier& pmt)
    { 
      *this = pmt;
    }


    /**
     * Get PMT identifier.
     *
     * \return                PMT identifier
     */
    int getPMTAddress() const 
    { 
      return address;
    }


    /**
     * Read PMT identifier from input.
     *
     * \param  in             input stream
     * \param  pmt            PMT identifier
     * \return                input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JDAQPMTIdentifier& pmt)
    {
      in >> static_cast<JDAQModuleIdentifier&>(pmt);
      in >> pmt.address;

      return in;
    }


    /**
     * Write PMT identifier to output.
     *
     * \param  out           output stream
     * \param  pmt           PMT identifier
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JDAQPMTIdentifier& pmt)
    {
      out << static_cast<const JDAQModuleIdentifier&>(pmt) << ' ';
      out << pmt.address;

      return out;
    }

 
    /**
     * Compare PMT identifiers.
     *
     * The comparison is applied to the module identifer and to the PMT address.
     * If the module identifier or PMT address is <tt>-1</tt>, the corresponding comparison evaluates to <tt>true</tt>.
     *
     * \param  first       PMT identifier
     * \param  second      PMT identifier
     * \result             true if first PMT equal second PMT; else false
     */
    static inline bool compare(const JDAQPMTIdentifier& first, const JDAQPMTIdentifier& second)
    {
      return ((first .getModuleIdentifier() == second.getModuleIdentifier() ||
	       first .getModuleIdentifier() == -1                           ||
	       second.getModuleIdentifier() == -1)                          &&
	      (first .getPMTAddress()       == second.getPMTAddress()       ||
	       first .getPMTAddress()       == -1                           ||
	       second.getPMTAddress()       == -1));
    }


    ClassDefNV(JDAQPMTIdentifier,1);


  protected:
    int      address;
  };

 
  /**
   * Less than operator for PMT identifiers.
   *
   * The less than operator is applied first to the module identifer and then to the PMT address.
   *
   * \param  first       PMT identifier
   * \param  second      PMT identifier
   * \result             true if first PMT lower than second PMT; else false
   */
  inline bool operator<(const JDAQPMTIdentifier& first, const JDAQPMTIdentifier& second)
  {
    if (first.getModuleIdentifier() == second.getModuleIdentifier())
      return first.getPMTAddress()       < second.getPMTAddress();
    else
      return first.getModuleIdentifier() < second.getModuleIdentifier();
  }

 
  /**
   * Equal operator for PMT identifiers.
   *
   * The equal operator is applied to the module identifer and to the PMT address.
   *
   * \param  first       PMT identifier
   * \param  second      PMT identifier
   * \result             true if first PMT equal second PMT; else false
   */
  inline bool operator==(const JDAQPMTIdentifier& first, const JDAQPMTIdentifier& second)
  {
    return (first.getModuleIdentifier() == second.getModuleIdentifier() &&
	    first.getPMTAddress()       == second.getPMTAddress());
  }


  /**
   * Not-equal operator for PMT identifiers.
   *
   * \param  first       PMT identifier
   * \param  second      PMT identifier
   * \result             true if first PMT identifier not equal to second; else false
   */
  inline bool operator!=(const JDAQPMTIdentifier& first,
			 const JDAQPMTIdentifier& second)
  {
    return !(first == second);
  }
}

#endif
#ifndef __JDAQPREAMBLE__
#define __JDAQPREAMBLE__

#include <ostream>
#include <iomanip>

#include "km3net-dataformat/online/JDAQRoot.hh"
#include "km3net-dataformat/online/JDAQDataTypes.hh"
#include "km3net-dataformat/online/JDAQAbstractPreamble.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {

  /**
   * DAQ preamble.
   *
   * The data type is determined by the return value of method getDataType().\n
   * This method should be overloaded so that each data type is uniquely mapped to an integer value.
   *
   * The size and type information of this object can be used for RTTI.
   */
  class JDAQPreamble :
    public JDAQAbstractPreamble,
    public TObject 
  {
  protected:
    
    /**
     * Constructor.
     *
     * \param  type           data type of derived class
     */
    template<class T>
    JDAQPreamble(const JDAQType<T>& type) :
      JDAQAbstractPreamble(type)
    {}

  public:

    friend size_t getSizeof<JDAQPreamble>();
    friend JReader& operator>>(JReader&, JDAQPreamble&);
    friend JWriter& operator<<(JWriter&, const JDAQPreamble&);

    /**
     * Default constructor.
     */
    JDAQPreamble() :
      JDAQAbstractPreamble()
    {}


    /**
     * Virtual destructor.
     */
    virtual ~JDAQPreamble()
    {}


    /**
     * Get DAQ preamble.
     *
     * This method should be used for binary I/O to get the actual data for the given object.\n
     * To this end, the following method should be overloaded for the corresponding data type.
     * <pre>
     *    size_t  getSizeof(const T&);
     * </pre>
     *
     * \param  object         object
     * \return                preamble
     */
    template<class T>
    static JDAQPreamble getDAQPreamble(const T& object)
    {
      static JDAQPreamble preamble;

      preamble.length = getSizeof(object);
      preamble.type   = KM3NETDAQ::getDataType<T>();

      return preamble;
    }


    /**
     * Print DAQ preamble.
     *
     * \param  out           output stream
     * \param  preamble      JDAQPreamble
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JDAQPreamble& preamble)
    {
      using namespace std;

      out << setw(8) << preamble.length;
      out << ' ';
      out << setw(6) << preamble.type;

      return out;
    }


    ClassDef(JDAQPreamble,1);
  };
}

#endif
#ifndef __JDAQPRINT__
#define __JDAQPRINT__

/**
 * \author mdejong
 */

namespace KM3NETDAQ {

  /**
   * Get DAQ print option.
   *
   * \return            print option
   */
  inline bool& getDAQLongprint()
  {
    static bool option;

    return option;
  }


  /**
   * Set DAQ print option.
   *
   * \param  option     print option
   */
  inline void setDAQLongprint(const bool option)
  {
    getDAQLongprint() = option;
  }
}

#endif
#ifndef __JDAQROOT__
#define __JDAQROOT__

#include <TObject.h>
#include <TBuffer.h>

#include "km3net-dataformat/online/JDAQException.hh"


/**
 * \author mdejong
 */

namespace JIO {
  class JReader;       // forward declaration for friend
  class JWriter;       // forward declaration for friend
}

namespace KM3NETDAQ {

  /**
   * Definition of method to get size of data type.
   *
   * This method should be specialised for each desired data type with fixed length.
   *
   * \return               number of bytes
   */
  template<class T>
  inline size_t getSizeof();


  using JIO::JReader;
  using JIO::JWriter;
} 

namespace JPP {
}

using namespace KM3NETDAQ;

#endif
#ifndef __JDAQSUMMARYFRAME__
#define __JDAQSUMMARYFRAME__

#include <limits>
#include <cmath>
#include <vector>

#include "km3net-dataformat/online/JDAQException.hh"
#include "km3net-dataformat/online/JDAQ.hh"
#include "km3net-dataformat/online/JDAQClock.hh"
#include "km3net-dataformat/online/JDAQModuleIdentifier.hh"
#include "km3net-dataformat/online/JDAQFrameStatus.hh"
#include "km3net-dataformat/online/JDAQSuperFrame.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {


  /**
   * Forward declaration for friend declaration of JDAQSummaryFrame inside JDAQRate.
   */
  class JDAQSummaryFrame;


  /**
   * Data storage class for rate measurement of one PMT.
   *  
   * Note that the rate value is compressed. 
   * The number of bins and corresponding abscissa values can be obtained with  
   * methods JDAQRare::getN and JDAQRate::getData, respectively. 
   */
  class JDAQRate {
  public:

    friend class JDAQSummaryFrame;


    typedef unsigned char  JRate_t;                 // type of value to store rate

    
    /**
     * Get minimal rate (below this, value is set to zero)
     *
     * \return                rate [Hz]
     */
    static double getMinimalRate()
    {
      return 2.0e3;
    }

    
    /**
     * Get maximal rate (above this, value is set to maximum)
     *
     * \return                rate [Hz]
     */
    static double getMaximalRate()
    {
      return 2.0e6;
    }
    

    /**
     * Get value.
     *
     * \param  numberOfHits   number of hits
     * \param  frameTime_ns   frame time [ns]
     * \return                value
     */
    static JRate_t getValue(const int numberOfHits, const double frameTime_ns)
    {
      return getValue(numberOfHits * 1.0e9 / frameTime_ns);
    }


    /**
     * Get value.
     *
     * \param  rate_Hz        rate [Hz]
     * \return                value
     */
    static JRate_t getValue(const double rate_Hz)
    {
      if      (rate_Hz <= getMinimalRate())
	return 0;
      else if (rate_Hz >= getMaximalRate())
	return std::numeric_limits<JRate_t>::max();
      else
	return (JRate_t) (log(rate_Hz/getMinimalRate()) / getFactor() + 0.5);
    }


    /**
     * Get count rate.
     *
     * \param  value          value
     * \return                rate [Hz]
     */
    static double getRate(const JRate_t value)
    {
      if (value == 0)
	return 0.0;
      else
	return get_rate(value);
    }


    /**
     * Get weight.
     *
     * \param  value          value
     * \return                weight [Hz^-1]
     */
    static double getWeight(const JRate_t value)
    {
      double W = 1.0;
      
      if      (value == 0)
	W = get_rate(0.5)   - getMinimalRate();
      else if (value == std::numeric_limits<JRate_t>::max())
	W = getMaximalRate() - get_rate(std::numeric_limits<JRate_t>::max() - 0.5);
      else
	W = get_rate((double) value + 0.5) - get_rate((double) value - 0.5);

      return 1.0 / W;
    }


    /**
     * Get number of bins.
     *
     * \return                number of bins
     */
    static int getN() 
    {
      return (int) std::numeric_limits<JRate_t>::max() + 1;
    }


    /**
     * Get abscissa values.
     *
     * \param  factor         scaling factor
     * \return                abscissa values
     */
    static const double* getData(const double factor = 1.0) 
    {
      static std::vector<double> buffer;

      buffer.clear();

      buffer.push_back(getMinimalRate() * factor);

      for (int i = 1; i != JDAQRate::getN(); ++i) {
	buffer.push_back(get_rate(i - 0.5) * factor);
      }
      
      buffer.push_back(getMaximalRate() * factor);

      return buffer.data();
    }
    
    
    /**
     * Default constructor.
     */
    JDAQRate() :
      value(0)
    {}

  
    /**
     * Get value.
     *
     * \return                value
     */
    JRate_t getValue() const
    {
      return value;
    }


    /**
     * Set value.
     *
     * \param  numberOfHits   number of hits
     * \param  frameTime_ns   frame time [ns]
     */
    void setValue(const int numberOfHits, const double frameTime_ns)
    {
      value = getValue(numberOfHits, frameTime_ns);
    }


    /**
     * Set value.
     *
     * \param  rate_Hz        rate [Hz]
     */
    void setValue(const double rate_Hz)
    {
      value = getValue(rate_Hz);
    }

  
    /**
     * Get count rate.
     *
     * \return                rate [Hz]
     */
    double getRate() const
    {
      return getRate(value);
    }


    /**
     * Get weight.
     *
     * \return                weight [Hz^-1]
     */
    double getWeight() const
    {
      return getWeight(value);
    }


    /** 
     * Scale rate.
     *
     * \param  factor         multiplication factor
     * \return                this rate
     */
    JDAQRate& mul(const double factor)
    {
      setValue(getRate() * factor);
      
      return *this;
    }


    /** 
     * Scale rate.
     *
     * \param  factor         multiplication factor
     * \return                this rate
     */
    JDAQRate& div(const double factor)
    {
      setValue(getRate() / factor);
      
      return *this;
    }


    /**
     * Check validity of rate.
     * The rate is considered valid if it is between the minimal and the maximal rate. 
     *
     * \return                true if valid; else false
     */
    bool is_valid() const
    {
      return (value != 0 && value != std::numeric_limits<JRate_t>::max());
    }


  protected:
    JRate_t value;
    

  private:
    /**
     * Get conversion factor.
     *
     * \return             factor
     */
    static const double getFactor()
    {
      return std::log(getMaximalRate() / getMinimalRate()) / std::numeric_limits<JRate_t>::max();
    }


    /**
     * Get count rate.
     *
     * \param  value          value
     * \return                rate [Hz]
     */
    static double get_rate(const double value)
    {
      return getMinimalRate() * std::exp(value * getFactor());
    }
  };


  /**
   * Equal operator for DAQ rates.
   *
   * \param  first     rate
   * \param  second    rate
   * \result           true if first rate equal to second; else false
   */
  inline bool operator==(const JDAQRate& first,
			 const JDAQRate& second)
  {
    return (first.getValue() == second.getValue());
  }


  /**
   * Not-equal operator for DAQ rates.
   *
   * \param  first     rate
   * \param  second    rate
   * \result           true if first rate not equal to second; else false
   */
  inline bool operator!=(const JDAQRate& first,
			 const JDAQRate& second)
  {
    return (first.getValue() != second.getValue());
  }
  

  /**
   * Data storage class for rate measurements of all PMTs in one module.
   */
  class JDAQSummaryFrame :
    public JDAQModuleIdentifier,
    public JDAQFrameStatus
  {
  public:

    typedef JDAQRate::JRate_t  JRate_t;

    friend size_t getSizeof<JDAQSummaryFrame>();
    friend JReader& operator>>(JReader&, JDAQSummaryFrame&);
    friend JWriter& operator<<(JWriter&, const JDAQSummaryFrame&);

    /**
     * Default constructor.
     */
    JDAQSummaryFrame() :
      JDAQModuleIdentifier(),
      JDAQFrameStatus()
    {}


    /**
     * Constructor.
     *
     * \param  id             module identifier
     */
    JDAQSummaryFrame(const JDAQModuleIdentifier& id) :
      JDAQModuleIdentifier(id),
      JDAQFrameStatus(JDAQFrameStatus::getInstance())
    {}


    /**
     * Constructor.
     *
     * Note that normally the rate is set to the number of hits per unit frame time
     * but if either the high-rate veto or FIFO (almost) full bit is on, 
     * the rate is set to the number of hits divided by the time of the last hit.
     *
     * \param  input          super frame 
     */
    JDAQSummaryFrame(const JDAQSuperFrame& input) :
      JDAQModuleIdentifier(input.getModuleID()),
      JDAQFrameStatus     (input.getDAQFrameStatus())
    {
      using namespace std;

      typedef JDAQHit::JPMT_t  JPMT_t;
      typedef JDAQHit::JTDC_t  JTDC_t;

      vector<int> counter(numeric_limits<JPMT_t>::max(), 0);

      int n = input.size();
      
      for (JDAQSuperFrame::const_iterator i = input.begin(); n != 0; --n, ++i) {
	++counter[i->getPMT()];
      }

      for (int i = 0; i != NUMBER_OF_PMTS; ++i) {
	data[i].setValue(counter[i], getFrameTime());
      }
      
      if (input.testHighRateVeto() || input.testFIFOStatus()) {

	// determine last hit for each PMT

	vector<JTDC_t> limit(numeric_limits<JPMT_t>::max(), 0);

	int n = input.size();

	for (JDAQSuperFrame::const_iterator i = input.begin(); n != 0; --n, ++i) {
	  if (i->getT() > limit[i->getPMT()]) {
	    limit[i->getPMT()] = i->getT();
	  }
	}
	
	for (int i = 0; i != NUMBER_OF_PMTS; ++i) {
	  if (input.testHighRateVeto(i) || input.testFIFOStatus(i)) {
	    if (limit[i] != 0) {
	      data[i].setValue((double) counter[i] * 1.0e9 / (double) limit[i]);
	    }
	  }
	}
      }
    }

  
    /**
     * Get DAQ rate of given PMT.
     *
     * \param  tdc            TDC
     * \return                JDAQRate
     */
    const JDAQRate& operator[](const int tdc) const
    {
      if (tdc >= 0 && tdc < NUMBER_OF_PMTS)
	return data[tdc];
      else
	throw JDAQException("TDC out of range.");
    }

  
    /**
     * Get DAQ rate of given PMT.
     *
     * \param  tdc            TDC
     * \return                JDAQRate
     */
    JDAQRate& operator[](const int tdc)
    {
      if (tdc >= 0 && tdc < NUMBER_OF_PMTS)
	return data[tdc];
      else
	throw JDAQException("TDC out of range.");
    }


    /**
     * Get value.
     *
     * \param  tdc            TDC
     * \return                value
     */
    JRate_t getValue(const int tdc) const
    {
      return data[tdc].getValue();
    }


    /**
     * Get count rate.
     *
     * \param  tdc            TDC
     * \param  factor         scaling factor
     * \return                rate x scaling factor [Hz]
     */
    double getRate(const int tdc, const double factor = 1.0) const
    {
      return data[tdc].getRate() * factor;
    }


    /**
     * Get weight.
     *
     * \param  tdc            TDC
     * \param  factor         scaling factor
     * \return                weight / scaling factor [Hz^-1]
     */
    double getWeight(const int tdc, const double factor = 1.0) const
    {
      return data[tdc].getWeight() / factor;
    }


    /**
     * Set count rate.
     *
     * \param  tdc            TDC
     * \param  rate_Hz        rate [Hz]
     */
    void setRate(const int tdc, const double rate_Hz)
    {
      return data[tdc].setValue(rate_Hz);
    }


    static int ROOT_IO_VERSION;     //!< Streamer version of JDAQSummaryslice as obtained from ROOT file.


    ClassDefNV(JDAQSummaryFrame,2);


  protected:

    JDAQRate data[NUMBER_OF_PMTS];
  };


  /**
   * Equal operator for DAQ summary frames.
   *
   * \param  first     summary frame
   * \param  second    summary frame
   * \result           true if first summary frame equal to second; else false
   */
  inline bool operator==(const JDAQSummaryFrame& first,
			 const JDAQSummaryFrame& second)
  {
    if (first.getModuleIdentifier() == second.getModuleIdentifier() &&
	first.getDAQFrameStatus()   == second.getDAQFrameStatus()) {

      for (int i = 0; i != NUMBER_OF_PMTS; ++i) {
	if (first[i] != second[i]) {
	  return false;
	}
      }

      return true;
      
    } else {

      return false;
    }	    
  }


  /**
   * Not-equal operator for DAQ summary frames.
   *
   * \param  first     summary frame
   * \param  second    summary frame
   * \result           true if first summary frame not equal to second; else false
   */
  inline bool operator!=(const JDAQSummaryFrame& first,
			 const JDAQSummaryFrame& second)
  {
    return !(first == second);
  }
}

#endif
#ifndef __JDAQSUMMARYSLICE__
#define __JDAQSUMMARYSLICE__

#include <ostream>
#include <iomanip>
#include <vector>

#include "km3net-dataformat/online/JDAQRoot.hh"
#include "km3net-dataformat/online/JDAQPreamble.hh"
#include "km3net-dataformat/online/JDAQSummaryFrame.hh"
#include "km3net-dataformat/online/JDAQSummarysliceHeader.hh"
#include "km3net-dataformat/online/JDAQTimeslice.hh"
#include "km3net-dataformat/online/JDAQClock.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {

  /**
   * Data summary slice.
   */
  class JDAQSummaryslice :
    public JDAQPreamble,
    public JDAQSummarysliceHeader,
    public std::vector<JDAQSummaryFrame>
  {
  public:

    friend size_t getSizeof(const JDAQSummaryslice&);
    friend JReader& operator>>(JReader&, JDAQSummaryslice&);
    friend JWriter& operator<<(JWriter&, const JDAQSummaryslice&);

    /**
     * Default constructor.
     */
    JDAQSummaryslice() :
      JDAQPreamble(JDAQType<JDAQSummaryslice>()),
      JDAQSummarysliceHeader(),
      std::vector<JDAQSummaryFrame>()
    {}


    /**
     * Constructor.
     *
     * \param  chronometer    DAQ chronometer
     */
    JDAQSummaryslice(const JDAQChronometer& chronometer) :
      JDAQPreamble(JDAQType<JDAQSummaryslice>()),
      JDAQSummarysliceHeader(chronometer),
      std::vector<JDAQSummaryFrame>()
    {}


    /**
     * Constructor.
     *
     * \param  timeslice      time slice
     */
    JDAQSummaryslice(const JDAQTimeslice& timeslice) :
      JDAQPreamble(JDAQType<JDAQSummaryslice>()),
      JDAQSummarysliceHeader(timeslice),
      std::vector<JDAQSummaryFrame>()
    {
      for (JDAQTimeslice::const_iterator i = timeslice.begin(); i != timeslice.end(); ++i) {
	this->push_back(JDAQSummaryFrame(*i));
      }
    }


    /**
     * Virtual destructor.
     */
    virtual ~JDAQSummaryslice()
    {}


    /**
     * Print DAQ summary.
     *
     * \param  out         output stream
     * \param  lpr         long print
     * \return             output stream
     */
    std::ostream& print(std::ostream& out, const bool lpr = false) const
    {
      using namespace std;

      out << this->ClassName() << endl;
      out << dynamic_cast<const JDAQPreamble&>   (*this) << endl;
      out << dynamic_cast<const JDAQChronometer&>(*this) << endl;
    
      for (JDAQSummaryslice::const_iterator module = this->begin(); module != this->end(); ++module) {

	out << ' ' << setw(10) << module->getModuleID();
        out << ' ' << setw(8)  << setfill('0') << hex << module->getStatus()     << dec << setfill(' ');
        out << '|' << setw(8)  << setfill('0') << hex << module->getFIFOStatus() << dec << setfill(' ');
	out << ' ' << setw(2)  << module->getUDPNumberOfReceivedPackets();
	out << ' ' << setw(2)  << module->getUDPMaximalSequenceNumber();

	if (lpr) {
	  for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
	    out << ' ' << fixed << showpoint << setw(4) << setprecision(1) << module->getRate(pmt) * 1.0e-3;
	  }
	}

	out << endl;
      }

      return out;
    }

    
    /**
     * Action method at file open.
     *
     * \param  version   version
     */
    static void actionAtFileOpen(int version)
    {
      JDAQSummaryFrame::ROOT_IO_VERSION = version;
    }


    ClassDef(JDAQSummaryslice,6);
  };


  /**
   * Print DAQ summary.
   *
   * \param  out         output stream
   * \param  summary     summary
   * \return             output stream
   */
  inline std::ostream& operator<<(std::ostream& out, const KM3NETDAQ::JDAQSummaryslice& summary)
  {
    return summary.print(out, getDAQLongprint());
  }


  /**
   * Equal operator for DAQ summary slices.
   *
   * \param  first     summary slice
   * \param  second    summary slice
   * \result           true if first summary slice equal to second; else false
   */
  inline bool operator==(const JDAQSummaryslice& first,
			 const JDAQSummaryslice& second)
  {
    return (first.getDAQSummarysliceHeader()                         == second.getDAQSummarysliceHeader()                         &&
	    static_cast<const std::vector<JDAQSummaryFrame>&>(first) == static_cast<const std::vector<JDAQSummaryFrame>&>(second));
  }


  /**
   * Not-equal operator for DAQ summary slices.
   *
   * \param  first     summary slice
   * \param  second    summary slice
   * \result           true if first summary slice not equal to second; else false
   */
  inline bool operator!=(const JDAQSummaryslice& first,
			 const JDAQSummaryslice& second)
  {
    return !(first == second);
  }
}

#endif
#ifndef __JDAQSUMMARYSLICEHEADER__
#define __JDAQSUMMARYSLICEHEADER__

#include "km3net-dataformat/online/JDAQRoot.hh"
#include "km3net-dataformat/online/JDAQHeader.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {

  /**
   * JDAQ summaryslice header.
   */
  class JDAQSummarysliceHeader :
    public JDAQHeader
  {
  public:
    /**
     * Default constructor.
     */
    JDAQSummarysliceHeader() :
      JDAQHeader()
    {}


    /**
     * Constructor.
     *
     * \param  chronometer    DAQ chronometer
     */
    JDAQSummarysliceHeader(const JDAQChronometer& chronometer) :
      JDAQHeader(chronometer)
    {}

    
    /**
     * Get DAQ summary slice header.
     *
     * \return                DAQ summary slice header
     */
    const JDAQSummarysliceHeader& getDAQSummarysliceHeader() const
    {
      return static_cast<const JDAQSummarysliceHeader&>(*this);
    }
    

    ClassDef(JDAQSummarysliceHeader,2);
  };


  /**
   * Equal operator for DAQ summary slice headers.
   *
   * \param  first     summary slice header
   * \param  second    summary slice header
   * \result           true if first summaryslice header equal to second; else false
   */
  inline bool operator==(const JDAQSummarysliceHeader& first,
			 const JDAQSummarysliceHeader& second)
  {
    return (first.getDAQHeader() == second.getDAQHeader());
  }


  /**
   * Not-equal operator for DAQ summary slice headers.
   *
   * \param  first     summary slice header
   * \param  second    summary slice header
   * \result           true if first summary slice header not equal to second; else false
   */
  inline bool operator!=(const JDAQSummarysliceHeader& first,
			 const JDAQSummarysliceHeader& second)
  {
    return !(first == second);
  }
}

#endif
#ifndef __JDAQSUPERFRAME__
#define __JDAQSUPERFRAME__

#include "km3net-dataformat/online/JDAQ.hh"
#include "km3net-dataformat/online/JDAQPreamble.hh"
#include "km3net-dataformat/online/JDAQSuperFrameHeader.hh"
#include "km3net-dataformat/online/JDAQFrame.hh"
#include "km3net-dataformat/online/JDAQHit.hh"
#include "km3net-dataformat/online/JDAQRoot.hh"
#include "km3net-dataformat/online/JDAQException.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {

  /**
   * Data frame of one optical module.
   */
  class JDAQSuperFrame :
    public JDAQPreamble,
    public JDAQSuperFrameHeader,
    public JDAQFrame
  {
  public:

    typedef  JDAQFrame::const_iterator           const_iterator;
    typedef  JDAQFrame::iterator                 iterator;
    typedef  JDAQFrame::const_reverse_iterator   const_reverse_iterator;
    typedef  JDAQFrame::reverse_iterator         reverse_iterator;

    friend size_t getSizeof(const JDAQSuperFrame&);
    friend JReader& operator>>(JReader&, JDAQSuperFrame&);
    friend JWriter& operator<<(JWriter&, const JDAQSuperFrame&);

    /**
     * Default constructor.
     */
    JDAQSuperFrame() :
      JDAQPreamble(JDAQType<JDAQSuperFrame>()),
      JDAQSuperFrameHeader(),
      JDAQFrame()
    {}


    /**
     * Constructor.
     *
     * \param  header         JDAQ super frame header
     */
    JDAQSuperFrame(const JDAQSuperFrameHeader& header) :
      JDAQPreamble(JDAQType<JDAQSuperFrame>()),
      JDAQSuperFrameHeader(header),
      JDAQFrame()
    {}


    /**
     * Copy constructor.
     *
     * \param  super_frame    JDAQ super frame
     */
    JDAQSuperFrame(const JDAQSuperFrame& super_frame) :
      JDAQPreamble(JDAQType<JDAQSuperFrame>()),
      JDAQSuperFrameHeader(super_frame.getDAQSuperFrameHeader()),
      JDAQFrame(super_frame)
    {}


    /**
     * Add data from same optical module.
     *
     * \param  super_frame    JDAQ super frame
     * \return                this JDAQ super frame
     */
    JDAQSuperFrame& add(const JDAQSuperFrame& super_frame) 
    {
      if (this->getModuleID() != super_frame.getModuleID())
	throw JDAQException("JDAQSuperFrame::add(): Different module identifiers.");

      return add(static_cast<const JDAQFrame&>(super_frame));
    }


    /**
     * Add hit.
     *
     * \param  hit              JDAQ hit
     * \return                  this JDAQ frame
     */
    JDAQSuperFrame& add(const JDAQHit& hit)
    {
      return add(1, &hit);
    }


    /**
     * Add data.
     *
     * \param  frame            JDAQ frame
     * \return                  this JDAQ frame
     */
    JDAQSuperFrame& add(const JDAQFrame& frame) 
    {
      return add(frame.numberOfHits, frame.buffer);
    }


    /**
     * Add data.
     *
     * \param  number_of_hits   number of hits
     * \param  data             pointer to data
     * \return                  this data frame
     */
    JDAQSuperFrame& add(const int number_of_hits, const JDAQHit* data)
    {
      JDAQFrame::add(number_of_hits, data);

      return *this;
    }


    ClassDef(JDAQSuperFrame,3);
  };


  /**
   * Equal operator for DAQ super frames.
   *
   * \param  first     super frame
   * \param  second    super frame
   * \result           true if first super frame equal to second; else false
   */
  inline bool operator==(const JDAQSuperFrame& first,
			 const JDAQSuperFrame& second)
  {
    if (first.getDAQSuperFrameHeader() == second.getDAQSuperFrameHeader() &&
	first.size()                   == second.size()) {

      for (JDAQSuperFrame::const_iterator p = first.begin(), q = second.begin(); p != first.end(); ++p, ++q) {
	if (*p != *q) {
	  return false;
	}
      }

      return true;

    } else {

      return false;
    }
  }


  /**
   * Not-equal operator for DAQ super frames.
   *
   * \param  first     super frame
   * \param  second    super frame
   * \result           true if first super frame not equal to second; else false
   */
  inline bool operator!=(const JDAQSuperFrame& first,
			 const JDAQSuperFrame& second)
  {
    return !(first == second);
  }
}
    
#endif
#ifndef __JDAQSUPERFRAMEHEADER__
#define __JDAQSUPERFRAMEHEADER__

#include "km3net-dataformat/online/JDAQ.hh"
#include "km3net-dataformat/online/JDAQHeader.hh"
#include "km3net-dataformat/online/JDAQModuleIdentifier.hh"
#include "km3net-dataformat/online/JDAQFrameStatus.hh"
#include "km3net-dataformat/online/JDAQRoot.hh"


/**
 * \author mdejong
 */
namespace KM3NETDAQ {

  /**
   * DAQ super frame header.
   */
  class JDAQSuperFrameHeader :
    public JDAQHeader,
    public JDAQModuleIdentifier,
    public JDAQFrameStatus
 {
  public:

    friend size_t getSizeof<JDAQSuperFrameHeader>();
    friend JReader& operator>>(JReader&, JDAQSuperFrameHeader&);
    friend JWriter& operator<<(JWriter&, const JDAQSuperFrameHeader&);

    /**
     * Default constructor.
     */
    JDAQSuperFrameHeader() :
      JDAQHeader          (),
      JDAQModuleIdentifier(),
      JDAQFrameStatus     ()
    {}


    /**
     * Constructor.
     *
     * \param  chronometer    chronometer
     * \param  id             module identifier
     */
    JDAQSuperFrameHeader(const JDAQChronometer& chronometer,
			 const int              id) :
      JDAQHeader          (chronometer),
      JDAQModuleIdentifier(id),
      JDAQFrameStatus     (JDAQFrameStatus::getInstance())
    {}


    /**
     * Constructor.
     *
     * \param  chronometer    chronometer
     * \param  id             module identifier
     * \param  status         frame status
     */
    JDAQSuperFrameHeader(const JDAQChronometer& chronometer,
			 const int              id,
			 const JDAQFrameStatus& status) :
      JDAQHeader          (chronometer),
      JDAQModuleIdentifier(id),
      JDAQFrameStatus     (status)
    {}


    /**
     * Get DAQ super frame header.
     *
     * \return                DAQ super frame header
     */
    const JDAQSuperFrameHeader& getDAQSuperFrameHeader() const
    {
      return static_cast<const JDAQSuperFrameHeader&>(*this);
    }


    /**
     * Set DAQ super frame header.
     *
     * \param  header         DAQ super frame header
     */
    void setDAQSuperFrameHeader(const JDAQSuperFrameHeader& header)
    {
      static_cast<JDAQSuperFrameHeader&>(*this) = header;
    }


    ClassDef(JDAQSuperFrameHeader,2);
  };


  /**
   * Equal operator for DAQ super frame headers.
   *
   * \param  first     super frame header
   * \param  second    super frame header
   * \result           true if first super frame header equal to second; else false
   */
  inline bool operator==(const JDAQSuperFrameHeader& first,
			 const JDAQSuperFrameHeader& second)
  {
    return (first.getDAQHeader()        == second.getDAQHeader()         &&
	    first.getModuleIdentifier() == second.getModuleIdentifier()  &&
	    first.getDAQFrameStatus()   == second.getDAQFrameStatus());
  }


  /**
   * Not-equal operator for DAQ super frame headers.
   *
   * \param  first     super frame header
   * \param  second    super frame header
   * \result           true if first super frame header not equal to second; else false
   */
  inline bool operator!=(const JDAQSuperFrameHeader& first,
			 const JDAQSuperFrameHeader& second)
  {
    return !(first == second);
  }
}

#endif
#ifndef __JDAQTIMESLICE__
#define __JDAQTIMESLICE__

#include <ostream>
#include <iomanip>
#include <vector>
#include <map>

#include "km3net-dataformat/online/JDAQRoot.hh"
#include "km3net-dataformat/online/JDAQPreamble.hh"
#include "km3net-dataformat/online/JDAQTimesliceHeader.hh"
#include "km3net-dataformat/online/JDAQSuperFrame.hh"
#include "km3net-dataformat/online/JDAQException.hh"
#include "km3net-dataformat/online/JDAQPrint.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {

  class JDAQEvent;
  class JDAQSummaryslice;
  

  /**
   * Data time slice.
   */
  class JDAQTimeslice :
    public JDAQPreamble,
    public JDAQTimesliceHeader,
    public std::vector<JDAQSuperFrame>
  {
  public:

    friend size_t getSizeof(const JDAQTimeslice&);
    friend JReader& operator>>(JReader&, JDAQTimeslice&);
    friend JWriter& operator<<(JWriter&, const JDAQTimeslice&);

    /**
     * Default constructor.
     */
    JDAQTimeslice() :
      JDAQPreamble(JDAQType<JDAQTimeslice>()),
      JDAQTimesliceHeader(),
      std::vector<JDAQSuperFrame>()
    {}


    /**
     * Constructor.
     *
     * \param  chronometer    DAQ chronometer
     */
    JDAQTimeslice(const JDAQChronometer& chronometer) :
      JDAQPreamble(JDAQType<JDAQTimeslice>()),
      JDAQTimesliceHeader(chronometer),
      std::vector<JDAQSuperFrame>()
    {}
    

    /**
     * Constructor.
     *
     * \param  event          DAQ event
     * \param  snapshot       use shapshot hits (else use triggered hits)
     */
    JDAQTimeslice(const JDAQEvent& event,
		  const bool       snapshot = true);


    /**
     * Constructor.
     *
     * \param  event          DAQ event
     * \param  summary        summary
     * \param  snapshot       use shapshot hits (else use triggered hits)
     */
    JDAQTimeslice(const JDAQEvent&        event,
		  const JDAQSummaryslice& summary,
		  const bool              snapshot = true);

    
    /**
     * Virtual destructor.
     */
    virtual ~JDAQTimeslice()
    {
      clear();
    }


    /**
     * Clear data.
     */
    void clear()
    {
      for (iterator i = this->begin(); i != this->end(); ++i) {
	i->clear();
      }

      std::vector<JDAQSuperFrame>::clear();
    }


    /**
     * Assignment operator.
     *
     * \param  timeslice      timeslice
     * \return                this timeslice
     */
    JDAQTimeslice& operator=(const JDAQTimeslice& timeslice)
    {
      clear();

      setDAQChronometer(timeslice.getDAQChronometer());

      for (const_iterator i = timeslice.begin(); i != timeslice.end(); ++i) {
	push_back(*i);
      }

      return *this;
    }


    /**
     * Add another timeslice.
     *
     * \param  timeslice      timeslice
     * \return                this timeslice
     */
    JDAQTimeslice& add(const JDAQTimeslice& timeslice) 
    {
      using namespace std;

      map<JDAQModuleIdentifier, int> buffer;

      for (const_iterator i = this->begin(); i != this->end(); ++i) {
	buffer[i->getModuleIdentifier()] = distance(static_cast<const JDAQTimeslice&>(*this).begin(),i);
      }

      for (JDAQTimeslice::const_iterator i = timeslice.begin(); i != timeslice.end(); ++i) {

	map<JDAQModuleIdentifier, int>::const_iterator p = buffer.find(i->getModuleIdentifier());
	
	if (p != buffer.end()) {

	  JDAQSuperFrame& frame = this->at(p->second);

	  frame.add(*i);

	  sort(frame.begin(), frame.end());

	} else {

	  this->push_back(*i);
	}
      }
      
      return *this;
    }


    /**
     * Print DAQ Timeslice.
     *
     * \param  out           output stream
     * \param  lpr           long print
     * \return               output stream
     */
    std::ostream& print(std::ostream& out, const bool lpr = false) const
    {
      using namespace std;
      
      out << this->ClassName() << endl;
      out << dynamic_cast<const JDAQPreamble&>   (*this) << endl;
      out << dynamic_cast<const JDAQChronometer&>(*this) << endl;
      
      for (JDAQTimeslice::const_iterator frame = this->begin(); frame != this->end(); ++frame) {
	
	out << ' ' << setw(10) << frame->getModuleID();
	out << ' ' << setw(6)  << frame->getLength();
	out << ' ' << setw(6)  << frame->getDataType();
	out << ' ' << setw(6)  << frame->getTimesliceStart();
	out << ' ' << setw(8)  << setfill('0') << hex << frame->getStatus()     << dec << setfill(' ');
	out << '|' << setw(8)  << setfill('0') << hex << frame->getFIFOStatus() << dec << setfill(' ');
	out << ' ' << setw(2)  << frame->getUDPNumberOfReceivedPackets();
	out << '/' << setw(2)  << frame->getUDPMaximalSequenceNumber();
	out << ' ' << setw(6)  << frame->size();
	
	if (!lpr) {
	  
	  if (!frame->empty()) {
	    
	    out << ' ' << setw(10) << frame-> begin()->getT();
	    out << " ... ";
	    out << ' ' << setw(10) << frame->rbegin()->getT();
	  }
	  
	  out << endl;
	  
	} else {
	  
	  out << endl;
	  
	  int n = 1;
	  
	  for (JDAQFrame::const_iterator hit = frame->begin(); hit != frame->end(); ++hit, ++n) {
	    out << setw(2) << (int) hit->getPMT() << ' ' 
		<< setw(8) << (int) hit->getT()   << ' ' 
		<< setw(3) << (int) hit->getToT() << (n%10 == 0 ? '\n' : ' ');
	  }

	  out << endl;
	}
      }

      return out;
    }


    ClassDef(JDAQTimeslice,4);
  };


  /**
   * Equal operator for DAQ time slices.
   *
   * \param  first     time slice
   * \param  second    time slice
   * \result           true if first time slice equal to second; else false
   */
  inline bool operator==(const JDAQTimeslice& first,
			 const JDAQTimeslice& second)
  {
    return (first.getDAQTimesliceHeader()                          == second.getDAQTimesliceHeader()                          &&
	    static_cast<const std::vector<JDAQSuperFrame>&>(first) == static_cast<const std::vector<JDAQSuperFrame>&>(second));
  }


  /**
   * Not-equal operator for DAQ time slices.
   *
   * \param  first     time slice
   * \param  second    time slice
   * \result           true if first time slice not equal to second; else false
   */
  inline bool operator!=(const JDAQTimeslice& first,
			 const JDAQTimeslice& second)
  {
    return !(first == second);
  }
  

  /**
   * Timeslice data structure for L0 data.
   */
  struct JDAQTimesliceL0 : public JDAQTimeslice { ClassDef(JDAQTimesliceL0,1); };


  /**
   * Timeslice data structure for L1 data.
   */
  struct JDAQTimesliceL1 : public JDAQTimeslice { ClassDef(JDAQTimesliceL1,1); };


  /**
   * Timeslice data structure for L2 data.
   */
  struct JDAQTimesliceL2 : public JDAQTimeslice { ClassDef(JDAQTimesliceL2,1); };


  /**
   * Timeslice data structure for SN data.
   */
  struct JDAQTimesliceSN : public JDAQTimeslice { ClassDef(JDAQTimesliceSN,1); };
  

  /**
   * Print DAQ Timeslice.
   *
   * \param  out           output stream
   * \param  timeslice     timeslice
   * \return               output stream
   */
  inline std::ostream& operator<<(std::ostream& out, const JDAQTimeslice& timeslice)
  {
    return timeslice.print(out, getDAQLongprint());
  }
}

#endif
#ifndef __JDAQTIMESLICEHEADER__
#define __JDAQTIMESLICEHEADER__

#include "km3net-dataformat/online/JDAQRoot.hh"
#include "km3net-dataformat/online/JDAQHeader.hh"


/**
 * \author mdejong
 */
namespace KM3NETDAQ {

  /**
   * JDAQ timeslice header.
   */
  class JDAQTimesliceHeader :
    public JDAQHeader
  {
  public:
    /**
     * Default constructor.
     */
    JDAQTimesliceHeader() :
      JDAQHeader()
    {}


    /**
     * Constructor.
     *
     * \param  chronometer    DAQ chronometer
     */
    JDAQTimesliceHeader(const JDAQChronometer& chronometer) :
      JDAQHeader(chronometer)
    {}


    /**
     * Get DAQ time slice header.
     *
     * \return                DAQ time slice header
     */
    const JDAQTimesliceHeader& getDAQTimesliceHeader() const
    {
      return static_cast<const JDAQTimesliceHeader&>(*this);
    }
    

    ClassDef(JDAQTimesliceHeader,2);
  };


  /**
   * Equal operator for DAQ time slice headers.
   *
   * \param  first     time slice header
   * \param  second    time slice header
   * \result           true if first timeslice header equal to second; else false
   */
  inline bool operator==(const JDAQTimesliceHeader& first,
			 const JDAQTimesliceHeader& second)
  {
    return (first.getDAQHeader() == second.getDAQHeader());
  }


  /**
   * Not-equal operator for DAQ time slice headers.
   *
   * \param  first     time slice header
   * \param  second    time slice header
   * \result           true if first time slice header not equal to second; else false
   */
  inline bool operator!=(const JDAQTimesliceHeader& first,
			 const JDAQTimesliceHeader& second)
  {
    return !(first == second);
  }
}

#endif
#ifndef __JDAQTRIGGERCOUNTER__
#define __JDAQTRIGGERCOUNTER__

#include "km3net-dataformat/online/JDAQRoot.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {


  /**
   * Type definition of trigger counter.
   */
  typedef unsigned long long int                            JTriggerCounter_t;


  /**
   * Auxiliary class to count triggers.
   */
  class JDAQTriggerCounter {
  private:
    /**
     * Constructor.
     *
     * \param  counter        counter value
     */
    JDAQTriggerCounter(const JTriggerCounter_t counter)
    {
      this->trigger_counter = counter;
    }


  public:

    friend size_t getSizeof<JDAQTriggerCounter>();
    friend JReader& operator>>(JReader&, JDAQTriggerCounter&);
    friend JWriter& operator<<(JWriter&, const JDAQTriggerCounter&);

    /**
     * Default constructor.
     *
     * This constructor increments the counter of the unique instance
     * of this class and stores the result in this object.
     */
    JDAQTriggerCounter()
    {
      trigger_counter = getInstance().next();
    }


    /**
     * Virtual destructor.
     */
    virtual ~JDAQTriggerCounter()
    {}


    /**
     * Get reference to unique instance of this class object.
     *
     * \return               reference to this class object
     */
    static JDAQTriggerCounter& getInstance()
    {
      static JDAQTriggerCounter counter(0);

      return counter;
    }


    /**
     * Get DAQ trigger counter.
     *
     * \return                DAQ trigger counter
     */
    const JDAQTriggerCounter& getDAQTriggerCounter() const
    {
      return static_cast<const JDAQTriggerCounter&>(*this);
    }


    /**
     * Reset counter of unique instance of this class object.
     */
    static void reset()
    {
      getInstance().trigger_counter = 0;
    }


    /**
     * Get trigger counter.
     *
     * \return                counter value
     */
    JTriggerCounter_t getCounter() const
    {
      return trigger_counter;
    }


    /**
     * Set trigger counter.
     *
     * \param  counter        counter value
     */
    void setCounter(const JTriggerCounter_t counter)
    {
      this->trigger_counter = counter;
    }


    /**
     * Increment trigger counter.
     *
     * \return                counter value
     */
    JTriggerCounter_t next()
    {
      return trigger_counter++;
    }


    ClassDef(JDAQTriggerCounter,1);


  protected:
    JTriggerCounter_t trigger_counter;
  };


  /**
   * Equal operator for DAQ trigger counters.
   *
   * \param  first     trigger counter
   * \param  second    trigger counter
   * \result           true if first trigger counter equal to second; else false
   */
  inline bool operator==(const JDAQTriggerCounter& first,
			 const JDAQTriggerCounter& second)
  {
    return (first.getCounter() == second.getCounter());
  }


  /**
   * Not-equal operator for DAQ trigger counters.
   *
   * \param  first     trigger counter
   * \param  second    trigger counter
   * \result           true if first trigger counter not equal to second; else false
   */
  inline bool operator!=(const JDAQTriggerCounter& first,
			 const JDAQTriggerCounter& second)
  {
    return !(first == second);
  }
}

#endif
#ifndef __JDAQTRIGGERMASK__
#define __JDAQTRIGGERMASK__

#include <string>
#include <istream>
#include <ostream>

#include "km3net-dataformat/online/JDAQRoot.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {


  /**
   * Type definition of trigger mask.
   */
  typedef unsigned long long int                            JTriggerMask_t;


  /**
   * Number of trigger bits.
   */
  static const unsigned int NUMBER_OF_TRIGGER_BITS = sizeof(JTriggerMask_t) * 8;
 

  /**
   * Convert trigger bit to trigger mask.
   *
   * \param  bit        trigger bit
   * \return            trigger mask
   */
  inline JTriggerMask_t getTriggerMask(const unsigned int bit)
  {
    if (bit < NUMBER_OF_TRIGGER_BITS)
      return JTriggerMask_t(1) << bit;
    else
      return 0;
  }


  /**
   * Auxiliary class for trigger mask.
   */
  class JDAQTriggerMask {
  public:

    friend size_t getSizeof<JDAQTriggerMask>();
    friend JReader& operator>>(JReader&, JDAQTriggerMask&);
    friend JWriter& operator<<(JWriter&, const JDAQTriggerMask&);

    /**
     * Default constructor.
     */
    JDAQTriggerMask() :
      trigger_mask(0)
    {}


    /**
     * Constructor.
     *
     * \param  mask           trigger mask
     */
    JDAQTriggerMask(const JTriggerMask_t mask) :
      trigger_mask(mask)
    {}


    /**
     * Constructor.
     *
     * \param  buffer         trigger bit pattern (i.e. sequence of '0' and '1').
     */
    JDAQTriggerMask(const std::string& buffer) :
      trigger_mask(valueOf(buffer).getTriggerMask())
    {}


    /**
     * Virtual destructor.
     */
    virtual ~JDAQTriggerMask()
    {}

    
    /**
     * Get DAQ trigger mask.
     *
     * \return                DAQ trigger mask
     */
    const JDAQTriggerMask& getDAQTriggerMask() const
    {
      return static_cast<const JDAQTriggerMask&>(*this);
    }
    

    /**
     * Get trigger mask.
     *
     * \return                trigger mask
     */
    JTriggerMask_t getTriggerMask() const
    {
      return trigger_mask;
    }


    /**
     * Set trigger mask.
     *
     * \param  mask           trigger mask
     */
    void setDAQTriggerMask(const JDAQTriggerMask& mask)
    {
      trigger_mask = mask.trigger_mask;
    }


    /**
     * Set trigger mask.
     *
     * \param  mask           trigger mask
     */
    void setTriggerMask(const JTriggerMask_t mask)
    {
      trigger_mask = mask;
    }


    /** 
     * Add trigger bit pattern.
     *
     * \param  mask           trigger mask
     * \return                trigger mask
     */
    JDAQTriggerMask& addTriggerMask(const JDAQTriggerMask& mask)
    {
      trigger_mask |= mask.trigger_mask;

      return *this;
    }


    /** 
     * Has trigger bit pattern.
     *
     * \param  mask           trigger mask
     * \return                true if one of the bits is set; else false
     */
    inline bool hasTriggerMask(const JDAQTriggerMask& mask) const
    {
      return trigger_mask & mask.trigger_mask;
    }
   

    /**
     * Add trigger bit.
     *
     * \param  bit            trigger bit
     * \return                trigger mask
     */
    inline JDAQTriggerMask& addTriggerBit(const unsigned int bit)
    {
      trigger_mask |= KM3NETDAQ::getTriggerMask(bit);

      return *this;
    }


    /**
     * Check trigger bit.
     *
     * \param  bit            trigger bit
     * \return                true if bit is set; else false
     */
    inline bool hasTriggerBit(const unsigned int bit) const
    {
      return trigger_mask & KM3NETDAQ::getTriggerMask(bit);
    }


    /**
     * Extract trigger mask.
     *
     * \param  buffer         trigger bit pattern (i.e. sequence of '0' and '1').
     * \return                trigger mask
     */
    static JDAQTriggerMask valueOf(const std::string& buffer)
    {
      JDAQTriggerMask trigger_mask;

      unsigned int bit = 0;

      for (std::string::const_reverse_iterator i = buffer.rbegin(); i != buffer.rend() && bit != NUMBER_OF_TRIGGER_BITS; ++i, ++bit) {
	if (*i == '1') {
	  trigger_mask.addTriggerBit(bit);
	}
      }

      return trigger_mask;
    }


    /**
     * Convert trigger mask.
     *
     * \return                trigger bit pattern (i.e. sequence of '0' and '1').
     */
    std::string toString() const
    {
      std::string buffer(NUMBER_OF_TRIGGER_BITS, '0');

      unsigned int bit = 0;

      for (std::string::reverse_iterator i = buffer.rbegin(); i != buffer.rend() && bit != NUMBER_OF_TRIGGER_BITS; ++i, ++bit) {
	if (hasTriggerBit(bit)) {
	  *i = '1';
	}
      }

      return buffer;
    }
    

    /**
     * Read JDAQTriggerMask from input stream.
     *
     * \param  in             input stream
     * \param  mask           JDAQTriggerMask
     * \return                input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JDAQTriggerMask& mask)
    {
      std::string buffer;
      
      if (in >> buffer) {
	mask= JDAQTriggerMask::valueOf(buffer);
      }
 
      return in;
    }


    /**
     * Write JDAQTriggerMask to output stream.
     *
     * \param  out           output stream
     * \param  mask          JDAQTriggerMask
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JDAQTriggerMask& mask)
    {
      out << mask.toString();

      return out;
    }


    ClassDef(JDAQTriggerMask,1);


  protected:
    JTriggerMask_t  trigger_mask;
  };
  

  static const JDAQTriggerMask TRIGGER_MASK_ON   =  JDAQTriggerMask(~JTriggerMask_t(0));  //!< Trigger mask on;
  static const JDAQTriggerMask TRIGGER_MASK_OFF  =  JDAQTriggerMask( JTriggerMask_t(0));  //!< Trigger mask off;


  /**
   * Equal operator for DAQ trigger masks.
   *
   * \param  first     trigger mask
   * \param  second    trigger mask
   * \result           true if first trigger mask equal to second; else false
   */
  inline bool operator==(const JDAQTriggerMask& first,
			 const JDAQTriggerMask& second)
  {
    return (first.getTriggerMask() == second.getTriggerMask());
  }


  /**
   * Not-equal operator for DAQ trigger masks.
   *
   * \param  first     trigger mask
   * \param  second    trigger mask
   * \result           true if first trigger mask not equal to second; else false
   */
  inline bool operator!=(const JDAQTriggerMask& first,
			 const JDAQTriggerMask& second)
  {
    return !(first == second);
  }
}

#endif
#ifndef __JDAQTRIGGEREDHIT__
#define __JDAQTRIGGEREDHIT__

#include "km3net-dataformat/online/JDAQRoot.hh"
#include "km3net-dataformat/online/JDAQModuleIdentifier.hh"
#include "km3net-dataformat/online/JDAQHit.hh"
#include "km3net-dataformat/online/JDAQKeyHit.hh"
#include "km3net-dataformat/online/JDAQTriggerMask.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {

  /**
   * DAQ triggered hit
   */
  class JDAQTriggeredHit :
    public JDAQKeyHit,
    public JDAQTriggerMask
  {
  public:

    friend size_t getSizeof<JDAQTriggeredHit>();
    friend JReader& operator>>(JReader&, JDAQTriggeredHit&);
    friend JWriter& operator<<(JWriter&, const JDAQTriggeredHit&);

    /**
     * Default constructor.
     */
    JDAQTriggeredHit() :
      JDAQKeyHit     (),
      JDAQTriggerMask()
    {}


    /**
     * Constructor.
     *
     * \param  ID             module identifier
     * \param  hit            PMT hit
     * \param  mask           trigger mask
     */
    JDAQTriggeredHit(const JDAQModuleIdentifier& ID,
		     const JDAQHit&              hit,
		     const JDAQTriggerMask&      mask) :
      JDAQKeyHit(ID,hit),
      JDAQTriggerMask(mask)
    {}


    /**
     * Virtual destructor.
     */
    virtual ~JDAQTriggeredHit()
    {}


    ClassDef(JDAQTriggeredHit,2);
  };


  /**
   * Equal operator for DAQ triggered hits.
   *
   * \param  first     triggered hit
   * \param  second    triggered hit
   * \result           true if first triggered hit equal to second; else false
   */
  inline bool operator==(const JDAQTriggeredHit& first,
			 const JDAQTriggeredHit& second)
  {
    return (static_cast<const JDAQKeyHit&>     (first) == static_cast<const JDAQKeyHit&>     (second) &&
	    static_cast<const JDAQTriggerMask&>(first) == static_cast<const JDAQTriggerMask&>(second));
  }


  /**
   * Not-equal operator for DAQ triggered hits.
   *
   * \param  first     triggered hit
   * \param  second    triggered hit
   * \result           true if first triggered hit not equal to second; else false
   */
  inline bool operator!=(const JDAQTriggeredHit& first,
			 const JDAQTriggeredHit& second)
  {
    return !(first == second);
  }
}

#endif
#ifndef __JDAQUTCEXTENDED__
#define __JDAQUTCEXTENDED__

/**
 * \author rbruijn
 */

#include <cstdint>
#include <istream>
#include <ostream>
#include <iomanip>
#include <limits>

#include "km3net-dataformat/online/JDAQRoot.hh"


namespace KM3NETDAQ {

  /**
   * Data structure for UTC time.
   */
  class JDAQUTCExtended 
  {
  public:

    friend size_t getSizeof<JDAQUTCExtended>();
    friend JReader& operator>>(JReader&, JDAQUTCExtended&);
    friend JWriter& operator<<(JWriter&, const JDAQUTCExtended&);


    /** 
     * Default constructor.
     */
    JDAQUTCExtended() :
      UTC_seconds(0),
      UTC_16nanosecondcycles(0)
    {}


    /**
     * Constructor.
     *
     * \param  seconds     seconds [s]
     * \param  cycles      cycles [16 ns] 
     */    
    JDAQUTCExtended(const uint32_t seconds,
		    const uint32_t cycles):
      UTC_seconds(seconds),
      UTC_16nanosecondcycles(cycles)
    {}
   

    /**
     * Constructor.
     *
     * \param  nanoseconds time [ns]
     */    
    JDAQUTCExtended(const double nanoseconds)
    {
      setTimeNanoSecond(nanoseconds);
    }


    /** 
     * Virtual destructor.
     */
    virtual ~JDAQUTCExtended()
    {}
        

    /** 
     * Get White Rabbit status.
     *
     * \return             true if okay; else false
     */
    bool getWRStatus() const
    {
      return (UTC_seconds & ~getMask()) != 0;
    }
        

    /** 
     * Get major time.
     *
     * \return             time [s]
     */
    uint32_t getUTCseconds() const
    {
      return (UTC_seconds & getMask());
    }
        

    /** 
     * Get minor time.
     *
     * \return             time [16 ns]
     */
    uint32_t getUTC16nanosecondcycles() const
    {
      return UTC_16nanosecondcycles;
    }
        

    /** 
     * Get time (limited to 16 ns cycles).
     *
     * \return             time [ns]
     */
    double getTimeNanoSecond() const
    {
      return getUTCseconds() * 1.0e9  +  getUTC16nanosecondcycles() * getTick();
    }
    

    /** 
     * Set time.
     *
     * \param  utc_ns      time [ns]
     */
    void setTimeNanoSecond(const double utc_ns)
    {
      UTC_seconds            = (uint32_t) ( utc_ns * 1.0e-9);
      UTC_16nanosecondcycles = (uint32_t) ((utc_ns - UTC_seconds*1.0e9) / getTick());
    }
    

    /** 
     * Add time.
     *
     * \param  t_ns        time [ns]
     */
    void addTimeNanoSecond(const double t_ns)
    {
      const double   x_ns  =  (double) getUTC16nanosecondcycles() * (double) getTick()  +  t_ns;
      const uint32_t t_s   =  (uint32_t) (x_ns * 1.0e-9);
      
      UTC_seconds            += t_s; 
      UTC_16nanosecondcycles  = (uint32_t) ((x_ns - t_s*1.0e9) / getTick());
    }


    /**
     * Get minimum possible value.
     *
     * \return                  minimum possible value
     */
    static JDAQUTCExtended min()
    {
      return JDAQUTCExtended(0,0);
    }


    /**
     * Get maximum possible value.
     *
     * \return                  maximum possible value
     */
    static JDAQUTCExtended max()
    {
      return JDAQUTCExtended(std::numeric_limits<uint32_t>::max(),
			     std::numeric_limits<uint32_t>::max());
    }


    /**
     * Get mask for seconds data.
     *
     * \return                  mask
     */
    static uint32_t getMask() 
    {
      return 0x7FFFFFFF;
    }


    /**
     * Get number of nano-seconds per tick.
     *
     * \return                  time [ns]
     */
    static double getTick()
    {
      return 16.0;
    }


    /**
     * Get arbitrary offset (e.g. for accuracy of time differences).
     *
     * \return                 UTC time
     */
    static const JDAQUTCExtended& getInstance() 
    {
      static JDAQUTCExtended utc(1600000000, 0);

      return utc;
    }


    /**
     * Read UTC time.
     *
     * \param  in            intput stream
     * \param  utc           UTC extended time
     * \return               intput stream
     */
    friend inline std::istream& operator>>(std::istream& in, JDAQUTCExtended& utc)
    {
      in >> utc.UTC_seconds;
      in.get();
      in >> utc.UTC_16nanosecondcycles;
      
      return in;
    }


    /**
     * Write UTC time.
     *
     * \param  out           output stream
     * \param  utc           UTC extended time
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JDAQUTCExtended& utc)
    {
      using namespace std;
      
      const char c = out.fill();

      out << setw(10) << utc.getUTCseconds();
      out << ':';
      out << setw(10) << setfill('0') << utc.getUTC16nanosecondcycles() << setfill(c);
      
      return out;
    }
    

    ClassDef(JDAQUTCExtended,1);


  protected:
    uint32_t UTC_seconds;
    uint32_t UTC_16nanosecondcycles;
  };


  /**
   * Less than operator for UTC times.
   *
   * \param  first       UTC time
   * \param  second      UTC time
   * \result             true if first UTC time earlier than second UTC time; else false
   */
  inline bool operator<(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
  {
    if (first.getUTCseconds() == second.getUTCseconds())
      return first.getUTC16nanosecondcycles() < second.getUTC16nanosecondcycles();
    else
      return first.getUTCseconds() < second.getUTCseconds();
  }


  /**
   * Greater than operator for UTC times.
   *
   * \param  first       UTC time
   * \param  second      UTC time
   * \result             true if first UTC time later than second UTC time; else false
   */
  inline bool operator>(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
  {
    return (second < first);
  }


  /**
   * Less than or equal operator for UTC times.
   *
   * \param  first       UTC time
   * \param  second      UTC time
   * \result             true if first UTC time earlier than second UTC time; else false
   */
  inline bool operator<=(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
  {
    return !(second < first);
  }


  /**
   * Greater than or equal operator for UTC times.
   *
   * \param  first       UTC time
   * \param  second      UTC time
   * \result             true if first UTC time earlier than second UTC time; else false
   */
  inline bool operator>=(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
  {
    return !(first < second);
  }

 
  /**
   * Equal operator for UTC times.
   *
   * \param  first       UTC time
   * \param  second      UTC time
   * \result             true if first UTC time equal second UTC time; else false
   */
  inline bool operator==(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
  {
    return (first.getUTCseconds()            == second.getUTCseconds()            &&
	    first.getUTC16nanosecondcycles() == second.getUTC16nanosecondcycles());
  }

 
  /**
   * Not equal operator for UTC times.
   *
   * \param  first       UTC time
   * \param  second      UTC time
   * \result             true if first UTC time not equal second UTC time; else false
   */
  inline bool operator!=(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
  {
    return !(first == second);
  }


  /**
   * Get time difference between two UTC times.
   *
   * \param  first       UTC time
   * \param  second      UTC time
   * \result             time difference [s]
   */
  inline double getTimeDifference(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
  {
    const double utc_s   =  ((double) second.getUTCseconds()            - (double) first.getUTCseconds());
    const double utc_ns  =  ((double) second.getUTC16nanosecondcycles() - (double) first.getUTC16nanosecondcycles()) * JDAQUTCExtended::getTick();

    return utc_s  +  utc_ns*1.0e-9;
  }
}

#endif
#ifndef AAOBJECTINCLUDED
#define AAOBJECTINCLUDED

#include "TObject.h"

#include <iostream>
#include <iomanip>
#include <string>
#include <algorithm>

#include "km3net-dataformat/offline/Exception.hh"


/*! \brief AAObject is a base class for I/O-classes that adds the possibility
  to add 'user' information which will also be stored in the ROOT file.
*/

struct AAObject : public TObject
{
  std::vector<double>      usr;              ///< user data
  std::vector<std::string> usr_names;        ///< user keys

  /**
   * Get index in user data of the item with given key.
   *
   * \param  key           key
   * \return               index (-1 if key does not exists)
   */
  int idx( const std::string& key ) const
  {
    auto i = std::find (usr_names.begin(), usr_names.end(), key );
    if (i == usr_names.end()) return -1;
    return i - usr_names.begin();
  }

  /**
   * Check availability of user data of the item with given key.
   *
   * \param  key           key
   * \return               true if available; else false
   */
  bool haveusr( const std::string& key ) const
  {
    return idx( key ) >= 0;
  }

  /**
   * Get index in user data of the item with given key.\n
   * This method throws a run-time exception if no user data are available.
   *
   * \param  key           key
   * \return               index (-1 if key does not exists)
   */
  int idxusr_checked( const std::string& key ) const
  {
    int r = idx( key );
    if (r < 0)
    {
      THROW(Exception, "No user data for key " << key << " in aanet object of type " << this -> ClassName());
    }
    return r;
  }


  /**
   * Get user data item with given key.\n
   * This method throws a run-time exception if no user data are available.
   *
   * \param  key           key
   * \return               value
   */
  double getusr(const std::string& key) const
  {
    const int i = idx( key );

    if ( i  < 0 )
    {
      THROW(Exception, "No user data for key " << key << " in aanet object of type " << this -> ClassName());
    }

    if ( unsigned(i) >= usr.size() )
    {
      THROW(Exception, "Warning: inconsistent user data " << i << " >= " << usr.size());
    }

    return usr[i];
  }

  /**
   * Set user data item with given key.\n
   *
   * \param  key           key
   * \param  value         value
   */
  void setusr(const std::string & key, double value )
  {
    int i = idx( key );
    if (i < 0)
    {
      if ( usr.size() < usr_names.size() )
      {
        // this should not happen, but let's just add empty data
        usr.resize( usr_names.size() );
      }
      else
      {
        // this is possible, add empty ("") names
        usr_names.resize( usr.size() );
      }

      usr_names.push_back( key );
      usr.push_back( value );
    }
    else
    {
      usr[i] = value;
    }
  }

  /**
   * Remove (first) user data item with given key.\n
   *
   * \param  key           key
   * \return               true if data have been removed; else false
   */
  bool delusr( const std::string& key )
  {
    int i = idx( key );
    if ( i < 0 ) return false;

    usr.erase ( usr.begin() + i );
    usr_names.erase( usr_names.begin() + i );
    return true;
  }

  /**
   * Clear user data.
   */
  void clearusr()
  {
    usr.resize(0);
    usr_names.resize(0);
  }

  /**
   * Print user data (i.e. list of all pairs of keys and values).
   *
   * \param  out           output stream
   */
  void printusr(std::ostream& out = std::cout )
  {
    unsigned n = std::max( usr.size(), usr_names.size() );

    for (unsigned i = 0; i < n ; i++)
    {
      std::string name = "(unnamed)";
      if ( i < usr_names.size() && usr_names[i] != "" ) name = usr_names[i];
      out << i << " \t " << name << " : \t ";
      if ( i < usr.size() ) out << usr[i] << std::endl;
      else                  out << "(none)" << std::endl;
    }
  }

  /**
   * Default constructor.
   */
  AAObject() : any(NULL) {}
  ~AAObject() {}


  TObject* any;                              ///< Pointer to "any" user data.

  ClassDef(AAObject, 6)
};

#endif
#ifndef EVT_HH_INCLUDED
#define EVT_HH_INCLUDED

#include "km3net-dataformat/offline/AAObject.hh"
#include "km3net-dataformat/offline/Hit.hh"
#include "km3net-dataformat/offline/Trk.hh"
#include "km3net-dataformat/offline/Hit.hh"
#include "km3net-dataformat/offline/Exception.hh"

#include "TTimeStamp.h"

#include <uuid/uuid.h>
#include <vector>

/**
 * The Evt class respresent a Monte Carlo (MC) event as well as an offline event.\n
 * Some data from the online (DAQ) event are copied.
 */

struct Evt: public AAObject
{
  int id;                       ///< offline event identifier
  int det_id;                   ///< detector identifier from DAQ
  int mc_id;                    ///< identifier of the MC event (as found in ascii or antcc file).

  int run_id;                   ///< DAQ run identifier
  int mc_run_id;                ///< MC run identifier

  int frame_index;              ///< from the raw data
  ULong64_t trigger_mask;       ///< trigger mask from raw data (i.e. the trigger bits)
  ULong64_t trigger_counter;    ///< trigger counter
  unsigned int overlays;        ///< number of overlaying triggered events
  TTimeStamp t;                 ///< UTC time of the timeslice, or the event_time for MC. (default: 01 Jan 1970 00:00:00)

  uuid_t header_uuid;           ///< UUID of header containing the event-weight information

  //hits and tracks
  std::vector<Hit> hits;        ///< list of hits
  std::vector<Trk> trks;        ///< list of reconstructed tracks (can be several because of prefits,showers, etc).

  //Monte carlo
  std::vector<double> w;         ///< MC: Weights w[0]=w1, w[1]=w2, w[2]=w3 (see e.g. <a href="https://simulation.pages.km3net.de/taglist/taglist.pdf">Tag list</a> or km3net-dataformat/definitions)
  std::vector<double> w2list;    ///< MC: factors that make up w[1]=w2       (see e.g. <a href="https://simulation.pages.km3net.de/taglist/taglist.pdf">Tag list</a> or km3net-dataformat/definitions)
  std::vector<double> w3list;    ///< MC: atmospheric flux information

  TTimeStamp mc_event_time;      ///< MC: true generation time (UTC) of the event, (default: 01 Jan 1970 00:00:00)
  double mc_t;                   ///< MC: time where the mc-event was put in the timeslice, since start of run (offset+frameidx*timeslice_duration)
  std::vector<Hit> mc_hits;      ///< MC: list of MC truth hits
  std::vector<Trk> mc_trks;      ///< MC: list of MC truth tracks

  // --- place to store user info ---
  TString  comment;              ///< user can use this as he/she likes
  int      index;                ///< user can use this as he/she likes
  int      flags;                ///< user can use this as he/she likes


  /**
   * Default constructor.
   */
  Evt() :
    id(0), det_id(0), mc_id(0), run_id(0), mc_run_id(0), frame_index(0),
    trigger_mask(0), trigger_counter(0),
    overlays(0), t(0), mc_event_time(0), mc_t(0), index(0), flags(0)
  {
    uuid_clear(this->header_uuid);
  }


  /**
   * Print event.
   *
   * \param  out           output stream
   */
  void print(std::ostream& out = std::cout) const
  {
    out << "Evt: id=" << id <<
        " run_id=" << run_id <<
        " #hits=" << hits.size() <<
        " #mc_hits=" << mc_hits.size() <<
        " #trks=" << trks.size() <<
        " #mc_trks=" << mc_trks.size() << std::endl;
  }


  /**
   * Reset event.
   */
  void clear()
  {
    *this = Evt();
  }

  
  /**
   * Clear the hit vectors and all the references to hits in the tracks
   */
  void clear_hits()
  {
    hits.clear();
    mc_hits.clear();
    for (auto& t : trks )    t.hit_ids.clear();
    for (auto& t : mc_trks ) t.hit_ids.clear();
  }


  /**
   * Return a vector with const pointers to the tracks that are 'primary'.\n
   * Here, primary means the tracks have no parents.
   *
   * This method only works if MC parent-child relations are availabe.
   *
   * \return               list of pointers to primary tracks
   */
  std::vector<const Trk*> primary_trks() const
  {
    std::vector<const Trk*> r;
    for (auto& t : mc_trks )
    {
      if ( t.is_primary() ) r.push_back(&t);
    }
    return r;
  }


 /**
   * Return a vector of pointers to tracks that are 'primary'.\n
   * Here, primary means the tracks have no parents.
   *
   * \return               list of pointers to primary tracks
   */
  std::vector<Trk*> primary_trks()
  {
    std::vector<Trk*> r;
    for (auto& t : mc_trks )
    {
      if ( t.is_primary() ) r.push_back(&t);
    }
    return r;
  }


  /**
   * Get a const pointer to the (first) neutrino from the MC track list.
   *
   * \return pointer to neutrino (nullptr if no neutrino is in the list)
   */
  const Trk* neutrino() const
  {
    for (auto& t : mc_trks )
    {
      if ( t.is_neutrino() ) return &t;
    }
    return nullptr;
  }

  /**
   * Get a pointer to the (first) neutrino from the MC track list.
   *
   * \return const pointer to neutrino (nullptr if no neutrino is in the list)
   */

  Trk* neutrino()
  {
    // see Effective C++, Scott Meyers, ISBN-13: 9780321334879.
    return const_cast<Trk *>(static_cast<const Evt &>(*this).neutrino() );
  }


  /**
   * Get a const pointer to primary neutrino from the MC track list.
   *
   * Only works if MC parent-child relations are availabe.
   *
   * \return const pointer to primary neutrino (may be nullptr)
   */
  const Trk* primary_neutrino() const
  {
    for ( auto& t : mc_trks )
    {
      if ( t.is_neutrino() and t.is_primary() ) return &t;
    }
    return nullptr;
  }

  /**
   * Get a pointer to primary neutrino from the MC track list.
   *
   * Only works if MC parent-child relations are availabe.
   *
   * \return pointer to primary neutrino
   */
  Trk* primary_neutrino()
  {
    return const_cast<Trk *>(static_cast<const Evt &>(*this).primary_neutrino() );
  }


  /**
   * Get a const pointer to the first leading lepton from the MC track list.
   * Here, leading means the lepton that has a neutrino as mother.
   *
   * Only works if MC parent-child relations are availabe.
   *
   * \return pointer to leadig lepton (may be nullptr in case not found)
   */
  const Trk* leading_lepton() const
  {
    const Trk* nu = primary_neutrino();
    if (!nu) return nullptr;

    for (auto& t : mc_trks )
    {
      if ( t.is_lepton()    &&
      t.mother_id == nu->id &&
      !t.is_orphan() ) return &t;
    }
    return nullptr;
  }

  /**
   * Get a pointer to leading lepton from the MC track list.
   * Here, leading means the lepton that has a neutrino as mother.
   *
   * Only works if MC parent-child relations are availabe.
   *
   * \return pointer to leadig lepton (may be nullptr in case not found)
   */
  Trk* leading_lepton()
  {
    return const_cast<Trk *>(static_cast<const Evt &>(*this).leading_lepton() );
  }

  /**
   * Get a const pointer to the (first) parent of the track 'child'.\n
   * This method return nullptr if no parent is found.
   *
   * \param  child         child particle
   * \return               pointer to parent
   */
  const Trk * get_parent_of( const Trk & child ) const
  {
    for (auto& t : mc_trks )
    {
      if (child.mother_id == t.id ) return &t;
    }
    return nullptr;
  }


 /**
   * Get a pointer ot the (first) parent of the track 'child'.\n
   * This method return nullptr if no parent is found.
   *
   * \param  child         child particle
   * \return               pointer to parent
   */

  Trk* get_parent_of( const Trk & child )
  {
    return const_cast<Trk *>(static_cast<const Evt &>(*this).get_parent_of(child) );
  }


  /**
   * Action method at file open.
   *
   * \param  version   version
   */
  static void actionAtFileOpen(int version)
  {
    ROOT_IO_VERSION = version;
  }

  static int ROOT_IO_VERSION;    //!< Streamer version as obtained from ROOT file.

  ClassDef(Evt, 16)
};

#endif
#ifndef EXCEPTION_HH_INCLUDED
#define EXCEPTION_HH_INCLUDED

#include <exception>
#include <string>
#include <ostream>
#include <sstream>


/**
 * General exception
 */
class Exception : public std::exception {
public:
  /**
   * Constructor.
   *
   * \param  error    error message
   */
  Exception(const std::string& error) :
    std::exception(),
    buffer(error)
  {}


  /**
   * Destructor.
   */
  ~Exception() throw()
  {}


  /**
   * Get error message.
   *
   * \return          error message
   */
  virtual const char* what() const throw()
  {
    return buffer.c_str();
  }


  /**
   * Print error message of JException.
   *
   * \param  out        output stream
   * \param  exception  exception
   */
  friend inline std::ostream& operator<<(std::ostream& out, const Exception& exception)
  {
    return out << exception.what();
  }


  /**
   * Get output stream for conversion of exception.
   *
   * Note that the ostream is emptied before use.
   *
   * \return           ostream
   */
  static inline std::ostream& getOstream()
  {
    static std::ostringstream buffer;

    buffer.str("");

    return buffer;
  }

private:
  const std::string buffer;
};


/**
 * Marco for throwing exception with std::ostream compatible message.
 *
 * \param  Exception_t     exception
 * \param  A               message
 */
#ifndef THROW
#define THROW(Exception_t, A) do { throw Exception_t(static_cast<std::ostringstream&>(Exception::getOstream() << __FILE__ << ':' << __LINE__ << std::endl << A).str()); } while(0)
#endif

#endif
#ifndef HEAD_HH_INCLUDED
#define HEAD_HH_INCLUDED

#include "km3net-dataformat/offline/Vec.hh"
#include "km3net-dataformat/offline/Exception.hh"

#include "TObject.h"

#include <string>
#include <sstream>
#include <iostream>
#include <map>
#include <algorithm>
#include <vector>


/**
 * Trim a string in place
 *
 * \param  s             input string
 */
static inline void trimstring(std::string &s)
{
  // from the left
  s.erase( s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
    return !std::isspace(ch);
  }));

  // from the right
  s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
    return !std::isspace(ch);
  }).base(), s.end());
}

/**
 * Split string at delimiter. Trailing and leading whitespace is removed from each token.
 * Empty tokens are not put in the output list.
 *
 * \param  str           input string
 * \param  delim         token delimiter
 * \return               list of tokens
 */
inline std::vector<std::string> splitstring(const std::string& str, char delim = ' ')
{
  using namespace std;

  vector<string> r;

  stringstream ss(str);
  string token;
  while (getline(ss, token, delim))
  {
    trimstring(token);
    if (token != "") r.push_back(token);
  }

  return r;
}


/**
 * The Head class reflects the header of Monte-Carlo event files, which consists of keys (also referred to as "tags") and values.
 */
struct Head : public TObject, std::map<std::string, std::string>
{
  struct tags {
    static constexpr const char* const UUID = "UUID";
  };
  

  /**
   * Check availability of data with the given key.
   *
   * \param  key           key
   * \return               true if data are available; else false
   */
  bool have_line (std::string key ) const
  {
    return count( key ) != 0;
  }

  /**
   * Get data with the given key.\n
   * This method throws a run-time exception if no data are available.
   *
   * \param  key           key
   * \return               data
   */
  const std::string& get_line( std::string key ) const
  {
    return this->at(key);
  }

  /**
   * Get data with the given key.\n
   * This method throws a run-time exception if no data are available.
   *
   * \param  key           key
   * \return               data
   */
  std::string& get_line( std::string key )
  {
    return this->at(key);
  }


  /**
  * In case of duplicate keys, they are internally stored in the map
  * with a suffix "_n". This function returns all the keys that start
  * with 'key' and end in "_n", with n an integer
  *
  * \param tag            tag (without suffix)
  */

  std::vector< std::string> matching_keys( const std::string& tag ) const
  {
    std::vector< std::string> r;

    auto match = [&] (const std::string & key) {

      if (key == tag) return true;

      if ( key.find( tag ) != 0 ) return false;

      // what is left should be of the form _d(ddd)
      std::string left = key.substr( tag.length(), key.length() );
      if (left.length() < 2 || left[0] != '_' ) return false ;
      for ( unsigned i = 1; i < left.length(); i++ )
      {
        if (!std::isdigit( left[i] )) return false ;
      }
      return true;
    };

    for ( auto& p : *this )
    {
      if ( match( p.first ) ) r.push_back( p.first );
    }

    return r;
  }




  /**
  * Get all data compatible with the given key. This means all data
  * that is internally stored with "key_n", with n an integer \n
  * This method throws a run-time exception if no data are available.
  *
  * \param  tag           tag (without suffix)
  * \return               data
  */
  std::vector< std::string > get_lines( const std::string& tag ) const
  {
    std::vector< std::string > r;

    for ( auto& key : matching_keys( tag ) ) {
      r.push_back( get_line( key ) );
    }

    return r;
  }


  /**
   * Set data with the given tag. The function will return the actual key that
   * is used internally to store the result, which is equal to the tag with an
   * optional "_n" added to ensure uniqueness.
   *
   * \param  tag           tag
   * \param  line          data
   * \param  ensure_unique add '_n' (with n an integer) to the tag if it would overwrite an existing key.
   */

  std::string set_line( std::string tag, std::string line , bool ensure_unique = true )
  {
    std::string k = tag;

    if (ensure_unique)
      for (int i = 1; find(k) != end() ; i++)
      {
        k = tag + "_" + std::to_string(i);
      }

    std::map<std::string, std::string>::operator[]( k ) = line;
    return k;
  }

  /**
   * Get data with the given key at given index.\n
   * This method throws a run-time exception if no data are available.
   *
   * \param  key           key
   * \param  idx           index
   * \return               data
   */
  std::string get_field( std::string key, int idx ) const
  {
    using namespace std;

    vector<string> v = splitstring( get_line(key) );

    if ( idx < 0 || idx >= int ( v.size() ) )
    {
      THROW(Exception, "Cannot find word number " << idx << " in line " << get_line(key) << " for key: " << key);
    }
    return v[idx];
  }

  /**
   * Get index of data with the given key at given field.\n
   *
   * Note that this method uses the dictionary define in method Head::_hdr_dict.
   *
   * \param  key           key
   * \param  field         field
   * \return               index (-1 if not present)
   */
  int get_index_of_field(std::string key, std::string field) const
  {
    auto& d = _hdr_dict();
    if ( d.count(key) == 0 ) return -1;
    auto v = d.at(key);
    auto i = std::find (v.begin(), v.end(), field );
    if (i == v.end()) return -1;
    return i - v.begin();
  }

  /**
   * Get data with the given key at given field.\n
   * This method throws a run-time exception if no field is available.
   *
   * Note that this method uses the dictionary define in method Head::_hdr_dict.
   *
   * \param  key           key
   * \param  field         field
   * \return               data
   */
  std::string get_field( std::string key, std::string field ) const
  {
    int idx = get_index_of_field(key, field);

    if ( idx == -1 )
    {
      THROW(Exception, "Failed to find" << key << " " << field);
    }

    return get_field( key, idx );
  }


  /**
   * Set data with the given key at given field.\n
   * This method throws a run-time exception if no field available.
   *
   * Note that this method uses the dictionary define in method Head::_hdr_dict.
   *
   * \param  key           key
   * \param  field         field
   * \param  value         vakue
   */
  void set_field( std::string key, std::string field, std::string value )
  {
    using namespace std;

    if ( field == "" ) get_line( key ) = value;

    int idx = get_index_of_field( key, field );

    if ( idx < 0 )
    {
      THROW(Exception, "GFailed to find field in header line: " << key << " " << field);
    }

    vector<string> vals = splitstring( get_line( key ) );

    // if the fields before do not exist, add padding
    while ( int( vals.size() ) <= idx ) vals.push_back("0");

    vals[idx] = value;
    ostringstream ss;

    for (unsigned i = 0; i < vals.size() ; i++ )
    {
      ss << vals[i];
      if ( i != vals.size() - 1) ss << " ";
    }
    set_line( key, ss.str() );

  }

  /**
   * Print header.
   *
   * \param  out           output stream
   */
  void print ( std::ostream& out = std::cout ) const
  {
    if (count("start_run")) out << "start_run: " << at("start_run") << std::endl;

    for ( auto& p : *this )
    {
      if ( p.first == "start_run" || p.first == "end_event" ) continue;
      out << p.first << ": " << p.second << std::endl ;
    }
    out << "end_event:" << std::endl;
  }

  /**
   * Get internal description of the known lines in header.
   *
   * \return               internal dictionary
   */
  static const std::map<std::string, std::vector<std::string> >& _hdr_dict() 
  {
    using namespace std;

    // map with, for each tag (key), a vector of field-names

    static map<string, vector<string> > r;
    if ( r.size() > 0 ) return r;

    string desc =
      "DAQ:livetime\n"
      "cut_primary cut_seamuon cut_in cut_nu:Emin Emax cosTmin cosTmax\n"
      "generator physics simul:program version date time\n"
      "seed:program level iseed\n"
      "PM1_type_area:type area TTS\n"
      "PDF:i1 i2\n"
      "model:interaction muon scattering numberOfEnergyBins\n"
      "can:zmin zmax r\n"
      "genvol:zmin zmax r volume numberOfEvents\n"
      "merge:time gain\n"
      "coord_origin:x y z\n"
      "translate:x y z\n"
      "genhencut:gDir Emin\n"
      "k40:rate time\n"               // note lower-case k  
      "K40:livetime\n"                // note capital K
      "norma:primaryFlux numberOfPrimaries\n"
      "livetime:numberOfSeconds errorOfSeconds\n"
      "flux:type key file_1 file_2\n"
      "spectrum:alpha\n"
      "fixedcan:xcenter ycenter zmin zmax radius\n"
      "start_run:run_id";

    for ( auto line : splitstring(desc, '\n') )
    {
      auto v = splitstring( line, ':');

      vector< string > fields = splitstring( v[1] );
      for ( auto key : splitstring( v[0] ) )
      {
        r[key] = fields;
      }
    }
    return r;
  }


  /**
   * Get the number of generated events needed for computing event rates.
   *
   * \return               number of events
   */
  double ngen() const
  {
    return stod ( get_field("genvol", "numberOfEvents") );
  }

  /**
   * Get the the live time provided by the DAQ sytstem (=number of processed timeslices * frametime).
   *
   * \return               live time [s]
   */
  double daq_livetime() const
  {
    return stod ( get_field("DAQ", "livetime") );
  }


  /**
   * Get the Monte Carlo live time
   *
   * \return               live time [s]
   */
  double mc_livetime() const
  {
    return stod ( get_field("livetime", "numberOfSeconds") );
  }

  /**
   * Get coordinate origin.
   *
   * \return               position
   */
  Vec coord_origin() const
  {
    return Vec( stod( get_field("coord_origin", "x") ),
                stod( get_field("coord_origin", "y") ),
                stod( get_field("coord_origin", "z") ));
  }

  /**
   * Get coordinate translation.
   *
   * \return               translation
   */
  Vec translate() const
  {
    return Vec( stod( get_field("translate", "x") ),
                stod( get_field("translate", "y") ),
                stod( get_field("translate", "z") ));
  }

  virtual ~Head() {}

  /**
   * Action method at file open.
   *
   * \param  version   version
   */
  static void actionAtFileOpen(int version)
  {
    ROOT_IO_VERSION = version;
  }

  static int ROOT_IO_VERSION;    //!< Streamer version as obtained from ROOT file.

  ClassDef(Head, 2 );
};


/**
 * Print header.
 *
 * \param  out         output stream
 * \param  h           header
 * \return             output stream
 */
inline std::ostream& operator<<(std::ostream& out, const Head& h)
{
  h.print(out);
  return out;
}


#endif
#ifndef HIT_HH_INCLUDED
#define HIT_HH_INCLUDED

#include "TObject.h"
#include "TString.h"
#include "km3net-dataformat/offline/Vec.hh"

struct Hit :
  public TObject
{
  int id;

  // straight from the data
  int dom_id;                          ///< module identifier from the data (unique in the detector).
  unsigned int channel_id;             ///< PMT channel id {0,1, .., 30} local to moduke
  unsigned int tdc;                    ///< hit tdc (=time in ns)
  unsigned int tot;                    ///< tot value as stored in raw data (int for pyroot)
  ULong64_t trig;                      ///< non-zero if the hit is a trigger hit.

  int pmt_id;                          ///< global PMT identifier as found in evt files

  // values after calibration
  double t;                            ///< hit time (from tdc+calibration or MC truth)
  double a;                            ///< hit amplitude (in p.e.)
  Vec pos;                             ///< hit position
  Vec dir;                             ///< hit direction; i.e. direction of the PMT

  int type;                            ///< particle type or parametrisation used for hit (mc only)
  int origin;                          ///< track id of the track that created this hit (mc only)

  unsigned pattern_flags;              ///< some number that you can use to flag the hit

  /**
   * Default constructor.
   */
  Hit(): id(0), dom_id(0), channel_id(0), tdc(0), tot(0), trig(0), pmt_id(0),
    t(0), a(0), type(0), origin(0), pattern_flags(0) {}
  //virtual ~Hit() {}


  /**
   * Read hit (useful in python).
   *
   * \param  h             hit
   */
  void read(const Hit& h) { *this = h;}

  /**
   * Write hit (useful in python).
   *
   * \param  h             hit
   */
  void write(Hit& h) const { h = *this;}

  /**
   * Print hit.
   *
   * \param  out           output stream
   */
  void print( std::ostream& out = std::cout ) const
  {
    out << "Hit: id=" << id << " dom=" << dom_id << " channel=" << channel_id;
    out << " pmt=" << pmt_id << " t=" << t << " tot=" << tot;
    out << " pos="; pos.print(out);
    out << " dir="; dir.print(out);
  }

  ClassDefNV(Hit, 106) // reserve <100 for antcc class of the same name
};

#endif
#ifndef MULTIHEAD_HH_INCLUDED
#define MULTIHEAD_HH_INCLUDED

#include <vector>
#include <uuid/uuid.h>

#include "km3net-dataformat/offline/Evt.hh"
#include "km3net-dataformat/offline/Head.hh"

#include "TObject.h"


/**
 * \author bjung
 */

struct MultiHead :
  public std::vector<Head>,
  public TObject
{
  /**
   * Default constructor.
   */
  MultiHead() :
    std::vector<Head>(),
    TObject()
  {}
    
    
  /**
   * Virtual destructor.
   */
  virtual ~MultiHead()
  {}
    

  /**
   * Find header with given UUID.\n
   * Note: The parameter useCache can be toggled on for faster lookup.\n
   *       This should not be used if your `MultiHead` object is modified between look-ups.
   *       
   *
   * \param  uuid           header UUID
   * \param  useCache       use caching for faster look-up
   * \return                header with given UUID
   */
  const_iterator find(const uuid_t& uuid,
		      const bool    useCache = false) const
  {
    using namespace std;

    static struct Cache
    {
      Cache() { uuid_clear(this->uuid); }
      
      const_iterator it;
      uuid_t         uuid;
    } cache;
    
    if (!useCache) {

      for (cache.it = this->cbegin(); cache.it != this->cend(); ++cache.it) {

	const Head& head     = *cache.it;
	string      uuid_str = head.at(Head::tags::UUID);

	uuid_str.erase(remove_if(uuid_str.begin(), uuid_str.end(), ::isspace), uuid_str.end());
	
	uuid_parse(uuid_str.c_str(), cache.uuid);
	
	if (uuid_compare(uuid, cache.uuid) == 0) {
	  return cache.it;
	}
      }
      
      return this->end();
      
    } else {

      if (uuid_compare(uuid, cache.uuid) == 0) {
	return cache.it;
      } else {
	return find(uuid, false);
      }
    }
  }


  /** 
   * Find the header corresponding to the given event.
   * Note: The parameter useCache can be toggled on for faster lookup.\n
   *       This should not be used if your `MultiHead` object is modified between look-ups.
   *
   * \param  event          event
   * \param  useCache       use caching for faster look-up
   * \return                header corresponding to the given event
   */
  const_iterator find(const Evt& event,
		      const bool useCache = false) const
  {
    return find(event.header_uuid, useCache);
  }


  /**
   * Insert the given header.
   *
   * \param  header         header
   * \return                true if insertion was successful; else false
   */
  bool insert(const Head& header)
  {
    using namespace std;
    
    string uuid_str = header.at(Head::tags::UUID);
    uuid_str.erase(remove_if(uuid_str.begin(), uuid_str.end(), ::isspace), uuid_str.end());

    uuid_t uuid;
    uuid_parse(uuid_str.c_str(), uuid);

    if (uuid_is_null(uuid) == 0 && find(uuid) == this->cend()) {
      
      this->push_back(header);
      
      return true;
    }
    
    return false;
  }
  

  /**
   * Join given `MultiHead` object with this `MultiHead` object.
   *
   * \param  multiHead      `MultiHead` object
   * \return                 number of inserted headers
   */
  size_t join(const MultiHead& multiHead)
  {
    using namespace std;

    size_t n = 0;
    
    for (const_iterator i = multiHead.cbegin(); i != multiHead.cend(); ++i) {
      n += (size_t) this->insert(*i);
    }

    return n;
  }
  
  
  /**
   * Action method at file open.
   *
   * \param  version   version
   */
  static void actionAtFileOpen(int version)
  {
    ROOT_IO_VERSION = version;
  }
  

  static int ROOT_IO_VERSION;    //!< Streamer version as obtained from ROOT file.

  ClassDef(MultiHead, 1);
};

#endif
#ifndef TRK_HH_INCLUDED
#define TRK_HH_INCLUDED

#include <vector>
#include "TDatabasePDG.h"
#include "TPDGCode.h"
#include "km3net-dataformat/offline/AAObject.hh"
#include "km3net-dataformat/offline/Vec.hh"
#include "km3net-dataformat/definitions/trkmembers.hh"

/** 
 * The Trk class represents a Monte Carlo (MC) particle as well as a reconstructed track/shower. 
 */
struct Trk: public AAObject
{
  int    id;                          ///< track identifier
  Vec    pos;                         ///< postion [m] of the track at time t 
  Vec    dir;                         ///< track direction
  double t;                           ///< track time [ns] (when the particle is at pos )
  double E;                           ///< Energy [GeV] (either MC truth or reconstructed)

  double len;                         ///< length, if applicable [m]
  double lik;                         ///< likelihood or lambda value (for aafit, lambda)
  int    type;                        ///< MC: particle type in PDG encoding
  int               rec_type;         ///< identifier of the fitting algorithm/chain/strategy, see km3net-dataformat/definitions/reconstruction.csv
  std::vector<int>  rec_stages;       ///< list of identifyers of succesfull fitting stages resulting in this track

  int status;                         ///< MC status code, see km3net-dataformat/definitions/trkmembers.csv for values
  int mother_id;                      ///< MC id of the parent particle 
  int counter;                        ///< used by CORSIKA7 MC generation to store interaction counters, see <a href="https://web.iap.kit.edu/corsika/usersguide/usersguide.pdf">CORSIKA Userguide</a>

  std::vector<double> fitinf;         ///< place to store additional fit info, see km3net-dataformat/definitions/fitparameters.csv
  std::vector<int>    hit_ids;        ///< list of associated hit-ids (corresponds to Hit::id).
  std::vector<double> error_matrix;   ///< (NxN) error covariance matrix for fit parameters (stored as linear vector)
  std::string    comment;             ///< use as you like

  /**
   * Default constructor.
   */
  Trk(): id(0),t(0),E(0),len(0),lik(0), type(0), rec_type(0), status(TRK_ST_UNDEFINED), mother_id(TRK_MOTHER_UNDEFINED), counter(0) {}




  /**
   * Read track (useful in python).
   *
   * \param  t             track
   */
  void read(const Trk& t) { *this = t;}

  /**
   * Write track (useful in python).
   *
   * \param  t             track
   */
  void write(Trk& t)      const { t = *this; }
 

  /**
   * Get the name of the MC particle type.
   *
   * \return               name
   */
  std::string name() const
  {
    TParticlePDG* p = TDatabasePDG::Instance()->GetParticle( type );
    if (!p) return "unnamed state ("+ std::to_string(type)+")";
    return p->GetName();
  }

  /**
   * Check if this is a primary particle.
   *
   * \return               true if primary; else false
   */  
  bool is_primary() const
  {
    return status==TRK_ST_PRIMARYNEUTRINO || status==TRK_ST_PRIMARYCOSMIC;
  }
  
  /**
   * Test whether given particle is a final state inside the detector.
   *
   * \return                true if particle is final state; else false
   */
  bool is_finalstate() const
  {
    return status==TRK_ST_FINALSTATE;
  }

  /**
   * Check if this is a netrino.
   *
   * Note that its is checked if the PDG type is a nu-e, nu-mu or nu-tau.
   *
   * \return               true if neutrino; else false
   */  
  bool is_neutrino() const
  {
    return type == kNuE || type == kNuEBar || type == kNuMu || type == kNuMuBar || type == kNuTau || type == kNuTauBar;
  }

  /**
   * Check if this is an electron or positron.
   *
   * \return               true if this is an electron or positron
   */
  bool is_e() const
  {
     return type == kElectron || type == kPositron;
  }

  /**
   * Check if this is a muon.
   *
   * Note that its is checked if the PDG type is a (anti-)muon.
   *
   * \return               true if muon; else false
   */
  bool is_muon() const 
  {
    return type == kMuonMinus || type == kMuonPlus;
  }

  /**
   * Check if this is a tau.
   *
   * Note that its is checked if the PDG type is a (anti-)tau.
   *
   * \return               true if tau; else false
   */
  bool is_tau() const
  {
    return type == kTauMinus || type == kTauPlus;
  }

  /**
   * Check if this is a charged lepton.
   *
   * Note that its is checked if the PDG type is a (anti-)electron, (anti-)muon or (anti-)tua.
   *
   * \return               true if charged lepton; else false
   */
  bool is_lepton() const 
  {
    return is_e() || is_muon() || is_tau();
  }

  /**
   * Check if this is an orphan (i.e. no mother).
   *
   * \return               true if orphan; else false
   */  
  bool is_orphan() const
  {
    return mother_id == TRK_MOTHER_NONE;
  }
  
  /**
   * Get list of of pointers to tracks, all of which have their mother identifier set to identifier of this track.
   *
   * \param  mctrks        list of input tracks
   * \return               list of pointers to tracks
   */
  std::vector< Trk* > get_daughters ( std::vector<Trk>& mctrks )
  {
    std::vector<Trk*> r;

    for( auto& t : mctrks )
      {
	     if ( t.mother_id == id ) r.push_back( &t );
      }
    return r;
  }

  /**
   * Print track.
   *
   * \param  out           output stream
   */
  void print(std::ostream& out=std::cout) const
  {
    out << "Trk: id=" << id << " pos="; pos.print(out);
    out << " dir="; dir.print(out);
    out << " t=" << t << " E=" << E << " pdg-type=" << type;
  }

  ClassDef(Trk,12)
};

#endif
#ifndef VEC_HH_INCLUDED
#define VEC_HH_INCLUDED

#include <cmath>
#include <iostream>
#include <sstream>
#include "Rtypes.h"

/**
 * The Vec class is a straightforward 3-d vector, which also works in pyroot.
 */
struct Vec
{
  double x,y,z;

  /**
   * Constructor.
   *
   * \param  x_            x position
   * \param  y_            y position
   * \param  z_            z position
   */
  Vec(double x_, double y_, double z_) : x(x_), y(y_), z(z_) {}
  
  /**
   * Default constructor.
   */
  Vec():x(0),y(0),z(0) {}
  
  /**
   * Get dot product.
   *
   * \param  v             vector
   * \return               dot product
   */
  double dot(const Vec& v) const { return v.x*x + v.y*y+ v.z*z;}
  
  /**
   * Get cross product.
   *
   * \param  r             vector
   * \return               cross product
   */
  Vec cross(const Vec r)   const { return Vec ( y*r.z-z*r.y, z*r.x-x*r.z, x*r.y-y*r.x);}

  /**
   * Add vector.
   *
   * \param  v             vector
   * \return               this vector
   */
  Vec& operator+=(const Vec& v)  { x+=v.x; y+=v.y; z+=v.z; return *this;}

  /**
   * Subtract vector.
   *
   * \param  v             vector
   * \return               this vector
   */
  Vec& operator-=(const Vec& v)  { x-=v.x; y-=v.y; z-=v.z; return *this;}

  /**
   * Multiply vector.
   *
   * \param  d             factor
   * \return               this vector
   */
  Vec& operator*=(double d)      { x*=d; y*=d; z*=d; return *this;}

  /**
   * Divide vector.
   *
   * \param  d             factor
   * \return               this vector
   */
  Vec& operator/=(double d)      { return operator*=( 1.0 / d ); }

  /**
   * Negate vector.
   *
   * \return               vector
   */
  Vec operator-() const          { return Vec(-x,-y,-z); }
  
  /**
   * Check equality with given vector.
   *
   * \param  v             vector
   * \return               true if (x,y,z) positions of two vectors are equal; else false
   */
  bool operator==( const Vec& v ) const { return x==v.x && y==v.y && z==v.z ; }

  /**
   * Check in-equality with given vector.
   *
   * \param  v             vector
   * \return               true if one of (x,y,z) positions of two vectors are not equal; else false
   */
  bool operator!=( const Vec& v ) const { return x!=v.x || y!=v.y || z!=v.z ; }

  /**
   * Set vector.
   *
   * \param  xx            x position
   * \param  yy            y position
   * \param  zz            z position
   * \return               this vector
   */
  Vec& set(double xx, double yy, double zz) { x=xx; y=yy; z=zz; return *this;}

  /**
   * Set vector according given zenith and azimuth angles.
   *
   * \param  theta         zenith  angle [rad]
   * \param  phi           azimuth angle [rad]
   * \return               this vector
   */
  Vec& set_angles(double theta, double phi)
  {
    x = sin ( theta ) * cos( phi );
    y = sin ( theta ) * sin( phi );
    z = cos ( theta );
    return *this;
  }

  /**
   * Get azimuth angle.
   *
   * \return               angle [rad]
   */
  double phi()   const { return atan2( y,x ); }

  /**
   * Get zenith angle.
   *
   * \return               angle [rad]
   */
  double theta() const { return acos(z); }

  /**
   * Get length.
   *
   * \return               length
   */
  double len()   const { double l = dot(*this); return (l > 0)? sqrt(l) : 0; }

  /**
   * Get length of (x,y) component.
   *
   * \return               length
   */
  double lenxy() const { const double r2 = x*x + y*y; return (r2>0) ? sqrt(r2) :0; }

  /**
   * Normalise this vector.
   *
   * \return               this vector
   */
  Vec& normalize() { return operator/=( len() ); }

  /**
   * Print vector.
   *
   * \param  out           output stream
   */
  void print( std::ostream& out = std::cout ) const
  {
  	out << "Vec:" << x << " " << y << " " << z;
  }

  /**
   * Get string representation of this vector
   *
   * \return               string
   */
  const char* __repr__() const 
  {
    static std::string buffer;

    std::ostringstream s; 
  
    print(s);

    buffer = s.str();

    return buffer.c_str();
  }

  /**
   * Add vector.
   *
   * \param  v             vector
   * \return               vector
   */
  Vec __add__(const Vec& v) const { Vec r=*this; return r+=v; }

  /**
   * Subtract vector.
   *
   * \param  v             vector
   * \return               vector
   */
  Vec __sub__(const Vec& v) const { Vec r=*this; return r-=v; }

  /**
   * Multiply vector.
   *
   * \param  d             factor
   * \return               vector
   */
  Vec __mul__(double d )    const { Vec r=*this; return r*=d; }

  /**
   * Multiply vector.
   *
   * \param  d             factor
   * \return               vector
   */
  Vec __rmul__(double d )   const { return __mul__(d);        } 

  /**
   * Divide vector.
   *
   * \param  d             factor
   * \return               vector
   */
  Vec __div__(double d )    const { Vec r=*this; return r/=d; }

  /**
   * Rotate around z-axis with given angle.
   *
   * \param  ang           angle [rad]
   * \return               this vector
   */
  Vec& rotate_z(double ang)
  {
    const Vec o = *this; 
    x = o.x *cos(ang) - o.y * sin(ang);
    y = o.x *sin(ang) + o.y * cos(ang);
    z = o.z;
    return *this;
  }

  /**
   * Rotate around x-axis with given angle.
   *
   * \param  ang           angle [rad]
   * \return               this vector
   */
  Vec& rotate_x(double ang)
  {
    const Vec o = *this;
    x = o.x;
    y = o.y *cos(ang) + o.z * -sin(ang);
    z = o.y *sin(ang) + o.z * cos(ang);
    return *this;
  }

  /**
   * Rotate around y-axis with given angle.
   *
   * \param  ang           angle [rad]
   * \return               this vector
   */
  Vec& rotate_y(double ang)
  {
    const Vec o = *this;
    x = o.x *cos(ang) + o.z * sin(ang);
    y = o.y;
    z = -o.x *sin(ang) + o.z * cos(ang);
    return *this;
  }

  ClassDefNV(Vec,3)
};

/**
 * Write vector to output stream.
 *
 * \param  out           output stream
 * \param  v             vector
 * \return               output stream
 */
inline std::ostream& operator<<( std::ostream& out , const Vec& v )
{
  out << v.x << " " << v.y << " " << v.z << " ";
  return out;
}

/**
 * Read vector from input stream.
 *
 * \param  in            input stream
 * \param  v             vector
 * \return               input stream
 */
inline std::istream& operator>>(std::istream& in, Vec& v) 
{ 
  in >> v.x >> v.y >> v.z ; return in;
}

/**
 * Get cosine of space angle between two vectors.
 *
 * \param  a             first  vector
 * \param  b             second vector
 * \return               cosine
 */
inline double cos_angle_between( const Vec& a, const Vec& b)
{
  const double n = a.len() * b.len();
  return a.dot(b) / n;
}

/**
 * Get space angle between two vectors.
 *
 * \param  a             first  vector
 * \param  b             second vector
 * \return               angle [rad]
 */
inline double angle_between( const Vec& a, const Vec& b )
{
  double c = cos_angle_between( a, b );
  if ( c < -1 ) return M_PI;
  if ( c > 1  ) return 0;
  return acos( c );
}

/**
 * Add two vectors.
 *
 * \param  a             first  vector
 * \param  b             second vector
 * \return               vector
 */
inline Vec operator+(const Vec& a, const Vec& b) { Vec r(a); return r+=b;}

/**
 * Subtract two vectors.
 *
 * \param  a             first  vector
 * \param  b             second vector
 * \return               vector
 */
inline Vec operator-(const Vec& a, const Vec& b) { Vec r(a); return r-=b;}

/**
 * Multiply vector.
 *
 * \param  a             factor
 * \param  v             vector
 * \return               vector
 */
inline Vec operator*(double a, const Vec& v)     { return Vec(a*v.x,a*v.y,a*v.z);}

/**
 * Multiply vector.
 *
 * \param  v             vector
 * \param  a             factor
 * \return               vector
 */
inline Vec operator*(const Vec& v, double a)     { return Vec(a*v.x,a*v.y,a*v.z);}

/**
 * Divide vector.
 *
 * \param  v             vector
 * \param  a             factor
 * \return               vector
 */
inline Vec operator/(const Vec& v, double a)     { return Vec(v.x/a,v.y/a,v.z/a);}

#endif
#ifndef IO_ASCII_INCLUDED
#define IO_ASCII_INCLUDED

#include <string>
#include <istream>
#include <ostream>
#include <sstream>

#include "km3net-dataformat/offline/Evt.hh"
#include "km3net-dataformat/offline/Hit.hh"
#include "km3net-dataformat/offline/Trk.hh"
#include "km3net-dataformat/offline/Head.hh"
#include "km3net-dataformat/offline/Exception.hh"
#include "km3net-dataformat/definitions/w2list_gseagen.hh" 
#include "km3net-dataformat/definitions/trkmembers.hh"

#include "TDatabasePDG.h"

namespace mc_keys
{
const char* const  auto_t          =  "auto";
const char* const  start_run_t     =  "start_run:";
const char* const  start_event_t   =  "start_event:";
const char* const  hit_t           =  "hit:";
const char* const  hit_raw_t       =  "hit_raw:";
const char* const  track_in_t      =  "track_in:";
const char* const  track_t         =  "track:";
const char* const  track_fit_t     =  "track_fit:";
const char* const  neutrino_t      =  "neutrino:";
const char* const  track_primary_t =  "track_primary:";
const char* const  track_bundle_t  =  "track_bundle:";
//const char* const  primarylepton_t =  "primarylepton:";
const char* const  weights_t       =  "weights:";
const char* const  w2list_t        =  "w2list:";
const char* const  w3list_t        =  "w3list:";
const char* const  hourangle_t     =  "hourangle:";
const char* const  eventtime_t     =  "eventtime:";
const char* const  center_on_can_t =  "center_on_can:";
const char* const  muon_decay_t    =  "muon_decay:";
const char* const  end_event_t     =  "end_event:";
}

namespace mc_usr_keys
{
// track-level quantities
const char* const energy_lost_in_can = "energy_lost_in_can";


// event-level corsika variables
const char* const muon_decay_x = "muon_decay_x";
const char* const muon_decay_y = "muon_decay_y";
const char* const muon_decay_z = "muon_decay_z";

const char* const center_on_can_x = "center_on_can_x";
const char* const center_on_can_y = "center_on_can_y";
const char* const center_on_can_z = "center_on_can_z";
const char* const hourangle = "hourangle";
}


namespace io_stringutil
{
/**
 * Check if string starts with given text.
 *
 * \param  a             input string
 * \param  b             text
 * \return               true if string start with text; else false
 */
inline bool startswith( const std::string& a, const std::string& b )
{
  if ( a.find( b ) == 0 ) return true;
  return false;
}

/**
 * Remove leading and trailing white spaces.
 *
 * \param  s             input string
 * \return               trimmed string
 */
inline std::string trim(const std::string& s)
{
  using namespace std;

  if ( s == "" ) return s;

  string::size_type i1;
  string::size_type i2;

  for (i1 = 0; i1 < s.length(); i1++)
  {
    if ( !isspace (s[i1]) ) break;
  }
  for (i2 = s.length() - 1 ; i2 > i1 ; i2--)
  {
    if ( !isspace (s[i2]) ) break;
  }
  return s.substr( i1, i2 - i1 + 1 );
}

}


/**
 * Convert Geant3 to PDG particle type.
 *
 * \param  geant3_code   Geant3 code
 * \return               PDG code
 */
inline int pdg_code( int geant3_code )
{
  if ( geant3_code == -1 ) return -1; // used for k40 hits
  if ( geant3_code < 0 ) return pdg_code( -geant3_code ); // used for scattered

  return TDatabasePDG::Instance()->ConvertGeant3ToPdg( geant3_code );
}

/**
 * Convert PDG to Geant3 particle type.
 *
 * \param  pdg_code      PDG code
 * \return               Geant3 code
 */
inline int geant3_code( int pdg_code )
{
  if (pdg_code == -1 )   return -1;
  if (pdg_code == +311 ) return geant3_code( 130 ); // K0 -> K0long
  if (pdg_code == -311 ) return geant3_code( 130 ); // K0bar -> K0long

  return TDatabasePDG::Instance()->ConvertPdgToGeant3( pdg_code );
}


/**
 * Read a Vec(tor) from a stream.
 *
 * \param  v             vector
 * \param  is            input stream
 * \return               true if correctly read; else false
 */
inline bool read ( Vec& v, std::istream& is)
{
  is >> v.x >> v.y >> v.z;
  return !is.fail();
}

/**
 * Write a Vec(tor) to a stream.
 *
 * \param  v             vector
 * \param  os            output stream
 * \return               true if correctly written; else false
 */
inline bool write( const Vec& v, std::ostream& os)
{
  os << v.x << ' ' << v.y << ' ' << v.z;
  return !os.fail();
}

/**
 * Read a hit from a stream.
 *
 * \param  h             hit
 * \param  is            input stream
 * \param  read_mc       option to read also type and origin
 * \return               true if correctly read; else false
 */
inline bool read ( Hit& h, std::istream& is, bool read_mc = false  )
{
  h.dom_id     = 0; // need a proper det file to
  h.channel_id = 0; // set these.

  is >> h.id >> h.pmt_id >> h.a >> h.t;
  if ( !read_mc )
  {
    return !is.fail();
  }
  else
  {
    is >> h.type >> h.origin;
  }

  // at this point, an additional pure_a and pure_t may be present,
  // but we do not read them.

  return !is.fail();
}


/**
 * Write a hit to a stream.
 *
 * \param  h             hit
 * \param  os            output stream
 * \param  tag           tag
 * \return               true if correctly written; else false
 */
inline bool write( const Hit& h, std::ostream& os, const std::string& tag = mc_keys::hit_t)
{
  int om_id = h.pmt_id; // todo: deal with this better.

  os << tag << ' ' << h.id << ' ' << om_id << ' ' << h.a << ' ' << h.t;
  if ( tag != mc_keys::hit_raw_t ) {
    os << ' ' << h.type  << ' ' << h.origin; // not writing pure_a and pure_t
  }
  os << std::endl;
  return !os.fail();
}


/**
 * Read data.
 *
 * \param  is            input stream
 * \return               data
 */
inline std::vector<double> read_line_to_vector( std::istream& is )
{
  using namespace std;

  vector<double> r;

  string ss;
  getline(is, ss);
  istringstream il(ss);
  for ( double x; il >> x ; ) r.push_back( x );

  return r;
}


/**
 * Put value in front of data.
 *
 * \param  vec           data
 * \param  value         value
 */
template<typename T>
inline void push_front( std::vector<T>& vec, const T& value )
{
  vec.insert( vec.begin(), value );
}


/**
 * Read event from a stream.
 *
 * \param  evt           event
 * \param  is            input stream
 * \param  skip_hits     option to skip reading of hits
 * \return               true if correctly read; else false
 */
inline bool read ( Evt& evt, std::istream& is, bool skip_hits = false )
{
  using namespace std;

  string w;

  // find next start_event

  while ( w != mc_keys::start_event_t && is.good() ) is >> w;

  int mc_event_type;   // dummy - this is always 1 in all files.
  is >> evt.mc_id >> mc_event_type;

  Trk trk_nu, trk_primary;
  bool have_trk_nu(false), have_trk_primary(false);


  evt.mc_trks.clear();
  evt.hits.clear();
  evt.mc_hits.clear();

  string w_old;

  while ( is )
  {
    static Hit h;
    static Trk t;

    is >> w;

    if (skip_hits && ( w == mc_keys::hit_t || w == mc_keys::hit_raw_t)) {
      is.ignore( 1000, '\n' );
      continue;
    }

    if ( w == mc_keys::hit_t ) {
      
      read( h, is, true );
      evt.mc_hits.push_back( h );
      
    } else if ( w == mc_keys::hit_raw_t ) {
      
      read( h, is, false);
      evt.hits.push_back( h );
      
    } else if ( w == mc_keys::track_in_t     ||
		w == mc_keys::track_t        ||
		w == mc_keys::neutrino_t     ||
		w == mc_keys::track_bundle_t ||
		w == mc_keys::track_primary_t ) {

      t.id  = 0;
      t.len = 0.0;
      t.clearusr();
      t.comment = w;
      
      string line;
      getline( is, line );
      istringstream ii(line);

      if ( w != mc_keys::track_bundle_t ) {
	ii >> t.id;
      } else {
	ii >> t.len;
      }
      
      ii >> t.pos >> t.dir >> t.E;

      if (!ii.fail()) {

	if ( w == mc_keys::track_in_t) {

	  t.status = TRK_ST_FINALSTATE;
	
	  ii >> t.t >> t.type;

	  if (!ii.fail()) {
	
	    t.type = pdg_code( t.type );
	
	    ii >> t.len;
	
	    if ( ii.fail() ) { // missing length is not an error
	      evt.mc_trks.push_back( t );
	      continue;
	    } 

	    double eloss = 0;
	    ii >> eloss;
	
	    if ( ii.fail() ) { // missing eloss is not an error
	      evt.mc_trks.push_back( t );
	      continue;
	    } 

	    t.setusr( mc_usr_keys::energy_lost_in_can, eloss);

	    evt.mc_trks.push_back( t );
	  }
	  
	} else if ( w == mc_keys::track_t ) {

	  ii >> t.t;
	
	  evt.trks.push_back( t );
	  
	} else if ( w == mc_keys::neutrino_t ) {

	  t.status = TRK_ST_PRIMARYNEUTRINO;
	
	  // the last item we will read is W2LIST_GSEAGEN_CC, make enough space;
	  if (evt.w2list.size() < W2LIST_GSEAGEN_CC+1 ) evt.w2list.resize(W2LIST_GSEAGEN_CC+1);

	  ii >> t.t >>
	    evt.w2list[W2LIST_GSEAGEN_BX]    >> 
	    evt.w2list[W2LIST_GSEAGEN_BY]    >> 
	    evt.w2list[W2LIST_GSEAGEN_ICHAN] >> 
	    t.type                           >> 
	    evt.w2list[W2LIST_GSEAGEN_CC];

	  trk_nu = t;
	  have_trk_nu = true;
	  
	} else if ( w == mc_keys::track_primary_t ) {
	
	  t.status = TRK_ST_PRIMARYCOSMIC;
	
	  ii >> t.t >> trk_primary.type; // nucleus id (in pdg format or not?)

	  trk_primary = t;
	  have_trk_primary = true;
	  
	} else if ( w == mc_keys::track_bundle_t ) {

	  t.type   = PDG_MUONBUNDLE;
	  t.status = TRK_ST_MUONBUNDLE;

	  evt.mc_trks.push_back( t );
	  
	} else {
	  
	  ostream& out = Exception::getOstream();
	  out << "Unknown tag " << w << " for trk ";
	  t.print(out);
	  throw Exception(static_cast<ostringstream&>(out).str());
	}
      }

      if ( ii.fail() ) {
	ostream& out = Exception::getOstream();
	out << "Error reading trk ";
	t.print(out);
	throw Exception(static_cast<ostringstream&>(out).str());
      }
      
    } else if ( w == mc_keys::weights_t) {
      
      evt.w = read_line_to_vector( is );
      
    } else if ( w == mc_keys::w2list_t) {
      
      auto v = read_line_to_vector( is );
      evt.w2list.resize( std::max( evt.w2list.size(), v.size()));
      std::copy( v.begin(), v.end() , evt.w2list.begin() );
      
    } else if ( w == mc_keys::w3list_t) {
      
      evt.w3list = read_line_to_vector( is );
      
    } else if ( w == mc_keys::hourangle_t ) {
      
      double ha;
      is >> ha;
      evt.setusr(mc_usr_keys::hourangle, ha );
      
    } else if ( w == mc_keys::center_on_can_t) {
      
      // in corsika files, there is the (undocumented?) center_on_can tag,
      // which denoets the projection of the primary on the can. The direction
      // of the center_on_can 'track' is by defintion the direction of the
      // primary. We record the position in the usr data.

      vector<double> v = read_line_to_vector( is );
      
      if ( v.size() > 3 ) {
        evt.setusr(mc_usr_keys::center_on_can_x, v[1] );
        evt.setusr(mc_usr_keys::center_on_can_y, v[2] );
        evt.setusr(mc_usr_keys::center_on_can_z, v[3] );
      }
      
    } else if ( w == mc_keys::eventtime_t ) {
      
      unsigned nsec, n16ns_ticks;
      is >> nsec >> n16ns_ticks;
      evt.mc_event_time.SetSec( nsec );
      evt.mc_event_time.SetNanoSec( n16ns_ticks * 16 );
      
    } else if ( w == mc_keys::muon_decay_t) {
      
      // in km3sim files, there are additional tags, including this one
      vector<double> v = read_line_to_vector( is );
      if ( v.size() > 4 )
      {
        evt.setusr(mc_usr_keys::muon_decay_x, v[2] );
        evt.setusr(mc_usr_keys::muon_decay_y, v[3] );
        evt.setusr(mc_usr_keys::muon_decay_z, v[4] );
      }
      
    } else if ( w == mc_keys::end_event_t) {
      
      // finalize the mc_tracks -- as best we can.

      // If there is both a primary, and a neutrino, then the primary
      // will go second (mc_trks[1]) with id=-1 and the neutrino will
      // be mc_trks[0] with id=0. Unless they are same particle (identical
      // pos,dir,E); in that case the primary is skipped.
      // The primarylepton tag is not stored as a seperate Trk.

      if ( have_trk_primary && have_trk_nu ) {
	
        bool same = trk_nu.pos == trk_primary.pos &&
                    trk_nu.dir == trk_primary.dir &&
                    trk_nu.E   == trk_primary.E;

        if (!same) {
          trk_primary.id = -1;
          push_front( evt.mc_trks, trk_primary);
        }

        trk_nu.id = 0;
        push_front( evt.mc_trks, trk_nu);
	
      } else if ( have_trk_primary  ) {
	
        trk_primary.id = 0;
        push_front( evt.mc_trks, trk_primary);
	
      } else if ( have_trk_nu ) {
	
        trk_nu.id = 0;
        push_front( evt.mc_trks, trk_nu);
      }

      return true;
      
    } else {
      is.ignore( 1000, '\n' );
    }
    
    w_old = w;
  }

  if (!is.eof()) {
    THROW(Exception, "Error while reading ascii event" << w << ' ' << evt.id);
  }

  return false;
}


/**
 * Write event to a stream.
 *
 * \param  evt           event
 * \param  os            output stream
 * \return               true if correctly read; else false
 */
inline bool write( const Evt& evt, std::ostream& os )
{
  using namespace std;

  // set precision to 12 digits.
  const int precision = 12;
  auto old_flags = os.flags();
  auto old_precision = os.precision( precision );
  os.unsetf( std::ios_base::scientific | std::ios_base::fixed ); // default behaviour

  os << mc_keys::start_event_t << ' ' << evt.mc_id << ' ' << 1 << endl;

  for ( auto& trk : evt.mc_trks ) {
    
    const std::string& tag = trk.comment;

    os <<  tag                                                << ' '
       << (tag != mc_keys::track_bundle_t ? trk.id : trk.len) << ' '
       << trk.pos                                             << ' '
       << trk.dir                                             << ' '
       << trk.E;
    
    if ( tag == mc_keys::track_in_t ) {
      
      os << ' ' << trk.t << ' ' << geant3_code(trk.type) << ' ' << trk.len;

      if ( trk.haveusr( mc_usr_keys::energy_lost_in_can ) ) {
	os << ' ' << trk.getusr( mc_usr_keys::energy_lost_in_can );
      }

      os << endl;
      
    } else if ( tag == mc_keys::track_primary_t ) {

      os << ' ' << trk.t << ' ' << trk.type << endl;
      
    } else if ( tag == mc_keys::neutrino_t ) {

      double bx(0), by(0);
      int ichan(0), cc(0);

      if ( evt.w2list.size() > W2LIST_GSEAGEN_CC ) {
	bx    = evt.w2list[W2LIST_GSEAGEN_BX];
	by    = evt.w2list[W2LIST_GSEAGEN_BY];
	ichan = evt.w2list[W2LIST_GSEAGEN_ICHAN];
	cc    = evt.w2list[W2LIST_GSEAGEN_CC];
      }

      os << ' ' << trk.t
	 << ' ' << bx
	 << ' ' << by
	 << ' ' << ichan
	 << ' ' << trk.type
	 << ' ' << cc
	 << endl;
      
    } else {

      os << endl;
    }
  }
  
  for ( auto& trk : evt.trks    ) {
    os << mc_keys::track_fit_t << ' ' << trk.id << ' ' << trk.pos << ' ' << trk.dir << ' ' << trk.E << ' ' << trk.t << endl;
  }
  
  for ( auto& hit : evt.mc_hits )  write ( hit, os, mc_keys::hit_t);
  for ( auto& hit : evt.hits    )  write ( hit, os, mc_keys::hit_raw_t);
  
  os << mc_keys::weights_t; for (auto&  w : evt.w      ) os << ' ' << w; os << endl;
  os << mc_keys::w2list_t;  for (auto&  w : evt.w2list ) os << ' ' << w; os << endl;
  os << mc_keys::w3list_t;  for (auto&  w : evt.w3list ) os << ' ' << w; os << endl;

  os << mc_keys::eventtime_t << evt.mc_event_time.GetSec() << " "
     << evt.mc_event_time.GetNanoSec() / 16 << endl;

  os << mc_keys::end_event_t << endl;

  // restore os to how we found it.
  os.flags( old_flags );
  os.precision( old_precision );

  return true;
}



/**
 * Read header from a stream.
 *
 * The stream may be positioned at any point before the tag mc_keys::start_run_t,
 * which marks the beginning of the header.
 * Information before the header (if any) is disgarded.
 *
 * \param  hdr           header
 * \param  is            input stream
 * \return               true if correctly read; else false
 */
inline bool read( Head& hdr, std::istream& is )
{
  using namespace std;

  string line;

  bool start = false;

  while (getline( is, line ))
  {
    if ( io_stringutil::startswith(line, mc_keys::end_event_t))
    {
      break;
    }

    if ( io_stringutil::startswith(line, mc_keys::start_run_t))
    {
      start = true;
    }

    if ( io_stringutil::startswith(line, mc_keys::start_event_t))
    {
      THROW(Exception, "Unexpected tag " << mc_keys::start_event_t << " found while reading header at " << line << " (could mean the evt file has no header)");
    }

    if (!start) continue;

    vector<string> v = splitstring( line, ':' );
    if (v.size() < 2 )
    {
      std::cout << "Warning: line with empty tag found when reading header" << endl;
      std::cout << "        "<< line << endl;
      std::cout << "         will be skipped" << endl;
      continue;
    }

    // the following with unsure key in the map is unique by adding _1 _2 etc.
    hdr.set_line( io_stringutil::trim(v[0]), io_stringutil::trim(v[1]) );

  }

  if (!start)
  {
    THROW(Exception, "Reading of MC header terminated before finding a start_run: tag. Please check your file");
  }

  return start;
}


/**
 * Write header to a stream.
 *
 * \param  hdr           header
 * \param  os            output stream
 * \return               true if correctly written; else false
 */
inline bool write( const Head& hdr, std::ostream& os )
{
  hdr.print(os);
  return true;
}

#endif
#ifndef IOONLINEINCLUDED
#define IOONLINEINCLUDED

#include "km3net-dataformat/offline/Evt.hh"
#include "km3net-dataformat/offline/Hit.hh"
#include "km3net-dataformat/offline/Trk.hh"
#include "km3net-dataformat/offline/Exception.hh"

#include "km3net-dataformat/online/JDAQEvent.hh"
#include "km3net-dataformat/online/JDAQKeyHit.hh"
#include "km3net-dataformat/online/JDAQTimeslice.hh"
#include "km3net-dataformat/online/JDAQSummaryslice.hh"

#include "TStreamerInfo.h"
#include "TFile.h"
#include "TTree.h"
#include "km3net-dataformat/definitions/root.hh"

#include <map>
#include <vector>


using namespace KM3NETDAQ;

/**
 * Read a hit from a DAQ hit.
 *
 * \param  hit           hit
 * \param  daqhit        DAQ hit
 */
inline void read(Hit& hit, const JDAQHit& daqhit )
{
  hit.channel_id = daqhit.getPMT();
  hit.tot        = daqhit.getToT();
  hit.tdc        = daqhit.getT(); // GetT() just return the bare TDC
}

/**
 * Read a hit from a DAQ key hit.
 *
 * \param  hit           hit
 * \param  daqhit        DAQ key hit
 */
inline void read(Hit& hit, const JDAQKeyHit& daqhit )
{
  hit.id = hit.pmt_id = 0;

  hit.dom_id     = daqhit.getModuleID();
  hit.channel_id = daqhit.getPMT();
  hit.tot        = daqhit.getToT();
  hit.tdc        = daqhit.getT(); // GetT() just return the bare TDC
}

/**
 * Read an event from a DAQ event.
 *
 * \param  evt           evt
 * \param  de            DAQ event
 */
inline void read(Evt& evt, const JDAQEvent& de)
{
  evt.run_id          = de.getRunNumber();
  evt.det_id          = de.getDetectorID();
  evt.frame_index     = de.getFrameIndex();
  evt.trigger_counter = de.getCounter();
  evt.overlays        = de.getOverlays();
  evt.trigger_mask    = de.getTriggerMask();
  evt.t.SetSec(     de.getTimesliceStart().getUTCseconds() );
  evt.t.SetNanoSec( de.getTimesliceStart().getUTC16nanosecondcycles() * 16 );

  // The only way to know the hits that are also in the triggeredhits collection
  // is by dom and channel id and time.

  Hit h;
  std::map<int, std::map< int, std::map < unsigned int, Hit*> > > M;

  const std::vector<JDAQSnapshotHit>&   snapshotHits = de.getHits<JDAQSnapshotHit>();
  const std::vector<JDAQTriggeredHit>& triggeredHits = de.getHits<JDAQTriggeredHit>();

  // http://stackoverflow.com/questions/10735135/reallocation-in-stdvector-after-stdvector-reserve
  evt.hits.clear();
  evt.hits.reserve(snapshotHits.size());

  for (auto& daqhit : snapshotHits ) // JDAQSnapshotHit
  {
    read( h, daqhit );
    h.trig = 0;
    evt.hits.push_back( h );
    M[ h.dom_id ][ h.channel_id ][ h.tdc ] = &(*evt.hits.rbegin());
  }

  for (auto& daqtrighit : triggeredHits)
  {
    Hit* g = M[daqtrighit.getModuleID()][daqtrighit.getPMT()][daqtrighit.getT()];

    if (g)
      g->trig = daqtrighit.getTriggerMask ();
    else
      THROW(Exception, "Failed to flag snaphot hit " << (int) daqtrighit.getModuleID() << "." << (int) daqtrighit.getPMT() << " " << daqtrighit.getT());
  }
}

/**
 * Read an event from a DAQ time slice.
 *
 * \param  evt           evt
 * \param  ts            DAQ time slice
 */

inline void read( Evt& evt, const JDAQTimeslice& ts )
{
  evt.run_id          = ts.getRunNumber();
  evt.det_id          = ts.getDetectorID();
  evt.frame_index     = ts.getFrameIndex();
  evt.t.SetSec( ts.getTimesliceStart().getUTCseconds() );
  evt.t.SetNanoSec( ts.getTimesliceStart().getUTC16nanosecondcycles() * 16 );
  evt.hits.clear();

  // a timeslice is a vector of JDAQSuperFrame's, which is a JDAQFrame, which
  // is an stl::vector-like object (supporting stl-like iteration.)

  Hit h; h.id = 0; h.pmt_id = 0;

  for (auto& sf : ts )
  {
    for (auto& daqhit : sf )
    {
      read( h, daqhit);
      h.dom_id = sf.getModuleID();
      evt.hits.push_back(h);
    }
  }
}


/**
 * Get summary slice from given file with given frame index. This function will
 * (re)build an index each time it encounters a new TFile as input.
 *
 * \param  f             pointer to ROOT file
 * \param  frame_index   frame index
 * \return               pointer to summary slice
 */

inline JDAQSummaryslice* get_summary_slice( TFile* f , int frame_index )
{
  static TFile* _f = 0;
  static TTree*  S = 0;
  static TBranch* BS = 0;
  JDAQSummaryslice *r = 0 ;

  if (!f) THROW(Exception, "get_summary_slice called with TFile pointer that is null");


  // in principle, event if the pointer-value is the same, we could have been given a new file

  if ( !_f || _f->GetUUID().Compare( f->GetUUID() ) != 0 ) // setup for tree reading and build tree index
  {
    _f = f;

    // first we have to deal with the following....
    // The streamer of JDAQSummaryFrame needs to know what to do since
    // this information is not written to root file.

    const char* name = JDAQSummaryslice::Class()->GetName();

    JDAQSummaryFrame::ROOT_IO_VERSION = ((TStreamerInfo*)_f -> GetStreamerInfoList()->FindObject(name))->GetClassVersion();

    S = (TTree*) _f->Get( TTREE_ONLINE_SUMMARYSLICE );

    if (!S)
    {
      THROW(Exception, "Failed to get summary slice TTree : " <<  TTREE_ONLINE_SUMMARYSLICE );
    }

    BS = S->GetBranch( TBRANCH_ONLINE_SUMMARYSLICE );

    if (!BS)
    {
      THROW(Exception, "Failed to get brach :" << TBRANCH_ONLINE_SUMMARYSLICE );
    }

    std::cout << "building index to lookup summary slices..." << std::endl;
    int n = S->BuildIndex("frame_index");
    (void) n;
    BS->SetAddress( &r );
  }

  int nbytes = S->GetEntryWithIndex( frame_index ); // returns -1 if not found
  if ( nbytes <= 0 )
  {
    THROW(Exception, "Failed to find summary slice entry with frame_index " << frame_index);
  }
  return r;
} 


#endif
#ifndef __TOOLS_MULTIPLICITY__
#define __TOOLS_MULTIPLICITY__

#include "km3net-dataformat/offline/Evt.hh"
#include "km3net-dataformat/offline/Trk.hh"


/**
 * Retrieve bundle multiplicity of given event.
 *
 * \param  event              event
 */
inline int get_multiplicity(const Evt& event)
{
  using namespace std;

  // Bundle multiplicity is stored in the `len` member variable for `track_bundle`s.
    
  for ( auto& t : event.mc_trks ) {
    if ( t.status == TRK_ST_MUONBUNDLE ) { return (int) t.len; } 
  }
    
  ostream& out = Exception::getOstream();
  out << "get_multiplicity(): The following event does not correspond to a muon bundle:" << endl;
  event.print(out);
  throw Exception(static_cast<ostringstream&>(out).str());
}

#endif
#ifndef __TOOLS_RECONSTRUCTION__
#define __TOOLS_RECONSTRUCTION__

#include <limits>
#include <algorithm>

#include "km3net-dataformat/offline/Hit.hh"
#include "km3net-dataformat/offline/Vec.hh"
#include "km3net-dataformat/offline/Trk.hh"
#include "km3net-dataformat/offline/Evt.hh"
#include "km3net-dataformat/offline/Exception.hh"
#include "km3net-dataformat/definitions/reconstruction.hh"


/**
 * \file
 *
 * Auxiliary methods for selection of reconstructed tracks.
 * \author mdejong
 */


/**
 * Range of reconstruction stages.
 */
struct rec_stages_range {
  /**
   * Defaut constructor.
   */
  rec_stages_range() :
    lower(0),
    upper(std::numeric_limits<int>::max())
  {}


  /**
   * Constructor.
   *
   * \param  lower          lower reconstruction stage
   * \param  upper          upper reconstruction stage
   */
  rec_stages_range(const int lower, const int upper) :
    lower(lower),
    upper(upper)
  {}


  /**
   * Constructor.
   *
   * \param  stage          reconstruction stage
   */
  rec_stages_range(const int stage) :
    lower(stage),
    upper(stage)
  {}

  
  /**
   * Test if given reconstruction stage is within range.
   *
   * \param  stage          reconstruction stage
   * \return                true if within range; else false
   */
  inline bool operator()(const int stage) const
  {
    return (stage >= lower && stage <= upper);
  }

  int lower;
  int upper;
};


/**
 * Reconstruction type dependent comparison of track quality.
 *
 * The specialisation of this class should implement the function object operator
 * <pre>
 *    inline bool operator()(const Trk& first, const Trk& second) const
 * </pre>
 * and return true if the first track is better then the second track.
 */
template<int reconstruction_type>
struct quality_sorter {
  /**
   * The default comparison is based on:
   *    -# number of reconstruction stages, i.e. <tt>Trk::rec_stages.size()</tt> (the larger the better);
   *    -# likelihood of the final track, i.e. <tt>Trk::lik</tt> (the larger the better).
   *
   * \param  first          first  track
   * \param  second         second track
   * \return                true if first track has better quality than second; else false
   */
  inline bool operator()(const Trk& first, const Trk& second) const
  {
    if (first.rec_stages.size() == second.rec_stages.size())
      return first.lik > second.lik;
    else
      return first.rec_stages.size() > second.rec_stages.size();
  }
};


/**
 * Auxiliary class to test whether given track has specified history.\n
 * The history of a track consists of a reconstruction type and a range of application types.
 */
struct has_history {
  /**
   * Constructor.
   *
   * \param  type           reconstruction type
   * \param  range          range of application types
   */
  has_history(const int type,  const rec_stages_range range) :
    type (type),
    range(range)
  {}

  /**
   * \param  track          track
   * \return                true if given track has specified history; else false
   */
  inline bool operator()(const Trk& track) const
  {
    if (track.rec_type == type)
      return std::find_if(track.rec_stages.begin(), track.rec_stages.end(), range) != track.rec_stages.end();
    else
      return false;
  }

  const int              type;    //!< reconstruction type
  const rec_stages_range range;   //!< range of application types
};
  

/**
 * Test whether given track has muon prefit in history.
 *
 * \param  track          track
 * \return                true if muon prefit in history; else false
 */
inline bool has_jppmuon_prefit(const Trk& track)
{
  return ::has_history(JPP_RECONSTRUCTION_TYPE, JMUONPREFIT)(track);
}


/**
 * Test whether given track has muon simplex fit in history.
 *
 * \param  track          track
 * \return                true if muon simplex fit in history; else false
 */
inline bool has_jppmuon_simplex(const Trk& track)
{
  return ::has_history(JPP_RECONSTRUCTION_TYPE, JMUONSIMPLEX)(track);
}


/**
 * Test whether given track has muon gandalf fit in history.
 *
 * \param  track          track
 * \return                true if muon gandalf fit in history; else false
 */
inline bool has_jppmuon_gandalf(const Trk& track)
{
  return ::has_history(JPP_RECONSTRUCTION_TYPE, JMUONGANDALF)(track);
}


/**
 * Test whether given track has muon energy fit in history.
 *
 * \param  track          track
 * \return                true if muon energy fit in history; else false
 */
inline bool has_jppmuon_energy(const Trk& track)
{
  return ::has_history(JPP_RECONSTRUCTION_TYPE, JMUONENERGY)(track);
}


/**
 * Test whether given track has muon start fit in history.
 *
 * \param  track          track
 * \return                true if muon start fit in history; else false
 */
inline bool has_jppmuon_start(const Trk& track)
{
  return ::has_history(JPP_RECONSTRUCTION_TYPE, JMUONSTART)(track);
}


/**
 * Test whether given track has default muon fit in history.
 *
 * \param  track          track
 * \return                true if muon fit in history; else false
 */
inline bool has_jppmuon_fit(const Trk& track)
{
  return ::has_history(JPP_RECONSTRUCTION_TYPE, rec_stages_range(JMUONBEGIN, JMUONEND))(track);
}  


/**
 * Test whether given track has shower prefit in history.
 *
 * \param  track          track
 * \return                true if shower prefit in history; else false
 */
inline bool has_shower_prefit(const Trk& track)
{
  return ::has_history(JPP_RECONSTRUCTION_TYPE, JSHOWERPREFIT)(track);
}


/**
 * Test whether given track has shower position fit in history.
 *
 * \param  track          track
 * \return                true if shower position fit in history; else false
 */
inline bool has_shower_positionfit(const Trk& track)
{
  return ::has_history(JPP_RECONSTRUCTION_TYPE, JSHOWERPOSITIONFIT)(track);
}  


/**
 * Test whether given track has shower complete fit in history.
 *
 * \param  track          track
 * \return                true if shower complete fit in history; else false
 */
inline bool has_shower_completefit(const Trk& track)
{
  return ::has_history(JPP_RECONSTRUCTION_TYPE, JSHOWERCOMPLETEFIT)(track);
}


/**
 * Test whether given track has default shower fit in history.
 *
 * \param  track          track
 * \return                true if shower fit in history; else false
 */
inline bool has_shower_fit(const Trk& track)
{
  return ::has_history(JPP_RECONSTRUCTION_TYPE, rec_stages_range(JSHOWERBEGIN, JSHOWEREND))(track);
}


/**
 * Test whether given track has default shower fit in history.
 *
 * \param  track          track
 * \return                true if shower fit in history; else false
 */
inline bool has_aashower_fit(const Trk& track)
{
  return ::has_history(AANET_RECONSTRUCTION_TYPE, rec_stages_range(AASHOWERBEGIN, AASHOWEREND))(track);
}


/**
 * Test whether given event has a track according selection.\n
 * The track selector corresponds to the function operator <tt>bool selector(const Trk&);</tt>.
 *
 * \param  evt            event
 * \param  selector       track selector
 * \return                true if at least one corresponding track; else false
 */
template<class JTrackSelector_t>
inline bool has_reconstructed_track(const Evt& evt, JTrackSelector_t selector)
{
  return std::find_if(evt.trks.begin(), evt.trks.end(), selector) != evt.trks.end();
}


/**
 * Test whether given event has a track according selection.
 *
 * \param  evt            event
 * \param  range          range of application types
 * \return                true if at least one corresponding track; else false
 */
template<int reconstruction_type>
inline bool has_reconstructed_track(const Evt& evt, const rec_stages_range range = rec_stages_range())
{
  return ::has_reconstructed_track(evt, ::has_history(reconstruction_type, range));
}
  

/**
 * Test whether given event has a track with muon reconstruction.
 *
 * \param  evt            event
 * \return                true if at least one reconstructed muon; else false
 */
inline bool has_reconstructed_jppmuon(const Evt& evt)
{
  return ::has_reconstructed_track(evt, has_jppmuon_fit);
}
  

/**
 * Test whether given event has a track with shower reconstruction.
 *
 * \param  evt            event
 * \return                true if at least one reconstructed shower; else false
 */
inline bool has_reconstructed_jppshower(const Evt& evt)
{
  return ::has_reconstructed_track(evt, ::has_shower_fit);
}
  

/**
 * Test whether given event has a track with aashower reconstruction.
 *
 * \param  evt            event
 * \return                true if at least one reconstructed shower; else false
 */
inline bool has_reconstructed_aashower(const Evt& evt)
{
  return ::has_reconstructed_track(evt, has_aashower_fit);
}


/**
 * Get best reconstructed track.\n
 * The track selector corresponds to the function operator <tt>bool selector(const Trk&);</tt> and
 * the track comparator to <tt>bool comparator(const Trk&, const Trk&);</tt>.\n
 * This method throws an exception in case no track is present.\n
 * The method <tt>has_reconstructed_track</tt> can be used to avoid this exception.
 *
 * \param  evt            event
 * \param  selector       track selector
 * \param  comparator     track comparator
 * \return                track
 */
template<class JTrackSelector_t, class JQualitySorter_t>
inline const Trk& get_best_reconstructed_track(const Evt&       evt,
					       JTrackSelector_t selector,
					       JQualitySorter_t comparator)
{
  std::vector<Trk>::const_iterator p = std::find_if(evt.trks.begin(), evt.trks.end(), selector);

  for (std::vector<Trk>::const_iterator i = p; i != evt.trks.end(); ++i) {
    if (selector(*i) && comparator(*i, *p)) {
      p = i;
    }
  }

  if (p != evt.trks.end())
    return *p;
  else
    THROW(Exception, "This event has no reconstructed track with given selector.");
}


/**
 * Get best reconstructed track.
 *
 * \param  evt            event
 * \param  range          range of application types
 * \return                track
 */
template<int reconstruction_type>
inline const Trk& get_best_reconstructed_track(const Evt& evt, const rec_stages_range range = rec_stages_range())
{
  return get_best_reconstructed_track(evt, ::has_history(reconstruction_type, range), quality_sorter<reconstruction_type>());
}


/**
 * Get best reconstructed muon.
 *
 * \param  evt            event
 * \return                track
 */
inline const Trk& get_best_reconstructed_jppmuon(const Evt& evt)
{
  return get_best_reconstructed_track(evt, has_jppmuon_fit, quality_sorter<JPP_RECONSTRUCTION_TYPE>());
}


/**
 * Get best reconstructed shower.
 *
 * \param  evt            event
 * \return                track
 */
inline const Trk& get_best_reconstructed_jppshower(const Evt& evt)
{
  return get_best_reconstructed_track(evt, ::has_shower_fit, quality_sorter<JPP_RECONSTRUCTION_TYPE>());
}


/**
 * Get best reconstructed aashower.
 *
 * \param  evt            event
 * \return                track
 */
inline const Trk& get_best_reconstructed_aashower(const Evt& evt)
{
  return get_best_reconstructed_track(evt, ::has_aashower_fit, quality_sorter<AANET_RECONSTRUCTION_TYPE>());
}

#endif
#ifndef __TOOLS__TIME_CONVERTER__
#define __TOOLS__TIME_CONVERTER__

#include "km3net-dataformat/offline/Evt.hh"
#include "km3net-dataformat/online/JDAQClock.hh"
#include "km3net-dataformat/online/JDAQChronometer.hh"


/**
 * \file
 * Auxiliary include file for time conversion between DAQ/trigger hit and Monte Carlo hit.
 *
 * \author mdejong
 */

/**
 * Auxiliary class to convert DAQ hit time to/from Monte Carlo hit time. 
 */
class time_converter
{
public:
  /**
   * Default constructor.
   */
  time_converter() :
    __t0(0.0),
    __t1(0.0)
  {}


  /**
   * Constructor.
   * Note that this constructor should only be used after incorporation of KM3NETDAQ::JDAQEvent.
   *
   * \param  event         event
   */
  time_converter(const Evt& event) :
    __t0(event.mc_t),
    __t1(getTimeOfRTS(event.frame_index))
  {}


  /**
   * Constructor.
   *
   * \param  event         Monte Carlo event
   * \param  chronometer   DAQ chronometer
   */
  time_converter(const Evt&             event,
		 const JDAQChronometer& chronometer) :
    __t0(event.mc_t),
    __t1(getTimeOfRTS(chronometer))
  {}


  /**
   * Get DAQ/trigger time minus Monte Carlo time. 
   *
   * \return               time difference [ns]
   */
  double getTime() const
  {
    return __t1 - __t0;
  }


  /**
   * Get Monte Carlo time minus DAQ/trigger time.
   *
   * \return               time difference [ns]
   */
  double putTime() const
  {
    return __t0 - __t1;
  }


  /**
   * Get Monte Carlo hit time.
   *
   * \param  t0            DAQ/trigger hit time [ns]
   * \return               Monte Carlo hit time [ns]
   */
  double getTime(const double t0) const
  {
    return t0 + __t1 - __t0;
  }


  /**
   * Get DAQ hit time.
   *
   * \param  t0            Monte Carlo hit time [ns]
   * \return               DAQ/trigger hit time [ns]
   */
  double putTime(const double t0) const
  {
    return t0 - __t1 + __t0;
  }

protected:
  double __t0;   // Monte Carlo event time [ns]
  double __t1;   // DAQ RTS [ns]
};

#endif

#undef  _BACKWARD_BACKWARD_WARNING_H
)DICTPAYLOAD";
    static const char* classesHeaders[] = {
"AAObject", payloadCode, "@",
"Evt", payloadCode, "@",
"Head", payloadCode, "@",
"Hit", payloadCode, "@",
"Hit::fgIsA", payloadCode, "@",
"KM3NETDAQ::JDAQAbstractPreamble", payloadCode, "@",
"KM3NETDAQ::JDAQChronometer", payloadCode, "@",
"KM3NETDAQ::JDAQEvent", payloadCode, "@",
"KM3NETDAQ::JDAQEventHeader", payloadCode, "@",
"KM3NETDAQ::JDAQFrame", payloadCode, "@",
"KM3NETDAQ::JDAQFrameStatus", payloadCode, "@",
"KM3NETDAQ::JDAQHeader", payloadCode, "@",
"KM3NETDAQ::JDAQHit", payloadCode, "@",
"KM3NETDAQ::JDAQKeyHit", payloadCode, "@",
"KM3NETDAQ::JDAQModuleIdentifier", payloadCode, "@",
"KM3NETDAQ::JDAQPMTIdentifier", payloadCode, "@",
"KM3NETDAQ::JDAQPreamble", payloadCode, "@",
"KM3NETDAQ::JDAQRate", payloadCode, "@",
"KM3NETDAQ::JDAQSummaryFrame", payloadCode, "@",
"KM3NETDAQ::JDAQSummaryslice", payloadCode, "@",
"KM3NETDAQ::JDAQSummarysliceHeader", payloadCode, "@",
"KM3NETDAQ::JDAQSuperFrame", payloadCode, "@",
"KM3NETDAQ::JDAQSuperFrameHeader", payloadCode, "@",
"KM3NETDAQ::JDAQTimeslice", payloadCode, "@",
"KM3NETDAQ::JDAQTimesliceHeader", payloadCode, "@",
"KM3NETDAQ::JDAQTimesliceL0", payloadCode, "@",
"KM3NETDAQ::JDAQTimesliceL1", payloadCode, "@",
"KM3NETDAQ::JDAQTimesliceL2", payloadCode, "@",
"KM3NETDAQ::JDAQTimesliceSN", payloadCode, "@",
"KM3NETDAQ::JDAQTriggerCounter", payloadCode, "@",
"KM3NETDAQ::JDAQTriggerMask", payloadCode, "@",
"KM3NETDAQ::JDAQTriggeredHit", payloadCode, "@",
"KM3NETDAQ::JDAQUTCExtended", payloadCode, "@",
"MultiHead", payloadCode, "@",
"Trk", payloadCode, "@",
"Trk::fgIsA", payloadCode, "@",
"Vec", payloadCode, "@",
"Vec::fgIsA", payloadCode, "@",
"angle_between", payloadCode, "@",
"cos_angle_between", payloadCode, "@",
"operator*", payloadCode, "@",
"operator+", payloadCode, "@",
"operator-", payloadCode, "@",
"operator/", payloadCode, "@",
"operator<<", payloadCode, "@",
"operator>>", payloadCode, "@",
nullptr
};
    static bool isInitialized = false;
    if (!isInitialized) {
      TROOT::RegisterModule("KM3NeTDictionary",
        headers, includePaths, payloadCode, fwdDeclCode,
        TriggerDictionaryInitialization_KM3NeTDictionary_Impl, {}, classesHeaders, /*hasCxxModule*/false);
      isInitialized = true;
    }
  }
  static struct DictInit {
    DictInit() {
      TriggerDictionaryInitialization_KM3NeTDictionary_Impl();
    }
  } __TheDictionaryInitializer;
}
void TriggerDictionaryInitialization_KM3NeTDictionary() {
  TriggerDictionaryInitialization_KM3NeTDictionary_Impl();
}