Jpp 20.0.0-rc.2
the software that should make you happy
Loading...
Searching...
No Matches
G__KM3NeTROOT.cc
Go to the documentation of this file.
1// Do NOT change. Changes will be lost next time file is generated
2
3#define R__DICTIONARY_FILENAME G__KM3NeTROOT
4#define R__NO_DEPRECATION
5
6/*******************************************************************/
7#include <stddef.h>
8#include <stdio.h>
9#include <stdlib.h>
10#include <string.h>
11#include <assert.h>
12#define G__DICTIONARY
13#include "ROOT/RConfig.hxx"
14#include "TClass.h"
15#include "TDictAttributeMap.h"
16#include "TInterpreter.h"
17#include "TROOT.h"
18#include "TBuffer.h"
19#include "TMemberInspector.h"
20#include "TInterpreter.h"
21#include "TVirtualMutex.h"
22#include "TError.h"
23
24#ifndef G__ROOT
25#define G__ROOT
26#endif
27
28#include "RtypesImp.h"
29#include "TIsAProxy.h"
30#include "TFileMergeInfo.h"
31#include <algorithm>
32#include "TCollectionProxyInfo.h"
33/*******************************************************************/
34
35#include "TDataMember.h"
36
37// Header files passed as explicit arguments
38#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQ.hh"
39#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQAbstractPreamble.hh"
40#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQChronometer.hh"
41#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQClock.hh"
42#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQDataTypes.hh"
43#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQEvent.hh"
44#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQEventHeader.hh"
45#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQException.hh"
46#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQFrame.hh"
47#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQFrameStatus.hh"
48#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQHeader.hh"
49#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQHit.hh"
50#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQKeyHit.hh"
51#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQModuleIdentifier.hh"
52#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQPMTIdentifier.hh"
53#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQPreamble.hh"
54#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQPrint.hh"
55#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQRoot.hh"
56#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQSummaryFrame.hh"
57#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQSummaryslice.hh"
58#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQSummarysliceHeader.hh"
59#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQSuperFrame.hh"
60#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQSuperFrameHeader.hh"
61#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQTimeslice.hh"
62#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQTimesliceHeader.hh"
63#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQTriggerCounter.hh"
64#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQTriggerMask.hh"
65#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQTriggeredHit.hh"
66#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/online/JDAQUTCExtended.hh"
67#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/offline/AAObject.hh"
68#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/offline/Evt.hh"
69#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/offline/Exception.hh"
70#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/offline/Head.hh"
71#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/offline/Hit.hh"
72#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/offline/MultiHead.hh"
73#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/offline/Trk.hh"
74#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/offline/Vec.hh"
75#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/offline/io_ascii.hh"
76#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/offline/io_online.hh"
77#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/tools/multiplicity.hh"
78#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/tools/reconstruction.hh"
79#include "/builds/common/jpp/externals/km3net-dataformat/build/km3net-dataformat/tools/time_converter.hh"
80
81// Header files passed via #pragma extra_include
82
83// The generated code does not explicitly qualify STL entities
84namespace std {} using namespace std;
85
86namespace ROOT {
87 static void *new_KM3NETDAQcLcLJDAQAbstractPreamble(void *p = nullptr);
88 static void *newArray_KM3NETDAQcLcLJDAQAbstractPreamble(Long_t size, void *p);
89 static void delete_KM3NETDAQcLcLJDAQAbstractPreamble(void *p);
90 static void deleteArray_KM3NETDAQcLcLJDAQAbstractPreamble(void *p);
91 static void destruct_KM3NETDAQcLcLJDAQAbstractPreamble(void *p);
92 static void streamer_KM3NETDAQcLcLJDAQAbstractPreamble(TBuffer &buf, void *obj);
93
94 // Function generating the singleton type initializer
95 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQAbstractPreamble*)
96 {
97 ::KM3NETDAQ::JDAQAbstractPreamble *ptr = nullptr;
98 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQAbstractPreamble >(nullptr);
99 static ::ROOT::TGenericClassInfo
100 instance("KM3NETDAQ::JDAQAbstractPreamble", ::KM3NETDAQ::JDAQAbstractPreamble::Class_Version(), "", 306,
101 typeid(::KM3NETDAQ::JDAQAbstractPreamble), ::ROOT::Internal::DefineBehavior(ptr, ptr),
102 &::KM3NETDAQ::JDAQAbstractPreamble::Dictionary, isa_proxy, 17,
103 sizeof(::KM3NETDAQ::JDAQAbstractPreamble) );
104 instance.SetNew(&new_KM3NETDAQcLcLJDAQAbstractPreamble);
105 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQAbstractPreamble);
106 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQAbstractPreamble);
107 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQAbstractPreamble);
108 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQAbstractPreamble);
109 instance.SetStreamerFunc(&streamer_KM3NETDAQcLcLJDAQAbstractPreamble);
110 return &instance;
111 }
112 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQAbstractPreamble*)
113 {
114 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQAbstractPreamble*>(nullptr));
115 }
116 // Static variable to force the class initialization
117 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQAbstractPreamble*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
118} // end of namespace ROOT
119
120namespace ROOT {
121 static void *new_KM3NETDAQcLcLJDAQUTCExtended(void *p = nullptr);
122 static void *newArray_KM3NETDAQcLcLJDAQUTCExtended(Long_t size, void *p);
123 static void delete_KM3NETDAQcLcLJDAQUTCExtended(void *p);
124 static void deleteArray_KM3NETDAQcLcLJDAQUTCExtended(void *p);
125 static void destruct_KM3NETDAQcLcLJDAQUTCExtended(void *p);
126
127 // Function generating the singleton type initializer
128 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQUTCExtended*)
129 {
130 ::KM3NETDAQ::JDAQUTCExtended *ptr = nullptr;
131 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQUTCExtended >(nullptr);
132 static ::ROOT::TGenericClassInfo
133 instance("KM3NETDAQ::JDAQUTCExtended", ::KM3NETDAQ::JDAQUTCExtended::Class_Version(), "km3net-dataformat/online/JDAQUTCExtended.hh", 22,
134 typeid(::KM3NETDAQ::JDAQUTCExtended), ::ROOT::Internal::DefineBehavior(ptr, ptr),
135 &::KM3NETDAQ::JDAQUTCExtended::Dictionary, isa_proxy, 4,
136 sizeof(::KM3NETDAQ::JDAQUTCExtended) );
137 instance.SetNew(&new_KM3NETDAQcLcLJDAQUTCExtended);
138 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQUTCExtended);
139 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQUTCExtended);
140 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQUTCExtended);
141 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQUTCExtended);
142 return &instance;
143 }
144 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQUTCExtended*)
145 {
146 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQUTCExtended*>(nullptr));
147 }
148 // Static variable to force the class initialization
149 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQUTCExtended*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
150} // end of namespace ROOT
151
152namespace ROOT {
153 static void *new_KM3NETDAQcLcLJDAQChronometer(void *p = nullptr);
154 static void *newArray_KM3NETDAQcLcLJDAQChronometer(Long_t size, void *p);
155 static void delete_KM3NETDAQcLcLJDAQChronometer(void *p);
156 static void deleteArray_KM3NETDAQcLcLJDAQChronometer(void *p);
157 static void destruct_KM3NETDAQcLcLJDAQChronometer(void *p);
158
159 // Function generating the singleton type initializer
160 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQChronometer*)
161 {
162 ::KM3NETDAQ::JDAQChronometer *ptr = nullptr;
163 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQChronometer >(nullptr);
164 static ::ROOT::TGenericClassInfo
165 instance("KM3NETDAQ::JDAQChronometer", ::KM3NETDAQ::JDAQChronometer::Class_Version(), "", 381,
166 typeid(::KM3NETDAQ::JDAQChronometer), ::ROOT::Internal::DefineBehavior(ptr, ptr),
167 &::KM3NETDAQ::JDAQChronometer::Dictionary, isa_proxy, 4,
168 sizeof(::KM3NETDAQ::JDAQChronometer) );
169 instance.SetNew(&new_KM3NETDAQcLcLJDAQChronometer);
170 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQChronometer);
171 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQChronometer);
172 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQChronometer);
173 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQChronometer);
174 return &instance;
175 }
176 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQChronometer*)
177 {
178 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQChronometer*>(nullptr));
179 }
180 // Static variable to force the class initialization
181 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQChronometer*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
182} // end of namespace ROOT
183
184namespace ROOT {
185 static void *new_KM3NETDAQcLcLJDAQPreamble(void *p = nullptr);
186 static void *newArray_KM3NETDAQcLcLJDAQPreamble(Long_t size, void *p);
187 static void delete_KM3NETDAQcLcLJDAQPreamble(void *p);
188 static void deleteArray_KM3NETDAQcLcLJDAQPreamble(void *p);
189 static void destruct_KM3NETDAQcLcLJDAQPreamble(void *p);
190 static void streamer_KM3NETDAQcLcLJDAQPreamble(TBuffer &buf, void *obj);
191
192 // Function generating the singleton type initializer
193 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQPreamble*)
194 {
195 ::KM3NETDAQ::JDAQPreamble *ptr = nullptr;
196 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQPreamble >(nullptr);
197 static ::ROOT::TGenericClassInfo
198 instance("KM3NETDAQ::JDAQPreamble", ::KM3NETDAQ::JDAQPreamble::Class_Version(), "km3net-dataformat/online/JDAQPreamble.hh", 26,
199 typeid(::KM3NETDAQ::JDAQPreamble), ::ROOT::Internal::DefineBehavior(ptr, ptr),
200 &::KM3NETDAQ::JDAQPreamble::Dictionary, isa_proxy, 17,
201 sizeof(::KM3NETDAQ::JDAQPreamble) );
202 instance.SetNew(&new_KM3NETDAQcLcLJDAQPreamble);
203 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQPreamble);
204 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQPreamble);
205 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQPreamble);
206 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQPreamble);
207 instance.SetStreamerFunc(&streamer_KM3NETDAQcLcLJDAQPreamble);
208 return &instance;
209 }
210 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQPreamble*)
211 {
212 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQPreamble*>(nullptr));
213 }
214 // Static variable to force the class initialization
215 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQPreamble*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
216} // end of namespace ROOT
217
218namespace ROOT {
219 static void *new_KM3NETDAQcLcLJDAQHeader(void *p = nullptr);
220 static void *newArray_KM3NETDAQcLcLJDAQHeader(Long_t size, void *p);
221 static void delete_KM3NETDAQcLcLJDAQHeader(void *p);
222 static void deleteArray_KM3NETDAQcLcLJDAQHeader(void *p);
223 static void destruct_KM3NETDAQcLcLJDAQHeader(void *p);
224
225 // Function generating the singleton type initializer
226 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQHeader*)
227 {
228 ::KM3NETDAQ::JDAQHeader *ptr = nullptr;
229 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQHeader >(nullptr);
230 static ::ROOT::TGenericClassInfo
231 instance("KM3NETDAQ::JDAQHeader", ::KM3NETDAQ::JDAQHeader::Class_Version(), "km3net-dataformat/online/JDAQHeader.hh", 17,
232 typeid(::KM3NETDAQ::JDAQHeader), ::ROOT::Internal::DefineBehavior(ptr, ptr),
233 &::KM3NETDAQ::JDAQHeader::Dictionary, isa_proxy, 4,
234 sizeof(::KM3NETDAQ::JDAQHeader) );
235 instance.SetNew(&new_KM3NETDAQcLcLJDAQHeader);
236 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQHeader);
237 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQHeader);
238 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQHeader);
239 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQHeader);
240 return &instance;
241 }
242 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQHeader*)
243 {
244 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQHeader*>(nullptr));
245 }
246 // Static variable to force the class initialization
247 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQHeader*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
248} // end of namespace ROOT
249
250namespace ROOT {
251 static void *new_KM3NETDAQcLcLJDAQTriggerCounter(void *p = nullptr);
252 static void *newArray_KM3NETDAQcLcLJDAQTriggerCounter(Long_t size, void *p);
253 static void delete_KM3NETDAQcLcLJDAQTriggerCounter(void *p);
254 static void deleteArray_KM3NETDAQcLcLJDAQTriggerCounter(void *p);
255 static void destruct_KM3NETDAQcLcLJDAQTriggerCounter(void *p);
256
257 // Function generating the singleton type initializer
258 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQTriggerCounter*)
259 {
260 ::KM3NETDAQ::JDAQTriggerCounter *ptr = nullptr;
261 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQTriggerCounter >(nullptr);
262 static ::ROOT::TGenericClassInfo
263 instance("KM3NETDAQ::JDAQTriggerCounter", ::KM3NETDAQ::JDAQTriggerCounter::Class_Version(), "km3net-dataformat/online/JDAQTriggerCounter.hh", 23,
264 typeid(::KM3NETDAQ::JDAQTriggerCounter), ::ROOT::Internal::DefineBehavior(ptr, ptr),
265 &::KM3NETDAQ::JDAQTriggerCounter::Dictionary, isa_proxy, 4,
266 sizeof(::KM3NETDAQ::JDAQTriggerCounter) );
267 instance.SetNew(&new_KM3NETDAQcLcLJDAQTriggerCounter);
268 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQTriggerCounter);
269 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQTriggerCounter);
270 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQTriggerCounter);
271 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQTriggerCounter);
272 return &instance;
273 }
274 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQTriggerCounter*)
275 {
276 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQTriggerCounter*>(nullptr));
277 }
278 // Static variable to force the class initialization
279 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQTriggerCounter*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
280} // end of namespace ROOT
281
282namespace ROOT {
283 static void *new_KM3NETDAQcLcLJDAQTriggerMask(void *p = nullptr);
284 static void *newArray_KM3NETDAQcLcLJDAQTriggerMask(Long_t size, void *p);
285 static void delete_KM3NETDAQcLcLJDAQTriggerMask(void *p);
286 static void deleteArray_KM3NETDAQcLcLJDAQTriggerMask(void *p);
287 static void destruct_KM3NETDAQcLcLJDAQTriggerMask(void *p);
288
289 // Function generating the singleton type initializer
290 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQTriggerMask*)
291 {
292 ::KM3NETDAQ::JDAQTriggerMask *ptr = nullptr;
293 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQTriggerMask >(nullptr);
294 static ::ROOT::TGenericClassInfo
295 instance("KM3NETDAQ::JDAQTriggerMask", ::KM3NETDAQ::JDAQTriggerMask::Class_Version(), "km3net-dataformat/online/JDAQTriggerMask.hh", 48,
296 typeid(::KM3NETDAQ::JDAQTriggerMask), ::ROOT::Internal::DefineBehavior(ptr, ptr),
297 &::KM3NETDAQ::JDAQTriggerMask::Dictionary, isa_proxy, 4,
298 sizeof(::KM3NETDAQ::JDAQTriggerMask) );
299 instance.SetNew(&new_KM3NETDAQcLcLJDAQTriggerMask);
300 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQTriggerMask);
301 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQTriggerMask);
302 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQTriggerMask);
303 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQTriggerMask);
304 return &instance;
305 }
306 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQTriggerMask*)
307 {
308 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQTriggerMask*>(nullptr));
309 }
310 // Static variable to force the class initialization
311 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQTriggerMask*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
312} // end of namespace ROOT
313
314namespace ROOT {
315 static void *new_KM3NETDAQcLcLJDAQEventHeader(void *p = nullptr);
316 static void *newArray_KM3NETDAQcLcLJDAQEventHeader(Long_t size, void *p);
317 static void delete_KM3NETDAQcLcLJDAQEventHeader(void *p);
318 static void deleteArray_KM3NETDAQcLcLJDAQEventHeader(void *p);
319 static void destruct_KM3NETDAQcLcLJDAQEventHeader(void *p);
320
321 // Function generating the singleton type initializer
322 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQEventHeader*)
323 {
324 ::KM3NETDAQ::JDAQEventHeader *ptr = nullptr;
325 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQEventHeader >(nullptr);
326 static ::ROOT::TGenericClassInfo
327 instance("KM3NETDAQ::JDAQEventHeader", ::KM3NETDAQ::JDAQEventHeader::Class_Version(), "km3net-dataformat/online/JDAQEventHeader.hh", 19,
328 typeid(::KM3NETDAQ::JDAQEventHeader), ::ROOT::Internal::DefineBehavior(ptr, ptr),
329 &::KM3NETDAQ::JDAQEventHeader::Dictionary, isa_proxy, 4,
330 sizeof(::KM3NETDAQ::JDAQEventHeader) );
331 instance.SetNew(&new_KM3NETDAQcLcLJDAQEventHeader);
332 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQEventHeader);
333 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQEventHeader);
334 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQEventHeader);
335 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQEventHeader);
336 return &instance;
337 }
338 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQEventHeader*)
339 {
340 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQEventHeader*>(nullptr));
341 }
342 // Static variable to force the class initialization
343 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQEventHeader*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
344} // end of namespace ROOT
345
346namespace ROOT {
347 static void *new_KM3NETDAQcLcLJDAQHit(void *p = nullptr);
348 static void *newArray_KM3NETDAQcLcLJDAQHit(Long_t size, void *p);
349 static void delete_KM3NETDAQcLcLJDAQHit(void *p);
350 static void deleteArray_KM3NETDAQcLcLJDAQHit(void *p);
351 static void destruct_KM3NETDAQcLcLJDAQHit(void *p);
352 static void streamer_KM3NETDAQcLcLJDAQHit(TBuffer &buf, void *obj);
353
354 // Function generating the singleton type initializer
355 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQHit*)
356 {
357 ::KM3NETDAQ::JDAQHit *ptr = nullptr;
358 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQHit >(nullptr);
359 static ::ROOT::TGenericClassInfo
360 instance("KM3NETDAQ::JDAQHit", ::KM3NETDAQ::JDAQHit::Class_Version(), "km3net-dataformat/online/JDAQHit.hh", 34,
361 typeid(::KM3NETDAQ::JDAQHit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
362 &::KM3NETDAQ::JDAQHit::Dictionary, isa_proxy, 17,
363 sizeof(::KM3NETDAQ::JDAQHit) );
364 instance.SetNew(&new_KM3NETDAQcLcLJDAQHit);
365 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQHit);
366 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQHit);
367 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQHit);
368 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQHit);
369 instance.SetStreamerFunc(&streamer_KM3NETDAQcLcLJDAQHit);
370 return &instance;
371 }
372 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQHit*)
373 {
374 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQHit*>(nullptr));
375 }
376 // Static variable to force the class initialization
377 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQHit*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
378} // end of namespace ROOT
379
380namespace ROOT {
381 static void *new_KM3NETDAQcLcLJDAQModuleIdentifier(void *p = nullptr);
382 static void *newArray_KM3NETDAQcLcLJDAQModuleIdentifier(Long_t size, void *p);
383 static void delete_KM3NETDAQcLcLJDAQModuleIdentifier(void *p);
384 static void deleteArray_KM3NETDAQcLcLJDAQModuleIdentifier(void *p);
385 static void destruct_KM3NETDAQcLcLJDAQModuleIdentifier(void *p);
386 static void streamer_KM3NETDAQcLcLJDAQModuleIdentifier(TBuffer &buf, void *obj);
387
388 // Function generating the singleton type initializer
389 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQModuleIdentifier*)
390 {
391 ::KM3NETDAQ::JDAQModuleIdentifier *ptr = nullptr;
392 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQModuleIdentifier >(nullptr);
393 static ::ROOT::TGenericClassInfo
394 instance("KM3NETDAQ::JDAQModuleIdentifier", ::KM3NETDAQ::JDAQModuleIdentifier::Class_Version(), "km3net-dataformat/online/JDAQModuleIdentifier.hh", 19,
395 typeid(::KM3NETDAQ::JDAQModuleIdentifier), ::ROOT::Internal::DefineBehavior(ptr, ptr),
396 &::KM3NETDAQ::JDAQModuleIdentifier::Dictionary, isa_proxy, 17,
397 sizeof(::KM3NETDAQ::JDAQModuleIdentifier) );
398 instance.SetNew(&new_KM3NETDAQcLcLJDAQModuleIdentifier);
399 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQModuleIdentifier);
400 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQModuleIdentifier);
401 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQModuleIdentifier);
402 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQModuleIdentifier);
403 instance.SetStreamerFunc(&streamer_KM3NETDAQcLcLJDAQModuleIdentifier);
404 return &instance;
405 }
406 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQModuleIdentifier*)
407 {
408 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQModuleIdentifier*>(nullptr));
409 }
410 // Static variable to force the class initialization
411 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQModuleIdentifier*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
412} // end of namespace ROOT
413
414namespace ROOT {
415 static void *new_KM3NETDAQcLcLJDAQPMTIdentifier(void *p = nullptr);
416 static void *newArray_KM3NETDAQcLcLJDAQPMTIdentifier(Long_t size, void *p);
417 static void delete_KM3NETDAQcLcLJDAQPMTIdentifier(void *p);
418 static void deleteArray_KM3NETDAQcLcLJDAQPMTIdentifier(void *p);
419 static void destruct_KM3NETDAQcLcLJDAQPMTIdentifier(void *p);
420 static void streamer_KM3NETDAQcLcLJDAQPMTIdentifier(TBuffer &buf, void *obj);
421
422 // Function generating the singleton type initializer
423 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQPMTIdentifier*)
424 {
425 ::KM3NETDAQ::JDAQPMTIdentifier *ptr = nullptr;
426 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQPMTIdentifier >(nullptr);
427 static ::ROOT::TGenericClassInfo
428 instance("KM3NETDAQ::JDAQPMTIdentifier", ::KM3NETDAQ::JDAQPMTIdentifier::Class_Version(), "km3net-dataformat/online/JDAQPMTIdentifier.hh", 20,
429 typeid(::KM3NETDAQ::JDAQPMTIdentifier), ::ROOT::Internal::DefineBehavior(ptr, ptr),
430 &::KM3NETDAQ::JDAQPMTIdentifier::Dictionary, isa_proxy, 17,
431 sizeof(::KM3NETDAQ::JDAQPMTIdentifier) );
432 instance.SetNew(&new_KM3NETDAQcLcLJDAQPMTIdentifier);
433 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQPMTIdentifier);
434 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQPMTIdentifier);
435 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQPMTIdentifier);
436 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQPMTIdentifier);
437 instance.SetStreamerFunc(&streamer_KM3NETDAQcLcLJDAQPMTIdentifier);
438 return &instance;
439 }
440 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQPMTIdentifier*)
441 {
442 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQPMTIdentifier*>(nullptr));
443 }
444 // Static variable to force the class initialization
445 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQPMTIdentifier*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
446} // end of namespace ROOT
447
448namespace ROOT {
449 static void *new_KM3NETDAQcLcLJDAQKeyHit(void *p = nullptr);
450 static void *newArray_KM3NETDAQcLcLJDAQKeyHit(Long_t size, void *p);
451 static void delete_KM3NETDAQcLcLJDAQKeyHit(void *p);
452 static void deleteArray_KM3NETDAQcLcLJDAQKeyHit(void *p);
453 static void destruct_KM3NETDAQcLcLJDAQKeyHit(void *p);
454 static void streamer_KM3NETDAQcLcLJDAQKeyHit(TBuffer &buf, void *obj);
455
456 // Function generating the singleton type initializer
457 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQKeyHit*)
458 {
459 ::KM3NETDAQ::JDAQKeyHit *ptr = nullptr;
460 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQKeyHit >(nullptr);
461 static ::ROOT::TGenericClassInfo
462 instance("KM3NETDAQ::JDAQKeyHit", ::KM3NETDAQ::JDAQKeyHit::Class_Version(), "km3net-dataformat/online/JDAQKeyHit.hh", 19,
463 typeid(::KM3NETDAQ::JDAQKeyHit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
464 &::KM3NETDAQ::JDAQKeyHit::Dictionary, isa_proxy, 17,
465 sizeof(::KM3NETDAQ::JDAQKeyHit) );
466 instance.SetNew(&new_KM3NETDAQcLcLJDAQKeyHit);
467 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQKeyHit);
468 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQKeyHit);
469 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQKeyHit);
470 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQKeyHit);
471 instance.SetStreamerFunc(&streamer_KM3NETDAQcLcLJDAQKeyHit);
472 return &instance;
473 }
474 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQKeyHit*)
475 {
476 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQKeyHit*>(nullptr));
477 }
478 // Static variable to force the class initialization
479 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQKeyHit*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
480} // end of namespace ROOT
481
482namespace ROOT {
483 static void *new_KM3NETDAQcLcLJDAQTriggeredHit(void *p = nullptr);
484 static void *newArray_KM3NETDAQcLcLJDAQTriggeredHit(Long_t size, void *p);
485 static void delete_KM3NETDAQcLcLJDAQTriggeredHit(void *p);
486 static void deleteArray_KM3NETDAQcLcLJDAQTriggeredHit(void *p);
487 static void destruct_KM3NETDAQcLcLJDAQTriggeredHit(void *p);
488 static void streamer_KM3NETDAQcLcLJDAQTriggeredHit(TBuffer &buf, void *obj);
489
490 // Function generating the singleton type initializer
491 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQTriggeredHit*)
492 {
493 ::KM3NETDAQ::JDAQTriggeredHit *ptr = nullptr;
494 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQTriggeredHit >(nullptr);
495 static ::ROOT::TGenericClassInfo
496 instance("KM3NETDAQ::JDAQTriggeredHit", ::KM3NETDAQ::JDAQTriggeredHit::Class_Version(), "km3net-dataformat/online/JDAQTriggeredHit.hh", 20,
497 typeid(::KM3NETDAQ::JDAQTriggeredHit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
498 &::KM3NETDAQ::JDAQTriggeredHit::Dictionary, isa_proxy, 17,
499 sizeof(::KM3NETDAQ::JDAQTriggeredHit) );
500 instance.SetNew(&new_KM3NETDAQcLcLJDAQTriggeredHit);
501 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQTriggeredHit);
502 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQTriggeredHit);
503 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQTriggeredHit);
504 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQTriggeredHit);
505 instance.SetStreamerFunc(&streamer_KM3NETDAQcLcLJDAQTriggeredHit);
506 return &instance;
507 }
508 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQTriggeredHit*)
509 {
510 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQTriggeredHit*>(nullptr));
511 }
512 // Static variable to force the class initialization
513 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQTriggeredHit*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
514} // end of namespace ROOT
515
516namespace ROOT {
517 static void *new_KM3NETDAQcLcLJDAQEvent(void *p = nullptr);
518 static void *newArray_KM3NETDAQcLcLJDAQEvent(Long_t size, void *p);
519 static void delete_KM3NETDAQcLcLJDAQEvent(void *p);
520 static void deleteArray_KM3NETDAQcLcLJDAQEvent(void *p);
521 static void destruct_KM3NETDAQcLcLJDAQEvent(void *p);
522
523 // Function generating the singleton type initializer
524 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQEvent*)
525 {
526 ::KM3NETDAQ::JDAQEvent *ptr = nullptr;
527 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQEvent >(nullptr);
528 static ::ROOT::TGenericClassInfo
529 instance("KM3NETDAQ::JDAQEvent", ::KM3NETDAQ::JDAQEvent::Class_Version(), "", 1059,
530 typeid(::KM3NETDAQ::JDAQEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
531 &::KM3NETDAQ::JDAQEvent::Dictionary, isa_proxy, 4,
532 sizeof(::KM3NETDAQ::JDAQEvent) );
533 instance.SetNew(&new_KM3NETDAQcLcLJDAQEvent);
534 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQEvent);
535 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQEvent);
536 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQEvent);
537 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQEvent);
538 return &instance;
539 }
540 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQEvent*)
541 {
542 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQEvent*>(nullptr));
543 }
544 // Static variable to force the class initialization
545 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQEvent*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
546} // end of namespace ROOT
547
548namespace ROOT {
549 static void *new_KM3NETDAQcLcLJDAQFrame(void *p = nullptr);
550 static void *newArray_KM3NETDAQcLcLJDAQFrame(Long_t size, void *p);
551 static void delete_KM3NETDAQcLcLJDAQFrame(void *p);
552 static void deleteArray_KM3NETDAQcLcLJDAQFrame(void *p);
553 static void destruct_KM3NETDAQcLcLJDAQFrame(void *p);
554
555 // Function generating the singleton type initializer
556 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQFrame*)
557 {
558 ::KM3NETDAQ::JDAQFrame *ptr = nullptr;
559 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQFrame >(nullptr);
560 static ::ROOT::TGenericClassInfo
561 instance("KM3NETDAQ::JDAQFrame", ::KM3NETDAQ::JDAQFrame::Class_Version(), "", 1595,
562 typeid(::KM3NETDAQ::JDAQFrame), ::ROOT::Internal::DefineBehavior(ptr, ptr),
563 &::KM3NETDAQ::JDAQFrame::Dictionary, isa_proxy, 4,
564 sizeof(::KM3NETDAQ::JDAQFrame) );
565 instance.SetNew(&new_KM3NETDAQcLcLJDAQFrame);
566 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQFrame);
567 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQFrame);
568 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQFrame);
569 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQFrame);
570 return &instance;
571 }
572 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQFrame*)
573 {
574 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQFrame*>(nullptr));
575 }
576 // Static variable to force the class initialization
577 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQFrame*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
578} // end of namespace ROOT
579
580namespace ROOT {
581 static void *new_KM3NETDAQcLcLJDAQFrameStatus(void *p = nullptr);
582 static void *newArray_KM3NETDAQcLcLJDAQFrameStatus(Long_t size, void *p);
583 static void delete_KM3NETDAQcLcLJDAQFrameStatus(void *p);
584 static void deleteArray_KM3NETDAQcLcLJDAQFrameStatus(void *p);
585 static void destruct_KM3NETDAQcLcLJDAQFrameStatus(void *p);
586
587 // Function generating the singleton type initializer
588 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQFrameStatus*)
589 {
590 ::KM3NETDAQ::JDAQFrameStatus *ptr = nullptr;
591 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQFrameStatus >(nullptr);
592 static ::ROOT::TGenericClassInfo
593 instance("KM3NETDAQ::JDAQFrameStatus", ::KM3NETDAQ::JDAQFrameStatus::Class_Version(), "", 1883,
594 typeid(::KM3NETDAQ::JDAQFrameStatus), ::ROOT::Internal::DefineBehavior(ptr, ptr),
595 &::KM3NETDAQ::JDAQFrameStatus::Dictionary, isa_proxy, 4,
596 sizeof(::KM3NETDAQ::JDAQFrameStatus) );
597 instance.SetNew(&new_KM3NETDAQcLcLJDAQFrameStatus);
598 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQFrameStatus);
599 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQFrameStatus);
600 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQFrameStatus);
601 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQFrameStatus);
602 return &instance;
603 }
604 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQFrameStatus*)
605 {
606 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQFrameStatus*>(nullptr));
607 }
608 // Static variable to force the class initialization
609 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQFrameStatus*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
610} // end of namespace ROOT
611
612namespace ROOT {
613 static void *new_KM3NETDAQcLcLJDAQSuperFrameHeader(void *p = nullptr);
614 static void *newArray_KM3NETDAQcLcLJDAQSuperFrameHeader(Long_t size, void *p);
615 static void delete_KM3NETDAQcLcLJDAQSuperFrameHeader(void *p);
616 static void deleteArray_KM3NETDAQcLcLJDAQSuperFrameHeader(void *p);
617 static void destruct_KM3NETDAQcLcLJDAQSuperFrameHeader(void *p);
618
619 // Function generating the singleton type initializer
620 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQSuperFrameHeader*)
621 {
622 ::KM3NETDAQ::JDAQSuperFrameHeader *ptr = nullptr;
623 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQSuperFrameHeader >(nullptr);
624 static ::ROOT::TGenericClassInfo
625 instance("KM3NETDAQ::JDAQSuperFrameHeader", ::KM3NETDAQ::JDAQSuperFrameHeader::Class_Version(), "km3net-dataformat/online/JDAQSuperFrameHeader.hh", 19,
626 typeid(::KM3NETDAQ::JDAQSuperFrameHeader), ::ROOT::Internal::DefineBehavior(ptr, ptr),
627 &::KM3NETDAQ::JDAQSuperFrameHeader::Dictionary, isa_proxy, 4,
628 sizeof(::KM3NETDAQ::JDAQSuperFrameHeader) );
629 instance.SetNew(&new_KM3NETDAQcLcLJDAQSuperFrameHeader);
630 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQSuperFrameHeader);
631 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQSuperFrameHeader);
632 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQSuperFrameHeader);
633 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQSuperFrameHeader);
634 return &instance;
635 }
636 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQSuperFrameHeader*)
637 {
638 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQSuperFrameHeader*>(nullptr));
639 }
640 // Static variable to force the class initialization
641 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQSuperFrameHeader*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
642} // end of namespace ROOT
643
644namespace ROOT {
645 static void *new_KM3NETDAQcLcLJDAQSuperFrame(void *p = nullptr);
646 static void *newArray_KM3NETDAQcLcLJDAQSuperFrame(Long_t size, void *p);
647 static void delete_KM3NETDAQcLcLJDAQSuperFrame(void *p);
648 static void deleteArray_KM3NETDAQcLcLJDAQSuperFrame(void *p);
649 static void destruct_KM3NETDAQcLcLJDAQSuperFrame(void *p);
650
651 // Function generating the singleton type initializer
652 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQSuperFrame*)
653 {
654 ::KM3NETDAQ::JDAQSuperFrame *ptr = nullptr;
655 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQSuperFrame >(nullptr);
656 static ::ROOT::TGenericClassInfo
657 instance("KM3NETDAQ::JDAQSuperFrame", ::KM3NETDAQ::JDAQSuperFrame::Class_Version(), "km3net-dataformat/online/JDAQSuperFrame.hh", 22,
658 typeid(::KM3NETDAQ::JDAQSuperFrame), ::ROOT::Internal::DefineBehavior(ptr, ptr),
659 &::KM3NETDAQ::JDAQSuperFrame::Dictionary, isa_proxy, 4,
660 sizeof(::KM3NETDAQ::JDAQSuperFrame) );
661 instance.SetNew(&new_KM3NETDAQcLcLJDAQSuperFrame);
662 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQSuperFrame);
663 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQSuperFrame);
664 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQSuperFrame);
665 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQSuperFrame);
666 return &instance;
667 }
668 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQSuperFrame*)
669 {
670 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQSuperFrame*>(nullptr));
671 }
672 // Static variable to force the class initialization
673 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQSuperFrame*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
674} // end of namespace ROOT
675
676namespace ROOT {
677 static TClass *KM3NETDAQcLcLJDAQRate_Dictionary();
678 static void KM3NETDAQcLcLJDAQRate_TClassManip(TClass*);
679 static void *new_KM3NETDAQcLcLJDAQRate(void *p = nullptr);
680 static void *newArray_KM3NETDAQcLcLJDAQRate(Long_t size, void *p);
681 static void delete_KM3NETDAQcLcLJDAQRate(void *p);
682 static void deleteArray_KM3NETDAQcLcLJDAQRate(void *p);
683 static void destruct_KM3NETDAQcLcLJDAQRate(void *p);
684
685 // Function generating the singleton type initializer
686 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQRate*)
687 {
688 ::KM3NETDAQ::JDAQRate *ptr = nullptr;
689 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::KM3NETDAQ::JDAQRate));
690 static ::ROOT::TGenericClassInfo
691 instance("KM3NETDAQ::JDAQRate", "", 3317,
692 typeid(::KM3NETDAQ::JDAQRate), ::ROOT::Internal::DefineBehavior(ptr, ptr),
693 &KM3NETDAQcLcLJDAQRate_Dictionary, isa_proxy, 4,
694 sizeof(::KM3NETDAQ::JDAQRate) );
695 instance.SetNew(&new_KM3NETDAQcLcLJDAQRate);
696 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQRate);
697 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQRate);
698 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQRate);
699 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQRate);
700 return &instance;
701 }
702 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQRate*)
703 {
704 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQRate*>(nullptr));
705 }
706 // Static variable to force the class initialization
707 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQRate*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
708
709 // Dictionary for non-ClassDef classes
710 static TClass *KM3NETDAQcLcLJDAQRate_Dictionary() {
711 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQRate*>(nullptr))->GetClass();
712 KM3NETDAQcLcLJDAQRate_TClassManip(theClass);
713 return theClass;
714 }
715
716 static void KM3NETDAQcLcLJDAQRate_TClassManip(TClass* ){
717 }
718
719} // end of namespace ROOT
720
721namespace ROOT {
722 static void *new_KM3NETDAQcLcLJDAQSummaryFrame(void *p = nullptr);
723 static void *newArray_KM3NETDAQcLcLJDAQSummaryFrame(Long_t size, void *p);
724 static void delete_KM3NETDAQcLcLJDAQSummaryFrame(void *p);
725 static void deleteArray_KM3NETDAQcLcLJDAQSummaryFrame(void *p);
726 static void destruct_KM3NETDAQcLcLJDAQSummaryFrame(void *p);
727 static void streamer_KM3NETDAQcLcLJDAQSummaryFrame(TBuffer &buf, void *obj);
728
729 // Function generating the singleton type initializer
730 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQSummaryFrame*)
731 {
732 ::KM3NETDAQ::JDAQSummaryFrame *ptr = nullptr;
733 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQSummaryFrame >(nullptr);
734 static ::ROOT::TGenericClassInfo
735 instance("KM3NETDAQ::JDAQSummaryFrame", ::KM3NETDAQ::JDAQSummaryFrame::Class_Version(), "", 3613,
736 typeid(::KM3NETDAQ::JDAQSummaryFrame), ::ROOT::Internal::DefineBehavior(ptr, ptr),
737 &::KM3NETDAQ::JDAQSummaryFrame::Dictionary, isa_proxy, 17,
738 sizeof(::KM3NETDAQ::JDAQSummaryFrame) );
739 instance.SetNew(&new_KM3NETDAQcLcLJDAQSummaryFrame);
740 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQSummaryFrame);
741 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQSummaryFrame);
742 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQSummaryFrame);
743 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQSummaryFrame);
744 instance.SetStreamerFunc(&streamer_KM3NETDAQcLcLJDAQSummaryFrame);
745 return &instance;
746 }
747 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQSummaryFrame*)
748 {
749 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQSummaryFrame*>(nullptr));
750 }
751 // Static variable to force the class initialization
752 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQSummaryFrame*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
753} // end of namespace ROOT
754
755namespace ROOT {
756 static void *new_KM3NETDAQcLcLJDAQSummarysliceHeader(void *p = nullptr);
757 static void *newArray_KM3NETDAQcLcLJDAQSummarysliceHeader(Long_t size, void *p);
758 static void delete_KM3NETDAQcLcLJDAQSummarysliceHeader(void *p);
759 static void deleteArray_KM3NETDAQcLcLJDAQSummarysliceHeader(void *p);
760 static void destruct_KM3NETDAQcLcLJDAQSummarysliceHeader(void *p);
761
762 // Function generating the singleton type initializer
763 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQSummarysliceHeader*)
764 {
765 ::KM3NETDAQ::JDAQSummarysliceHeader *ptr = nullptr;
766 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQSummarysliceHeader >(nullptr);
767 static ::ROOT::TGenericClassInfo
768 instance("KM3NETDAQ::JDAQSummarysliceHeader", ::KM3NETDAQ::JDAQSummarysliceHeader::Class_Version(), "km3net-dataformat/online/JDAQSummarysliceHeader.hh", 17,
769 typeid(::KM3NETDAQ::JDAQSummarysliceHeader), ::ROOT::Internal::DefineBehavior(ptr, ptr),
770 &::KM3NETDAQ::JDAQSummarysliceHeader::Dictionary, isa_proxy, 4,
771 sizeof(::KM3NETDAQ::JDAQSummarysliceHeader) );
772 instance.SetNew(&new_KM3NETDAQcLcLJDAQSummarysliceHeader);
773 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQSummarysliceHeader);
774 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQSummarysliceHeader);
775 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQSummarysliceHeader);
776 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQSummarysliceHeader);
777 return &instance;
778 }
779 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQSummarysliceHeader*)
780 {
781 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQSummarysliceHeader*>(nullptr));
782 }
783 // Static variable to force the class initialization
784 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQSummarysliceHeader*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
785} // end of namespace ROOT
786
787namespace ROOT {
788 static void *new_KM3NETDAQcLcLJDAQTimesliceHeader(void *p = nullptr);
789 static void *newArray_KM3NETDAQcLcLJDAQTimesliceHeader(Long_t size, void *p);
790 static void delete_KM3NETDAQcLcLJDAQTimesliceHeader(void *p);
791 static void deleteArray_KM3NETDAQcLcLJDAQTimesliceHeader(void *p);
792 static void destruct_KM3NETDAQcLcLJDAQTimesliceHeader(void *p);
793
794 // Function generating the singleton type initializer
795 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQTimesliceHeader*)
796 {
797 ::KM3NETDAQ::JDAQTimesliceHeader *ptr = nullptr;
798 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQTimesliceHeader >(nullptr);
799 static ::ROOT::TGenericClassInfo
800 instance("KM3NETDAQ::JDAQTimesliceHeader", ::KM3NETDAQ::JDAQTimesliceHeader::Class_Version(), "km3net-dataformat/online/JDAQTimesliceHeader.hh", 16,
801 typeid(::KM3NETDAQ::JDAQTimesliceHeader), ::ROOT::Internal::DefineBehavior(ptr, ptr),
802 &::KM3NETDAQ::JDAQTimesliceHeader::Dictionary, isa_proxy, 4,
803 sizeof(::KM3NETDAQ::JDAQTimesliceHeader) );
804 instance.SetNew(&new_KM3NETDAQcLcLJDAQTimesliceHeader);
805 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQTimesliceHeader);
806 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQTimesliceHeader);
807 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQTimesliceHeader);
808 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQTimesliceHeader);
809 return &instance;
810 }
811 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQTimesliceHeader*)
812 {
813 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQTimesliceHeader*>(nullptr));
814 }
815 // Static variable to force the class initialization
816 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQTimesliceHeader*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
817} // end of namespace ROOT
818
819namespace ROOT {
820 static void *new_KM3NETDAQcLcLJDAQTimeslice(void *p = nullptr);
821 static void *newArray_KM3NETDAQcLcLJDAQTimeslice(Long_t size, void *p);
822 static void delete_KM3NETDAQcLcLJDAQTimeslice(void *p);
823 static void deleteArray_KM3NETDAQcLcLJDAQTimeslice(void *p);
824 static void destruct_KM3NETDAQcLcLJDAQTimeslice(void *p);
825
826 // Function generating the singleton type initializer
827 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQTimeslice*)
828 {
829 ::KM3NETDAQ::JDAQTimeslice *ptr = nullptr;
830 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQTimeslice >(nullptr);
831 static ::ROOT::TGenericClassInfo
832 instance("KM3NETDAQ::JDAQTimeslice", ::KM3NETDAQ::JDAQTimeslice::Class_Version(), "km3net-dataformat/online/JDAQTimeslice.hh", 30,
833 typeid(::KM3NETDAQ::JDAQTimeslice), ::ROOT::Internal::DefineBehavior(ptr, ptr),
834 &::KM3NETDAQ::JDAQTimeslice::Dictionary, isa_proxy, 4,
835 sizeof(::KM3NETDAQ::JDAQTimeslice) );
836 instance.SetNew(&new_KM3NETDAQcLcLJDAQTimeslice);
837 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQTimeslice);
838 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQTimeslice);
839 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQTimeslice);
840 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQTimeslice);
841 return &instance;
842 }
843 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQTimeslice*)
844 {
845 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQTimeslice*>(nullptr));
846 }
847 // Static variable to force the class initialization
848 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQTimeslice*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
849} // end of namespace ROOT
850
851namespace ROOT {
852 static void *new_KM3NETDAQcLcLJDAQTimesliceL0(void *p = nullptr);
853 static void *newArray_KM3NETDAQcLcLJDAQTimesliceL0(Long_t size, void *p);
854 static void delete_KM3NETDAQcLcLJDAQTimesliceL0(void *p);
855 static void deleteArray_KM3NETDAQcLcLJDAQTimesliceL0(void *p);
856 static void destruct_KM3NETDAQcLcLJDAQTimesliceL0(void *p);
857
858 // Function generating the singleton type initializer
859 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQTimesliceL0*)
860 {
861 ::KM3NETDAQ::JDAQTimesliceL0 *ptr = nullptr;
862 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQTimesliceL0 >(nullptr);
863 static ::ROOT::TGenericClassInfo
864 instance("KM3NETDAQ::JDAQTimesliceL0", ::KM3NETDAQ::JDAQTimesliceL0::Class_Version(), "km3net-dataformat/online/JDAQTimeslice.hh", 259,
865 typeid(::KM3NETDAQ::JDAQTimesliceL0), ::ROOT::Internal::DefineBehavior(ptr, ptr),
866 &::KM3NETDAQ::JDAQTimesliceL0::Dictionary, isa_proxy, 4,
867 sizeof(::KM3NETDAQ::JDAQTimesliceL0) );
868 instance.SetNew(&new_KM3NETDAQcLcLJDAQTimesliceL0);
869 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQTimesliceL0);
870 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQTimesliceL0);
871 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQTimesliceL0);
872 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQTimesliceL0);
873 return &instance;
874 }
875 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQTimesliceL0*)
876 {
877 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQTimesliceL0*>(nullptr));
878 }
879 // Static variable to force the class initialization
880 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQTimesliceL0*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
881} // end of namespace ROOT
882
883namespace ROOT {
884 static void *new_KM3NETDAQcLcLJDAQTimesliceL1(void *p = nullptr);
885 static void *newArray_KM3NETDAQcLcLJDAQTimesliceL1(Long_t size, void *p);
886 static void delete_KM3NETDAQcLcLJDAQTimesliceL1(void *p);
887 static void deleteArray_KM3NETDAQcLcLJDAQTimesliceL1(void *p);
888 static void destruct_KM3NETDAQcLcLJDAQTimesliceL1(void *p);
889
890 // Function generating the singleton type initializer
891 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQTimesliceL1*)
892 {
893 ::KM3NETDAQ::JDAQTimesliceL1 *ptr = nullptr;
894 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQTimesliceL1 >(nullptr);
895 static ::ROOT::TGenericClassInfo
896 instance("KM3NETDAQ::JDAQTimesliceL1", ::KM3NETDAQ::JDAQTimesliceL1::Class_Version(), "km3net-dataformat/online/JDAQTimeslice.hh", 265,
897 typeid(::KM3NETDAQ::JDAQTimesliceL1), ::ROOT::Internal::DefineBehavior(ptr, ptr),
898 &::KM3NETDAQ::JDAQTimesliceL1::Dictionary, isa_proxy, 4,
899 sizeof(::KM3NETDAQ::JDAQTimesliceL1) );
900 instance.SetNew(&new_KM3NETDAQcLcLJDAQTimesliceL1);
901 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQTimesliceL1);
902 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQTimesliceL1);
903 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQTimesliceL1);
904 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQTimesliceL1);
905 return &instance;
906 }
907 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQTimesliceL1*)
908 {
909 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQTimesliceL1*>(nullptr));
910 }
911 // Static variable to force the class initialization
912 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQTimesliceL1*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
913} // end of namespace ROOT
914
915namespace ROOT {
916 static void *new_KM3NETDAQcLcLJDAQTimesliceL2(void *p = nullptr);
917 static void *newArray_KM3NETDAQcLcLJDAQTimesliceL2(Long_t size, void *p);
918 static void delete_KM3NETDAQcLcLJDAQTimesliceL2(void *p);
919 static void deleteArray_KM3NETDAQcLcLJDAQTimesliceL2(void *p);
920 static void destruct_KM3NETDAQcLcLJDAQTimesliceL2(void *p);
921
922 // Function generating the singleton type initializer
923 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQTimesliceL2*)
924 {
925 ::KM3NETDAQ::JDAQTimesliceL2 *ptr = nullptr;
926 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQTimesliceL2 >(nullptr);
927 static ::ROOT::TGenericClassInfo
928 instance("KM3NETDAQ::JDAQTimesliceL2", ::KM3NETDAQ::JDAQTimesliceL2::Class_Version(), "km3net-dataformat/online/JDAQTimeslice.hh", 271,
929 typeid(::KM3NETDAQ::JDAQTimesliceL2), ::ROOT::Internal::DefineBehavior(ptr, ptr),
930 &::KM3NETDAQ::JDAQTimesliceL2::Dictionary, isa_proxy, 4,
931 sizeof(::KM3NETDAQ::JDAQTimesliceL2) );
932 instance.SetNew(&new_KM3NETDAQcLcLJDAQTimesliceL2);
933 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQTimesliceL2);
934 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQTimesliceL2);
935 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQTimesliceL2);
936 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQTimesliceL2);
937 return &instance;
938 }
939 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQTimesliceL2*)
940 {
941 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQTimesliceL2*>(nullptr));
942 }
943 // Static variable to force the class initialization
944 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQTimesliceL2*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
945} // end of namespace ROOT
946
947namespace ROOT {
948 static void *new_KM3NETDAQcLcLJDAQTimesliceSN(void *p = nullptr);
949 static void *newArray_KM3NETDAQcLcLJDAQTimesliceSN(Long_t size, void *p);
950 static void delete_KM3NETDAQcLcLJDAQTimesliceSN(void *p);
951 static void deleteArray_KM3NETDAQcLcLJDAQTimesliceSN(void *p);
952 static void destruct_KM3NETDAQcLcLJDAQTimesliceSN(void *p);
953
954 // Function generating the singleton type initializer
955 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQTimesliceSN*)
956 {
957 ::KM3NETDAQ::JDAQTimesliceSN *ptr = nullptr;
958 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQTimesliceSN >(nullptr);
959 static ::ROOT::TGenericClassInfo
960 instance("KM3NETDAQ::JDAQTimesliceSN", ::KM3NETDAQ::JDAQTimesliceSN::Class_Version(), "km3net-dataformat/online/JDAQTimeslice.hh", 277,
961 typeid(::KM3NETDAQ::JDAQTimesliceSN), ::ROOT::Internal::DefineBehavior(ptr, ptr),
962 &::KM3NETDAQ::JDAQTimesliceSN::Dictionary, isa_proxy, 4,
963 sizeof(::KM3NETDAQ::JDAQTimesliceSN) );
964 instance.SetNew(&new_KM3NETDAQcLcLJDAQTimesliceSN);
965 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQTimesliceSN);
966 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQTimesliceSN);
967 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQTimesliceSN);
968 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQTimesliceSN);
969 return &instance;
970 }
971 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQTimesliceSN*)
972 {
973 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQTimesliceSN*>(nullptr));
974 }
975 // Static variable to force the class initialization
976 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQTimesliceSN*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
977} // end of namespace ROOT
978
979namespace ROOT {
980 static void *new_KM3NETDAQcLcLJDAQSummaryslice(void *p = nullptr);
981 static void *newArray_KM3NETDAQcLcLJDAQSummaryslice(Long_t size, void *p);
982 static void delete_KM3NETDAQcLcLJDAQSummaryslice(void *p);
983 static void deleteArray_KM3NETDAQcLcLJDAQSummaryslice(void *p);
984 static void destruct_KM3NETDAQcLcLJDAQSummaryslice(void *p);
985
986 // Function generating the singleton type initializer
987 static TGenericClassInfo *GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQSummaryslice*)
988 {
989 ::KM3NETDAQ::JDAQSummaryslice *ptr = nullptr;
990 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::KM3NETDAQ::JDAQSummaryslice >(nullptr);
991 static ::ROOT::TGenericClassInfo
992 instance("KM3NETDAQ::JDAQSummaryslice", ::KM3NETDAQ::JDAQSummaryslice::Class_Version(), "", 3860,
993 typeid(::KM3NETDAQ::JDAQSummaryslice), ::ROOT::Internal::DefineBehavior(ptr, ptr),
994 &::KM3NETDAQ::JDAQSummaryslice::Dictionary, isa_proxy, 4,
995 sizeof(::KM3NETDAQ::JDAQSummaryslice) );
996 instance.SetNew(&new_KM3NETDAQcLcLJDAQSummaryslice);
997 instance.SetNewArray(&newArray_KM3NETDAQcLcLJDAQSummaryslice);
998 instance.SetDelete(&delete_KM3NETDAQcLcLJDAQSummaryslice);
999 instance.SetDeleteArray(&deleteArray_KM3NETDAQcLcLJDAQSummaryslice);
1000 instance.SetDestructor(&destruct_KM3NETDAQcLcLJDAQSummaryslice);
1001 return &instance;
1002 }
1003 TGenericClassInfo *GenerateInitInstance(const ::KM3NETDAQ::JDAQSummaryslice*)
1004 {
1005 return GenerateInitInstanceLocal(static_cast<::KM3NETDAQ::JDAQSummaryslice*>(nullptr));
1006 }
1007 // Static variable to force the class initialization
1008 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::KM3NETDAQ::JDAQSummaryslice*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
1009} // end of namespace ROOT
1010
1011namespace ROOT {
1012 static void *new_AAObject(void *p = nullptr);
1013 static void *newArray_AAObject(Long_t size, void *p);
1014 static void delete_AAObject(void *p);
1015 static void deleteArray_AAObject(void *p);
1016 static void destruct_AAObject(void *p);
1017
1018 // Function generating the singleton type initializer
1019 static TGenericClassInfo *GenerateInitInstanceLocal(const ::AAObject*)
1020 {
1021 ::AAObject *ptr = nullptr;
1022 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::AAObject >(nullptr);
1023 static ::ROOT::TGenericClassInfo
1024 instance("AAObject", ::AAObject::Class_Version(), "", 5696,
1025 typeid(::AAObject), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1026 &::AAObject::Dictionary, isa_proxy, 4,
1027 sizeof(::AAObject) );
1028 instance.SetNew(&new_AAObject);
1029 instance.SetNewArray(&newArray_AAObject);
1030 instance.SetDelete(&delete_AAObject);
1031 instance.SetDeleteArray(&deleteArray_AAObject);
1032 instance.SetDestructor(&destruct_AAObject);
1033 return &instance;
1034 }
1035 TGenericClassInfo *GenerateInitInstance(const ::AAObject*)
1036 {
1037 return GenerateInitInstanceLocal(static_cast<::AAObject*>(nullptr));
1038 }
1039 // Static variable to force the class initialization
1040 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::AAObject*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
1041} // end of namespace ROOT
1042
1043namespace ROOT {
1044 static void *new_Vec(void *p = nullptr);
1045 static void *newArray_Vec(Long_t size, void *p);
1046 static void delete_Vec(void *p);
1047 static void deleteArray_Vec(void *p);
1048 static void destruct_Vec(void *p);
1049
1050 // Function generating the singleton type initializer
1051 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Vec*)
1052 {
1053 ::Vec *ptr = nullptr;
1054 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Vec >(nullptr);
1055 static ::ROOT::TGenericClassInfo
1056 instance("Vec", ::Vec::Class_Version(), "km3net-dataformat/offline/Vec.hh", 12,
1057 typeid(::Vec), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1058 &::Vec::Dictionary, isa_proxy, 4,
1059 sizeof(::Vec) );
1060 instance.SetNew(&new_Vec);
1061 instance.SetNewArray(&newArray_Vec);
1062 instance.SetDelete(&delete_Vec);
1063 instance.SetDeleteArray(&deleteArray_Vec);
1064 instance.SetDestructor(&destruct_Vec);
1065 return &instance;
1066 }
1067 TGenericClassInfo *GenerateInitInstance(const ::Vec*)
1068 {
1069 return GenerateInitInstanceLocal(static_cast<::Vec*>(nullptr));
1070 }
1071 // Static variable to force the class initialization
1072 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::Vec*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
1073} // end of namespace ROOT
1074
1075namespace ROOT {
1076 static void *new_Hit(void *p = nullptr);
1077 static void *newArray_Hit(Long_t size, void *p);
1078 static void delete_Hit(void *p);
1079 static void deleteArray_Hit(void *p);
1080 static void destruct_Hit(void *p);
1081
1082 // Function generating the singleton type initializer
1083 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Hit*)
1084 {
1085 ::Hit *ptr = nullptr;
1086 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Hit >(nullptr);
1087 static ::ROOT::TGenericClassInfo
1088 instance("Hit", ::Hit::Class_Version(), "km3net-dataformat/offline/Hit.hh", 8,
1089 typeid(::Hit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1090 &::Hit::Dictionary, isa_proxy, 4,
1091 sizeof(::Hit) );
1092 instance.SetNew(&new_Hit);
1093 instance.SetNewArray(&newArray_Hit);
1094 instance.SetDelete(&delete_Hit);
1095 instance.SetDeleteArray(&deleteArray_Hit);
1096 instance.SetDestructor(&destruct_Hit);
1097 return &instance;
1098 }
1099 TGenericClassInfo *GenerateInitInstance(const ::Hit*)
1100 {
1101 return GenerateInitInstanceLocal(static_cast<::Hit*>(nullptr));
1102 }
1103 // Static variable to force the class initialization
1104 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::Hit*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
1105} // end of namespace ROOT
1106
1107namespace ROOT {
1108 static void *new_Trk(void *p = nullptr);
1109 static void *newArray_Trk(Long_t size, void *p);
1110 static void delete_Trk(void *p);
1111 static void deleteArray_Trk(void *p);
1112 static void destruct_Trk(void *p);
1113
1114 // Function generating the singleton type initializer
1115 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Trk*)
1116 {
1117 ::Trk *ptr = nullptr;
1118 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Trk >(nullptr);
1119 static ::ROOT::TGenericClassInfo
1120 instance("Trk", ::Trk::Class_Version(), "km3net-dataformat/offline/Trk.hh", 14,
1121 typeid(::Trk), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1122 &::Trk::Dictionary, isa_proxy, 4,
1123 sizeof(::Trk) );
1124 instance.SetNew(&new_Trk);
1125 instance.SetNewArray(&newArray_Trk);
1126 instance.SetDelete(&delete_Trk);
1127 instance.SetDeleteArray(&deleteArray_Trk);
1128 instance.SetDestructor(&destruct_Trk);
1129 return &instance;
1130 }
1131 TGenericClassInfo *GenerateInitInstance(const ::Trk*)
1132 {
1133 return GenerateInitInstanceLocal(static_cast<::Trk*>(nullptr));
1134 }
1135 // Static variable to force the class initialization
1136 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::Trk*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
1137} // end of namespace ROOT
1138
1139namespace ROOT {
1140 static void *new_Evt(void *p = nullptr);
1141 static void *newArray_Evt(Long_t size, void *p);
1142 static void delete_Evt(void *p);
1143 static void deleteArray_Evt(void *p);
1144 static void destruct_Evt(void *p);
1145
1146 // Function generating the singleton type initializer
1147 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Evt*)
1148 {
1149 ::Evt *ptr = nullptr;
1150 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Evt >(nullptr);
1151 static ::ROOT::TGenericClassInfo
1152 instance("Evt", ::Evt::Class_Version(), "", 5875,
1153 typeid(::Evt), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1154 &::Evt::Dictionary, isa_proxy, 4,
1155 sizeof(::Evt) );
1156 instance.SetNew(&new_Evt);
1157 instance.SetNewArray(&newArray_Evt);
1158 instance.SetDelete(&delete_Evt);
1159 instance.SetDeleteArray(&deleteArray_Evt);
1160 instance.SetDestructor(&destruct_Evt);
1161 return &instance;
1162 }
1163 TGenericClassInfo *GenerateInitInstance(const ::Evt*)
1164 {
1165 return GenerateInitInstanceLocal(static_cast<::Evt*>(nullptr));
1166 }
1167 // Static variable to force the class initialization
1168 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::Evt*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
1169} // end of namespace ROOT
1170
1171namespace ROOT {
1172 static void *new_Head(void *p = nullptr);
1173 static void *newArray_Head(Long_t size, void *p);
1174 static void delete_Head(void *p);
1175 static void deleteArray_Head(void *p);
1176 static void destruct_Head(void *p);
1177
1178 // Function generating the singleton type initializer
1179 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Head*)
1180 {
1181 ::Head *ptr = nullptr;
1182 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Head >(nullptr);
1183 static ::ROOT::TGenericClassInfo
1184 instance("Head", ::Head::Class_Version(), "", 6287,
1185 typeid(::Head), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1186 &::Head::Dictionary, isa_proxy, 4,
1187 sizeof(::Head) );
1188 instance.SetNew(&new_Head);
1189 instance.SetNewArray(&newArray_Head);
1190 instance.SetDelete(&delete_Head);
1191 instance.SetDeleteArray(&deleteArray_Head);
1192 instance.SetDestructor(&destruct_Head);
1193 return &instance;
1194 }
1195 TGenericClassInfo *GenerateInitInstance(const ::Head*)
1196 {
1197 return GenerateInitInstanceLocal(static_cast<::Head*>(nullptr));
1198 }
1199 // Static variable to force the class initialization
1200 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::Head*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
1201} // end of namespace ROOT
1202
1203namespace ROOT {
1204 static void *new_MultiHead(void *p = nullptr);
1205 static void *newArray_MultiHead(Long_t size, void *p);
1206 static void delete_MultiHead(void *p);
1207 static void deleteArray_MultiHead(void *p);
1208 static void destruct_MultiHead(void *p);
1209
1210 // Function generating the singleton type initializer
1211 static TGenericClassInfo *GenerateInitInstanceLocal(const ::MultiHead*)
1212 {
1213 ::MultiHead *ptr = nullptr;
1214 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::MultiHead >(nullptr);
1215 static ::ROOT::TGenericClassInfo
1216 instance("MultiHead", ::MultiHead::Class_Version(), "", 6761,
1217 typeid(::MultiHead), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1218 &::MultiHead::Dictionary, isa_proxy, 4,
1219 sizeof(::MultiHead) );
1220 instance.SetNew(&new_MultiHead);
1221 instance.SetNewArray(&newArray_MultiHead);
1222 instance.SetDelete(&delete_MultiHead);
1223 instance.SetDeleteArray(&deleteArray_MultiHead);
1224 instance.SetDestructor(&destruct_MultiHead);
1225 return &instance;
1226 }
1227 TGenericClassInfo *GenerateInitInstance(const ::MultiHead*)
1228 {
1229 return GenerateInitInstanceLocal(static_cast<::MultiHead*>(nullptr));
1230 }
1231 // Static variable to force the class initialization
1232 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::MultiHead*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
1233} // end of namespace ROOT
1234
1235namespace KM3NETDAQ {
1236//______________________________________________________________________________
1237atomic_TClass_ptr JDAQAbstractPreamble::fgIsA(nullptr); // static to hold class pointer
1238
1239//______________________________________________________________________________
1240const char *JDAQAbstractPreamble::Class_Name()
1241{
1242 return "KM3NETDAQ::JDAQAbstractPreamble";
1243}
1244
1245//______________________________________________________________________________
1246const char *JDAQAbstractPreamble::ImplFileName()
1247{
1248 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQAbstractPreamble*)nullptr)->GetImplFileName();
1249}
1250
1251//______________________________________________________________________________
1252int JDAQAbstractPreamble::ImplFileLine()
1253{
1254 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQAbstractPreamble*)nullptr)->GetImplFileLine();
1255}
1256
1257//______________________________________________________________________________
1258TClass *JDAQAbstractPreamble::Dictionary()
1259{
1260 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQAbstractPreamble*)nullptr)->GetClass();
1261 return fgIsA;
1262}
1263
1264//______________________________________________________________________________
1265TClass *JDAQAbstractPreamble::Class()
1266{
1267 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQAbstractPreamble*)nullptr)->GetClass(); }
1268 return fgIsA;
1269}
1270
1271} // namespace KM3NETDAQ
1272namespace KM3NETDAQ {
1273//______________________________________________________________________________
1274atomic_TClass_ptr JDAQUTCExtended::fgIsA(nullptr); // static to hold class pointer
1275
1276//______________________________________________________________________________
1277const char *JDAQUTCExtended::Class_Name()
1278{
1279 return "KM3NETDAQ::JDAQUTCExtended";
1280}
1281
1282//______________________________________________________________________________
1283const char *JDAQUTCExtended::ImplFileName()
1284{
1285 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQUTCExtended*)nullptr)->GetImplFileName();
1286}
1287
1288//______________________________________________________________________________
1289int JDAQUTCExtended::ImplFileLine()
1290{
1291 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQUTCExtended*)nullptr)->GetImplFileLine();
1292}
1293
1294//______________________________________________________________________________
1295TClass *JDAQUTCExtended::Dictionary()
1296{
1297 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQUTCExtended*)nullptr)->GetClass();
1298 return fgIsA;
1299}
1300
1301//______________________________________________________________________________
1302TClass *JDAQUTCExtended::Class()
1303{
1304 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQUTCExtended*)nullptr)->GetClass(); }
1305 return fgIsA;
1306}
1307
1308} // namespace KM3NETDAQ
1309namespace KM3NETDAQ {
1310//______________________________________________________________________________
1311atomic_TClass_ptr JDAQChronometer::fgIsA(nullptr); // static to hold class pointer
1312
1313//______________________________________________________________________________
1314const char *JDAQChronometer::Class_Name()
1315{
1316 return "KM3NETDAQ::JDAQChronometer";
1317}
1318
1319//______________________________________________________________________________
1320const char *JDAQChronometer::ImplFileName()
1321{
1322 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQChronometer*)nullptr)->GetImplFileName();
1323}
1324
1325//______________________________________________________________________________
1326int JDAQChronometer::ImplFileLine()
1327{
1328 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQChronometer*)nullptr)->GetImplFileLine();
1329}
1330
1331//______________________________________________________________________________
1332TClass *JDAQChronometer::Dictionary()
1333{
1334 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQChronometer*)nullptr)->GetClass();
1335 return fgIsA;
1336}
1337
1338//______________________________________________________________________________
1339TClass *JDAQChronometer::Class()
1340{
1341 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQChronometer*)nullptr)->GetClass(); }
1342 return fgIsA;
1343}
1344
1345} // namespace KM3NETDAQ
1346namespace KM3NETDAQ {
1347//______________________________________________________________________________
1348atomic_TClass_ptr JDAQPreamble::fgIsA(nullptr); // static to hold class pointer
1349
1350//______________________________________________________________________________
1351const char *JDAQPreamble::Class_Name()
1352{
1353 return "KM3NETDAQ::JDAQPreamble";
1354}
1355
1356//______________________________________________________________________________
1357const char *JDAQPreamble::ImplFileName()
1358{
1359 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQPreamble*)nullptr)->GetImplFileName();
1360}
1361
1362//______________________________________________________________________________
1363int JDAQPreamble::ImplFileLine()
1364{
1365 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQPreamble*)nullptr)->GetImplFileLine();
1366}
1367
1368//______________________________________________________________________________
1369TClass *JDAQPreamble::Dictionary()
1370{
1371 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQPreamble*)nullptr)->GetClass();
1372 return fgIsA;
1373}
1374
1375//______________________________________________________________________________
1376TClass *JDAQPreamble::Class()
1377{
1378 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQPreamble*)nullptr)->GetClass(); }
1379 return fgIsA;
1380}
1381
1382} // namespace KM3NETDAQ
1383namespace KM3NETDAQ {
1384//______________________________________________________________________________
1385atomic_TClass_ptr JDAQHeader::fgIsA(nullptr); // static to hold class pointer
1386
1387//______________________________________________________________________________
1388const char *JDAQHeader::Class_Name()
1389{
1390 return "KM3NETDAQ::JDAQHeader";
1391}
1392
1393//______________________________________________________________________________
1394const char *JDAQHeader::ImplFileName()
1395{
1396 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQHeader*)nullptr)->GetImplFileName();
1397}
1398
1399//______________________________________________________________________________
1400int JDAQHeader::ImplFileLine()
1401{
1402 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQHeader*)nullptr)->GetImplFileLine();
1403}
1404
1405//______________________________________________________________________________
1406TClass *JDAQHeader::Dictionary()
1407{
1408 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQHeader*)nullptr)->GetClass();
1409 return fgIsA;
1410}
1411
1412//______________________________________________________________________________
1413TClass *JDAQHeader::Class()
1414{
1415 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQHeader*)nullptr)->GetClass(); }
1416 return fgIsA;
1417}
1418
1419} // namespace KM3NETDAQ
1420namespace KM3NETDAQ {
1421//______________________________________________________________________________
1422atomic_TClass_ptr JDAQTriggerCounter::fgIsA(nullptr); // static to hold class pointer
1423
1424//______________________________________________________________________________
1425const char *JDAQTriggerCounter::Class_Name()
1426{
1427 return "KM3NETDAQ::JDAQTriggerCounter";
1428}
1429
1430//______________________________________________________________________________
1431const char *JDAQTriggerCounter::ImplFileName()
1432{
1433 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggerCounter*)nullptr)->GetImplFileName();
1434}
1435
1436//______________________________________________________________________________
1437int JDAQTriggerCounter::ImplFileLine()
1438{
1439 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggerCounter*)nullptr)->GetImplFileLine();
1440}
1441
1442//______________________________________________________________________________
1443TClass *JDAQTriggerCounter::Dictionary()
1444{
1445 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggerCounter*)nullptr)->GetClass();
1446 return fgIsA;
1447}
1448
1449//______________________________________________________________________________
1450TClass *JDAQTriggerCounter::Class()
1451{
1452 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggerCounter*)nullptr)->GetClass(); }
1453 return fgIsA;
1454}
1455
1456} // namespace KM3NETDAQ
1457namespace KM3NETDAQ {
1458//______________________________________________________________________________
1459atomic_TClass_ptr JDAQTriggerMask::fgIsA(nullptr); // static to hold class pointer
1460
1461//______________________________________________________________________________
1462const char *JDAQTriggerMask::Class_Name()
1463{
1464 return "KM3NETDAQ::JDAQTriggerMask";
1465}
1466
1467//______________________________________________________________________________
1468const char *JDAQTriggerMask::ImplFileName()
1469{
1470 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggerMask*)nullptr)->GetImplFileName();
1471}
1472
1473//______________________________________________________________________________
1474int JDAQTriggerMask::ImplFileLine()
1475{
1476 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggerMask*)nullptr)->GetImplFileLine();
1477}
1478
1479//______________________________________________________________________________
1480TClass *JDAQTriggerMask::Dictionary()
1481{
1482 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggerMask*)nullptr)->GetClass();
1483 return fgIsA;
1484}
1485
1486//______________________________________________________________________________
1487TClass *JDAQTriggerMask::Class()
1488{
1489 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggerMask*)nullptr)->GetClass(); }
1490 return fgIsA;
1491}
1492
1493} // namespace KM3NETDAQ
1494namespace KM3NETDAQ {
1495//______________________________________________________________________________
1496atomic_TClass_ptr JDAQEventHeader::fgIsA(nullptr); // static to hold class pointer
1497
1498//______________________________________________________________________________
1499const char *JDAQEventHeader::Class_Name()
1500{
1501 return "KM3NETDAQ::JDAQEventHeader";
1502}
1503
1504//______________________________________________________________________________
1505const char *JDAQEventHeader::ImplFileName()
1506{
1507 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQEventHeader*)nullptr)->GetImplFileName();
1508}
1509
1510//______________________________________________________________________________
1511int JDAQEventHeader::ImplFileLine()
1512{
1513 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQEventHeader*)nullptr)->GetImplFileLine();
1514}
1515
1516//______________________________________________________________________________
1517TClass *JDAQEventHeader::Dictionary()
1518{
1519 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQEventHeader*)nullptr)->GetClass();
1520 return fgIsA;
1521}
1522
1523//______________________________________________________________________________
1524TClass *JDAQEventHeader::Class()
1525{
1526 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQEventHeader*)nullptr)->GetClass(); }
1527 return fgIsA;
1528}
1529
1530} // namespace KM3NETDAQ
1531namespace KM3NETDAQ {
1532//______________________________________________________________________________
1533atomic_TClass_ptr JDAQHit::fgIsA(nullptr); // static to hold class pointer
1534
1535//______________________________________________________________________________
1536const char *JDAQHit::Class_Name()
1537{
1538 return "KM3NETDAQ::JDAQHit";
1539}
1540
1541//______________________________________________________________________________
1542const char *JDAQHit::ImplFileName()
1543{
1544 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQHit*)nullptr)->GetImplFileName();
1545}
1546
1547//______________________________________________________________________________
1548int JDAQHit::ImplFileLine()
1549{
1550 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQHit*)nullptr)->GetImplFileLine();
1551}
1552
1553//______________________________________________________________________________
1554TClass *JDAQHit::Dictionary()
1555{
1556 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQHit*)nullptr)->GetClass();
1557 return fgIsA;
1558}
1559
1560//______________________________________________________________________________
1561TClass *JDAQHit::Class()
1562{
1563 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQHit*)nullptr)->GetClass(); }
1564 return fgIsA;
1565}
1566
1567} // namespace KM3NETDAQ
1568namespace KM3NETDAQ {
1569//______________________________________________________________________________
1570atomic_TClass_ptr JDAQModuleIdentifier::fgIsA(nullptr); // static to hold class pointer
1571
1572//______________________________________________________________________________
1573const char *JDAQModuleIdentifier::Class_Name()
1574{
1575 return "KM3NETDAQ::JDAQModuleIdentifier";
1576}
1577
1578//______________________________________________________________________________
1579const char *JDAQModuleIdentifier::ImplFileName()
1580{
1581 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQModuleIdentifier*)nullptr)->GetImplFileName();
1582}
1583
1584//______________________________________________________________________________
1585int JDAQModuleIdentifier::ImplFileLine()
1586{
1587 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQModuleIdentifier*)nullptr)->GetImplFileLine();
1588}
1589
1590//______________________________________________________________________________
1591TClass *JDAQModuleIdentifier::Dictionary()
1592{
1593 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQModuleIdentifier*)nullptr)->GetClass();
1594 return fgIsA;
1595}
1596
1597//______________________________________________________________________________
1598TClass *JDAQModuleIdentifier::Class()
1599{
1600 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQModuleIdentifier*)nullptr)->GetClass(); }
1601 return fgIsA;
1602}
1603
1604} // namespace KM3NETDAQ
1605namespace KM3NETDAQ {
1606//______________________________________________________________________________
1607atomic_TClass_ptr JDAQPMTIdentifier::fgIsA(nullptr); // static to hold class pointer
1608
1609//______________________________________________________________________________
1610const char *JDAQPMTIdentifier::Class_Name()
1611{
1612 return "KM3NETDAQ::JDAQPMTIdentifier";
1613}
1614
1615//______________________________________________________________________________
1616const char *JDAQPMTIdentifier::ImplFileName()
1617{
1618 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQPMTIdentifier*)nullptr)->GetImplFileName();
1619}
1620
1621//______________________________________________________________________________
1622int JDAQPMTIdentifier::ImplFileLine()
1623{
1624 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQPMTIdentifier*)nullptr)->GetImplFileLine();
1625}
1626
1627//______________________________________________________________________________
1628TClass *JDAQPMTIdentifier::Dictionary()
1629{
1630 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQPMTIdentifier*)nullptr)->GetClass();
1631 return fgIsA;
1632}
1633
1634//______________________________________________________________________________
1635TClass *JDAQPMTIdentifier::Class()
1636{
1637 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQPMTIdentifier*)nullptr)->GetClass(); }
1638 return fgIsA;
1639}
1640
1641} // namespace KM3NETDAQ
1642namespace KM3NETDAQ {
1643//______________________________________________________________________________
1644atomic_TClass_ptr JDAQKeyHit::fgIsA(nullptr); // static to hold class pointer
1645
1646//______________________________________________________________________________
1647const char *JDAQKeyHit::Class_Name()
1648{
1649 return "KM3NETDAQ::JDAQKeyHit";
1650}
1651
1652//______________________________________________________________________________
1653const char *JDAQKeyHit::ImplFileName()
1654{
1655 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQKeyHit*)nullptr)->GetImplFileName();
1656}
1657
1658//______________________________________________________________________________
1659int JDAQKeyHit::ImplFileLine()
1660{
1661 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQKeyHit*)nullptr)->GetImplFileLine();
1662}
1663
1664//______________________________________________________________________________
1665TClass *JDAQKeyHit::Dictionary()
1666{
1667 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQKeyHit*)nullptr)->GetClass();
1668 return fgIsA;
1669}
1670
1671//______________________________________________________________________________
1672TClass *JDAQKeyHit::Class()
1673{
1674 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQKeyHit*)nullptr)->GetClass(); }
1675 return fgIsA;
1676}
1677
1678} // namespace KM3NETDAQ
1679namespace KM3NETDAQ {
1680//______________________________________________________________________________
1681atomic_TClass_ptr JDAQTriggeredHit::fgIsA(nullptr); // static to hold class pointer
1682
1683//______________________________________________________________________________
1684const char *JDAQTriggeredHit::Class_Name()
1685{
1686 return "KM3NETDAQ::JDAQTriggeredHit";
1687}
1688
1689//______________________________________________________________________________
1690const char *JDAQTriggeredHit::ImplFileName()
1691{
1692 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggeredHit*)nullptr)->GetImplFileName();
1693}
1694
1695//______________________________________________________________________________
1696int JDAQTriggeredHit::ImplFileLine()
1697{
1698 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggeredHit*)nullptr)->GetImplFileLine();
1699}
1700
1701//______________________________________________________________________________
1702TClass *JDAQTriggeredHit::Dictionary()
1703{
1704 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggeredHit*)nullptr)->GetClass();
1705 return fgIsA;
1706}
1707
1708//______________________________________________________________________________
1709TClass *JDAQTriggeredHit::Class()
1710{
1711 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTriggeredHit*)nullptr)->GetClass(); }
1712 return fgIsA;
1713}
1714
1715} // namespace KM3NETDAQ
1716namespace KM3NETDAQ {
1717//______________________________________________________________________________
1718atomic_TClass_ptr JDAQEvent::fgIsA(nullptr); // static to hold class pointer
1719
1720//______________________________________________________________________________
1721const char *JDAQEvent::Class_Name()
1722{
1723 return "KM3NETDAQ::JDAQEvent";
1724}
1725
1726//______________________________________________________________________________
1727const char *JDAQEvent::ImplFileName()
1728{
1729 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQEvent*)nullptr)->GetImplFileName();
1730}
1731
1732//______________________________________________________________________________
1733int JDAQEvent::ImplFileLine()
1734{
1735 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQEvent*)nullptr)->GetImplFileLine();
1736}
1737
1738//______________________________________________________________________________
1739TClass *JDAQEvent::Dictionary()
1740{
1741 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQEvent*)nullptr)->GetClass();
1742 return fgIsA;
1743}
1744
1745//______________________________________________________________________________
1746TClass *JDAQEvent::Class()
1747{
1748 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQEvent*)nullptr)->GetClass(); }
1749 return fgIsA;
1750}
1751
1752} // namespace KM3NETDAQ
1753namespace KM3NETDAQ {
1754//______________________________________________________________________________
1755atomic_TClass_ptr JDAQFrame::fgIsA(nullptr); // static to hold class pointer
1756
1757//______________________________________________________________________________
1758const char *JDAQFrame::Class_Name()
1759{
1760 return "KM3NETDAQ::JDAQFrame";
1761}
1762
1763//______________________________________________________________________________
1764const char *JDAQFrame::ImplFileName()
1765{
1766 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQFrame*)nullptr)->GetImplFileName();
1767}
1768
1769//______________________________________________________________________________
1770int JDAQFrame::ImplFileLine()
1771{
1772 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQFrame*)nullptr)->GetImplFileLine();
1773}
1774
1775//______________________________________________________________________________
1776TClass *JDAQFrame::Dictionary()
1777{
1778 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQFrame*)nullptr)->GetClass();
1779 return fgIsA;
1780}
1781
1782//______________________________________________________________________________
1783TClass *JDAQFrame::Class()
1784{
1785 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQFrame*)nullptr)->GetClass(); }
1786 return fgIsA;
1787}
1788
1789} // namespace KM3NETDAQ
1790namespace KM3NETDAQ {
1791//______________________________________________________________________________
1792atomic_TClass_ptr JDAQFrameStatus::fgIsA(nullptr); // static to hold class pointer
1793
1794//______________________________________________________________________________
1795const char *JDAQFrameStatus::Class_Name()
1796{
1797 return "KM3NETDAQ::JDAQFrameStatus";
1798}
1799
1800//______________________________________________________________________________
1801const char *JDAQFrameStatus::ImplFileName()
1802{
1803 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQFrameStatus*)nullptr)->GetImplFileName();
1804}
1805
1806//______________________________________________________________________________
1807int JDAQFrameStatus::ImplFileLine()
1808{
1809 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQFrameStatus*)nullptr)->GetImplFileLine();
1810}
1811
1812//______________________________________________________________________________
1813TClass *JDAQFrameStatus::Dictionary()
1814{
1815 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQFrameStatus*)nullptr)->GetClass();
1816 return fgIsA;
1817}
1818
1819//______________________________________________________________________________
1820TClass *JDAQFrameStatus::Class()
1821{
1822 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQFrameStatus*)nullptr)->GetClass(); }
1823 return fgIsA;
1824}
1825
1826} // namespace KM3NETDAQ
1827namespace KM3NETDAQ {
1828//______________________________________________________________________________
1829atomic_TClass_ptr JDAQSuperFrameHeader::fgIsA(nullptr); // static to hold class pointer
1830
1831//______________________________________________________________________________
1832const char *JDAQSuperFrameHeader::Class_Name()
1833{
1834 return "KM3NETDAQ::JDAQSuperFrameHeader";
1835}
1836
1837//______________________________________________________________________________
1838const char *JDAQSuperFrameHeader::ImplFileName()
1839{
1840 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSuperFrameHeader*)nullptr)->GetImplFileName();
1841}
1842
1843//______________________________________________________________________________
1844int JDAQSuperFrameHeader::ImplFileLine()
1845{
1846 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSuperFrameHeader*)nullptr)->GetImplFileLine();
1847}
1848
1849//______________________________________________________________________________
1850TClass *JDAQSuperFrameHeader::Dictionary()
1851{
1852 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSuperFrameHeader*)nullptr)->GetClass();
1853 return fgIsA;
1854}
1855
1856//______________________________________________________________________________
1857TClass *JDAQSuperFrameHeader::Class()
1858{
1859 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSuperFrameHeader*)nullptr)->GetClass(); }
1860 return fgIsA;
1861}
1862
1863} // namespace KM3NETDAQ
1864namespace KM3NETDAQ {
1865//______________________________________________________________________________
1866atomic_TClass_ptr JDAQSuperFrame::fgIsA(nullptr); // static to hold class pointer
1867
1868//______________________________________________________________________________
1869const char *JDAQSuperFrame::Class_Name()
1870{
1871 return "KM3NETDAQ::JDAQSuperFrame";
1872}
1873
1874//______________________________________________________________________________
1875const char *JDAQSuperFrame::ImplFileName()
1876{
1877 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSuperFrame*)nullptr)->GetImplFileName();
1878}
1879
1880//______________________________________________________________________________
1881int JDAQSuperFrame::ImplFileLine()
1882{
1883 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSuperFrame*)nullptr)->GetImplFileLine();
1884}
1885
1886//______________________________________________________________________________
1887TClass *JDAQSuperFrame::Dictionary()
1888{
1889 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSuperFrame*)nullptr)->GetClass();
1890 return fgIsA;
1891}
1892
1893//______________________________________________________________________________
1894TClass *JDAQSuperFrame::Class()
1895{
1896 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSuperFrame*)nullptr)->GetClass(); }
1897 return fgIsA;
1898}
1899
1900} // namespace KM3NETDAQ
1901namespace KM3NETDAQ {
1902//______________________________________________________________________________
1903atomic_TClass_ptr JDAQSummaryFrame::fgIsA(nullptr); // static to hold class pointer
1904
1905//______________________________________________________________________________
1906const char *JDAQSummaryFrame::Class_Name()
1907{
1908 return "KM3NETDAQ::JDAQSummaryFrame";
1909}
1910
1911//______________________________________________________________________________
1912const char *JDAQSummaryFrame::ImplFileName()
1913{
1914 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummaryFrame*)nullptr)->GetImplFileName();
1915}
1916
1917//______________________________________________________________________________
1918int JDAQSummaryFrame::ImplFileLine()
1919{
1920 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummaryFrame*)nullptr)->GetImplFileLine();
1921}
1922
1923//______________________________________________________________________________
1924TClass *JDAQSummaryFrame::Dictionary()
1925{
1926 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummaryFrame*)nullptr)->GetClass();
1927 return fgIsA;
1928}
1929
1930//______________________________________________________________________________
1931TClass *JDAQSummaryFrame::Class()
1932{
1933 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummaryFrame*)nullptr)->GetClass(); }
1934 return fgIsA;
1935}
1936
1937} // namespace KM3NETDAQ
1938namespace KM3NETDAQ {
1939//______________________________________________________________________________
1940atomic_TClass_ptr JDAQSummarysliceHeader::fgIsA(nullptr); // static to hold class pointer
1941
1942//______________________________________________________________________________
1943const char *JDAQSummarysliceHeader::Class_Name()
1944{
1945 return "KM3NETDAQ::JDAQSummarysliceHeader";
1946}
1947
1948//______________________________________________________________________________
1949const char *JDAQSummarysliceHeader::ImplFileName()
1950{
1951 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummarysliceHeader*)nullptr)->GetImplFileName();
1952}
1953
1954//______________________________________________________________________________
1955int JDAQSummarysliceHeader::ImplFileLine()
1956{
1957 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummarysliceHeader*)nullptr)->GetImplFileLine();
1958}
1959
1960//______________________________________________________________________________
1961TClass *JDAQSummarysliceHeader::Dictionary()
1962{
1963 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummarysliceHeader*)nullptr)->GetClass();
1964 return fgIsA;
1965}
1966
1967//______________________________________________________________________________
1968TClass *JDAQSummarysliceHeader::Class()
1969{
1970 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummarysliceHeader*)nullptr)->GetClass(); }
1971 return fgIsA;
1972}
1973
1974} // namespace KM3NETDAQ
1975namespace KM3NETDAQ {
1976//______________________________________________________________________________
1977atomic_TClass_ptr JDAQTimesliceHeader::fgIsA(nullptr); // static to hold class pointer
1978
1979//______________________________________________________________________________
1980const char *JDAQTimesliceHeader::Class_Name()
1981{
1982 return "KM3NETDAQ::JDAQTimesliceHeader";
1983}
1984
1985//______________________________________________________________________________
1986const char *JDAQTimesliceHeader::ImplFileName()
1987{
1988 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceHeader*)nullptr)->GetImplFileName();
1989}
1990
1991//______________________________________________________________________________
1992int JDAQTimesliceHeader::ImplFileLine()
1993{
1994 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceHeader*)nullptr)->GetImplFileLine();
1995}
1996
1997//______________________________________________________________________________
1998TClass *JDAQTimesliceHeader::Dictionary()
1999{
2000 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceHeader*)nullptr)->GetClass();
2001 return fgIsA;
2002}
2003
2004//______________________________________________________________________________
2005TClass *JDAQTimesliceHeader::Class()
2006{
2007 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceHeader*)nullptr)->GetClass(); }
2008 return fgIsA;
2009}
2010
2011} // namespace KM3NETDAQ
2012namespace KM3NETDAQ {
2013//______________________________________________________________________________
2014atomic_TClass_ptr JDAQTimeslice::fgIsA(nullptr); // static to hold class pointer
2015
2016//______________________________________________________________________________
2017const char *JDAQTimeslice::Class_Name()
2018{
2019 return "KM3NETDAQ::JDAQTimeslice";
2020}
2021
2022//______________________________________________________________________________
2023const char *JDAQTimeslice::ImplFileName()
2024{
2025 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimeslice*)nullptr)->GetImplFileName();
2026}
2027
2028//______________________________________________________________________________
2029int JDAQTimeslice::ImplFileLine()
2030{
2031 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimeslice*)nullptr)->GetImplFileLine();
2032}
2033
2034//______________________________________________________________________________
2035TClass *JDAQTimeslice::Dictionary()
2036{
2037 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimeslice*)nullptr)->GetClass();
2038 return fgIsA;
2039}
2040
2041//______________________________________________________________________________
2042TClass *JDAQTimeslice::Class()
2043{
2044 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimeslice*)nullptr)->GetClass(); }
2045 return fgIsA;
2046}
2047
2048} // namespace KM3NETDAQ
2049namespace KM3NETDAQ {
2050//______________________________________________________________________________
2051atomic_TClass_ptr JDAQTimesliceL0::fgIsA(nullptr); // static to hold class pointer
2052
2053//______________________________________________________________________________
2054const char *JDAQTimesliceL0::Class_Name()
2055{
2056 return "KM3NETDAQ::JDAQTimesliceL0";
2057}
2058
2059//______________________________________________________________________________
2060const char *JDAQTimesliceL0::ImplFileName()
2061{
2062 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL0*)nullptr)->GetImplFileName();
2063}
2064
2065//______________________________________________________________________________
2066int JDAQTimesliceL0::ImplFileLine()
2067{
2068 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL0*)nullptr)->GetImplFileLine();
2069}
2070
2071//______________________________________________________________________________
2072TClass *JDAQTimesliceL0::Dictionary()
2073{
2074 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL0*)nullptr)->GetClass();
2075 return fgIsA;
2076}
2077
2078//______________________________________________________________________________
2079TClass *JDAQTimesliceL0::Class()
2080{
2081 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL0*)nullptr)->GetClass(); }
2082 return fgIsA;
2083}
2084
2085} // namespace KM3NETDAQ
2086namespace KM3NETDAQ {
2087//______________________________________________________________________________
2088atomic_TClass_ptr JDAQTimesliceL1::fgIsA(nullptr); // static to hold class pointer
2089
2090//______________________________________________________________________________
2091const char *JDAQTimesliceL1::Class_Name()
2092{
2093 return "KM3NETDAQ::JDAQTimesliceL1";
2094}
2095
2096//______________________________________________________________________________
2097const char *JDAQTimesliceL1::ImplFileName()
2098{
2099 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL1*)nullptr)->GetImplFileName();
2100}
2101
2102//______________________________________________________________________________
2103int JDAQTimesliceL1::ImplFileLine()
2104{
2105 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL1*)nullptr)->GetImplFileLine();
2106}
2107
2108//______________________________________________________________________________
2109TClass *JDAQTimesliceL1::Dictionary()
2110{
2111 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL1*)nullptr)->GetClass();
2112 return fgIsA;
2113}
2114
2115//______________________________________________________________________________
2116TClass *JDAQTimesliceL1::Class()
2117{
2118 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL1*)nullptr)->GetClass(); }
2119 return fgIsA;
2120}
2121
2122} // namespace KM3NETDAQ
2123namespace KM3NETDAQ {
2124//______________________________________________________________________________
2125atomic_TClass_ptr JDAQTimesliceL2::fgIsA(nullptr); // static to hold class pointer
2126
2127//______________________________________________________________________________
2128const char *JDAQTimesliceL2::Class_Name()
2129{
2130 return "KM3NETDAQ::JDAQTimesliceL2";
2131}
2132
2133//______________________________________________________________________________
2134const char *JDAQTimesliceL2::ImplFileName()
2135{
2136 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL2*)nullptr)->GetImplFileName();
2137}
2138
2139//______________________________________________________________________________
2140int JDAQTimesliceL2::ImplFileLine()
2141{
2142 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL2*)nullptr)->GetImplFileLine();
2143}
2144
2145//______________________________________________________________________________
2146TClass *JDAQTimesliceL2::Dictionary()
2147{
2148 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL2*)nullptr)->GetClass();
2149 return fgIsA;
2150}
2151
2152//______________________________________________________________________________
2153TClass *JDAQTimesliceL2::Class()
2154{
2155 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceL2*)nullptr)->GetClass(); }
2156 return fgIsA;
2157}
2158
2159} // namespace KM3NETDAQ
2160namespace KM3NETDAQ {
2161//______________________________________________________________________________
2162atomic_TClass_ptr JDAQTimesliceSN::fgIsA(nullptr); // static to hold class pointer
2163
2164//______________________________________________________________________________
2165const char *JDAQTimesliceSN::Class_Name()
2166{
2167 return "KM3NETDAQ::JDAQTimesliceSN";
2168}
2169
2170//______________________________________________________________________________
2171const char *JDAQTimesliceSN::ImplFileName()
2172{
2173 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceSN*)nullptr)->GetImplFileName();
2174}
2175
2176//______________________________________________________________________________
2177int JDAQTimesliceSN::ImplFileLine()
2178{
2179 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceSN*)nullptr)->GetImplFileLine();
2180}
2181
2182//______________________________________________________________________________
2183TClass *JDAQTimesliceSN::Dictionary()
2184{
2185 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceSN*)nullptr)->GetClass();
2186 return fgIsA;
2187}
2188
2189//______________________________________________________________________________
2190TClass *JDAQTimesliceSN::Class()
2191{
2192 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQTimesliceSN*)nullptr)->GetClass(); }
2193 return fgIsA;
2194}
2195
2196} // namespace KM3NETDAQ
2197namespace KM3NETDAQ {
2198//______________________________________________________________________________
2199atomic_TClass_ptr JDAQSummaryslice::fgIsA(nullptr); // static to hold class pointer
2200
2201//______________________________________________________________________________
2202const char *JDAQSummaryslice::Class_Name()
2203{
2204 return "KM3NETDAQ::JDAQSummaryslice";
2205}
2206
2207//______________________________________________________________________________
2208const char *JDAQSummaryslice::ImplFileName()
2209{
2210 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummaryslice*)nullptr)->GetImplFileName();
2211}
2212
2213//______________________________________________________________________________
2214int JDAQSummaryslice::ImplFileLine()
2215{
2216 return ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummaryslice*)nullptr)->GetImplFileLine();
2217}
2218
2219//______________________________________________________________________________
2220TClass *JDAQSummaryslice::Dictionary()
2221{
2222 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummaryslice*)nullptr)->GetClass();
2223 return fgIsA;
2224}
2225
2226//______________________________________________________________________________
2227TClass *JDAQSummaryslice::Class()
2228{
2229 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::KM3NETDAQ::JDAQSummaryslice*)nullptr)->GetClass(); }
2230 return fgIsA;
2231}
2232
2233} // namespace KM3NETDAQ
2234//______________________________________________________________________________
2235atomic_TClass_ptr AAObject::fgIsA(nullptr); // static to hold class pointer
2236
2237//______________________________________________________________________________
2238const char *AAObject::Class_Name()
2239{
2240 return "AAObject";
2241}
2242
2243//______________________________________________________________________________
2244const char *AAObject::ImplFileName()
2245{
2246 return ::ROOT::GenerateInitInstanceLocal((const ::AAObject*)nullptr)->GetImplFileName();
2247}
2248
2249//______________________________________________________________________________
2250int AAObject::ImplFileLine()
2251{
2252 return ::ROOT::GenerateInitInstanceLocal((const ::AAObject*)nullptr)->GetImplFileLine();
2253}
2254
2255//______________________________________________________________________________
2256TClass *AAObject::Dictionary()
2257{
2258 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::AAObject*)nullptr)->GetClass();
2259 return fgIsA;
2260}
2261
2262//______________________________________________________________________________
2263TClass *AAObject::Class()
2264{
2265 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::AAObject*)nullptr)->GetClass(); }
2266 return fgIsA;
2267}
2268
2269//______________________________________________________________________________
2270atomic_TClass_ptr Vec::fgIsA(nullptr); // static to hold class pointer
2271
2272//______________________________________________________________________________
2273const char *Vec::Class_Name()
2274{
2275 return "Vec";
2276}
2277
2278//______________________________________________________________________________
2279const char *Vec::ImplFileName()
2280{
2281 return ::ROOT::GenerateInitInstanceLocal((const ::Vec*)nullptr)->GetImplFileName();
2282}
2283
2284//______________________________________________________________________________
2285int Vec::ImplFileLine()
2286{
2287 return ::ROOT::GenerateInitInstanceLocal((const ::Vec*)nullptr)->GetImplFileLine();
2288}
2289
2290//______________________________________________________________________________
2291TClass *Vec::Dictionary()
2292{
2293 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Vec*)nullptr)->GetClass();
2294 return fgIsA;
2295}
2296
2297//______________________________________________________________________________
2298TClass *Vec::Class()
2299{
2300 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Vec*)nullptr)->GetClass(); }
2301 return fgIsA;
2302}
2303
2304//______________________________________________________________________________
2305atomic_TClass_ptr Hit::fgIsA(nullptr); // static to hold class pointer
2306
2307//______________________________________________________________________________
2308const char *Hit::Class_Name()
2309{
2310 return "Hit";
2311}
2312
2313//______________________________________________________________________________
2314const char *Hit::ImplFileName()
2315{
2316 return ::ROOT::GenerateInitInstanceLocal((const ::Hit*)nullptr)->GetImplFileName();
2317}
2318
2319//______________________________________________________________________________
2320int Hit::ImplFileLine()
2321{
2322 return ::ROOT::GenerateInitInstanceLocal((const ::Hit*)nullptr)->GetImplFileLine();
2323}
2324
2325//______________________________________________________________________________
2326TClass *Hit::Dictionary()
2327{
2328 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Hit*)nullptr)->GetClass();
2329 return fgIsA;
2330}
2331
2332//______________________________________________________________________________
2333TClass *Hit::Class()
2334{
2335 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Hit*)nullptr)->GetClass(); }
2336 return fgIsA;
2337}
2338
2339//______________________________________________________________________________
2340atomic_TClass_ptr Trk::fgIsA(nullptr); // static to hold class pointer
2341
2342//______________________________________________________________________________
2343const char *Trk::Class_Name()
2344{
2345 return "Trk";
2346}
2347
2348//______________________________________________________________________________
2349const char *Trk::ImplFileName()
2350{
2351 return ::ROOT::GenerateInitInstanceLocal((const ::Trk*)nullptr)->GetImplFileName();
2352}
2353
2354//______________________________________________________________________________
2355int Trk::ImplFileLine()
2356{
2357 return ::ROOT::GenerateInitInstanceLocal((const ::Trk*)nullptr)->GetImplFileLine();
2358}
2359
2360//______________________________________________________________________________
2361TClass *Trk::Dictionary()
2362{
2363 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Trk*)nullptr)->GetClass();
2364 return fgIsA;
2365}
2366
2367//______________________________________________________________________________
2368TClass *Trk::Class()
2369{
2370 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Trk*)nullptr)->GetClass(); }
2371 return fgIsA;
2372}
2373
2374//______________________________________________________________________________
2375atomic_TClass_ptr Evt::fgIsA(nullptr); // static to hold class pointer
2376
2377//______________________________________________________________________________
2378const char *Evt::Class_Name()
2379{
2380 return "Evt";
2381}
2382
2383//______________________________________________________________________________
2384const char *Evt::ImplFileName()
2385{
2386 return ::ROOT::GenerateInitInstanceLocal((const ::Evt*)nullptr)->GetImplFileName();
2387}
2388
2389//______________________________________________________________________________
2390int Evt::ImplFileLine()
2391{
2392 return ::ROOT::GenerateInitInstanceLocal((const ::Evt*)nullptr)->GetImplFileLine();
2393}
2394
2395//______________________________________________________________________________
2396TClass *Evt::Dictionary()
2397{
2398 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Evt*)nullptr)->GetClass();
2399 return fgIsA;
2400}
2401
2402//______________________________________________________________________________
2403TClass *Evt::Class()
2404{
2405 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Evt*)nullptr)->GetClass(); }
2406 return fgIsA;
2407}
2408
2409//______________________________________________________________________________
2410atomic_TClass_ptr Head::fgIsA(nullptr); // static to hold class pointer
2411
2412//______________________________________________________________________________
2413const char *Head::Class_Name()
2414{
2415 return "Head";
2416}
2417
2418//______________________________________________________________________________
2419const char *Head::ImplFileName()
2420{
2421 return ::ROOT::GenerateInitInstanceLocal((const ::Head*)nullptr)->GetImplFileName();
2422}
2423
2424//______________________________________________________________________________
2425int Head::ImplFileLine()
2426{
2427 return ::ROOT::GenerateInitInstanceLocal((const ::Head*)nullptr)->GetImplFileLine();
2428}
2429
2430//______________________________________________________________________________
2431TClass *Head::Dictionary()
2432{
2433 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Head*)nullptr)->GetClass();
2434 return fgIsA;
2435}
2436
2437//______________________________________________________________________________
2438TClass *Head::Class()
2439{
2440 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Head*)nullptr)->GetClass(); }
2441 return fgIsA;
2442}
2443
2444//______________________________________________________________________________
2445atomic_TClass_ptr MultiHead::fgIsA(nullptr); // static to hold class pointer
2446
2447//______________________________________________________________________________
2448const char *MultiHead::Class_Name()
2449{
2450 return "MultiHead";
2451}
2452
2453//______________________________________________________________________________
2454const char *MultiHead::ImplFileName()
2455{
2456 return ::ROOT::GenerateInitInstanceLocal((const ::MultiHead*)nullptr)->GetImplFileName();
2457}
2458
2459//______________________________________________________________________________
2460int MultiHead::ImplFileLine()
2461{
2462 return ::ROOT::GenerateInitInstanceLocal((const ::MultiHead*)nullptr)->GetImplFileLine();
2463}
2464
2465//______________________________________________________________________________
2466TClass *MultiHead::Dictionary()
2467{
2468 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MultiHead*)nullptr)->GetClass();
2469 return fgIsA;
2470}
2471
2472//______________________________________________________________________________
2473TClass *MultiHead::Class()
2474{
2475 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MultiHead*)nullptr)->GetClass(); }
2476 return fgIsA;
2477}
2478
2479namespace ROOT {
2480 // Wrappers around operator new
2481 static void *new_KM3NETDAQcLcLJDAQAbstractPreamble(void *p) {
2482 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQAbstractPreamble : new ::KM3NETDAQ::JDAQAbstractPreamble;
2483 }
2484 static void *newArray_KM3NETDAQcLcLJDAQAbstractPreamble(Long_t nElements, void *p) {
2485 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQAbstractPreamble[nElements] : new ::KM3NETDAQ::JDAQAbstractPreamble[nElements];
2486 }
2487 // Wrapper around operator delete
2488 static void delete_KM3NETDAQcLcLJDAQAbstractPreamble(void *p) {
2489 delete (static_cast<::KM3NETDAQ::JDAQAbstractPreamble*>(p));
2490 }
2491 static void deleteArray_KM3NETDAQcLcLJDAQAbstractPreamble(void *p) {
2492 delete [] (static_cast<::KM3NETDAQ::JDAQAbstractPreamble*>(p));
2493 }
2494 static void destruct_KM3NETDAQcLcLJDAQAbstractPreamble(void *p) {
2495 typedef ::KM3NETDAQ::JDAQAbstractPreamble current_t;
2496 (static_cast<current_t*>(p))->~current_t();
2497 }
2498 // Wrapper around a custom streamer member function.
2499 static void streamer_KM3NETDAQcLcLJDAQAbstractPreamble(TBuffer &buf, void *obj) {
2500 ((::KM3NETDAQ::JDAQAbstractPreamble*)obj)->::KM3NETDAQ::JDAQAbstractPreamble::Streamer(buf);
2501 }
2502} // end of namespace ROOT for class ::KM3NETDAQ::JDAQAbstractPreamble
2503
2504namespace KM3NETDAQ {
2505//______________________________________________________________________________
2506void JDAQUTCExtended::Streamer(TBuffer &R__b)
2507{
2508 // Stream an object of class KM3NETDAQ::JDAQUTCExtended.
2509
2510 if (R__b.IsReading()) {
2511 R__b.ReadClassBuffer(KM3NETDAQ::JDAQUTCExtended::Class(),this);
2512 } else {
2513 R__b.WriteClassBuffer(KM3NETDAQ::JDAQUTCExtended::Class(),this);
2514 }
2515}
2516
2517} // namespace KM3NETDAQ
2518namespace ROOT {
2519 // Wrappers around operator new
2520 static void *new_KM3NETDAQcLcLJDAQUTCExtended(void *p) {
2521 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQUTCExtended : new ::KM3NETDAQ::JDAQUTCExtended;
2522 }
2523 static void *newArray_KM3NETDAQcLcLJDAQUTCExtended(Long_t nElements, void *p) {
2524 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQUTCExtended[nElements] : new ::KM3NETDAQ::JDAQUTCExtended[nElements];
2525 }
2526 // Wrapper around operator delete
2527 static void delete_KM3NETDAQcLcLJDAQUTCExtended(void *p) {
2528 delete (static_cast<::KM3NETDAQ::JDAQUTCExtended*>(p));
2529 }
2530 static void deleteArray_KM3NETDAQcLcLJDAQUTCExtended(void *p) {
2531 delete [] (static_cast<::KM3NETDAQ::JDAQUTCExtended*>(p));
2532 }
2533 static void destruct_KM3NETDAQcLcLJDAQUTCExtended(void *p) {
2534 typedef ::KM3NETDAQ::JDAQUTCExtended current_t;
2535 (static_cast<current_t*>(p))->~current_t();
2536 }
2537} // end of namespace ROOT for class ::KM3NETDAQ::JDAQUTCExtended
2538
2539namespace KM3NETDAQ {
2540//______________________________________________________________________________
2541void JDAQChronometer::Streamer(TBuffer &R__b)
2542{
2543 // Stream an object of class KM3NETDAQ::JDAQChronometer.
2544
2545 if (R__b.IsReading()) {
2546 R__b.ReadClassBuffer(KM3NETDAQ::JDAQChronometer::Class(),this);
2547 } else {
2548 R__b.WriteClassBuffer(KM3NETDAQ::JDAQChronometer::Class(),this);
2549 }
2550}
2551
2552} // namespace KM3NETDAQ
2553namespace ROOT {
2554 // Wrappers around operator new
2555 static void *new_KM3NETDAQcLcLJDAQChronometer(void *p) {
2556 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQChronometer : new ::KM3NETDAQ::JDAQChronometer;
2557 }
2558 static void *newArray_KM3NETDAQcLcLJDAQChronometer(Long_t nElements, void *p) {
2559 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQChronometer[nElements] : new ::KM3NETDAQ::JDAQChronometer[nElements];
2560 }
2561 // Wrapper around operator delete
2562 static void delete_KM3NETDAQcLcLJDAQChronometer(void *p) {
2563 delete (static_cast<::KM3NETDAQ::JDAQChronometer*>(p));
2564 }
2565 static void deleteArray_KM3NETDAQcLcLJDAQChronometer(void *p) {
2566 delete [] (static_cast<::KM3NETDAQ::JDAQChronometer*>(p));
2567 }
2568 static void destruct_KM3NETDAQcLcLJDAQChronometer(void *p) {
2569 typedef ::KM3NETDAQ::JDAQChronometer current_t;
2570 (static_cast<current_t*>(p))->~current_t();
2571 }
2572} // end of namespace ROOT for class ::KM3NETDAQ::JDAQChronometer
2573
2574namespace ROOT {
2575 // Wrappers around operator new
2576 static void *new_KM3NETDAQcLcLJDAQPreamble(void *p) {
2577 return p ? new(p) ::KM3NETDAQ::JDAQPreamble : new ::KM3NETDAQ::JDAQPreamble;
2578 }
2579 static void *newArray_KM3NETDAQcLcLJDAQPreamble(Long_t nElements, void *p) {
2580 return p ? new(p) ::KM3NETDAQ::JDAQPreamble[nElements] : new ::KM3NETDAQ::JDAQPreamble[nElements];
2581 }
2582 // Wrapper around operator delete
2583 static void delete_KM3NETDAQcLcLJDAQPreamble(void *p) {
2584 delete (static_cast<::KM3NETDAQ::JDAQPreamble*>(p));
2585 }
2586 static void deleteArray_KM3NETDAQcLcLJDAQPreamble(void *p) {
2587 delete [] (static_cast<::KM3NETDAQ::JDAQPreamble*>(p));
2588 }
2589 static void destruct_KM3NETDAQcLcLJDAQPreamble(void *p) {
2590 typedef ::KM3NETDAQ::JDAQPreamble current_t;
2591 (static_cast<current_t*>(p))->~current_t();
2592 }
2593 // Wrapper around a custom streamer member function.
2594 static void streamer_KM3NETDAQcLcLJDAQPreamble(TBuffer &buf, void *obj) {
2595 ((::KM3NETDAQ::JDAQPreamble*)obj)->::KM3NETDAQ::JDAQPreamble::Streamer(buf);
2596 }
2597} // end of namespace ROOT for class ::KM3NETDAQ::JDAQPreamble
2598
2599namespace KM3NETDAQ {
2600//______________________________________________________________________________
2601void JDAQHeader::Streamer(TBuffer &R__b)
2602{
2603 // Stream an object of class KM3NETDAQ::JDAQHeader.
2604
2605 if (R__b.IsReading()) {
2606 R__b.ReadClassBuffer(KM3NETDAQ::JDAQHeader::Class(),this);
2607 } else {
2608 R__b.WriteClassBuffer(KM3NETDAQ::JDAQHeader::Class(),this);
2609 }
2610}
2611
2612} // namespace KM3NETDAQ
2613namespace ROOT {
2614 // Wrappers around operator new
2615 static void *new_KM3NETDAQcLcLJDAQHeader(void *p) {
2616 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQHeader : new ::KM3NETDAQ::JDAQHeader;
2617 }
2618 static void *newArray_KM3NETDAQcLcLJDAQHeader(Long_t nElements, void *p) {
2619 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQHeader[nElements] : new ::KM3NETDAQ::JDAQHeader[nElements];
2620 }
2621 // Wrapper around operator delete
2622 static void delete_KM3NETDAQcLcLJDAQHeader(void *p) {
2623 delete (static_cast<::KM3NETDAQ::JDAQHeader*>(p));
2624 }
2625 static void deleteArray_KM3NETDAQcLcLJDAQHeader(void *p) {
2626 delete [] (static_cast<::KM3NETDAQ::JDAQHeader*>(p));
2627 }
2628 static void destruct_KM3NETDAQcLcLJDAQHeader(void *p) {
2629 typedef ::KM3NETDAQ::JDAQHeader current_t;
2630 (static_cast<current_t*>(p))->~current_t();
2631 }
2632} // end of namespace ROOT for class ::KM3NETDAQ::JDAQHeader
2633
2634namespace KM3NETDAQ {
2635//______________________________________________________________________________
2636void JDAQTriggerCounter::Streamer(TBuffer &R__b)
2637{
2638 // Stream an object of class KM3NETDAQ::JDAQTriggerCounter.
2639
2640 if (R__b.IsReading()) {
2641 R__b.ReadClassBuffer(KM3NETDAQ::JDAQTriggerCounter::Class(),this);
2642 } else {
2643 R__b.WriteClassBuffer(KM3NETDAQ::JDAQTriggerCounter::Class(),this);
2644 }
2645}
2646
2647} // namespace KM3NETDAQ
2648namespace ROOT {
2649 // Wrappers around operator new
2650 static void *new_KM3NETDAQcLcLJDAQTriggerCounter(void *p) {
2651 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQTriggerCounter : new ::KM3NETDAQ::JDAQTriggerCounter;
2652 }
2653 static void *newArray_KM3NETDAQcLcLJDAQTriggerCounter(Long_t nElements, void *p) {
2654 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQTriggerCounter[nElements] : new ::KM3NETDAQ::JDAQTriggerCounter[nElements];
2655 }
2656 // Wrapper around operator delete
2657 static void delete_KM3NETDAQcLcLJDAQTriggerCounter(void *p) {
2658 delete (static_cast<::KM3NETDAQ::JDAQTriggerCounter*>(p));
2659 }
2660 static void deleteArray_KM3NETDAQcLcLJDAQTriggerCounter(void *p) {
2661 delete [] (static_cast<::KM3NETDAQ::JDAQTriggerCounter*>(p));
2662 }
2663 static void destruct_KM3NETDAQcLcLJDAQTriggerCounter(void *p) {
2664 typedef ::KM3NETDAQ::JDAQTriggerCounter current_t;
2665 (static_cast<current_t*>(p))->~current_t();
2666 }
2667} // end of namespace ROOT for class ::KM3NETDAQ::JDAQTriggerCounter
2668
2669namespace KM3NETDAQ {
2670//______________________________________________________________________________
2671void JDAQTriggerMask::Streamer(TBuffer &R__b)
2672{
2673 // Stream an object of class KM3NETDAQ::JDAQTriggerMask.
2674
2675 if (R__b.IsReading()) {
2676 R__b.ReadClassBuffer(KM3NETDAQ::JDAQTriggerMask::Class(),this);
2677 } else {
2678 R__b.WriteClassBuffer(KM3NETDAQ::JDAQTriggerMask::Class(),this);
2679 }
2680}
2681
2682} // namespace KM3NETDAQ
2683namespace ROOT {
2684 // Wrappers around operator new
2685 static void *new_KM3NETDAQcLcLJDAQTriggerMask(void *p) {
2686 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQTriggerMask : new ::KM3NETDAQ::JDAQTriggerMask;
2687 }
2688 static void *newArray_KM3NETDAQcLcLJDAQTriggerMask(Long_t nElements, void *p) {
2689 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQTriggerMask[nElements] : new ::KM3NETDAQ::JDAQTriggerMask[nElements];
2690 }
2691 // Wrapper around operator delete
2692 static void delete_KM3NETDAQcLcLJDAQTriggerMask(void *p) {
2693 delete (static_cast<::KM3NETDAQ::JDAQTriggerMask*>(p));
2694 }
2695 static void deleteArray_KM3NETDAQcLcLJDAQTriggerMask(void *p) {
2696 delete [] (static_cast<::KM3NETDAQ::JDAQTriggerMask*>(p));
2697 }
2698 static void destruct_KM3NETDAQcLcLJDAQTriggerMask(void *p) {
2699 typedef ::KM3NETDAQ::JDAQTriggerMask current_t;
2700 (static_cast<current_t*>(p))->~current_t();
2701 }
2702} // end of namespace ROOT for class ::KM3NETDAQ::JDAQTriggerMask
2703
2704namespace KM3NETDAQ {
2705//______________________________________________________________________________
2706void JDAQEventHeader::Streamer(TBuffer &R__b)
2707{
2708 // Stream an object of class KM3NETDAQ::JDAQEventHeader.
2709
2710 if (R__b.IsReading()) {
2711 R__b.ReadClassBuffer(KM3NETDAQ::JDAQEventHeader::Class(),this);
2712 } else {
2713 R__b.WriteClassBuffer(KM3NETDAQ::JDAQEventHeader::Class(),this);
2714 }
2715}
2716
2717} // namespace KM3NETDAQ
2718namespace ROOT {
2719 // Wrappers around operator new
2720 static void *new_KM3NETDAQcLcLJDAQEventHeader(void *p) {
2721 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQEventHeader : new ::KM3NETDAQ::JDAQEventHeader;
2722 }
2723 static void *newArray_KM3NETDAQcLcLJDAQEventHeader(Long_t nElements, void *p) {
2724 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQEventHeader[nElements] : new ::KM3NETDAQ::JDAQEventHeader[nElements];
2725 }
2726 // Wrapper around operator delete
2727 static void delete_KM3NETDAQcLcLJDAQEventHeader(void *p) {
2728 delete (static_cast<::KM3NETDAQ::JDAQEventHeader*>(p));
2729 }
2730 static void deleteArray_KM3NETDAQcLcLJDAQEventHeader(void *p) {
2731 delete [] (static_cast<::KM3NETDAQ::JDAQEventHeader*>(p));
2732 }
2733 static void destruct_KM3NETDAQcLcLJDAQEventHeader(void *p) {
2734 typedef ::KM3NETDAQ::JDAQEventHeader current_t;
2735 (static_cast<current_t*>(p))->~current_t();
2736 }
2737} // end of namespace ROOT for class ::KM3NETDAQ::JDAQEventHeader
2738
2739namespace ROOT {
2740 // Wrappers around operator new
2741 static void *new_KM3NETDAQcLcLJDAQHit(void *p) {
2742 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQHit : new ::KM3NETDAQ::JDAQHit;
2743 }
2744 static void *newArray_KM3NETDAQcLcLJDAQHit(Long_t nElements, void *p) {
2745 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQHit[nElements] : new ::KM3NETDAQ::JDAQHit[nElements];
2746 }
2747 // Wrapper around operator delete
2748 static void delete_KM3NETDAQcLcLJDAQHit(void *p) {
2749 delete (static_cast<::KM3NETDAQ::JDAQHit*>(p));
2750 }
2751 static void deleteArray_KM3NETDAQcLcLJDAQHit(void *p) {
2752 delete [] (static_cast<::KM3NETDAQ::JDAQHit*>(p));
2753 }
2754 static void destruct_KM3NETDAQcLcLJDAQHit(void *p) {
2755 typedef ::KM3NETDAQ::JDAQHit current_t;
2756 (static_cast<current_t*>(p))->~current_t();
2757 }
2758 // Wrapper around a custom streamer member function.
2759 static void streamer_KM3NETDAQcLcLJDAQHit(TBuffer &buf, void *obj) {
2760 ((::KM3NETDAQ::JDAQHit*)obj)->::KM3NETDAQ::JDAQHit::Streamer(buf);
2761 }
2762} // end of namespace ROOT for class ::KM3NETDAQ::JDAQHit
2763
2764namespace ROOT {
2765 // Wrappers around operator new
2766 static void *new_KM3NETDAQcLcLJDAQModuleIdentifier(void *p) {
2767 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQModuleIdentifier : new ::KM3NETDAQ::JDAQModuleIdentifier;
2768 }
2769 static void *newArray_KM3NETDAQcLcLJDAQModuleIdentifier(Long_t nElements, void *p) {
2770 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQModuleIdentifier[nElements] : new ::KM3NETDAQ::JDAQModuleIdentifier[nElements];
2771 }
2772 // Wrapper around operator delete
2773 static void delete_KM3NETDAQcLcLJDAQModuleIdentifier(void *p) {
2774 delete (static_cast<::KM3NETDAQ::JDAQModuleIdentifier*>(p));
2775 }
2776 static void deleteArray_KM3NETDAQcLcLJDAQModuleIdentifier(void *p) {
2777 delete [] (static_cast<::KM3NETDAQ::JDAQModuleIdentifier*>(p));
2778 }
2779 static void destruct_KM3NETDAQcLcLJDAQModuleIdentifier(void *p) {
2780 typedef ::KM3NETDAQ::JDAQModuleIdentifier current_t;
2781 (static_cast<current_t*>(p))->~current_t();
2782 }
2783 // Wrapper around a custom streamer member function.
2784 static void streamer_KM3NETDAQcLcLJDAQModuleIdentifier(TBuffer &buf, void *obj) {
2785 ((::KM3NETDAQ::JDAQModuleIdentifier*)obj)->::KM3NETDAQ::JDAQModuleIdentifier::Streamer(buf);
2786 }
2787} // end of namespace ROOT for class ::KM3NETDAQ::JDAQModuleIdentifier
2788
2789namespace ROOT {
2790 // Wrappers around operator new
2791 static void *new_KM3NETDAQcLcLJDAQPMTIdentifier(void *p) {
2792 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQPMTIdentifier : new ::KM3NETDAQ::JDAQPMTIdentifier;
2793 }
2794 static void *newArray_KM3NETDAQcLcLJDAQPMTIdentifier(Long_t nElements, void *p) {
2795 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQPMTIdentifier[nElements] : new ::KM3NETDAQ::JDAQPMTIdentifier[nElements];
2796 }
2797 // Wrapper around operator delete
2798 static void delete_KM3NETDAQcLcLJDAQPMTIdentifier(void *p) {
2799 delete (static_cast<::KM3NETDAQ::JDAQPMTIdentifier*>(p));
2800 }
2801 static void deleteArray_KM3NETDAQcLcLJDAQPMTIdentifier(void *p) {
2802 delete [] (static_cast<::KM3NETDAQ::JDAQPMTIdentifier*>(p));
2803 }
2804 static void destruct_KM3NETDAQcLcLJDAQPMTIdentifier(void *p) {
2805 typedef ::KM3NETDAQ::JDAQPMTIdentifier current_t;
2806 (static_cast<current_t*>(p))->~current_t();
2807 }
2808 // Wrapper around a custom streamer member function.
2809 static void streamer_KM3NETDAQcLcLJDAQPMTIdentifier(TBuffer &buf, void *obj) {
2810 ((::KM3NETDAQ::JDAQPMTIdentifier*)obj)->::KM3NETDAQ::JDAQPMTIdentifier::Streamer(buf);
2811 }
2812} // end of namespace ROOT for class ::KM3NETDAQ::JDAQPMTIdentifier
2813
2814namespace ROOT {
2815 // Wrappers around operator new
2816 static void *new_KM3NETDAQcLcLJDAQKeyHit(void *p) {
2817 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQKeyHit : new ::KM3NETDAQ::JDAQKeyHit;
2818 }
2819 static void *newArray_KM3NETDAQcLcLJDAQKeyHit(Long_t nElements, void *p) {
2820 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQKeyHit[nElements] : new ::KM3NETDAQ::JDAQKeyHit[nElements];
2821 }
2822 // Wrapper around operator delete
2823 static void delete_KM3NETDAQcLcLJDAQKeyHit(void *p) {
2824 delete (static_cast<::KM3NETDAQ::JDAQKeyHit*>(p));
2825 }
2826 static void deleteArray_KM3NETDAQcLcLJDAQKeyHit(void *p) {
2827 delete [] (static_cast<::KM3NETDAQ::JDAQKeyHit*>(p));
2828 }
2829 static void destruct_KM3NETDAQcLcLJDAQKeyHit(void *p) {
2830 typedef ::KM3NETDAQ::JDAQKeyHit current_t;
2831 (static_cast<current_t*>(p))->~current_t();
2832 }
2833 // Wrapper around a custom streamer member function.
2834 static void streamer_KM3NETDAQcLcLJDAQKeyHit(TBuffer &buf, void *obj) {
2835 ((::KM3NETDAQ::JDAQKeyHit*)obj)->::KM3NETDAQ::JDAQKeyHit::Streamer(buf);
2836 }
2837} // end of namespace ROOT for class ::KM3NETDAQ::JDAQKeyHit
2838
2839namespace ROOT {
2840 // Wrappers around operator new
2841 static void *new_KM3NETDAQcLcLJDAQTriggeredHit(void *p) {
2842 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQTriggeredHit : new ::KM3NETDAQ::JDAQTriggeredHit;
2843 }
2844 static void *newArray_KM3NETDAQcLcLJDAQTriggeredHit(Long_t nElements, void *p) {
2845 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQTriggeredHit[nElements] : new ::KM3NETDAQ::JDAQTriggeredHit[nElements];
2846 }
2847 // Wrapper around operator delete
2848 static void delete_KM3NETDAQcLcLJDAQTriggeredHit(void *p) {
2849 delete (static_cast<::KM3NETDAQ::JDAQTriggeredHit*>(p));
2850 }
2851 static void deleteArray_KM3NETDAQcLcLJDAQTriggeredHit(void *p) {
2852 delete [] (static_cast<::KM3NETDAQ::JDAQTriggeredHit*>(p));
2853 }
2854 static void destruct_KM3NETDAQcLcLJDAQTriggeredHit(void *p) {
2855 typedef ::KM3NETDAQ::JDAQTriggeredHit current_t;
2856 (static_cast<current_t*>(p))->~current_t();
2857 }
2858 // Wrapper around a custom streamer member function.
2859 static void streamer_KM3NETDAQcLcLJDAQTriggeredHit(TBuffer &buf, void *obj) {
2860 ((::KM3NETDAQ::JDAQTriggeredHit*)obj)->::KM3NETDAQ::JDAQTriggeredHit::Streamer(buf);
2861 }
2862} // end of namespace ROOT for class ::KM3NETDAQ::JDAQTriggeredHit
2863
2864namespace KM3NETDAQ {
2865//______________________________________________________________________________
2866void JDAQEvent::Streamer(TBuffer &R__b)
2867{
2868 // Stream an object of class KM3NETDAQ::JDAQEvent.
2869
2870 if (R__b.IsReading()) {
2871 R__b.ReadClassBuffer(KM3NETDAQ::JDAQEvent::Class(),this);
2872 } else {
2873 R__b.WriteClassBuffer(KM3NETDAQ::JDAQEvent::Class(),this);
2874 }
2875}
2876
2877} // namespace KM3NETDAQ
2878namespace ROOT {
2879 // Wrappers around operator new
2880 static void *new_KM3NETDAQcLcLJDAQEvent(void *p) {
2881 return p ? new(p) ::KM3NETDAQ::JDAQEvent : new ::KM3NETDAQ::JDAQEvent;
2882 }
2883 static void *newArray_KM3NETDAQcLcLJDAQEvent(Long_t nElements, void *p) {
2884 return p ? new(p) ::KM3NETDAQ::JDAQEvent[nElements] : new ::KM3NETDAQ::JDAQEvent[nElements];
2885 }
2886 // Wrapper around operator delete
2887 static void delete_KM3NETDAQcLcLJDAQEvent(void *p) {
2888 delete (static_cast<::KM3NETDAQ::JDAQEvent*>(p));
2889 }
2890 static void deleteArray_KM3NETDAQcLcLJDAQEvent(void *p) {
2891 delete [] (static_cast<::KM3NETDAQ::JDAQEvent*>(p));
2892 }
2893 static void destruct_KM3NETDAQcLcLJDAQEvent(void *p) {
2894 typedef ::KM3NETDAQ::JDAQEvent current_t;
2895 (static_cast<current_t*>(p))->~current_t();
2896 }
2897} // end of namespace ROOT for class ::KM3NETDAQ::JDAQEvent
2898
2899namespace KM3NETDAQ {
2900//______________________________________________________________________________
2901void JDAQFrame::Streamer(TBuffer &R__b)
2902{
2903 // Stream an object of class KM3NETDAQ::JDAQFrame.
2904
2905 if (R__b.IsReading()) {
2906 R__b.ReadClassBuffer(KM3NETDAQ::JDAQFrame::Class(),this);
2907 } else {
2908 R__b.WriteClassBuffer(KM3NETDAQ::JDAQFrame::Class(),this);
2909 }
2910}
2911
2912} // namespace KM3NETDAQ
2913namespace ROOT {
2914 // Wrappers around operator new
2915 static void *new_KM3NETDAQcLcLJDAQFrame(void *p) {
2916 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQFrame : new ::KM3NETDAQ::JDAQFrame;
2917 }
2918 static void *newArray_KM3NETDAQcLcLJDAQFrame(Long_t nElements, void *p) {
2919 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQFrame[nElements] : new ::KM3NETDAQ::JDAQFrame[nElements];
2920 }
2921 // Wrapper around operator delete
2922 static void delete_KM3NETDAQcLcLJDAQFrame(void *p) {
2923 delete (static_cast<::KM3NETDAQ::JDAQFrame*>(p));
2924 }
2925 static void deleteArray_KM3NETDAQcLcLJDAQFrame(void *p) {
2926 delete [] (static_cast<::KM3NETDAQ::JDAQFrame*>(p));
2927 }
2928 static void destruct_KM3NETDAQcLcLJDAQFrame(void *p) {
2929 typedef ::KM3NETDAQ::JDAQFrame current_t;
2930 (static_cast<current_t*>(p))->~current_t();
2931 }
2932} // end of namespace ROOT for class ::KM3NETDAQ::JDAQFrame
2933
2934namespace KM3NETDAQ {
2935//______________________________________________________________________________
2936void JDAQFrameStatus::Streamer(TBuffer &R__b)
2937{
2938 // Stream an object of class KM3NETDAQ::JDAQFrameStatus.
2939
2940 if (R__b.IsReading()) {
2941 R__b.ReadClassBuffer(KM3NETDAQ::JDAQFrameStatus::Class(),this);
2942 } else {
2943 R__b.WriteClassBuffer(KM3NETDAQ::JDAQFrameStatus::Class(),this);
2944 }
2945}
2946
2947} // namespace KM3NETDAQ
2948namespace ROOT {
2949 // Wrappers around operator new
2950 static void *new_KM3NETDAQcLcLJDAQFrameStatus(void *p) {
2951 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQFrameStatus : new ::KM3NETDAQ::JDAQFrameStatus;
2952 }
2953 static void *newArray_KM3NETDAQcLcLJDAQFrameStatus(Long_t nElements, void *p) {
2954 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQFrameStatus[nElements] : new ::KM3NETDAQ::JDAQFrameStatus[nElements];
2955 }
2956 // Wrapper around operator delete
2957 static void delete_KM3NETDAQcLcLJDAQFrameStatus(void *p) {
2958 delete (static_cast<::KM3NETDAQ::JDAQFrameStatus*>(p));
2959 }
2960 static void deleteArray_KM3NETDAQcLcLJDAQFrameStatus(void *p) {
2961 delete [] (static_cast<::KM3NETDAQ::JDAQFrameStatus*>(p));
2962 }
2963 static void destruct_KM3NETDAQcLcLJDAQFrameStatus(void *p) {
2964 typedef ::KM3NETDAQ::JDAQFrameStatus current_t;
2965 (static_cast<current_t*>(p))->~current_t();
2966 }
2967} // end of namespace ROOT for class ::KM3NETDAQ::JDAQFrameStatus
2968
2969namespace KM3NETDAQ {
2970//______________________________________________________________________________
2971void JDAQSuperFrameHeader::Streamer(TBuffer &R__b)
2972{
2973 // Stream an object of class KM3NETDAQ::JDAQSuperFrameHeader.
2974
2975 if (R__b.IsReading()) {
2976 R__b.ReadClassBuffer(KM3NETDAQ::JDAQSuperFrameHeader::Class(),this);
2977 } else {
2978 R__b.WriteClassBuffer(KM3NETDAQ::JDAQSuperFrameHeader::Class(),this);
2979 }
2980}
2981
2982} // namespace KM3NETDAQ
2983namespace ROOT {
2984 // Wrappers around operator new
2985 static void *new_KM3NETDAQcLcLJDAQSuperFrameHeader(void *p) {
2986 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQSuperFrameHeader : new ::KM3NETDAQ::JDAQSuperFrameHeader;
2987 }
2988 static void *newArray_KM3NETDAQcLcLJDAQSuperFrameHeader(Long_t nElements, void *p) {
2989 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQSuperFrameHeader[nElements] : new ::KM3NETDAQ::JDAQSuperFrameHeader[nElements];
2990 }
2991 // Wrapper around operator delete
2992 static void delete_KM3NETDAQcLcLJDAQSuperFrameHeader(void *p) {
2993 delete (static_cast<::KM3NETDAQ::JDAQSuperFrameHeader*>(p));
2994 }
2995 static void deleteArray_KM3NETDAQcLcLJDAQSuperFrameHeader(void *p) {
2996 delete [] (static_cast<::KM3NETDAQ::JDAQSuperFrameHeader*>(p));
2997 }
2998 static void destruct_KM3NETDAQcLcLJDAQSuperFrameHeader(void *p) {
2999 typedef ::KM3NETDAQ::JDAQSuperFrameHeader current_t;
3000 (static_cast<current_t*>(p))->~current_t();
3001 }
3002} // end of namespace ROOT for class ::KM3NETDAQ::JDAQSuperFrameHeader
3003
3004namespace KM3NETDAQ {
3005//______________________________________________________________________________
3006void JDAQSuperFrame::Streamer(TBuffer &R__b)
3007{
3008 // Stream an object of class KM3NETDAQ::JDAQSuperFrame.
3009
3010 if (R__b.IsReading()) {
3011 R__b.ReadClassBuffer(KM3NETDAQ::JDAQSuperFrame::Class(),this);
3012 } else {
3013 R__b.WriteClassBuffer(KM3NETDAQ::JDAQSuperFrame::Class(),this);
3014 }
3015}
3016
3017} // namespace KM3NETDAQ
3018namespace ROOT {
3019 // Wrappers around operator new
3020 static void *new_KM3NETDAQcLcLJDAQSuperFrame(void *p) {
3021 return p ? new(p) ::KM3NETDAQ::JDAQSuperFrame : new ::KM3NETDAQ::JDAQSuperFrame;
3022 }
3023 static void *newArray_KM3NETDAQcLcLJDAQSuperFrame(Long_t nElements, void *p) {
3024 return p ? new(p) ::KM3NETDAQ::JDAQSuperFrame[nElements] : new ::KM3NETDAQ::JDAQSuperFrame[nElements];
3025 }
3026 // Wrapper around operator delete
3027 static void delete_KM3NETDAQcLcLJDAQSuperFrame(void *p) {
3028 delete (static_cast<::KM3NETDAQ::JDAQSuperFrame*>(p));
3029 }
3030 static void deleteArray_KM3NETDAQcLcLJDAQSuperFrame(void *p) {
3031 delete [] (static_cast<::KM3NETDAQ::JDAQSuperFrame*>(p));
3032 }
3033 static void destruct_KM3NETDAQcLcLJDAQSuperFrame(void *p) {
3034 typedef ::KM3NETDAQ::JDAQSuperFrame current_t;
3035 (static_cast<current_t*>(p))->~current_t();
3036 }
3037} // end of namespace ROOT for class ::KM3NETDAQ::JDAQSuperFrame
3038
3039namespace ROOT {
3040 // Wrappers around operator new
3041 static void *new_KM3NETDAQcLcLJDAQRate(void *p) {
3042 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQRate : new ::KM3NETDAQ::JDAQRate;
3043 }
3044 static void *newArray_KM3NETDAQcLcLJDAQRate(Long_t nElements, void *p) {
3045 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQRate[nElements] : new ::KM3NETDAQ::JDAQRate[nElements];
3046 }
3047 // Wrapper around operator delete
3048 static void delete_KM3NETDAQcLcLJDAQRate(void *p) {
3049 delete (static_cast<::KM3NETDAQ::JDAQRate*>(p));
3050 }
3051 static void deleteArray_KM3NETDAQcLcLJDAQRate(void *p) {
3052 delete [] (static_cast<::KM3NETDAQ::JDAQRate*>(p));
3053 }
3054 static void destruct_KM3NETDAQcLcLJDAQRate(void *p) {
3055 typedef ::KM3NETDAQ::JDAQRate current_t;
3056 (static_cast<current_t*>(p))->~current_t();
3057 }
3058} // end of namespace ROOT for class ::KM3NETDAQ::JDAQRate
3059
3060namespace ROOT {
3061 // Wrappers around operator new
3062 static void *new_KM3NETDAQcLcLJDAQSummaryFrame(void *p) {
3063 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQSummaryFrame : new ::KM3NETDAQ::JDAQSummaryFrame;
3064 }
3065 static void *newArray_KM3NETDAQcLcLJDAQSummaryFrame(Long_t nElements, void *p) {
3066 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQSummaryFrame[nElements] : new ::KM3NETDAQ::JDAQSummaryFrame[nElements];
3067 }
3068 // Wrapper around operator delete
3069 static void delete_KM3NETDAQcLcLJDAQSummaryFrame(void *p) {
3070 delete (static_cast<::KM3NETDAQ::JDAQSummaryFrame*>(p));
3071 }
3072 static void deleteArray_KM3NETDAQcLcLJDAQSummaryFrame(void *p) {
3073 delete [] (static_cast<::KM3NETDAQ::JDAQSummaryFrame*>(p));
3074 }
3075 static void destruct_KM3NETDAQcLcLJDAQSummaryFrame(void *p) {
3076 typedef ::KM3NETDAQ::JDAQSummaryFrame current_t;
3077 (static_cast<current_t*>(p))->~current_t();
3078 }
3079 // Wrapper around a custom streamer member function.
3080 static void streamer_KM3NETDAQcLcLJDAQSummaryFrame(TBuffer &buf, void *obj) {
3081 ((::KM3NETDAQ::JDAQSummaryFrame*)obj)->::KM3NETDAQ::JDAQSummaryFrame::Streamer(buf);
3082 }
3083} // end of namespace ROOT for class ::KM3NETDAQ::JDAQSummaryFrame
3084
3085namespace KM3NETDAQ {
3086//______________________________________________________________________________
3087void JDAQSummarysliceHeader::Streamer(TBuffer &R__b)
3088{
3089 // Stream an object of class KM3NETDAQ::JDAQSummarysliceHeader.
3090
3091 if (R__b.IsReading()) {
3092 R__b.ReadClassBuffer(KM3NETDAQ::JDAQSummarysliceHeader::Class(),this);
3093 } else {
3094 R__b.WriteClassBuffer(KM3NETDAQ::JDAQSummarysliceHeader::Class(),this);
3095 }
3096}
3097
3098} // namespace KM3NETDAQ
3099namespace ROOT {
3100 // Wrappers around operator new
3101 static void *new_KM3NETDAQcLcLJDAQSummarysliceHeader(void *p) {
3102 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQSummarysliceHeader : new ::KM3NETDAQ::JDAQSummarysliceHeader;
3103 }
3104 static void *newArray_KM3NETDAQcLcLJDAQSummarysliceHeader(Long_t nElements, void *p) {
3105 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQSummarysliceHeader[nElements] : new ::KM3NETDAQ::JDAQSummarysliceHeader[nElements];
3106 }
3107 // Wrapper around operator delete
3108 static void delete_KM3NETDAQcLcLJDAQSummarysliceHeader(void *p) {
3109 delete (static_cast<::KM3NETDAQ::JDAQSummarysliceHeader*>(p));
3110 }
3111 static void deleteArray_KM3NETDAQcLcLJDAQSummarysliceHeader(void *p) {
3112 delete [] (static_cast<::KM3NETDAQ::JDAQSummarysliceHeader*>(p));
3113 }
3114 static void destruct_KM3NETDAQcLcLJDAQSummarysliceHeader(void *p) {
3115 typedef ::KM3NETDAQ::JDAQSummarysliceHeader current_t;
3116 (static_cast<current_t*>(p))->~current_t();
3117 }
3118} // end of namespace ROOT for class ::KM3NETDAQ::JDAQSummarysliceHeader
3119
3120namespace KM3NETDAQ {
3121//______________________________________________________________________________
3122void JDAQTimesliceHeader::Streamer(TBuffer &R__b)
3123{
3124 // Stream an object of class KM3NETDAQ::JDAQTimesliceHeader.
3125
3126 if (R__b.IsReading()) {
3127 R__b.ReadClassBuffer(KM3NETDAQ::JDAQTimesliceHeader::Class(),this);
3128 } else {
3129 R__b.WriteClassBuffer(KM3NETDAQ::JDAQTimesliceHeader::Class(),this);
3130 }
3131}
3132
3133} // namespace KM3NETDAQ
3134namespace ROOT {
3135 // Wrappers around operator new
3136 static void *new_KM3NETDAQcLcLJDAQTimesliceHeader(void *p) {
3137 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQTimesliceHeader : new ::KM3NETDAQ::JDAQTimesliceHeader;
3138 }
3139 static void *newArray_KM3NETDAQcLcLJDAQTimesliceHeader(Long_t nElements, void *p) {
3140 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::KM3NETDAQ::JDAQTimesliceHeader[nElements] : new ::KM3NETDAQ::JDAQTimesliceHeader[nElements];
3141 }
3142 // Wrapper around operator delete
3143 static void delete_KM3NETDAQcLcLJDAQTimesliceHeader(void *p) {
3144 delete (static_cast<::KM3NETDAQ::JDAQTimesliceHeader*>(p));
3145 }
3146 static void deleteArray_KM3NETDAQcLcLJDAQTimesliceHeader(void *p) {
3147 delete [] (static_cast<::KM3NETDAQ::JDAQTimesliceHeader*>(p));
3148 }
3149 static void destruct_KM3NETDAQcLcLJDAQTimesliceHeader(void *p) {
3150 typedef ::KM3NETDAQ::JDAQTimesliceHeader current_t;
3151 (static_cast<current_t*>(p))->~current_t();
3152 }
3153} // end of namespace ROOT for class ::KM3NETDAQ::JDAQTimesliceHeader
3154
3155namespace KM3NETDAQ {
3156//______________________________________________________________________________
3157void JDAQTimeslice::Streamer(TBuffer &R__b)
3158{
3159 // Stream an object of class KM3NETDAQ::JDAQTimeslice.
3160
3161 if (R__b.IsReading()) {
3162 R__b.ReadClassBuffer(KM3NETDAQ::JDAQTimeslice::Class(),this);
3163 } else {
3164 R__b.WriteClassBuffer(KM3NETDAQ::JDAQTimeslice::Class(),this);
3165 }
3166}
3167
3168} // namespace KM3NETDAQ
3169namespace ROOT {
3170 // Wrappers around operator new
3171 static void *new_KM3NETDAQcLcLJDAQTimeslice(void *p) {
3172 return p ? new(p) ::KM3NETDAQ::JDAQTimeslice : new ::KM3NETDAQ::JDAQTimeslice;
3173 }
3174 static void *newArray_KM3NETDAQcLcLJDAQTimeslice(Long_t nElements, void *p) {
3175 return p ? new(p) ::KM3NETDAQ::JDAQTimeslice[nElements] : new ::KM3NETDAQ::JDAQTimeslice[nElements];
3176 }
3177 // Wrapper around operator delete
3178 static void delete_KM3NETDAQcLcLJDAQTimeslice(void *p) {
3179 delete (static_cast<::KM3NETDAQ::JDAQTimeslice*>(p));
3180 }
3181 static void deleteArray_KM3NETDAQcLcLJDAQTimeslice(void *p) {
3182 delete [] (static_cast<::KM3NETDAQ::JDAQTimeslice*>(p));
3183 }
3184 static void destruct_KM3NETDAQcLcLJDAQTimeslice(void *p) {
3185 typedef ::KM3NETDAQ::JDAQTimeslice current_t;
3186 (static_cast<current_t*>(p))->~current_t();
3187 }
3188} // end of namespace ROOT for class ::KM3NETDAQ::JDAQTimeslice
3189
3190namespace KM3NETDAQ {
3191//______________________________________________________________________________
3192void JDAQTimesliceL0::Streamer(TBuffer &R__b)
3193{
3194 // Stream an object of class KM3NETDAQ::JDAQTimesliceL0.
3195
3196 if (R__b.IsReading()) {
3197 R__b.ReadClassBuffer(KM3NETDAQ::JDAQTimesliceL0::Class(),this);
3198 } else {
3199 R__b.WriteClassBuffer(KM3NETDAQ::JDAQTimesliceL0::Class(),this);
3200 }
3201}
3202
3203} // namespace KM3NETDAQ
3204namespace ROOT {
3205 // Wrappers around operator new
3206 static void *new_KM3NETDAQcLcLJDAQTimesliceL0(void *p) {
3207 return p ? new(p) ::KM3NETDAQ::JDAQTimesliceL0 : new ::KM3NETDAQ::JDAQTimesliceL0;
3208 }
3209 static void *newArray_KM3NETDAQcLcLJDAQTimesliceL0(Long_t nElements, void *p) {
3210 return p ? new(p) ::KM3NETDAQ::JDAQTimesliceL0[nElements] : new ::KM3NETDAQ::JDAQTimesliceL0[nElements];
3211 }
3212 // Wrapper around operator delete
3213 static void delete_KM3NETDAQcLcLJDAQTimesliceL0(void *p) {
3214 delete (static_cast<::KM3NETDAQ::JDAQTimesliceL0*>(p));
3215 }
3216 static void deleteArray_KM3NETDAQcLcLJDAQTimesliceL0(void *p) {
3217 delete [] (static_cast<::KM3NETDAQ::JDAQTimesliceL0*>(p));
3218 }
3219 static void destruct_KM3NETDAQcLcLJDAQTimesliceL0(void *p) {
3220 typedef ::KM3NETDAQ::JDAQTimesliceL0 current_t;
3221 (static_cast<current_t*>(p))->~current_t();
3222 }
3223} // end of namespace ROOT for class ::KM3NETDAQ::JDAQTimesliceL0
3224
3225namespace KM3NETDAQ {
3226//______________________________________________________________________________
3227void JDAQTimesliceL1::Streamer(TBuffer &R__b)
3228{
3229 // Stream an object of class KM3NETDAQ::JDAQTimesliceL1.
3230
3231 if (R__b.IsReading()) {
3232 R__b.ReadClassBuffer(KM3NETDAQ::JDAQTimesliceL1::Class(),this);
3233 } else {
3234 R__b.WriteClassBuffer(KM3NETDAQ::JDAQTimesliceL1::Class(),this);
3235 }
3236}
3237
3238} // namespace KM3NETDAQ
3239namespace ROOT {
3240 // Wrappers around operator new
3241 static void *new_KM3NETDAQcLcLJDAQTimesliceL1(void *p) {
3242 return p ? new(p) ::KM3NETDAQ::JDAQTimesliceL1 : new ::KM3NETDAQ::JDAQTimesliceL1;
3243 }
3244 static void *newArray_KM3NETDAQcLcLJDAQTimesliceL1(Long_t nElements, void *p) {
3245 return p ? new(p) ::KM3NETDAQ::JDAQTimesliceL1[nElements] : new ::KM3NETDAQ::JDAQTimesliceL1[nElements];
3246 }
3247 // Wrapper around operator delete
3248 static void delete_KM3NETDAQcLcLJDAQTimesliceL1(void *p) {
3249 delete (static_cast<::KM3NETDAQ::JDAQTimesliceL1*>(p));
3250 }
3251 static void deleteArray_KM3NETDAQcLcLJDAQTimesliceL1(void *p) {
3252 delete [] (static_cast<::KM3NETDAQ::JDAQTimesliceL1*>(p));
3253 }
3254 static void destruct_KM3NETDAQcLcLJDAQTimesliceL1(void *p) {
3255 typedef ::KM3NETDAQ::JDAQTimesliceL1 current_t;
3256 (static_cast<current_t*>(p))->~current_t();
3257 }
3258} // end of namespace ROOT for class ::KM3NETDAQ::JDAQTimesliceL1
3259
3260namespace KM3NETDAQ {
3261//______________________________________________________________________________
3262void JDAQTimesliceL2::Streamer(TBuffer &R__b)
3263{
3264 // Stream an object of class KM3NETDAQ::JDAQTimesliceL2.
3265
3266 if (R__b.IsReading()) {
3267 R__b.ReadClassBuffer(KM3NETDAQ::JDAQTimesliceL2::Class(),this);
3268 } else {
3269 R__b.WriteClassBuffer(KM3NETDAQ::JDAQTimesliceL2::Class(),this);
3270 }
3271}
3272
3273} // namespace KM3NETDAQ
3274namespace ROOT {
3275 // Wrappers around operator new
3276 static void *new_KM3NETDAQcLcLJDAQTimesliceL2(void *p) {
3277 return p ? new(p) ::KM3NETDAQ::JDAQTimesliceL2 : new ::KM3NETDAQ::JDAQTimesliceL2;
3278 }
3279 static void *newArray_KM3NETDAQcLcLJDAQTimesliceL2(Long_t nElements, void *p) {
3280 return p ? new(p) ::KM3NETDAQ::JDAQTimesliceL2[nElements] : new ::KM3NETDAQ::JDAQTimesliceL2[nElements];
3281 }
3282 // Wrapper around operator delete
3283 static void delete_KM3NETDAQcLcLJDAQTimesliceL2(void *p) {
3284 delete (static_cast<::KM3NETDAQ::JDAQTimesliceL2*>(p));
3285 }
3286 static void deleteArray_KM3NETDAQcLcLJDAQTimesliceL2(void *p) {
3287 delete [] (static_cast<::KM3NETDAQ::JDAQTimesliceL2*>(p));
3288 }
3289 static void destruct_KM3NETDAQcLcLJDAQTimesliceL2(void *p) {
3290 typedef ::KM3NETDAQ::JDAQTimesliceL2 current_t;
3291 (static_cast<current_t*>(p))->~current_t();
3292 }
3293} // end of namespace ROOT for class ::KM3NETDAQ::JDAQTimesliceL2
3294
3295namespace KM3NETDAQ {
3296//______________________________________________________________________________
3297void JDAQTimesliceSN::Streamer(TBuffer &R__b)
3298{
3299 // Stream an object of class KM3NETDAQ::JDAQTimesliceSN.
3300
3301 if (R__b.IsReading()) {
3302 R__b.ReadClassBuffer(KM3NETDAQ::JDAQTimesliceSN::Class(),this);
3303 } else {
3304 R__b.WriteClassBuffer(KM3NETDAQ::JDAQTimesliceSN::Class(),this);
3305 }
3306}
3307
3308} // namespace KM3NETDAQ
3309namespace ROOT {
3310 // Wrappers around operator new
3311 static void *new_KM3NETDAQcLcLJDAQTimesliceSN(void *p) {
3312 return p ? new(p) ::KM3NETDAQ::JDAQTimesliceSN : new ::KM3NETDAQ::JDAQTimesliceSN;
3313 }
3314 static void *newArray_KM3NETDAQcLcLJDAQTimesliceSN(Long_t nElements, void *p) {
3315 return p ? new(p) ::KM3NETDAQ::JDAQTimesliceSN[nElements] : new ::KM3NETDAQ::JDAQTimesliceSN[nElements];
3316 }
3317 // Wrapper around operator delete
3318 static void delete_KM3NETDAQcLcLJDAQTimesliceSN(void *p) {
3319 delete (static_cast<::KM3NETDAQ::JDAQTimesliceSN*>(p));
3320 }
3321 static void deleteArray_KM3NETDAQcLcLJDAQTimesliceSN(void *p) {
3322 delete [] (static_cast<::KM3NETDAQ::JDAQTimesliceSN*>(p));
3323 }
3324 static void destruct_KM3NETDAQcLcLJDAQTimesliceSN(void *p) {
3325 typedef ::KM3NETDAQ::JDAQTimesliceSN current_t;
3326 (static_cast<current_t*>(p))->~current_t();
3327 }
3328} // end of namespace ROOT for class ::KM3NETDAQ::JDAQTimesliceSN
3329
3330namespace KM3NETDAQ {
3331//______________________________________________________________________________
3332void JDAQSummaryslice::Streamer(TBuffer &R__b)
3333{
3334 // Stream an object of class KM3NETDAQ::JDAQSummaryslice.
3335
3336 if (R__b.IsReading()) {
3337 R__b.ReadClassBuffer(KM3NETDAQ::JDAQSummaryslice::Class(),this);
3338 } else {
3339 R__b.WriteClassBuffer(KM3NETDAQ::JDAQSummaryslice::Class(),this);
3340 }
3341}
3342
3343} // namespace KM3NETDAQ
3344namespace ROOT {
3345 // Wrappers around operator new
3346 static void *new_KM3NETDAQcLcLJDAQSummaryslice(void *p) {
3347 return p ? new(p) ::KM3NETDAQ::JDAQSummaryslice : new ::KM3NETDAQ::JDAQSummaryslice;
3348 }
3349 static void *newArray_KM3NETDAQcLcLJDAQSummaryslice(Long_t nElements, void *p) {
3350 return p ? new(p) ::KM3NETDAQ::JDAQSummaryslice[nElements] : new ::KM3NETDAQ::JDAQSummaryslice[nElements];
3351 }
3352 // Wrapper around operator delete
3353 static void delete_KM3NETDAQcLcLJDAQSummaryslice(void *p) {
3354 delete (static_cast<::KM3NETDAQ::JDAQSummaryslice*>(p));
3355 }
3356 static void deleteArray_KM3NETDAQcLcLJDAQSummaryslice(void *p) {
3357 delete [] (static_cast<::KM3NETDAQ::JDAQSummaryslice*>(p));
3358 }
3359 static void destruct_KM3NETDAQcLcLJDAQSummaryslice(void *p) {
3360 typedef ::KM3NETDAQ::JDAQSummaryslice current_t;
3361 (static_cast<current_t*>(p))->~current_t();
3362 }
3363} // end of namespace ROOT for class ::KM3NETDAQ::JDAQSummaryslice
3364
3365//______________________________________________________________________________
3366void AAObject::Streamer(TBuffer &R__b)
3367{
3368 // Stream an object of class AAObject.
3369
3370 if (R__b.IsReading()) {
3371 R__b.ReadClassBuffer(AAObject::Class(),this);
3372 } else {
3373 R__b.WriteClassBuffer(AAObject::Class(),this);
3374 }
3375}
3376
3377namespace ROOT {
3378 // Wrappers around operator new
3379 static void *new_AAObject(void *p) {
3380 return p ? new(p) ::AAObject : new ::AAObject;
3381 }
3382 static void *newArray_AAObject(Long_t nElements, void *p) {
3383 return p ? new(p) ::AAObject[nElements] : new ::AAObject[nElements];
3384 }
3385 // Wrapper around operator delete
3386 static void delete_AAObject(void *p) {
3387 delete (static_cast<::AAObject*>(p));
3388 }
3389 static void deleteArray_AAObject(void *p) {
3390 delete [] (static_cast<::AAObject*>(p));
3391 }
3392 static void destruct_AAObject(void *p) {
3393 typedef ::AAObject current_t;
3394 (static_cast<current_t*>(p))->~current_t();
3395 }
3396} // end of namespace ROOT for class ::AAObject
3397
3398//______________________________________________________________________________
3399void Vec::Streamer(TBuffer &R__b)
3400{
3401 // Stream an object of class Vec.
3402
3403 if (R__b.IsReading()) {
3404 R__b.ReadClassBuffer(Vec::Class(),this);
3405 } else {
3406 R__b.WriteClassBuffer(Vec::Class(),this);
3407 }
3408}
3409
3410namespace ROOT {
3411 // Wrappers around operator new
3412 static void *new_Vec(void *p) {
3413 return p ? new(p) ::Vec : new ::Vec;
3414 }
3415 static void *newArray_Vec(Long_t nElements, void *p) {
3416 return p ? new(p) ::Vec[nElements] : new ::Vec[nElements];
3417 }
3418 // Wrapper around operator delete
3419 static void delete_Vec(void *p) {
3420 delete (static_cast<::Vec*>(p));
3421 }
3422 static void deleteArray_Vec(void *p) {
3423 delete [] (static_cast<::Vec*>(p));
3424 }
3425 static void destruct_Vec(void *p) {
3426 typedef ::Vec current_t;
3427 (static_cast<current_t*>(p))->~current_t();
3428 }
3429} // end of namespace ROOT for class ::Vec
3430
3431//______________________________________________________________________________
3432void Hit::Streamer(TBuffer &R__b)
3433{
3434 // Stream an object of class Hit.
3435
3436 if (R__b.IsReading()) {
3437 R__b.ReadClassBuffer(Hit::Class(),this);
3438 } else {
3439 R__b.WriteClassBuffer(Hit::Class(),this);
3440 }
3441}
3442
3443namespace ROOT {
3444 // Wrappers around operator new
3445 static void *new_Hit(void *p) {
3446 return p ? new(p) ::Hit : new ::Hit;
3447 }
3448 static void *newArray_Hit(Long_t nElements, void *p) {
3449 return p ? new(p) ::Hit[nElements] : new ::Hit[nElements];
3450 }
3451 // Wrapper around operator delete
3452 static void delete_Hit(void *p) {
3453 delete (static_cast<::Hit*>(p));
3454 }
3455 static void deleteArray_Hit(void *p) {
3456 delete [] (static_cast<::Hit*>(p));
3457 }
3458 static void destruct_Hit(void *p) {
3459 typedef ::Hit current_t;
3460 (static_cast<current_t*>(p))->~current_t();
3461 }
3462} // end of namespace ROOT for class ::Hit
3463
3464//______________________________________________________________________________
3465void Trk::Streamer(TBuffer &R__b)
3466{
3467 // Stream an object of class Trk.
3468
3469 if (R__b.IsReading()) {
3470 R__b.ReadClassBuffer(Trk::Class(),this);
3471 } else {
3472 R__b.WriteClassBuffer(Trk::Class(),this);
3473 }
3474}
3475
3476namespace ROOT {
3477 // Wrappers around operator new
3478 static void *new_Trk(void *p) {
3479 return p ? new(p) ::Trk : new ::Trk;
3480 }
3481 static void *newArray_Trk(Long_t nElements, void *p) {
3482 return p ? new(p) ::Trk[nElements] : new ::Trk[nElements];
3483 }
3484 // Wrapper around operator delete
3485 static void delete_Trk(void *p) {
3486 delete (static_cast<::Trk*>(p));
3487 }
3488 static void deleteArray_Trk(void *p) {
3489 delete [] (static_cast<::Trk*>(p));
3490 }
3491 static void destruct_Trk(void *p) {
3492 typedef ::Trk current_t;
3493 (static_cast<current_t*>(p))->~current_t();
3494 }
3495} // end of namespace ROOT for class ::Trk
3496
3497//______________________________________________________________________________
3498void Evt::Streamer(TBuffer &R__b)
3499{
3500 // Stream an object of class Evt.
3501
3502 if (R__b.IsReading()) {
3503 R__b.ReadClassBuffer(Evt::Class(),this);
3504 } else {
3505 R__b.WriteClassBuffer(Evt::Class(),this);
3506 }
3507}
3508
3509namespace ROOT {
3510 // Wrappers around operator new
3511 static void *new_Evt(void *p) {
3512 return p ? new(p) ::Evt : new ::Evt;
3513 }
3514 static void *newArray_Evt(Long_t nElements, void *p) {
3515 return p ? new(p) ::Evt[nElements] : new ::Evt[nElements];
3516 }
3517 // Wrapper around operator delete
3518 static void delete_Evt(void *p) {
3519 delete (static_cast<::Evt*>(p));
3520 }
3521 static void deleteArray_Evt(void *p) {
3522 delete [] (static_cast<::Evt*>(p));
3523 }
3524 static void destruct_Evt(void *p) {
3525 typedef ::Evt current_t;
3526 (static_cast<current_t*>(p))->~current_t();
3527 }
3528} // end of namespace ROOT for class ::Evt
3529
3530//______________________________________________________________________________
3531void Head::Streamer(TBuffer &R__b)
3532{
3533 // Stream an object of class Head.
3534
3535 if (R__b.IsReading()) {
3536 R__b.ReadClassBuffer(Head::Class(),this);
3537 } else {
3538 R__b.WriteClassBuffer(Head::Class(),this);
3539 }
3540}
3541
3542namespace ROOT {
3543 // Wrappers around operator new
3544 static void *new_Head(void *p) {
3545 return p ? new(p) ::Head : new ::Head;
3546 }
3547 static void *newArray_Head(Long_t nElements, void *p) {
3548 return p ? new(p) ::Head[nElements] : new ::Head[nElements];
3549 }
3550 // Wrapper around operator delete
3551 static void delete_Head(void *p) {
3552 delete (static_cast<::Head*>(p));
3553 }
3554 static void deleteArray_Head(void *p) {
3555 delete [] (static_cast<::Head*>(p));
3556 }
3557 static void destruct_Head(void *p) {
3558 typedef ::Head current_t;
3559 (static_cast<current_t*>(p))->~current_t();
3560 }
3561} // end of namespace ROOT for class ::Head
3562
3563//______________________________________________________________________________
3564void MultiHead::Streamer(TBuffer &R__b)
3565{
3566 // Stream an object of class MultiHead.
3567
3568 if (R__b.IsReading()) {
3569 R__b.ReadClassBuffer(MultiHead::Class(),this);
3570 } else {
3571 R__b.WriteClassBuffer(MultiHead::Class(),this);
3572 }
3573}
3574
3575namespace ROOT {
3576 // Wrappers around operator new
3577 static void *new_MultiHead(void *p) {
3578 return p ? new(p) ::MultiHead : new ::MultiHead;
3579 }
3580 static void *newArray_MultiHead(Long_t nElements, void *p) {
3581 return p ? new(p) ::MultiHead[nElements] : new ::MultiHead[nElements];
3582 }
3583 // Wrapper around operator delete
3584 static void delete_MultiHead(void *p) {
3585 delete (static_cast<::MultiHead*>(p));
3586 }
3587 static void deleteArray_MultiHead(void *p) {
3588 delete [] (static_cast<::MultiHead*>(p));
3589 }
3590 static void destruct_MultiHead(void *p) {
3591 typedef ::MultiHead current_t;
3592 (static_cast<current_t*>(p))->~current_t();
3593 }
3594} // end of namespace ROOT for class ::MultiHead
3595
3596namespace ROOT {
3597 static TClass *vectorlEstringgR_Dictionary();
3598 static void vectorlEstringgR_TClassManip(TClass*);
3599 static void *new_vectorlEstringgR(void *p = nullptr);
3600 static void *newArray_vectorlEstringgR(Long_t size, void *p);
3601 static void delete_vectorlEstringgR(void *p);
3602 static void deleteArray_vectorlEstringgR(void *p);
3603 static void destruct_vectorlEstringgR(void *p);
3604
3605 // Function generating the singleton type initializer
3606 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<string>*)
3607 {
3608 vector<string> *ptr = nullptr;
3609 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<string>));
3610 static ::ROOT::TGenericClassInfo
3611 instance("vector<string>", -2, "vector", 389,
3612 typeid(vector<string>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3613 &vectorlEstringgR_Dictionary, isa_proxy, 0,
3614 sizeof(vector<string>) );
3615 instance.SetNew(&new_vectorlEstringgR);
3616 instance.SetNewArray(&newArray_vectorlEstringgR);
3617 instance.SetDelete(&delete_vectorlEstringgR);
3618 instance.SetDeleteArray(&deleteArray_vectorlEstringgR);
3619 instance.SetDestructor(&destruct_vectorlEstringgR);
3620 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<string> >()));
3621
3622 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> > > >"));
3623 return &instance;
3624 }
3625 // Static variable to force the class initialization
3626 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<string>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
3627
3628 // Dictionary for non-ClassDef classes
3629 static TClass *vectorlEstringgR_Dictionary() {
3630 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<string>*>(nullptr))->GetClass();
3631 vectorlEstringgR_TClassManip(theClass);
3632 return theClass;
3633 }
3634
3635 static void vectorlEstringgR_TClassManip(TClass* ){
3636 }
3637
3638} // end of namespace ROOT
3639
3640namespace ROOT {
3641 // Wrappers around operator new
3642 static void *new_vectorlEstringgR(void *p) {
3643 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<string> : new vector<string>;
3644 }
3645 static void *newArray_vectorlEstringgR(Long_t nElements, void *p) {
3646 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<string>[nElements] : new vector<string>[nElements];
3647 }
3648 // Wrapper around operator delete
3649 static void delete_vectorlEstringgR(void *p) {
3650 delete (static_cast<vector<string>*>(p));
3651 }
3652 static void deleteArray_vectorlEstringgR(void *p) {
3653 delete [] (static_cast<vector<string>*>(p));
3654 }
3655 static void destruct_vectorlEstringgR(void *p) {
3656 typedef vector<string> current_t;
3657 (static_cast<current_t*>(p))->~current_t();
3658 }
3659} // end of namespace ROOT for class vector<string>
3660
3661namespace ROOT {
3662 static TClass *vectorlEintgR_Dictionary();
3663 static void vectorlEintgR_TClassManip(TClass*);
3664 static void *new_vectorlEintgR(void *p = nullptr);
3665 static void *newArray_vectorlEintgR(Long_t size, void *p);
3666 static void delete_vectorlEintgR(void *p);
3667 static void deleteArray_vectorlEintgR(void *p);
3668 static void destruct_vectorlEintgR(void *p);
3669
3670 // Function generating the singleton type initializer
3671 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<int>*)
3672 {
3673 vector<int> *ptr = nullptr;
3674 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<int>));
3675 static ::ROOT::TGenericClassInfo
3676 instance("vector<int>", -2, "vector", 389,
3677 typeid(vector<int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3678 &vectorlEintgR_Dictionary, isa_proxy, 0,
3679 sizeof(vector<int>) );
3680 instance.SetNew(&new_vectorlEintgR);
3681 instance.SetNewArray(&newArray_vectorlEintgR);
3682 instance.SetDelete(&delete_vectorlEintgR);
3683 instance.SetDeleteArray(&deleteArray_vectorlEintgR);
3684 instance.SetDestructor(&destruct_vectorlEintgR);
3685 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<int> >()));
3686
3687 instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<int>","std::vector<int, std::allocator<int> >"));
3688 return &instance;
3689 }
3690 // Static variable to force the class initialization
3691 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<int>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
3692
3693 // Dictionary for non-ClassDef classes
3694 static TClass *vectorlEintgR_Dictionary() {
3695 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<int>*>(nullptr))->GetClass();
3696 vectorlEintgR_TClassManip(theClass);
3697 return theClass;
3698 }
3699
3700 static void vectorlEintgR_TClassManip(TClass* ){
3701 }
3702
3703} // end of namespace ROOT
3704
3705namespace ROOT {
3706 // Wrappers around operator new
3707 static void *new_vectorlEintgR(void *p) {
3708 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<int> : new vector<int>;
3709 }
3710 static void *newArray_vectorlEintgR(Long_t nElements, void *p) {
3711 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<int>[nElements] : new vector<int>[nElements];
3712 }
3713 // Wrapper around operator delete
3714 static void delete_vectorlEintgR(void *p) {
3715 delete (static_cast<vector<int>*>(p));
3716 }
3717 static void deleteArray_vectorlEintgR(void *p) {
3718 delete [] (static_cast<vector<int>*>(p));
3719 }
3720 static void destruct_vectorlEintgR(void *p) {
3721 typedef vector<int> current_t;
3722 (static_cast<current_t*>(p))->~current_t();
3723 }
3724} // end of namespace ROOT for class vector<int>
3725
3726namespace ROOT {
3727 static TClass *vectorlEdoublegR_Dictionary();
3728 static void vectorlEdoublegR_TClassManip(TClass*);
3729 static void *new_vectorlEdoublegR(void *p = nullptr);
3730 static void *newArray_vectorlEdoublegR(Long_t size, void *p);
3731 static void delete_vectorlEdoublegR(void *p);
3732 static void deleteArray_vectorlEdoublegR(void *p);
3733 static void destruct_vectorlEdoublegR(void *p);
3734
3735 // Function generating the singleton type initializer
3736 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<double>*)
3737 {
3738 vector<double> *ptr = nullptr;
3739 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<double>));
3740 static ::ROOT::TGenericClassInfo
3741 instance("vector<double>", -2, "vector", 389,
3742 typeid(vector<double>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3743 &vectorlEdoublegR_Dictionary, isa_proxy, 0,
3744 sizeof(vector<double>) );
3745 instance.SetNew(&new_vectorlEdoublegR);
3746 instance.SetNewArray(&newArray_vectorlEdoublegR);
3747 instance.SetDelete(&delete_vectorlEdoublegR);
3748 instance.SetDeleteArray(&deleteArray_vectorlEdoublegR);
3749 instance.SetDestructor(&destruct_vectorlEdoublegR);
3750 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<double> >()));
3751
3752 instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<double>","std::vector<double, std::allocator<double> >"));
3753 return &instance;
3754 }
3755 // Static variable to force the class initialization
3756 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<double>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
3757
3758 // Dictionary for non-ClassDef classes
3759 static TClass *vectorlEdoublegR_Dictionary() {
3760 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<double>*>(nullptr))->GetClass();
3761 vectorlEdoublegR_TClassManip(theClass);
3762 return theClass;
3763 }
3764
3765 static void vectorlEdoublegR_TClassManip(TClass* ){
3766 }
3767
3768} // end of namespace ROOT
3769
3770namespace ROOT {
3771 // Wrappers around operator new
3772 static void *new_vectorlEdoublegR(void *p) {
3773 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<double> : new vector<double>;
3774 }
3775 static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) {
3776 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<double>[nElements] : new vector<double>[nElements];
3777 }
3778 // Wrapper around operator delete
3779 static void delete_vectorlEdoublegR(void *p) {
3780 delete (static_cast<vector<double>*>(p));
3781 }
3782 static void deleteArray_vectorlEdoublegR(void *p) {
3783 delete [] (static_cast<vector<double>*>(p));
3784 }
3785 static void destruct_vectorlEdoublegR(void *p) {
3786 typedef vector<double> current_t;
3787 (static_cast<current_t*>(p))->~current_t();
3788 }
3789} // end of namespace ROOT for class vector<double>
3790
3791namespace ROOT {
3792 static TClass *vectorlETrkgR_Dictionary();
3793 static void vectorlETrkgR_TClassManip(TClass*);
3794 static void *new_vectorlETrkgR(void *p = nullptr);
3795 static void *newArray_vectorlETrkgR(Long_t size, void *p);
3796 static void delete_vectorlETrkgR(void *p);
3797 static void deleteArray_vectorlETrkgR(void *p);
3798 static void destruct_vectorlETrkgR(void *p);
3799
3800 // Function generating the singleton type initializer
3801 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<Trk>*)
3802 {
3803 vector<Trk> *ptr = nullptr;
3804 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<Trk>));
3805 static ::ROOT::TGenericClassInfo
3806 instance("vector<Trk>", -2, "vector", 389,
3807 typeid(vector<Trk>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3808 &vectorlETrkgR_Dictionary, isa_proxy, 0,
3809 sizeof(vector<Trk>) );
3810 instance.SetNew(&new_vectorlETrkgR);
3811 instance.SetNewArray(&newArray_vectorlETrkgR);
3812 instance.SetDelete(&delete_vectorlETrkgR);
3813 instance.SetDeleteArray(&deleteArray_vectorlETrkgR);
3814 instance.SetDestructor(&destruct_vectorlETrkgR);
3815 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<Trk> >()));
3816
3817 instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<Trk>","std::vector<Trk, std::allocator<Trk> >"));
3818 return &instance;
3819 }
3820 // Static variable to force the class initialization
3821 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<Trk>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
3822
3823 // Dictionary for non-ClassDef classes
3824 static TClass *vectorlETrkgR_Dictionary() {
3825 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<Trk>*>(nullptr))->GetClass();
3826 vectorlETrkgR_TClassManip(theClass);
3827 return theClass;
3828 }
3829
3830 static void vectorlETrkgR_TClassManip(TClass* ){
3831 }
3832
3833} // end of namespace ROOT
3834
3835namespace ROOT {
3836 // Wrappers around operator new
3837 static void *new_vectorlETrkgR(void *p) {
3838 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<Trk> : new vector<Trk>;
3839 }
3840 static void *newArray_vectorlETrkgR(Long_t nElements, void *p) {
3841 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<Trk>[nElements] : new vector<Trk>[nElements];
3842 }
3843 // Wrapper around operator delete
3844 static void delete_vectorlETrkgR(void *p) {
3845 delete (static_cast<vector<Trk>*>(p));
3846 }
3847 static void deleteArray_vectorlETrkgR(void *p) {
3848 delete [] (static_cast<vector<Trk>*>(p));
3849 }
3850 static void destruct_vectorlETrkgR(void *p) {
3851 typedef vector<Trk> current_t;
3852 (static_cast<current_t*>(p))->~current_t();
3853 }
3854} // end of namespace ROOT for class vector<Trk>
3855
3856namespace ROOT {
3857 static TClass *vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR_Dictionary();
3858 static void vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR_TClassManip(TClass*);
3859 static void *new_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p = nullptr);
3860 static void *newArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(Long_t size, void *p);
3861 static void delete_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p);
3862 static void deleteArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p);
3863 static void destruct_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p);
3864
3865 // Function generating the singleton type initializer
3866 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<KM3NETDAQ::JDAQTriggeredHit>*)
3867 {
3868 vector<KM3NETDAQ::JDAQTriggeredHit> *ptr = nullptr;
3869 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<KM3NETDAQ::JDAQTriggeredHit>));
3870 static ::ROOT::TGenericClassInfo
3871 instance("vector<KM3NETDAQ::JDAQTriggeredHit>", -2, "vector", 389,
3872 typeid(vector<KM3NETDAQ::JDAQTriggeredHit>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3873 &vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR_Dictionary, isa_proxy, 0,
3874 sizeof(vector<KM3NETDAQ::JDAQTriggeredHit>) );
3875 instance.SetNew(&new_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR);
3876 instance.SetNewArray(&newArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR);
3877 instance.SetDelete(&delete_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR);
3878 instance.SetDeleteArray(&deleteArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR);
3879 instance.SetDestructor(&destruct_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR);
3880 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<KM3NETDAQ::JDAQTriggeredHit> >()));
3881
3882 instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<KM3NETDAQ::JDAQTriggeredHit>","std::vector<KM3NETDAQ::JDAQTriggeredHit, std::allocator<KM3NETDAQ::JDAQTriggeredHit> >"));
3883 return &instance;
3884 }
3885 // Static variable to force the class initialization
3886 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<KM3NETDAQ::JDAQTriggeredHit>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
3887
3888 // Dictionary for non-ClassDef classes
3889 static TClass *vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR_Dictionary() {
3890 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<KM3NETDAQ::JDAQTriggeredHit>*>(nullptr))->GetClass();
3891 vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR_TClassManip(theClass);
3892 return theClass;
3893 }
3894
3897
3898} // end of namespace ROOT
3899
3900namespace ROOT {
3901 // Wrappers around operator new
3902 static void *new_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p) {
3903 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQTriggeredHit> : new vector<KM3NETDAQ::JDAQTriggeredHit>;
3904 }
3905 static void *newArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(Long_t nElements, void *p) {
3906 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQTriggeredHit>[nElements] : new vector<KM3NETDAQ::JDAQTriggeredHit>[nElements];
3907 }
3908 // Wrapper around operator delete
3909 static void delete_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p) {
3910 delete (static_cast<vector<KM3NETDAQ::JDAQTriggeredHit>*>(p));
3911 }
3912 static void deleteArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p) {
3913 delete [] (static_cast<vector<KM3NETDAQ::JDAQTriggeredHit>*>(p));
3914 }
3915 static void destruct_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p) {
3916 typedef vector<KM3NETDAQ::JDAQTriggeredHit> current_t;
3917 (static_cast<current_t*>(p))->~current_t();
3918 }
3919} // end of namespace ROOT for class vector<KM3NETDAQ::JDAQTriggeredHit>
3920
3921namespace ROOT {
3922 static TClass *vectorlEKM3NETDAQcLcLJDAQSuperFramegR_Dictionary();
3923 static void vectorlEKM3NETDAQcLcLJDAQSuperFramegR_TClassManip(TClass*);
3924 static void *new_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p = nullptr);
3925 static void *newArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(Long_t size, void *p);
3926 static void delete_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p);
3927 static void deleteArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p);
3928 static void destruct_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p);
3929
3930 // Function generating the singleton type initializer
3931 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<KM3NETDAQ::JDAQSuperFrame>*)
3932 {
3933 vector<KM3NETDAQ::JDAQSuperFrame> *ptr = nullptr;
3934 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<KM3NETDAQ::JDAQSuperFrame>));
3935 static ::ROOT::TGenericClassInfo
3936 instance("vector<KM3NETDAQ::JDAQSuperFrame>", -2, "vector", 389,
3937 typeid(vector<KM3NETDAQ::JDAQSuperFrame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3938 &vectorlEKM3NETDAQcLcLJDAQSuperFramegR_Dictionary, isa_proxy, 0,
3939 sizeof(vector<KM3NETDAQ::JDAQSuperFrame>) );
3940 instance.SetNew(&new_vectorlEKM3NETDAQcLcLJDAQSuperFramegR);
3941 instance.SetNewArray(&newArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR);
3942 instance.SetDelete(&delete_vectorlEKM3NETDAQcLcLJDAQSuperFramegR);
3943 instance.SetDeleteArray(&deleteArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR);
3944 instance.SetDestructor(&destruct_vectorlEKM3NETDAQcLcLJDAQSuperFramegR);
3945 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<KM3NETDAQ::JDAQSuperFrame> >()));
3946
3947 instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<KM3NETDAQ::JDAQSuperFrame>","std::vector<KM3NETDAQ::JDAQSuperFrame, std::allocator<KM3NETDAQ::JDAQSuperFrame> >"));
3948 return &instance;
3949 }
3950 // Static variable to force the class initialization
3951 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<KM3NETDAQ::JDAQSuperFrame>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
3952
3953 // Dictionary for non-ClassDef classes
3954 static TClass *vectorlEKM3NETDAQcLcLJDAQSuperFramegR_Dictionary() {
3955 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<KM3NETDAQ::JDAQSuperFrame>*>(nullptr))->GetClass();
3956 vectorlEKM3NETDAQcLcLJDAQSuperFramegR_TClassManip(theClass);
3957 return theClass;
3958 }
3959
3962
3963} // end of namespace ROOT
3964
3965namespace ROOT {
3966 // Wrappers around operator new
3967 static void *new_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p) {
3968 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQSuperFrame> : new vector<KM3NETDAQ::JDAQSuperFrame>;
3969 }
3970 static void *newArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(Long_t nElements, void *p) {
3971 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQSuperFrame>[nElements] : new vector<KM3NETDAQ::JDAQSuperFrame>[nElements];
3972 }
3973 // Wrapper around operator delete
3974 static void delete_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p) {
3975 delete (static_cast<vector<KM3NETDAQ::JDAQSuperFrame>*>(p));
3976 }
3977 static void deleteArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p) {
3978 delete [] (static_cast<vector<KM3NETDAQ::JDAQSuperFrame>*>(p));
3979 }
3980 static void destruct_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p) {
3981 typedef vector<KM3NETDAQ::JDAQSuperFrame> current_t;
3982 (static_cast<current_t*>(p))->~current_t();
3983 }
3984} // end of namespace ROOT for class vector<KM3NETDAQ::JDAQSuperFrame>
3985
3986namespace ROOT {
3987 static TClass *vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_Dictionary();
3988 static void vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_TClassManip(TClass*);
3989 static void *new_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p = nullptr);
3990 static void *newArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(Long_t size, void *p);
3991 static void delete_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p);
3992 static void deleteArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p);
3993 static void destruct_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p);
3994
3995 // Function generating the singleton type initializer
3996 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<KM3NETDAQ::JDAQSummaryFrame>*)
3997 {
3998 vector<KM3NETDAQ::JDAQSummaryFrame> *ptr = nullptr;
3999 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<KM3NETDAQ::JDAQSummaryFrame>));
4000 static ::ROOT::TGenericClassInfo
4001 instance("vector<KM3NETDAQ::JDAQSummaryFrame>", -2, "vector", 389,
4002 typeid(vector<KM3NETDAQ::JDAQSummaryFrame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4003 &vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_Dictionary, isa_proxy, 0,
4004 sizeof(vector<KM3NETDAQ::JDAQSummaryFrame>) );
4005 instance.SetNew(&new_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR);
4006 instance.SetNewArray(&newArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR);
4007 instance.SetDelete(&delete_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR);
4008 instance.SetDeleteArray(&deleteArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR);
4009 instance.SetDestructor(&destruct_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR);
4010 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<KM3NETDAQ::JDAQSummaryFrame> >()));
4011
4012 instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<KM3NETDAQ::JDAQSummaryFrame>","std::vector<KM3NETDAQ::JDAQSummaryFrame, std::allocator<KM3NETDAQ::JDAQSummaryFrame> >"));
4013 return &instance;
4014 }
4015 // Static variable to force the class initialization
4016 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<KM3NETDAQ::JDAQSummaryFrame>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
4017
4018 // Dictionary for non-ClassDef classes
4019 static TClass *vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_Dictionary() {
4020 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<KM3NETDAQ::JDAQSummaryFrame>*>(nullptr))->GetClass();
4021 vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_TClassManip(theClass);
4022 return theClass;
4023 }
4024
4027
4028} // end of namespace ROOT
4029
4030namespace ROOT {
4031 // Wrappers around operator new
4032 static void *new_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p) {
4033 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQSummaryFrame> : new vector<KM3NETDAQ::JDAQSummaryFrame>;
4034 }
4035 static void *newArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(Long_t nElements, void *p) {
4036 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQSummaryFrame>[nElements] : new vector<KM3NETDAQ::JDAQSummaryFrame>[nElements];
4037 }
4038 // Wrapper around operator delete
4039 static void delete_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p) {
4040 delete (static_cast<vector<KM3NETDAQ::JDAQSummaryFrame>*>(p));
4041 }
4042 static void deleteArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p) {
4043 delete [] (static_cast<vector<KM3NETDAQ::JDAQSummaryFrame>*>(p));
4044 }
4045 static void destruct_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p) {
4046 typedef vector<KM3NETDAQ::JDAQSummaryFrame> current_t;
4047 (static_cast<current_t*>(p))->~current_t();
4048 }
4049} // end of namespace ROOT for class vector<KM3NETDAQ::JDAQSummaryFrame>
4050
4051namespace ROOT {
4052 static TClass *vectorlEKM3NETDAQcLcLJDAQKeyHitgR_Dictionary();
4053 static void vectorlEKM3NETDAQcLcLJDAQKeyHitgR_TClassManip(TClass*);
4054 static void *new_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p = nullptr);
4055 static void *newArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(Long_t size, void *p);
4056 static void delete_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p);
4057 static void deleteArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p);
4058 static void destruct_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p);
4059
4060 // Function generating the singleton type initializer
4061 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<KM3NETDAQ::JDAQKeyHit>*)
4062 {
4063 vector<KM3NETDAQ::JDAQKeyHit> *ptr = nullptr;
4064 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<KM3NETDAQ::JDAQKeyHit>));
4065 static ::ROOT::TGenericClassInfo
4066 instance("vector<KM3NETDAQ::JDAQKeyHit>", -2, "vector", 389,
4067 typeid(vector<KM3NETDAQ::JDAQKeyHit>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4068 &vectorlEKM3NETDAQcLcLJDAQKeyHitgR_Dictionary, isa_proxy, 0,
4069 sizeof(vector<KM3NETDAQ::JDAQKeyHit>) );
4070 instance.SetNew(&new_vectorlEKM3NETDAQcLcLJDAQKeyHitgR);
4071 instance.SetNewArray(&newArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR);
4072 instance.SetDelete(&delete_vectorlEKM3NETDAQcLcLJDAQKeyHitgR);
4073 instance.SetDeleteArray(&deleteArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR);
4074 instance.SetDestructor(&destruct_vectorlEKM3NETDAQcLcLJDAQKeyHitgR);
4075 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<KM3NETDAQ::JDAQKeyHit> >()));
4076
4077 instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<KM3NETDAQ::JDAQKeyHit>","std::vector<KM3NETDAQ::JDAQKeyHit, std::allocator<KM3NETDAQ::JDAQKeyHit> >"));
4078 return &instance;
4079 }
4080 // Static variable to force the class initialization
4081 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<KM3NETDAQ::JDAQKeyHit>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
4082
4083 // Dictionary for non-ClassDef classes
4084 static TClass *vectorlEKM3NETDAQcLcLJDAQKeyHitgR_Dictionary() {
4085 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<KM3NETDAQ::JDAQKeyHit>*>(nullptr))->GetClass();
4086 vectorlEKM3NETDAQcLcLJDAQKeyHitgR_TClassManip(theClass);
4087 return theClass;
4088 }
4089
4092
4093} // end of namespace ROOT
4094
4095namespace ROOT {
4096 // Wrappers around operator new
4097 static void *new_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p) {
4098 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQKeyHit> : new vector<KM3NETDAQ::JDAQKeyHit>;
4099 }
4100 static void *newArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(Long_t nElements, void *p) {
4101 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQKeyHit>[nElements] : new vector<KM3NETDAQ::JDAQKeyHit>[nElements];
4102 }
4103 // Wrapper around operator delete
4104 static void delete_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p) {
4105 delete (static_cast<vector<KM3NETDAQ::JDAQKeyHit>*>(p));
4106 }
4107 static void deleteArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p) {
4108 delete [] (static_cast<vector<KM3NETDAQ::JDAQKeyHit>*>(p));
4109 }
4110 static void destruct_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p) {
4111 typedef vector<KM3NETDAQ::JDAQKeyHit> current_t;
4112 (static_cast<current_t*>(p))->~current_t();
4113 }
4114} // end of namespace ROOT for class vector<KM3NETDAQ::JDAQKeyHit>
4115
4116namespace ROOT {
4117 static TClass *vectorlEHitgR_Dictionary();
4118 static void vectorlEHitgR_TClassManip(TClass*);
4119 static void *new_vectorlEHitgR(void *p = nullptr);
4120 static void *newArray_vectorlEHitgR(Long_t size, void *p);
4121 static void delete_vectorlEHitgR(void *p);
4122 static void deleteArray_vectorlEHitgR(void *p);
4123 static void destruct_vectorlEHitgR(void *p);
4124
4125 // Function generating the singleton type initializer
4126 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<Hit>*)
4127 {
4128 vector<Hit> *ptr = nullptr;
4129 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<Hit>));
4130 static ::ROOT::TGenericClassInfo
4131 instance("vector<Hit>", -2, "vector", 389,
4132 typeid(vector<Hit>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4133 &vectorlEHitgR_Dictionary, isa_proxy, 0,
4134 sizeof(vector<Hit>) );
4135 instance.SetNew(&new_vectorlEHitgR);
4136 instance.SetNewArray(&newArray_vectorlEHitgR);
4137 instance.SetDelete(&delete_vectorlEHitgR);
4138 instance.SetDeleteArray(&deleteArray_vectorlEHitgR);
4139 instance.SetDestructor(&destruct_vectorlEHitgR);
4140 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<Hit> >()));
4141
4142 instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<Hit>","std::vector<Hit, std::allocator<Hit> >"));
4143 return &instance;
4144 }
4145 // Static variable to force the class initialization
4146 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<Hit>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
4147
4148 // Dictionary for non-ClassDef classes
4149 static TClass *vectorlEHitgR_Dictionary() {
4150 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<Hit>*>(nullptr))->GetClass();
4151 vectorlEHitgR_TClassManip(theClass);
4152 return theClass;
4153 }
4154
4155 static void vectorlEHitgR_TClassManip(TClass* ){
4156 }
4157
4158} // end of namespace ROOT
4159
4160namespace ROOT {
4161 // Wrappers around operator new
4162 static void *new_vectorlEHitgR(void *p) {
4163 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<Hit> : new vector<Hit>;
4164 }
4165 static void *newArray_vectorlEHitgR(Long_t nElements, void *p) {
4166 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<Hit>[nElements] : new vector<Hit>[nElements];
4167 }
4168 // Wrapper around operator delete
4169 static void delete_vectorlEHitgR(void *p) {
4170 delete (static_cast<vector<Hit>*>(p));
4171 }
4172 static void deleteArray_vectorlEHitgR(void *p) {
4173 delete [] (static_cast<vector<Hit>*>(p));
4174 }
4175 static void destruct_vectorlEHitgR(void *p) {
4176 typedef vector<Hit> current_t;
4177 (static_cast<current_t*>(p))->~current_t();
4178 }
4179} // end of namespace ROOT for class vector<Hit>
4180
4181namespace ROOT {
4182 static TClass *vectorlEHeadgR_Dictionary();
4183 static void vectorlEHeadgR_TClassManip(TClass*);
4184 static void *new_vectorlEHeadgR(void *p = nullptr);
4185 static void *newArray_vectorlEHeadgR(Long_t size, void *p);
4186 static void delete_vectorlEHeadgR(void *p);
4187 static void deleteArray_vectorlEHeadgR(void *p);
4188 static void destruct_vectorlEHeadgR(void *p);
4189
4190 // Function generating the singleton type initializer
4191 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<Head>*)
4192 {
4193 vector<Head> *ptr = nullptr;
4194 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<Head>));
4195 static ::ROOT::TGenericClassInfo
4196 instance("vector<Head>", -2, "vector", 389,
4197 typeid(vector<Head>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4198 &vectorlEHeadgR_Dictionary, isa_proxy, 0,
4199 sizeof(vector<Head>) );
4200 instance.SetNew(&new_vectorlEHeadgR);
4201 instance.SetNewArray(&newArray_vectorlEHeadgR);
4202 instance.SetDelete(&delete_vectorlEHeadgR);
4203 instance.SetDeleteArray(&deleteArray_vectorlEHeadgR);
4204 instance.SetDestructor(&destruct_vectorlEHeadgR);
4205 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<Head> >()));
4206
4207 instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<Head>","std::vector<Head, std::allocator<Head> >"));
4208 return &instance;
4209 }
4210 // Static variable to force the class initialization
4211 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<Head>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
4212
4213 // Dictionary for non-ClassDef classes
4214 static TClass *vectorlEHeadgR_Dictionary() {
4215 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<Head>*>(nullptr))->GetClass();
4216 vectorlEHeadgR_TClassManip(theClass);
4217 return theClass;
4218 }
4219
4220 static void vectorlEHeadgR_TClassManip(TClass* ){
4221 }
4222
4223} // end of namespace ROOT
4224
4225namespace ROOT {
4226 // Wrappers around operator new
4227 static void *new_vectorlEHeadgR(void *p) {
4228 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<Head> : new vector<Head>;
4229 }
4230 static void *newArray_vectorlEHeadgR(Long_t nElements, void *p) {
4231 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<Head>[nElements] : new vector<Head>[nElements];
4232 }
4233 // Wrapper around operator delete
4234 static void delete_vectorlEHeadgR(void *p) {
4235 delete (static_cast<vector<Head>*>(p));
4236 }
4237 static void deleteArray_vectorlEHeadgR(void *p) {
4238 delete [] (static_cast<vector<Head>*>(p));
4239 }
4240 static void destruct_vectorlEHeadgR(void *p) {
4241 typedef vector<Head> current_t;
4242 (static_cast<current_t*>(p))->~current_t();
4243 }
4244} // end of namespace ROOT for class vector<Head>
4245
4246namespace ROOT {
4247 static TClass *maplEstringcOstringgR_Dictionary();
4248 static void maplEstringcOstringgR_TClassManip(TClass*);
4249 static void *new_maplEstringcOstringgR(void *p = nullptr);
4250 static void *newArray_maplEstringcOstringgR(Long_t size, void *p);
4251 static void delete_maplEstringcOstringgR(void *p);
4252 static void deleteArray_maplEstringcOstringgR(void *p);
4253 static void destruct_maplEstringcOstringgR(void *p);
4254
4255 // Function generating the singleton type initializer
4256 static TGenericClassInfo *GenerateInitInstanceLocal(const map<string,string>*)
4257 {
4258 map<string,string> *ptr = nullptr;
4259 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<string,string>));
4260 static ::ROOT::TGenericClassInfo
4261 instance("map<string,string>", -2, "map", 100,
4262 typeid(map<string,string>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4263 &maplEstringcOstringgR_Dictionary, isa_proxy, 0,
4264 sizeof(map<string,string>) );
4265 instance.SetNew(&new_maplEstringcOstringgR);
4266 instance.SetNewArray(&newArray_maplEstringcOstringgR);
4267 instance.SetDelete(&delete_maplEstringcOstringgR);
4268 instance.SetDeleteArray(&deleteArray_maplEstringcOstringgR);
4269 instance.SetDestructor(&destruct_maplEstringcOstringgR);
4270 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<string,string> >()));
4271
4272 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> > > > >"));
4273 return &instance;
4274 }
4275 // Static variable to force the class initialization
4276 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const map<string,string>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
4277
4278 // Dictionary for non-ClassDef classes
4279 static TClass *maplEstringcOstringgR_Dictionary() {
4280 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const map<string,string>*>(nullptr))->GetClass();
4281 maplEstringcOstringgR_TClassManip(theClass);
4282 return theClass;
4283 }
4284
4285 static void maplEstringcOstringgR_TClassManip(TClass* ){
4286 }
4287
4288} // end of namespace ROOT
4289
4290namespace ROOT {
4291 // Wrappers around operator new
4292 static void *new_maplEstringcOstringgR(void *p) {
4293 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map<string,string> : new map<string,string>;
4294 }
4295 static void *newArray_maplEstringcOstringgR(Long_t nElements, void *p) {
4296 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map<string,string>[nElements] : new map<string,string>[nElements];
4297 }
4298 // Wrapper around operator delete
4299 static void delete_maplEstringcOstringgR(void *p) {
4300 delete (static_cast<map<string,string>*>(p));
4301 }
4302 static void deleteArray_maplEstringcOstringgR(void *p) {
4303 delete [] (static_cast<map<string,string>*>(p));
4304 }
4305 static void destruct_maplEstringcOstringgR(void *p) {
4306 typedef map<string,string> current_t;
4307 (static_cast<current_t*>(p))->~current_t();
4308 }
4309} // end of namespace ROOT for class map<string,string>
4310
4311namespace {
4312 void TriggerDictionaryInitialization_G__KM3NeTROOT_Impl() {
4313 static const char* headers[] = {
4314"0",
4315nullptr
4316 };
4317 static const char* includePaths[] = {
4318"/builds/common/jpp/externals/km3net-dataformat/build",
4319"/usr/include",
4320"/usr/local/include/",
4321"/builds/common/jpp/externals/km3net-dataformat/build/src/",
4322nullptr
4323 };
4324 static const char* fwdDeclCode = R"DICTFWDDCLS(
4325#line 1 "G__KM3NeTROOT dictionary forward declarations' payload"
4326#pragma clang diagnostic ignored "-Wkeyword-compat"
4327#pragma clang diagnostic ignored "-Wignored-attributes"
4328#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
4329extern int __Cling_AutoLoading_Map;
4330namespace KM3NETDAQ{class JDAQAbstractPreamble;}
4331namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQUTCExtended.hh"))) JDAQUTCExtended;}
4332namespace KM3NETDAQ{class JDAQChronometer;}
4333namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQPreamble.hh"))) JDAQPreamble;}
4334namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQHeader.hh"))) __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQEventHeader.hh"))) JDAQHeader;}
4335namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTriggerCounter.hh"))) __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQEventHeader.hh"))) JDAQTriggerCounter;}
4336namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTriggerMask.hh"))) __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQEventHeader.hh"))) JDAQTriggerMask;}
4337namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQEventHeader.hh"))) JDAQEventHeader;}
4338namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQHit.hh"))) JDAQHit;}
4339namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQModuleIdentifier.hh"))) __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQKeyHit.hh"))) JDAQModuleIdentifier;}
4340namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQPMTIdentifier.hh"))) __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQKeyHit.hh"))) JDAQPMTIdentifier;}
4341namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQKeyHit.hh"))) JDAQKeyHit;}
4342namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTriggeredHit.hh"))) JDAQTriggeredHit;}
4343namespace KM3NETDAQ{class JDAQEvent;}
4344namespace KM3NETDAQ{class JDAQFrame;}
4345namespace KM3NETDAQ{class JDAQFrameStatus;}
4346namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQSuperFrameHeader.hh"))) __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQSuperFrame.hh"))) JDAQSuperFrameHeader;}
4347namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQSuperFrame.hh"))) JDAQSuperFrame;}
4348namespace KM3NETDAQ{class JDAQRate;}
4349namespace KM3NETDAQ{class JDAQSummaryFrame;}
4350namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQSummarysliceHeader.hh"))) JDAQSummarysliceHeader;}
4351namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimesliceHeader.hh"))) __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimeslice.hh"))) JDAQTimesliceHeader;}
4352namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimeslice.hh"))) JDAQTimeslice;}
4353namespace KM3NETDAQ{struct __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimeslice.hh"))) JDAQTimesliceL0;}
4354namespace KM3NETDAQ{struct __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimeslice.hh"))) JDAQTimesliceL1;}
4355namespace KM3NETDAQ{struct __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimeslice.hh"))) JDAQTimesliceL2;}
4356namespace KM3NETDAQ{struct __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimeslice.hh"))) JDAQTimesliceSN;}
4357namespace KM3NETDAQ{class JDAQSummaryslice;}
4358struct AAObject;
4359struct __attribute__((annotate("$clingAutoload$km3net-dataformat/offline/Vec.hh"))) __attribute__((annotate("$clingAutoload$km3net-dataformat/offline/Hit.hh"))) Vec;
4360struct __attribute__((annotate("$clingAutoload$km3net-dataformat/offline/Hit.hh"))) Hit;
4361struct __attribute__((annotate("$clingAutoload$km3net-dataformat/offline/Trk.hh"))) Trk;
4362struct Evt;
4363struct Head;
4364struct MultiHead;
4365)DICTFWDDCLS";
4366 static const char* payloadCode = R"DICTPAYLOAD(
4367#line 1 "G__KM3NeTROOT dictionary payload"
4368
4369
4370#define _BACKWARD_BACKWARD_WARNING_H
4371// Inline headers
4372#ifndef __JDAQ__
4373#define __JDAQ__
4374
4375#include "km3net-dataformat/online/JDAQException.hh"
4376
4377
4378/**
4379 * \file
4380 *
4381 * KM3NeT DAQ constants, bit handling, etc.
4382 * \author mdejong
4383 */
4384
4385
4386/**
4387 * %KM3NeT DAQ data structures and auxiliaries.
4388 */
4389namespace KM3NETDAQ {
4390
4391#define KM3NET 1
4392#define ANTARES 2
4393
4394#if NAMESPACE == ANTARES
4395 static const int NUMBER_OF_PMTS = 3; //!< Total number of PMTs in module
4396#else
4397 static const int NUMBER_OF_PMTS = 31; //!< Total number of PMTs in module
4398#endif
4399
4400#undef KM3NET
4401#undef ANTARES
4402
4403
4404 /**
4405 * Auxiliary data structure for single bit.
4406 */
4407 struct JBit {
4408 /**
4409 * Default constructor.
4410 */
4411 JBit() :
4412 bit(0)
4413 {}
4414
4415
4416 /**
4417 * Constructor.
4418 *
4419 * \param __bit bit [0, 31]
4420 */
4421 JBit(int __bit) :
4422 bit(__bit)
4423 {
4424 if (bit < 0 || bit > 31) {
4425 throw JDAQException("JBit: illegal bit range.");
4426 }
4427 }
4428
4429
4430 /**
4431 * Get bit mask.
4432 *
4433 * In the returned mask, the single bit at <tt>bit</tt> set to 1.
4434 *
4435 * \return bit mask
4436 */
4437 int get() const
4438 {
4439 return 1 << bit;
4440 }
4441
4442
4443 /**
4444 * Set bit in given bit mask.
4445 *
4446 * \param mask bit mask (I/O)
4447 */
4448 void set(int& mask) const
4449 {
4450 mask |= get();
4451 }
4452
4453
4454 /**
4455 * Unset bit in given bit mask.
4456 *
4457 * \param mask bit mask (I/O)
4458 */
4459 void unset(int& mask) const
4460 {
4461 mask &= ~get();
4462 }
4463
4464
4465 /**
4466 * Set bit in given bit mask.
4467 *
4468 * \param mask bit mask (I/0)
4469 * \param value bit status
4470 */
4471 void set(int& mask, const bool value) const
4472 {
4473 if (value)
4474 set (mask);
4475 else
4476 unset(mask);
4477 }
4478
4479
4480 /**
4481 * Write given value as bit mask.
4482 *
4483 * \param value value
4484 * \return bit mask
4485 */
4486 int write(const int value) const
4487 {
4488 return (value << bit) & get();
4489 }
4490
4491
4492 /**
4493 * Read given bit mask as value.
4494 *
4495 * \param mask bit mask
4496 * \return value
4497 */
4498 int read(const int mask) const
4499 {
4500 return (mask & get()) >> bit;
4501 }
4502
4503
4504 /**
4505 * Test bit.
4506 *
4507 * \param mask bit mask
4508 * \return true if bit set; else false
4509 */
4510 bool has(const int mask) const
4511 {
4512 return (mask & get()) != 0;
4513 }
4514
4515
4516 int bit; //!< bit
4517 };
4518
4519
4520 /**
4521 * Auxiliary data structure for range of bits.
4522 */
4523 struct JBits {
4524 /**
4525 * Default constructor.
4526 */
4527 JBits() :
4528 lsb(0),
4529 msb(0)
4530 {}
4531
4532
4533 /**
4534 * Constructor.
4535 *
4536 * \param __lsb least significant bit [0, 31]
4537 * \param __msb most significant bit [lsb, 31]
4538 */
4539 JBits(int __lsb, int __msb) :
4540 lsb(__lsb),
4541 msb(__msb)
4542 {
4543 if (lsb < 0 || lsb > 31 ||
4544 msb < lsb || msb > 31) {
4545 throw JDAQException("JBits: illegal bit range.");
4546 }
4547 }
4548
4549
4550 /**
4551 * Get bit mask.
4552 *
4553 * In the returned mask, the bits from <tt>lsb</tt> (included) to <tt>msb</tt> (included) are set to 1.
4554 *
4555 * \return bit mask
4556 */
4557 int get() const
4558 {
4559 static const unsigned int mask[] = { 0x00000001,
4560 0x00000003,
4561 0x00000007,
4562 0x0000000F,
4563
4564 0x0000001F,
4565 0x0000003F,
4566 0x0000007F,
4567 0x000000FF,
4568
4569 0x000001FF,
4570 0x000003FF,
4571 0x000007FF,
4572 0x00000FFF,
4573
4574 0x00001FFF,
4575 0x00003FFF,
4576 0x00007FFF,
4577 0x0000FFFF,
4578
4579 0x0001FFFF,
4580 0x0003FFFF,
4581 0x0007FFFF,
4582 0x000FFFFF,
4583
4584 0x001FFFFF,
4585 0x003FFFFF,
4586 0x007FFFFF,
4587 0x00FFFFFF,
4588
4589 0x01FFFFFF,
4590 0x03FFFFFF,
4591 0x07FFFFFF,
4592 0x0FFFFFFF,
4593
4594 0x1FFFFFFF,
4595 0x3FFFFFFF,
4596 0x7FFFFFFF,
4597 0xFFFFFFFF };
4598
4599 return (int) (mask[msb-lsb] << lsb);
4600 }
4601
4602
4603 /**
4604 * Write given value as bit mask.
4605 *
4606 * \param value value
4607 * \return bit mask
4608 */
4609 int write(const int value) const
4610 {
4611 return (value << lsb) & get();
4612 }
4613
4614
4615 /**
4616 * Read given bit mask as value.
4617 *
4618 * \param mask bit mask
4619 * \return value
4620 */
4621 int read(const int mask) const
4622 {
4623 return (mask & get()) >> lsb;
4624 }
4625
4626
4627 /**
4628 * Test bit mask.
4629 *
4630 * \param mask bit mask
4631 * \return true if at least one of the bits is set; else false
4632 */
4633 bool has(const int mask) const
4634 {
4635 return (get() & mask) != 0;
4636 }
4637
4638
4639 int lsb; //!< least significant bit
4640 int msb; //!< most significant bit
4641 };
4642
4643
4644 static const JBit DAQ_WHITE_RABBIT (31); //!< White Rabbit status
4645 static const JBits DAQ_TDC ( 0, 30); //!< TDC high-rate veto status
4646 static const JBits DAQ_FIFO ( 0, 30); //!< FIFO almost full bits
4647
4648 static const JBit DAQ_UDP_TRAILER (31); //!< UDP trailer
4649 static const JBits DAQ_UDP_RECEIVED_PACKETS( 0, 15); //!< Mask of UDP received packets
4650 static const JBits DAQ_UDP_SEQUENCE_NUMBER (16, 31); //!< Mask of UDP sequence number
4651}
4652
4653#endif
4654#ifndef __JDAQABSTRACTPREAMBLE__
4655#define __JDAQABSTRACTPREAMBLE__
4656
4657#include "km3net-dataformat/online/JDAQDataTypes.hh"
4658#include "km3net-dataformat/online/JDAQRoot.hh"
4659
4660
4661/**
4662 * \author rbruijn
4663 */
4664
4665namespace KM3NETDAQ {
4666
4667
4668 /**
4669 * Simple data structure for the DAQ preamble required for a correct calculation
4670 * of the object size for binary I/O.
4671 *
4672 * Note that JDAQPreamble derives from this and adds I/O and ROOT functionality.
4673 */
4674 class JDAQAbstractPreamble {
4675 protected:
4676 /**
4677 * Constructor.
4678 *
4679 * \param type data type of derived class
4680 */
4681 template<class T>
4682 JDAQAbstractPreamble(JDAQType<T> type) :
4683 length(0),
4684 type (KM3NETDAQ::getDataType(type))
4685 {}
4686
4687 public:
4688 /**
4689 * Default constuctor
4690 */
4691 JDAQAbstractPreamble() :
4692 length(0),
4693 type (0)
4694 {}
4695
4696
4697 /**
4698 * Get length.
4699 *
4700 * \return number of bytes
4701 */
4702 int getLength() const
4703 {
4704 return length;
4705 }
4706
4707
4708 /**
4709 * Get data type.
4710 *
4711 * \return data type
4712 */
4713 int getDataType() const
4714 {
4715 return type;
4716 }
4717
4718
4719 ClassDefNV(JDAQAbstractPreamble,1);
4720
4721 protected:
4722 int length;
4723 int type;
4724 };
4725}
4726
4727#endif
4728#ifndef __JDAQCHRONOMETER__
4729#define __JDAQCHRONOMETER__
4730
4731#include <ostream>
4732#include <iomanip>
4733
4734#include "km3net-dataformat/online/JDAQRoot.hh"
4735#include "km3net-dataformat/online/JDAQUTCExtended.hh"
4736#include "km3net-dataformat/online/JDAQClock.hh"
4737
4738
4739/**
4740 * \author mdejong
4741 */
4742
4743namespace KM3NETDAQ {
4744
4745 /**
4746 * DAQ chronometer.
4747 */
4748 class JDAQChronometer
4749 {
4750 public:
4751
4752 friend size_t getSizeof<JDAQChronometer>();
4753 friend JReader& operator>>(JReader&, JDAQChronometer&);
4754 friend JWriter& operator<<(JWriter&, const JDAQChronometer&);
4755
4756 /**
4757 * Default constructor.
4758 */
4759 JDAQChronometer() :
4760 detector_id(0),
4761 run (0),
4762 frame_index(0),
4763 timeslice_start()
4764 {}
4765
4766
4767 /**
4768 * Constructor.
4769 *
4770 * \param __detector_id detector identifier
4771 * \param __run run number
4772 * \param __frame_index frame index
4773 */
4774 JDAQChronometer(const int __detector_id,
4775 const int __run,
4776 const int __frame_index) :
4777 detector_id(__detector_id),
4778 run (__run),
4779 frame_index(__frame_index),
4780 timeslice_start(getTimeOfFrame(__frame_index))
4781 {}
4782
4783
4784 /**
4785 * Constructor.
4786 *
4787 * \param __detector_id detector identifier
4788 * \param __run run number
4789 * \param __frame_index frame index
4790 * \param __timeslice_start start of time slice
4791 */
4792 JDAQChronometer(const int __detector_id,
4793 const int __run,
4794 const int __frame_index,
4795 const JDAQUTCExtended& __timeslice_start) :
4796 detector_id(__detector_id),
4797 run (__run),
4798 frame_index(__frame_index),
4799 timeslice_start(__timeslice_start)
4800 {}
4801
4802
4803 /**
4804 * Virtual destructor.
4805 */
4806 virtual ~JDAQChronometer()
4807 {}
4808
4809
4810 /**
4811 * Get DAQ chronometer.
4812 *
4813 * \return DAQ chronometer
4814 */
4815 const JDAQChronometer& getDAQChronometer() const
4816 {
4817 return static_cast<const JDAQChronometer&>(*this);
4818 }
4819
4820
4821 /**
4822 * Set DAQ chronometer.
4823 *
4824 * \param chronometer DAQ chronometer
4825 */
4826 void setDAQChronometer(const JDAQChronometer& chronometer)
4827 {
4828 static_cast<JDAQChronometer&>(*this) = chronometer;
4829 }
4830
4831
4832 /**
4833 * Get detector identifier.
4834 *
4835 * \return detector identifier
4836 */
4837 int getDetectorID() const
4838 {
4839 return detector_id;
4840 }
4841
4842
4843 /**
4844 * Get run number.
4845 *
4846 * \return run number
4847 */
4848 int getRunNumber() const
4849 {
4850 return run;
4851 }
4852
4853
4854 /**
4855 * Get frame index.
4856 *
4857 * \return frame index
4858 */
4859 int getFrameIndex() const
4860 {
4861 return frame_index;
4862 }
4863
4864
4865 /**
4866 * Get start of timeslice
4867 *
4868 * \return timeslice start
4869 */
4870
4871 JDAQUTCExtended getTimesliceStart() const
4872 {
4873 return timeslice_start;
4874 }
4875
4876
4877 /**
4878 * Set run number.
4879 *
4880 * \param run run number
4881 */
4882 void setRunNumber(const int run)
4883 {
4884 this->run = run;
4885 }
4886
4887
4888 /**
4889 * Set frame index.
4890 *
4891 * \param frame_index frame index
4892 */
4893 void setFrameIndex(const int frame_index)
4894 {
4895 this->frame_index = frame_index;
4896 }
4897
4898
4899 /**
4900 * Set timeslice start time
4901 *
4902 * \param timeslice_start timeslice start time
4903 */
4904 void setTimesliceStart(const JDAQUTCExtended& timeslice_start)
4905 {
4906 this->timeslice_start = timeslice_start;
4907 }
4908
4909
4910 ClassDef(JDAQChronometer,3);
4911
4912
4913 protected:
4914 int detector_id;
4915 int run;
4916 int frame_index;
4917 JDAQUTCExtended timeslice_start;
4918 };
4919
4920
4921 /**
4922 * Print DAQ chronometer.
4923 *
4924 * \param out output stream
4925 * \param chronometer JDAQChronometer
4926 * \return output stream
4927 */
4928 inline std::ostream& operator<<(std::ostream& out, const JDAQChronometer& chronometer)
4929 {
4930 using namespace std;
4931
4932 out << setw(8) << chronometer.getDetectorID();
4933 out << ' ';
4934 out << setw(8) << chronometer.getRunNumber();
4935 out << ' ';
4936 out << setw(8) << chronometer.getFrameIndex();
4937 out << ' ';
4938 out << chronometer.getTimesliceStart();
4939
4940 return out;
4941 }
4942
4943
4944 /**
4945 * Get time of last RTS in ns since start of run for a given chronometer.
4946 *
4947 * \param chronometer chronometer
4948 * \return time [ns]
4949 */
4950 inline double getTimeOfRTS(const JDAQChronometer& chronometer)
4951 {
4952 return getTimeOfRTS(chronometer.getFrameIndex());
4953 }
4954
4955
4956 /**
4957 * Equal operator for DAQ chronometers.
4958 *
4959 * \param first chronometer
4960 * \param second chronometer
4961 * \result true if first chronometer equal to second; else false
4962 */
4963 inline bool operator==(const JDAQChronometer& first,
4964 const JDAQChronometer& second)
4965 {
4966 return (first.getDetectorID() == second.getDetectorID() &&
4967 first.getRunNumber() == second.getRunNumber() &&
4968 first.getFrameIndex() == second.getFrameIndex() &&
4969 first.getTimesliceStart() == second.getTimesliceStart());
4970 }
4971
4972
4973 /**
4974 * Not-equal operator for DAQ chronometers.
4975 *
4976 * \param first chronometer
4977 * \param second chronometer
4978 * \result true if first chronometer not equal to second; else false
4979 */
4980 inline bool operator!=(const JDAQChronometer& first,
4981 const JDAQChronometer& second)
4982 {
4983 return !(first == second);
4984 }
4985
4986
4987 /**
4988 * Get time difference between two chronometers.
4989 *
4990 * \param first chronometer
4991 * \param second chronometer
4992 * \result time difference [s]
4993 */
4994 inline double getTimeDifference(const JDAQChronometer& first, const JDAQChronometer& second)
4995 {
4996 return getTimeDifference(first.getTimesliceStart(), second.getTimesliceStart());
4997 }
4998}
4999
5000#endif
5001#ifndef __JDAQCLOCK__
5002#define __JDAQCLOCK__
5003
5004#include <istream>
5005#include <ostream>
5006#include <exception>
5007#include <cmath>
5008
5009#include "km3net-dataformat/online/JDAQException.hh"
5010
5011
5012/**
5013 * \author mdejong
5014 */
5015
5016namespace KM3NETDAQ {
5017
5018 namespace {
5019 static double FRAME_TIME_NS = 100000000.0; //!< Frame time [ns]
5020 static double RESET_TIME_NS = FRAME_TIME_NS; //!< TDC dynamic range [ns]
5021 }
5022
5023
5024 /**
5025 * Auxiliary class to set DAQ system clock parameters.
5026 */
5027 class JDAQClock {
5028 public:
5029 /**
5030 * Clock types.
5031 */
5032 enum JDAQClock_t { KM3NET = 1, PPM_DU = 3, ANTARES = 101 };
5033
5034
5035 /**
5036 * Constructor.
5037 *
5038 * \param clock clock type
5039 */
5040 JDAQClock(const JDAQClock_t clock = KM3NET)
5041 {
5042 this->clock = clock;
5043
5044 set();
5045 }
5046
5047
5048 /**
5049 * Get clock type.
5050 *
5051 * \return clock type
5052 */
5053 JDAQClock_t get() const
5054 {
5055 return clock;
5056 }
5057
5058
5059 /**
5060 * Set clock type.
5061 *
5062 * \param clock clock type
5063 */
5064 void set(const JDAQClock_t clock)
5065 {
5066 this->clock = clock;
5067
5068 set();
5069 }
5070
5071
5072 /**
5073 * Set DAQ clock parameters.
5074 */
5075 void set()
5076 {
5077 switch (this->clock) {
5078
5079 case KM3NET:
5080 FRAME_TIME_NS = 100000000.0;
5081 RESET_TIME_NS = FRAME_TIME_NS;
5082 break;
5083
5084 case PPM_DU:
5085 FRAME_TIME_NS = (1<<27);
5086 RESET_TIME_NS = FRAME_TIME_NS;
5087 break;
5088
5089 case ANTARES:
5090 FRAME_TIME_NS = 13107200.0 * 8;
5091 RESET_TIME_NS = 419430400.0;
5092 break;
5093
5094 default:
5095 throw JDAQException("Undefined clock.");
5096 }
5097 }
5098
5099
5100 /**
5101 * Read clock from input.
5102 *
5103 * \param in input stream
5104 * \param clock JClock
5105 * \return input stream
5106 */
5107 friend inline std::istream& operator>>(std::istream& in, JDAQClock& clock)
5108 {
5109 using namespace std;
5110
5111 int clk;
5112
5113 in >> clk;
5114
5115 try {
5116 clock.set((JDAQClock_t) clk);
5117 }
5118 catch(const std::exception& error) {
5119 in.setstate(ios_base::badbit);
5120 }
5121
5122 return in;
5123 }
5124
5125
5126 /**
5127 * Write clock to output.
5128 *
5129 * \param out output stream
5130 * \param clock JClock
5131 * \return output stream
5132 */
5133 friend inline std::ostream& operator<<(std::ostream& out, const JDAQClock& clock)
5134 {
5135 return out << clock.clock;
5136 }
5137
5138
5139 protected:
5140 JDAQClock_t clock;
5141 };
5142
5143
5144 /**
5145 * Equal operator for JDAQClock.
5146 *
5147 * \param first JDAQClock
5148 * \param second JDAQClock
5149 * \return true if both clock types are equal; else false
5150 */
5151 inline bool operator==(const JDAQClock& first, const JDAQClock& second)
5152 {
5153 return first.get() == second.get();
5154 }
5155
5156
5157 /**
5158 * Get frame time duration.
5159 *
5160 * \return frame time [ns]
5161 */
5162 inline double getFrameTime()
5163 {
5164 return FRAME_TIME_NS;
5165 }
5166
5167
5168 /**
5169 * Get TDC dynamic range.
5170 *
5171 * \return TDC dynamic range [ns]
5172 */
5173 inline double getRTS()
5174 {
5175 return RESET_TIME_NS;
5176 }
5177
5178
5179 /**
5180 * Get start time of frame in ns since start of run for a given frame index.
5181 *
5182 * \param frame_index frame index
5183 * \return time [ns]
5184 */
5185 inline double getTimeOfFrame(const int frame_index)
5186 {
5187 if (frame_index != 0)
5188 return (double) (frame_index - 1) * FRAME_TIME_NS;
5189 else
5190 return 0;
5191 }
5192
5193
5194 /**
5195 * Get start time of frame in ns since start of run for a given frame index.
5196 *
5197 * \param frame_index frame index
5198 * \return time [ns]
5199 */
5200 inline double getTimeOfFrame(const unsigned int frame_index)
5201 {
5202 if (frame_index != 0)
5203 return (double) (frame_index - 1) * FRAME_TIME_NS;
5204 else
5205 return 0;
5206 }
5207
5208
5209 /**
5210 * Get time of last RTS in ns since start of run for a given time.
5211 *
5212 * \param t_ns time [ns]
5213 * \return time [ns]
5214 */
5215 inline double getTimeOfRTS(const double t_ns)
5216 {
5217 return std::floor(t_ns/RESET_TIME_NS) * RESET_TIME_NS;
5218 }
5219
5220
5221 /**
5222 * Get time of last RTS in ns since start of run for a given frame index.
5223 *
5224 * \param frame_index frame index
5225 * \return time [ns]
5226 */
5227 inline double getTimeOfRTS(const int frame_index)
5228 {
5229 return std::floor(getTimeOfFrame(frame_index)/RESET_TIME_NS) * RESET_TIME_NS;
5230 }
5231
5232
5233 /**
5234 * Get time of last RTS in ns since start of run for a given frame index.
5235 *
5236 * \param frame_index frame index
5237 * \return time [ns]
5238 */
5239 inline double getTimeOfRTS(const unsigned int frame_index)
5240 {
5241 return std::floor(getTimeOfFrame(frame_index)/RESET_TIME_NS) * RESET_TIME_NS;
5242 }
5243
5244
5245 /**
5246 * Get frame index for a given time in ns.
5247 *
5248 * \param t_ns time [ns]
5249 * \return frame index
5250 */
5251 inline int getFrameIndex(const double t_ns)
5252 {
5253 return (int) (t_ns / FRAME_TIME_NS) + 1;
5254 }
5255
5256
5257 /**
5258 * Get time in ns since last RTS for a given frame index.
5259 *
5260 * \param frame_index frame index
5261 * \return time [ns]
5262 */
5263 inline double getTimeSinceRTS(const int frame_index)
5264 {
5265 return std::fmod(getTimeOfFrame(frame_index), RESET_TIME_NS);
5266 }
5267
5268
5269 /**
5270 * Get time in ns since last RTS for a given frame index.
5271 *
5272 * \param frame_index frame index
5273 * \return time [ns]
5274 */
5275 inline double getTimeSinceRTS(const unsigned int frame_index)
5276 {
5277 return std::fmod(getTimeOfFrame(frame_index), RESET_TIME_NS);
5278 }
5279
5280
5281 /**
5282 * Get time in ns since last RTS for a given time in ns.
5283 *
5284 * \param t_ns time [ns]
5285 * \return time [ns]
5286 */
5287 inline double getTimeSinceRTS(const double& t_ns)
5288 {
5289 return std::fmod(t_ns, RESET_TIME_NS);
5290 }
5291}
5292
5293namespace ANTARES {
5294 /**
5295 * Set clock.
5296 */
5297 inline void setClock()
5298 {
5299 KM3NETDAQ::JDAQClock clock(KM3NETDAQ::JDAQClock::ANTARES);
5300 }
5301
5302 using KM3NETDAQ::getFrameTime;
5303 using KM3NETDAQ::getRTS;
5304 using KM3NETDAQ::getTimeOfFrame;
5305 using KM3NETDAQ::getTimeOfRTS;
5306 using KM3NETDAQ::getFrameIndex;
5307 using KM3NETDAQ::getTimeSinceRTS;
5308}
5309
5310namespace KM3NET {
5311 /**
5312 * Set clock.
5313 */
5314 inline void setClock()
5315 {
5316 KM3NETDAQ::JDAQClock clock(KM3NETDAQ::JDAQClock::KM3NET);
5317 }
5318
5319 using KM3NETDAQ::getFrameTime;
5320 using KM3NETDAQ::getRTS;
5321 using KM3NETDAQ::getTimeOfFrame;
5322 using KM3NETDAQ::getTimeOfRTS;
5323 using KM3NETDAQ::getFrameIndex;
5324 using KM3NETDAQ::getTimeSinceRTS;
5325}
5326
5327#endif
5328#ifndef __JDAQDATATYPES__
5329#define __JDAQDATATYPES__
5330
5331#include "km3net-dataformat/definitions/daqdatatypes.hh"
5332
5333/**
5334 * \author mdejong
5335 */
5336
5337namespace KM3NETDAQ {
5338
5339 /**
5340 * Auxiliary class for a DAQ type holder.\n
5341 * This class can be used to transfer a template class to a method argument.
5342 */
5343 template<class T>
5344 struct JDAQType {
5345 typedef T data_type;
5346 };
5347
5348
5349 /**
5350 * Template definition for method returning data type.\n
5351 * The template argument refers to the data type for future I/O operations.
5352 */
5353 template<class T>
5354 inline int getDataType()
5355 {
5356 return getDataType(JDAQType<T>());
5357 }
5358
5359
5360 /**
5361 * Argument definition for method returning data type.\n
5362 * The method argument refers to the data type for future I/O operations.\n
5363 * This method should be overloaded for each corresponding class.
5364 *
5365 * \param type data type
5366 */
5367 template<class T>
5368 inline int getDataType(const JDAQType<T>& type);
5369
5370
5371 class JDAQSuperFrame;
5372 class JDAQSummaryFrame;
5373 class JDAQTimeslice;
5374 struct JDAQTimesliceL0;
5375 struct JDAQTimesliceL1;
5376 struct JDAQTimesliceL2;
5377 struct JDAQTimesliceSN;
5378 class JDAQSummaryslice;
5379 class JDAQEvent;
5380
5381
5382 inline int getDataType(const JDAQType<JDAQSuperFrame>&) { return DAQSUPERFRAME; }
5383 inline int getDataType(const JDAQType<JDAQSummaryFrame>&) { return DAQSUMMARYFRAME; }
5384 inline int getDataType(const JDAQType<JDAQTimeslice>&) { return DAQTIMESLICE; }
5385 inline int getDataType(const JDAQType<JDAQTimesliceL0>&) { return DAQTIMESLICEL0; }
5386 inline int getDataType(const JDAQType<JDAQTimesliceL1>&) { return DAQTIMESLICEL1; }
5387 inline int getDataType(const JDAQType<JDAQTimesliceL2>&) { return DAQTIMESLICEL2; }
5388 inline int getDataType(const JDAQType<JDAQTimesliceSN>&) { return DAQTIMESLICESN; }
5389 inline int getDataType(const JDAQType<JDAQSummaryslice>&) { return DAQSUMMARYSLICE; }
5390 inline int getDataType(const JDAQType<JDAQEvent>&) { return DAQEVENT; }
5391}
5392
5393#endif
5394#ifndef __JDAQEVENT__
5395#define __JDAQEVENT__
5396
5397#include <ostream>
5398#include <iomanip>
5399#include <vector>
5400
5401#include "km3net-dataformat/online/JDAQRoot.hh"
5402#include "km3net-dataformat/online/JDAQPreamble.hh"
5403#include "km3net-dataformat/online/JDAQEventHeader.hh"
5404#include "km3net-dataformat/online/JDAQHit.hh"
5405#include "km3net-dataformat/online/JDAQKeyHit.hh"
5406#include "km3net-dataformat/online/JDAQTriggeredHit.hh"
5407#include "km3net-dataformat/online/JDAQPrint.hh"
5408
5409
5410/**
5411 * \author mdejong
5412 */
5413
5414namespace KM3NETDAQ {
5415
5416
5417 typedef JDAQKeyHit JDAQSnapshotHit;
5418
5419
5420 /**
5421 * DAQ Event.
5422 */
5423 class JDAQEvent :
5424 public JDAQPreamble,
5425 public JDAQEventHeader
5426 {
5427 public:
5428
5429 using JDAQTriggerMask::getTriggerMask;
5430
5431 friend size_t getSizeof(const JDAQEvent&);
5432 friend JReader& operator>>(JReader&, JDAQEvent&);
5433 friend JWriter& operator<<(JWriter&, const JDAQEvent&);
5434
5435 /**
5436 * Default constructor.
5437 */
5438 JDAQEvent() :
5439 JDAQPreamble(JDAQType<JDAQEvent>()),
5440 JDAQEventHeader()
5441 {}
5442
5443
5444 /**
5445 * Constructor.
5446 *
5447 * \param header header
5448 */
5449 JDAQEvent(const JDAQEventHeader& header) :
5450 JDAQPreamble(JDAQType<JDAQEvent>()),
5451 JDAQEventHeader(header)
5452 {}
5453
5454
5455 /**
5456 * Template const_iterator
5457 */
5458 template<class T>
5459 class const_iterator :
5460 public std::vector<T>::const_iterator
5461 {
5462 public:
5463 /**
5464 * Default constructor.
5465 */
5466 const_iterator() :
5467 std::vector<T>::const_iterator()
5468 {}
5469
5470
5471 /**
5472 * Copy constructor.
5473 *
5474 * \param i iterator
5475 */
5476 const_iterator(const typename std::vector<T>::const_iterator& i) :
5477 std::vector<T>::const_iterator(i)
5478 {}
5479 };
5480
5481
5482 /**
5483 * Template const_reverse_iterator
5484 */
5485 template<class T>
5486 class const_reverse_iterator :
5487 public std::vector<T>::const_reverse_iterator
5488 {
5489 public:
5490 /**
5491 * Default constructor.
5492 */
5493 const_reverse_iterator() :
5494 std::vector<T>::const_reverse_iterator()
5495 {}
5496
5497
5498 /**
5499 * Copy constructor.
5500 *
5501 * \param i iterator
5502 */
5503 const_reverse_iterator(const typename std::vector<T>::const_reverse_iterator& i) :
5504 std::vector<T>::const_reverse_iterator(i)
5505 {}
5506 };
5507
5508
5509 /**
5510 * Get container with hits.
5511 *
5512 * \return container with hits
5513 */
5514 template<class T>
5515 const std::vector<T>& getHits() const;
5516
5517
5518 /**
5519 * Get container with hits.
5520 *
5521 * \return container with hits
5522 */
5523 template<class T>
5524 std::vector<T>& getHits();
5525
5526
5527 /**
5528 * Get begin of data.
5529 *
5530 * \return begin of data
5531 */
5532 template<class T>
5533 const_iterator<T> begin() const;
5534
5535
5536 /**
5537 * Get end of data.
5538 *
5539 * \return end of data
5540 */
5541 template<class T>
5542 const_iterator<T> end() const;
5543
5544
5545 /**
5546 * Get reverse begin of data.
5547 *
5548 * \return begin of data
5549 */
5550 template<class T>
5551 const_reverse_iterator<T> rbegin() const;
5552
5553
5554 /**
5555 * Get reverse end of data.
5556 *
5557 * \return end of data
5558 */
5559 template<class T>
5560 const_reverse_iterator<T> rend() const;
5561
5562
5563 /**
5564 * Get number of hits.
5565 *
5566 * \return number of hits
5567 */
5568 template<class T>
5569 unsigned int size() const;
5570
5571
5572 /**
5573 * Check emptyness of hit container.
5574 *
5575 * \return true if empty; else false
5576 */
5577 template<class T>
5578 bool empty() const;
5579
5580
5581 /**
5582 * Clear event.
5583 */
5584 void clear()
5585 {
5586 snapshotHits .clear();
5587 triggeredHits.clear();
5588 }
5589
5590
5591 /**
5592 * Add hit.
5593 *
5594 * \param hit hit
5595 */
5596 void push_back(const JDAQKeyHit& hit)
5597 {
5598 snapshotHits.push_back(hit);
5599 }
5600
5601
5602 /**
5603 * Add hit.
5604 *
5605 * \param hit hit
5606 */
5607 void push_back(const JDAQTriggeredHit& hit)
5608 {
5609 triggeredHits.push_back(hit);
5610 }
5611
5612
5613 /**
5614 * Get trigger mask of given hit.
5615 *
5616 * \param hit hit
5617 * \return trigger mask
5618 */
5619 static JTriggerMask_t getTriggerMask(const JDAQTriggeredHit& hit)
5620 {
5621 return hit.getTriggerMask();
5622 }
5623
5624
5625 /**
5626 * Get trigger mask of given hit.
5627 *
5628 * \param hit hit
5629 * \return trigger mask
5630 */
5631 JTriggerMask_t getTriggerMask(const JDAQSnapshotHit& hit) const
5632 {
5633 for (std::vector<JDAQTriggeredHit>::const_iterator i = triggeredHits.begin(); i != triggeredHits.end(); ++i) {
5634 if (*i == hit) {
5635 return i->getTriggerMask();
5636 }
5637 }
5638
5639 return JTriggerMask_t(0);
5640 }
5641
5642
5643 /**
5644 * Print DAQ Event.
5645 *
5646 * \param out output stream
5647 * \param lpr long print
5648 * \return output stream
5649 */
5650 std::ostream& print(std::ostream& out, const bool lpr = false) const;
5651
5652
5653 ClassDef(JDAQEvent,4);
5654
5655
5656 protected:
5657 std::vector<JDAQTriggeredHit> triggeredHits;
5658 std::vector<JDAQSnapshotHit> snapshotHits;
5659 };
5660
5661
5662 /**
5663 * Equal operator for DAQ events.
5664 *
5665 * \param first event
5666 * \param second event
5667 * \result true if first event equal to second; else false
5668 */
5669 bool operator==(const JDAQEvent& first,
5670 const JDAQEvent& second);
5671
5672
5673 /**
5674 * Not-equal operator for DAQ events.
5675 *
5676 * \param first event
5677 * \param second event
5678 * \result true if first event not equal to second; else false
5679 */
5680 inline bool operator!=(const JDAQEvent& first,
5681 const JDAQEvent& second)
5682 {
5683 return !(first == second);
5684 }
5685
5686
5687 /**
5688 * Print DAQ Event.
5689 *
5690 * \param out output stream
5691 * \param event event
5692 * \return output stream
5693 */
5694 inline std::ostream& operator<<(std::ostream& out, const JDAQEvent& event)
5695 {
5696 return event.print(out, getDAQLongprint());
5697 }
5698
5699
5700 /**
5701 * Get time difference between two events.
5702 *
5703 * \param first event
5704 * \param second event
5705 * \result time difference [s]
5706 */
5707 inline double getTimeDifference(const JDAQEvent& first, const JDAQEvent& second);
5708}
5709
5710#endif
5711#ifndef __JDAQEVENTHEADER__
5712#define __JDAQEVENTHEADER__
5713
5714#include "km3net-dataformat/online/JDAQRoot.hh"
5715#include "km3net-dataformat/online/JDAQHeader.hh"
5716#include "km3net-dataformat/online/JDAQTriggerCounter.hh"
5717#include "km3net-dataformat/online/JDAQTriggerMask.hh"
5718
5719
5720/**
5721 * \author mdejong
5722 */
5723
5724namespace KM3NETDAQ {
5725
5726 /**
5727 * JDAQ event header.
5728 */
5729 class JDAQEventHeader :
5730 public JDAQHeader,
5731 public JDAQTriggerCounter,
5732 public JDAQTriggerMask
5733 {
5734 public:
5735
5736 friend size_t getSizeof<JDAQEventHeader>();
5737 friend JReader& operator>>(JReader&, JDAQEventHeader&);
5738 friend JWriter& operator<<(JWriter&, const JDAQEventHeader&);
5739
5740 /**
5741 * Default constructor.
5742 */
5743 JDAQEventHeader() :
5744 JDAQHeader(),
5745 JDAQTriggerCounter(),
5746 JDAQTriggerMask(),
5747 overlays(0)
5748 {}
5749
5750
5751 /**
5752 * Get DAQ event header.
5753 *
5754 * \return DAQ event header
5755 */
5756 const JDAQEventHeader& getDAQEventHeader() const
5757 {
5758 return static_cast<const JDAQEventHeader&>(*this);
5759 }
5760
5761
5762 /**
5763 * Check if header is same.
5764 *
5765 * \param header DAQ event header
5766 * \return true if event headers are same; else false
5767 */
5768 inline bool is_same(const JDAQEventHeader& header) const
5769 {
5770 return (this->getDetectorID() == header.getDetectorID() &&
5771 this->getRunNumber() == header.getRunNumber() &&
5772 this->getFrameIndex() == header.getFrameIndex() &&
5773 this->getCounter() == header.getCounter());
5774 }
5775
5776
5777 /**
5778 * Get number of overlays.
5779 *
5780 * \return number of overlays
5781 */
5782 unsigned int getOverlays() const
5783 {
5784 return overlays;
5785 }
5786
5787
5788 ClassDef(JDAQEventHeader,3);
5789
5790
5791 protected:
5792 unsigned int overlays;
5793 };
5794
5795
5796 /**
5797 * Equal operator for DAQ event headers.
5798 *
5799 * \param first event header
5800 * \param second event header
5801 * \result true if first event header equal to second; else false
5802 */
5803 inline bool operator==(const JDAQEventHeader& first,
5804 const JDAQEventHeader& second)
5805 {
5806 return (first.getDAQHeader() == second.getDAQHeader() &&
5807 first.getDAQTriggerCounter() == second.getDAQTriggerCounter() &&
5808 first.getDAQTriggerMask() == second.getDAQTriggerMask());
5809 }
5810
5811
5812 /**
5813 * Not-equal operator for DAQ event headers.
5814 *
5815 * \param first event header
5816 * \param second event header
5817 * \result true if first event header not equal to second; else false
5818 */
5819 inline bool operator!=(const JDAQEventHeader& first,
5820 const JDAQEventHeader& second)
5821 {
5822 return !(first == second);
5823 }
5824}
5825
5826#endif
5827#ifndef __JDAQEXCEPTION__
5828#define __JDAQEXCEPTION__
5829
5830#include <exception>
5831#include <ostream>
5832
5833
5834/**
5835 * \author mdejong
5836 */
5837
5838namespace KM3NETDAQ {
5839
5840
5841 /**
5842 * General exception
5843 */
5844 class JDAQException : public std::exception {
5845 public:
5846 /**
5847 * Constructor.
5848 *
5849 * \param error error message
5850 */
5851 JDAQException(const std::string& error) :
5852 std::exception(),
5853 buffer(error)
5854 {}
5855
5856
5857 /**
5858 * Destructor.
5859 */
5860 ~JDAQException() throw()
5861 {}
5862
5863
5864 /**
5865 * Get error message.
5866 *
5867 * \return error message
5868 */
5869 virtual const char* what() const throw()
5870 {
5871 return buffer.c_str();
5872 }
5873
5874
5875 /**
5876 * Print error message of JDAQException.
5877 *
5878 * \param out output stream
5879 * \param exception exception
5880 */
5881 friend inline std::ostream& operator<<(std::ostream& out, const JDAQException& exception)
5882 {
5883 return out << exception.what();
5884 }
5885
5886 private:
5887 const std::string buffer;
5888 };
5889}
5890
5891#endif
5892#ifndef __JDAQFRAME__
5893#define __JDAQFRAME__
5894
5895#include <stdlib.h>
5896#include <string.h>
5897#include <string>
5898#include <iterator>
5899#include <algorithm>
5900
5901#include "km3net-dataformat/online/JDAQHit.hh"
5902#include "km3net-dataformat/online/JDAQRoot.hh"
5903#include "km3net-dataformat/online/JDAQException.hh"
5904
5905
5906/**
5907 * \author mdejong
5908 */
5909namespace KM3NETDAQ {
5910
5911 /**
5912 * Subset of data frame.
5913 **/
5914 class JDAQFrameSubset
5915 {
5916 public:
5917
5918 typedef const JDAQHit* const_iterator;
5919 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
5920
5921
5922 /**
5923 * Constructor.
5924 *
5925 * \param number_of_hits number of hits
5926 * \param data pointer to data
5927 */
5928 JDAQFrameSubset(const int number_of_hits, const JDAQHit* data) :
5929 numberOfHits(number_of_hits),
5930 buffer(data)
5931 {}
5932
5933
5934 const_iterator begin() const { return buffer; }
5935 const_iterator end() const { return buffer + numberOfHits; }
5936
5937 const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
5938 const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
5939
5940 bool empty() const { return numberOfHits == 0; }
5941
5942 int size() const { return numberOfHits; }
5943
5944 const JDAQHit* data() const { return buffer; }
5945
5946
5947 private:
5948 const int numberOfHits;
5949 const JDAQHit* buffer;
5950 };
5951
5952
5953 /**
5954 * Data frame.
5955 */
5956 class JDAQFrame
5957 {
5958 public:
5959
5960 typedef const JDAQHit* const_iterator;
5961 typedef JDAQHit* iterator;
5962 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
5963 typedef std::reverse_iterator<iterator> reverse_iterator;
5964
5965 friend size_t getSizeof(const JDAQFrame&);
5966 friend JReader& operator>>(JReader&, JDAQFrame&);
5967 friend JWriter& operator<<(JWriter&, const JDAQFrame&);
5968
5969 /**
5970 * Default constructor.
5971 */
5972 JDAQFrame() :
5973 numberOfHits(0),
5974 buffer(NULL)
5975 {}
5976
5977
5978 /**
5979 * Copy constructor.
5980 *
5981 * \param frame frame
5982 */
5983 JDAQFrame(const JDAQFrame& frame) :
5984 numberOfHits(0),
5985 buffer(NULL)
5986 {
5987 add(frame);
5988 }
5989
5990
5991 /**
5992 * Move constructor.
5993 *
5994 * \param frame frame
5995 */
5996 JDAQFrame(JDAQFrame&& frame) :
5997 numberOfHits(frame.numberOfHits),
5998 buffer (frame.buffer)
5999 {
6000 frame.numberOfHits = 0;
6001 frame.buffer = NULL;
6002 }
6003
6004
6005 /**
6006 * Constructor.
6007 *
6008 * \param number_of_hits number of hits
6009 * \param data pointer to data
6010 */
6011 JDAQFrame(const int number_of_hits, const JDAQHit* data) :
6012 numberOfHits(0),
6013 buffer(NULL)
6014 {
6015 add(number_of_hits, data);
6016 }
6017
6018
6019 /**
6020 * Destructor.
6021 */
6022 virtual ~JDAQFrame()
6023 {
6024 clear();
6025 }
6026
6027
6028 /**
6029 * Assignment operator.
6030 *
6031 * \param frame frame
6032 * \return this frame
6033 */
6034 JDAQFrame& operator=(const JDAQFrame& frame)
6035 {
6036 add(frame);
6037
6038 return *this;
6039 }
6040
6041
6042 /**
6043 * Clear data.
6044 */
6045 void clear()
6046 {
6047 if (buffer != NULL) {
6048 free(buffer);
6049 }
6050
6051 numberOfHits = 0;
6052 buffer = NULL;
6053 }
6054
6055
6056 const_iterator begin() const { return buffer; }
6057 const_iterator end() const { return buffer + numberOfHits; }
6058
6059
6060 iterator begin() { return buffer; }
6061 iterator end() { return buffer + numberOfHits; }
6062
6063
6064 const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
6065 const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
6066
6067
6068 reverse_iterator rbegin() { return reverse_iterator(end()); }
6069 reverse_iterator rend() { return reverse_iterator(begin()); }
6070
6071
6072 bool empty() const { return numberOfHits == 0; }
6073
6074 int size() const { return numberOfHits; }
6075
6076 const JDAQHit* data() const { return buffer; }
6077 JDAQHit* data() { return buffer; }
6078
6079
6080 /**
6081 * Get hit at given index.
6082 *
6083 * \param index index
6084 * \return hit
6085 */
6086 const JDAQHit& operator[](int index) const
6087 {
6088 return buffer[index];
6089 }
6090
6091 /**
6092 * Get subset of data.
6093 *
6094 * \param i1 first index of hit (included)
6095 * \param i2 last index of hit (excluded)
6096 * \return frame
6097 */
6098 JDAQFrameSubset subset(const int i1, const int i2) const
6099 {
6100 return JDAQFrameSubset(i2 - i1, buffer + i1);
6101 }
6102
6103
6104 /**
6105 * Add data.
6106 *
6107 * \param frame frame
6108 * \return this frame
6109 */
6110 JDAQFrame& add(const JDAQFrame& frame)
6111 {
6112 return add(frame.numberOfHits, frame.buffer);
6113 }
6114
6115
6116 /**
6117 * Add data.
6118 *
6119 * \param number_of_hits number of hits
6120 * \param data pointer to data
6121 * \return this data frame
6122 */
6123 JDAQFrame& add(const int number_of_hits, const JDAQHit* data)
6124 {
6125 if (number_of_hits > 0) {
6126
6127 resize(numberOfHits + number_of_hits);
6128
6129 memcpy(buffer + numberOfHits - number_of_hits, data, number_of_hits * sizeof(JDAQHit));
6130 }
6131
6132 return *this;
6133 }
6134
6135
6136 /**
6137 * Swap data.
6138 *
6139 * \param frame frame
6140 */
6141 void swap(JDAQFrame& frame)
6142 {
6143 std::swap(numberOfHits, frame.numberOfHits);
6144 std::swap(buffer, frame.buffer);
6145 }
6146
6147
6148 int numberOfHits; // following comment line is used by rootcint
6149 JDAQHit* buffer; // [numberOfHits]
6150
6151
6152 ClassDef(JDAQFrame,1);
6153
6154
6155 protected:
6156 /**
6157 * Resize internal buffer.
6158 *
6159 * This method increases the size of the buffer if necessary.
6160 * Otherwise, the current size is maintained.
6161 *
6162 * \param number_of_hits total number of hits to allocate
6163 */
6164 void resize(const int number_of_hits)
6165 {
6166 if (number_of_hits > numberOfHits) {
6167
6168 const int number_of_bytes = number_of_hits * sizeof(JDAQHit);
6169
6170 if (buffer == NULL)
6171 buffer = (JDAQHit*) malloc(number_of_bytes);
6172 else
6173 buffer = (JDAQHit*) realloc(buffer, number_of_bytes);
6174
6175 if (buffer == NULL) {
6176 throw JDAQException("JDAQFrame::resize(): Memory exception - number of hits = " + std::to_string(number_of_hits));
6177 }
6178
6179 numberOfHits = number_of_hits;
6180 }
6181 }
6182 };
6183
6184
6185 /**
6186 * Equal operator for DAQ frames.
6187 *
6188 * \param first frame
6189 * \param second frame
6190 * \result true if first frame equal to second; else false
6191 */
6192 inline bool operator==(const JDAQFrame& first,
6193 const JDAQFrame& second)
6194 {
6195 if (first.size() == second.size()) {
6196
6197 for (JDAQFrame::const_iterator p = first.begin(), q = second.begin(); p != first.end(); ++p, ++q) {
6198 if (*p != *q) {
6199 return false;
6200 }
6201 }
6202
6203 return true;
6204
6205 } else {
6206
6207 return false;
6208 }
6209 }
6210
6211
6212 /**
6213 * Not-equal operator for DAQ frames.
6214 *
6215 * \param first frame
6216 * \param second frame
6217 * \result true if first frame not equal to second; else false
6218 */
6219 inline bool operator!=(const JDAQFrame& first,
6220 const JDAQFrame& second)
6221 {
6222 return !(first == second);
6223 }
6224}
6225
6226#endif
6227#ifndef __JDAQFRAMESTATUS__
6228#define __JDAQFRAMESTATUS__
6229
6230#include "km3net-dataformat/online/JDAQ.hh"
6231#include "km3net-dataformat/online/JDAQException.hh"
6232#include "km3net-dataformat/online/JDAQRoot.hh"
6233
6234
6235/**
6236 * \author mdejong
6237 */
6238namespace KM3NETDAQ {
6239
6240 /**
6241 * DAQ frame status.
6242 */
6243 class JDAQFrameStatus {
6244 public:
6245
6246 friend size_t getSizeof<JDAQFrameStatus>();
6247 friend JReader& operator>>(JReader&, JDAQFrameStatus&);
6248 friend JWriter& operator<<(JWriter&, const JDAQFrameStatus&);
6249
6250 /**
6251 * Default constructor.
6252 */
6253 JDAQFrameStatus() :
6254 daq (0),
6255 status (0),
6256 fifo (0),
6257 status_3(0),
6258 status_4(0)
6259 {}
6260
6261
6262 /**
6263 * Constructor.
6264 *
6265 * \param __daq DAQ status
6266 * \param __status TDC status
6267 * \param __fifo FIFO status
6268 * \param __status_3 spare
6269 * \param __status_4 spare
6270 */
6271 JDAQFrameStatus(const int __daq,
6272 const int __status,
6273 const int __fifo,
6274 const int __status_3 = 0,
6275 const int __status_4 = 0) :
6276 daq (__daq),
6277 status (__status),
6278 fifo (__fifo),
6279 status_3(__status_3),
6280 status_4(__status_4)
6281 {}
6282
6283
6284 /**
6285 * Get reference to unique instance of this class object.
6286 *
6287 * This instance has default values which correspond to a valid DAQ frame status.
6288 *
6289 * \return reference to this class object
6290 */
6291 static const JDAQFrameStatus& getInstance()
6292 {
6293 static const JDAQFrameStatus status(DAQ_UDP_RECEIVED_PACKETS.write(2) | DAQ_UDP_SEQUENCE_NUMBER.write(1),
6294 DAQ_WHITE_RABBIT.write(1),
6295 DAQ_FIFO.write(0) | DAQ_UDP_TRAILER.write(1));
6296
6297 return status;
6298 }
6299
6300
6301 /**
6302 * Get DAQ frame status.
6303 *
6304 * \return DAQ frame status
6305 */
6306 const JDAQFrameStatus& getDAQFrameStatus() const
6307 {
6308 return static_cast<const JDAQFrameStatus&>(*this);
6309 }
6310
6311
6312 /**
6313 * Set DAQ frame status.
6314 *
6315 * \param status DAQ frame status
6316 */
6317 void setDAQFrameStatus(const JDAQFrameStatus& status)
6318 {
6319 static_cast<JDAQFrameStatus&>(*this) = status;
6320 }
6321
6322
6323 /**
6324 * Get DAQ status.
6325 *
6326 * \return DAQ status
6327 */
6328 int getDAQStatus() const
6329 {
6330 return this->daq;
6331 }
6332
6333
6334 /**
6335 * Get TDC and White Rabbit status.
6336 *
6337 * \return status
6338 */
6339 int getStatus() const
6340 {
6341 return this->status;
6342 }
6343
6344
6345 /**
6346 * Get FIFO status.
6347 *
6348 * \return FIFO status
6349 */
6350 int getFIFOStatus() const
6351 {
6352 return this->fifo;
6353 }
6354
6355
6356 /**
6357 * Test DAQ status of packets.
6358 *
6359 * \return true if okay; else false
6360 */
6361 bool testDAQStatus() const
6362 {
6363 return (getUDPNumberOfReceivedPackets() == (getUDPMaximalSequenceNumber() + 1)) && hasUDPTrailer();
6364 }
6365
6366
6367 /**
6368 * Test TDC and White Rabbit status.
6369 *
6370 * \return true if okay; else false
6371 */
6372 bool testStatus() const
6373 {
6374 return testWhiteRabbitStatus() && testTDCStatus();
6375 }
6376
6377
6378 /**
6379 * Get number of received UDP packets.
6380 *
6381 * \return UDP received packets
6382 */
6383 int getUDPNumberOfReceivedPackets() const
6384 {
6385 return DAQ_UDP_RECEIVED_PACKETS.read(this->daq);
6386 }
6387
6388
6389 /**
6390 * Get maximal sequence number of UDP packet.
6391 *
6392 * \return UDP sequence number
6393 */
6394 int getUDPMaximalSequenceNumber() const
6395 {
6396 return DAQ_UDP_SEQUENCE_NUMBER.read(this->daq);
6397 }
6398
6399
6400 /**
6401 * Test White Rabbit status.
6402 *
6403 * \return true if okay; else false
6404 */
6405 bool testWhiteRabbitStatus() const
6406 {
6407 return DAQ_WHITE_RABBIT.has(this->status);
6408 }
6409
6410
6411 /**
6412 * Test TDC status.
6413 *
6414 * \return true if okay; else false
6415 */
6416 bool testTDCStatus() const
6417 {
6418 return !testHighRateVeto();
6419 }
6420
6421
6422 /**
6423 * Test high-rate veto status.
6424 *
6425 * \return true if one of the TDCs is high-rate vetoed; else false
6426 */
6427 bool testHighRateVeto() const
6428 {
6429 return DAQ_TDC.has(this->status);
6430 }
6431
6432
6433 /**
6434 * Test high-rate veto status.
6435 *
6436 * \param tdc TDC
6437 * \return true if TDC is high-rate vetoed; else false
6438 */
6439 bool testHighRateVeto(const int tdc) const
6440 {
6441 return JBit(tdc).has(this->status);
6442 }
6443
6444
6445 /**
6446 * Count high-rate veto status.
6447 *
6448 * \return number of the TDCs with high-rate veto
6449 */
6450 int countHighRateVeto() const
6451 {
6452 int n = 0;
6453
6454 if (testHighRateVeto()) {
6455 for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
6456 if (JBit(pmt).has(this->status)) {
6457 ++n;
6458 }
6459 }
6460 }
6461
6462 return n;
6463 }
6464
6465
6466 /**
6467 * Test FIFO status.
6468 *
6469 * \return true if one of the TDCs has FIFO almost full; else false
6470 */
6471 bool testFIFOStatus() const
6472 {
6473 return DAQ_FIFO.has(this->fifo);
6474 }
6475
6476
6477 /**
6478 * Test FIFO status.
6479 *
6480 * \param tdc TDC
6481 * \return true if FIFO is almost full; else false
6482 */
6483 bool testFIFOStatus(const int tdc) const
6484 {
6485 return JBit(tdc).has(this->fifo);
6486 }
6487
6488
6489 /**
6490 * Count FIFO status.
6491 *
6492 * \return number of the TDCs with FIFO almost full
6493 */
6494 int countFIFOStatus() const
6495 {
6496 int n = 0;
6497
6498 if (testFIFOStatus()) {
6499 for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
6500 if (JBit(pmt).has(this->fifo)) {
6501 ++n;
6502 }
6503 }
6504 }
6505
6506 return n;
6507 }
6508
6509 /**
6510 * Count active channels.
6511 * \return number of TDCs without high rate veto or FIFO almost full
6512 */
6513 int countActiveChannels() const
6514 {
6515 int n = NUMBER_OF_PMTS;
6516
6517 if (testHighRateVeto() || testFIFOStatus()) {
6518 for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
6519 if ( JBit(pmt).has(this->status) || JBit(pmt).has(this->fifo) ) {
6520 --n;
6521 }
6522 }
6523 }
6524
6525 return n;
6526
6527 }
6528
6529
6530 /**
6531 * Get UDP trailer status.
6532 *
6533 * \return true if UDP trailer present; else false
6534 */
6535 bool hasUDPTrailer() const
6536 {
6537 return DAQ_UDP_TRAILER.has(this->fifo);
6538 }
6539
6540
6541 /**
6542 * Set high-rate veto.
6543 *
6544 * \param tdc TDC
6545 * \param value value
6546 */
6547 void setHighRateVeto(const int tdc, const bool value)
6548 {
6549 JBit(tdc).set(this->status, value);
6550 }
6551
6552
6553 ClassDefNV(JDAQFrameStatus,1);
6554
6555 protected:
6556 int daq; // DAQ status
6557 int status; // TDC status
6558 int fifo; // FIFO status
6559 int status_3; // spare
6560 int status_4; // spare
6561 };
6562
6563
6564 /**
6565 * Equal operator for DAQ frame status.
6566 *
6567 * \param first frame status
6568 * \param second frame status
6569 * \result true if first frame status equal to second; else false
6570 */
6571 inline bool operator==(const JDAQFrameStatus& first,
6572 const JDAQFrameStatus& second)
6573 {
6574 return (first.getDAQStatus() == second.getDAQStatus() &&
6575 first.getStatus() == second.getStatus() &&
6576 first.getFIFOStatus() == second.getFIFOStatus());
6577 }
6578
6579
6580 /**
6581 * Not-equal operator for DAQ frame status.
6582 *
6583 * \param first frame status
6584 * \param second frame status
6585 * \result true if first frame status not equal to second; else false
6586 */
6587 inline bool operator!=(const JDAQFrameStatus& first,
6588 const JDAQFrameStatus& second)
6589 {
6590 return !(first == second);
6591 }
6592}
6593
6594#endif
6595#ifndef __JDAQHEADER__
6596#define __JDAQHEADER__
6597
6598#include "km3net-dataformat/online/JDAQRoot.hh"
6599#include "km3net-dataformat/online/JDAQChronometer.hh"
6600
6601
6602/**
6603 * \author mdejong
6604 */
6605
6606namespace KM3NETDAQ {
6607
6608 /**
6609 * DAQ header.
6610 */
6611 class JDAQHeader :
6612 public JDAQChronometer
6613 {
6614 public:
6615
6616 friend size_t getSizeof<JDAQHeader>();
6617 friend JReader& operator>>(JReader&, JDAQHeader&);
6618 friend JWriter& operator<<(JWriter&, const JDAQHeader&);
6619
6620 /**
6621 * Default constructor.
6622 */
6623 JDAQHeader() :
6624 JDAQChronometer()
6625 {}
6626
6627
6628 /**
6629 * Constructor.
6630 *
6631 * \param chronometer chronometer
6632 */
6633 JDAQHeader(const JDAQChronometer& chronometer) :
6634 JDAQChronometer(chronometer)
6635 {}
6636
6637
6638 /**
6639 * Get DAQ header.
6640 *
6641 * \return DAQ header
6642 */
6643 const JDAQHeader& getDAQHeader() const
6644 {
6645 return static_cast<const JDAQHeader&>(*this);
6646 }
6647
6648
6649 /**
6650 * Set DAQ header.
6651 *
6652 * \param header DAQ header
6653 */
6654 void setDAQHeader(const JDAQHeader& header)
6655 {
6656 static_cast<JDAQHeader&>(*this) = header;
6657 }
6658
6659
6660 ClassDef(JDAQHeader,2);
6661 };
6662
6663
6664 /**
6665 * Equal operator for DAQ headers.
6666 *
6667 * \param first header
6668 * \param second header
6669 * \result true if first header equal to second; else false
6670 */
6671 inline bool operator==(const JDAQHeader& first,
6672 const JDAQHeader& second)
6673 {
6674 return (first.getDAQChronometer() == second.getDAQChronometer());
6675 }
6676
6677
6678 /**
6679 * Not-equal operator for DAQ headers.
6680 *
6681 * \param first header
6682 * \param second header
6683 * \result true if first header not equal to second; else false
6684 */
6685 inline bool operator!=(const JDAQHeader& first,
6686 const JDAQHeader& second)
6687 {
6688 return !(first == second);
6689 }
6690}
6691
6692#endif
6693#ifndef __JDAQHIT__
6694#define __JDAQHIT__
6695
6696#include <istream>
6697#include <ostream>
6698#include <iomanip>
6699
6700#ifndef __CINT__
6701#include <netinet/in.h>
6702#endif
6703
6704#include "km3net-dataformat/online/JDAQ.hh"
6705#include "km3net-dataformat/online/JDAQRoot.hh"
6706#include "km3net-dataformat/online/JDAQException.hh"
6707
6708
6709/**
6710 * \author mdejong
6711 */
6712
6713namespace KM3NETDAQ {
6714 /**
6715 * Hit data structure.
6716 *
6717 * N.B.
6718 * The size of this data structure (i.e. the value obtained with the <tt>sizeof()</tt> operator
6719 * should exactly match the preset number of bytes from the DAQ system.
6720 * The <tt>pragma</tt> statement is necessary to ensure the correct size of this object.
6721 * Furthermore, this data structure should have no virtual methods and no virtual destructor.
6722 * Consequently, the standard ROOT <tt>CLassDef()</tt> macro is replaced by
6723 * the designated <tt>ClassDefNV()</tt> macro.
6724 */
6725#pragma pack(push,1)
6726 class JDAQHit
6727 {
6728 public:
6729
6730 typedef unsigned char JPMT_t; //!< PMT channel in FPGA
6731 typedef unsigned int JTDC_t; //!< leading edge [ns]
6732 typedef unsigned char JTOT_t; //!< time over threshold [ns]
6733
6734 friend size_t getSizeof<JDAQHit>();
6735 friend JReader& operator>>(JReader&, JDAQHit&);
6736 friend JWriter& operator<<(JWriter&, const JDAQHit&);
6737
6738 /**
6739 * Default constructor.
6740 */
6741 JDAQHit()
6742 {}
6743
6744
6745 /**
6746 * Constructor.
6747 *
6748 * \param pmt_id PMT channel
6749 * \param tdc_ns time of hit [ns]
6750 * \param tot_ns time over threshold [ns]
6751 */
6752 JDAQHit(const JPMT_t pmt_id,
6753 const JTDC_t tdc_ns,
6754 const JTOT_t tot_ns) :
6755 pmt(pmt_id),
6756 tdc(htonl(tdc_ns)),
6757 //tdc(tdc_ns),
6758 tot(tot_ns)
6759 {}
6760
6761
6762 /**
6763 * Get PMT.
6764 *
6765 * \return PMT
6766 */
6767 inline JPMT_t getPMT() const
6768 {
6769 return pmt;
6770 }
6771
6772
6773 /**
6774 * Get time.
6775 *
6776 * \return time [ns]
6777 */
6778 inline JTDC_t getT() const
6779 {
6780 return ntohl(tdc);
6781 }
6782
6783
6784 /**
6785 * Get time-over-threshold.
6786 *
6787 * \return time-over-threshold [ns]
6788 */
6789 inline JTOT_t getToT() const
6790 {
6791 return tot;
6792 }
6793
6794
6795 /**
6796 * Get maximal time-over-threshold.
6797 *
6798 * \return time-over-threshold [ns]
6799 */
6800 static JTOT_t getMaximalToT()
6801 {
6802 return 0xFF;
6803 }
6804
6805
6806 /**
6807 * Read DAQ hit from input.
6808 *
6809 * \param in input stream
6810 * \param hit hit
6811 * \return input stream
6812 */
6813 friend inline std::istream& operator>>(std::istream& in, JDAQHit& hit)
6814 {
6815 int pmt;
6816 int tdc;
6817 int tot;
6818
6819 if (in >> pmt >> tdc >> tot) {
6820 hit = JDAQHit(pmt, tdc, tot);
6821 }
6822
6823 return in;
6824 }
6825
6826
6827 /**
6828 * Write DAQ hit to output.
6829 *
6830 * \param out output stream
6831 * \param hit hit
6832 * \return output stream
6833 */
6834 friend inline std::ostream& operator<<(std::ostream& out, const JDAQHit& hit)
6835 {
6836 using namespace std;
6837
6838 out << setw(2) << (int) hit.getPMT() << ' '
6839 << setw(8) << (int) hit.getT() << ' '
6840 << setw(3) << (int) hit.getToT();
6841
6842 return out;
6843 }
6844
6845
6846 ClassDefNV(JDAQHit,2);
6847
6848
6849 protected:
6850 JPMT_t pmt; //!< PMT readout channel in FPGA
6851 JTDC_t tdc; //!< leading edge [ns]
6852 JTOT_t tot; //!< time over threshold [ns]
6853 };
6854#pragma pack(pop)
6855
6856
6857 /**
6858 * Less than operator for DAQ hits.
6859 *
6860 * The less than operator is applied first to the time and then to the PMT channel of the hits.
6861 *
6862 * \param first hit
6863 * \param second hit
6864 * \result true if first hit earlier than second; else false
6865 */
6866 inline bool operator<(const JDAQHit& first,
6867 const JDAQHit& second)
6868 {
6869 if (first.getT() != second.getT())
6870 return first.getT() < second.getT();
6871 else
6872 return first.getPMT() < second.getPMT();
6873 }
6874
6875
6876 /**
6877 * Equal operator for DAQ hits.
6878 *
6879 * \param first hit
6880 * \param second hit
6881 * \result true if first hit equal to second; else false
6882 */
6883 inline bool operator==(const JDAQHit& first,
6884 const JDAQHit& second)
6885 {
6886 return (first.getPMT() == second.getPMT() &&
6887 first.getT() == second.getT() &&
6888 first.getToT() == second.getToT());
6889 }
6890
6891
6892 /**
6893 * Not-equal operator for DAQ hits.
6894 *
6895 * \param first hit
6896 * \param second hit
6897 * \result true if first hit not equal to second; else false
6898 */
6899 inline bool operator!=(const JDAQHit& first,
6900 const JDAQHit& second)
6901 {
6902 return !(first == second);
6903 }
6904}
6905
6906#endif
6907#ifndef __JDAQKEYHIT__
6908#define __JDAQKEYHIT__
6909
6910#include "km3net-dataformat/online/JDAQRoot.hh"
6911#include "km3net-dataformat/online/JDAQModuleIdentifier.hh"
6912#include "km3net-dataformat/online/JDAQHit.hh"
6913#include "km3net-dataformat/online/JDAQPMTIdentifier.hh"
6914
6915
6916/**
6917 * \author mdejong
6918 */
6919
6920namespace KM3NETDAQ {
6921
6922 /**
6923 * DAQ key hit
6924 */
6925 class JDAQKeyHit :
6926 public JDAQModuleIdentifier,
6927 public JDAQHit
6928 {
6929 public:
6930
6931 friend size_t getSizeof<JDAQKeyHit>();
6932 friend JReader& operator>>(JReader&, JDAQKeyHit&);
6933 friend JWriter& operator<<(JWriter&, const JDAQKeyHit&);
6934
6935 /**
6936 * Default constructor.
6937 */
6938 JDAQKeyHit() :
6939 JDAQModuleIdentifier(),
6940 JDAQHit()
6941 {}
6942
6943
6944 /**
6945 * Constructor.
6946 *
6947 * \param id module identifier
6948 * \param hit PMT hit
6949 */
6950 JDAQKeyHit(const JDAQModuleIdentifier& id,
6951 const JDAQHit& hit) :
6952 JDAQModuleIdentifier(id),
6953 JDAQHit(hit)
6954 {}
6955
6956
6957 /**
6958 * Virtual destructor.
6959 */
6960 virtual ~JDAQKeyHit()
6961 {}
6962
6963
6964 /**
6965 * Type conversion operator.
6966 *
6967 * \return axis
6968 */
6969 operator JDAQPMTIdentifier () const
6970 {
6971 return JDAQPMTIdentifier(this->getModuleID(), this->getPMT());
6972 }
6973
6974
6975 ClassDef(JDAQKeyHit,1);
6976 };
6977
6978
6979
6980 /**
6981 * Less than operator for DAQ hits.
6982 *
6983 * The less than operator is applied first to the module idientifier then to the PMT channel and then to the time of the hits.
6984 *
6985 * \param first hit
6986 * \param second hit
6987 * \result true if first hit before than second; else false
6988 */
6989 inline bool operator<(const JDAQKeyHit& first,
6990 const JDAQKeyHit& second)
6991 {
6992 if (first.getModuleID() == second.getModuleID()) {
6993 if (first.getPMT() == second.getPMT())
6994 return first.getT() < second.getT();
6995 else
6996 return first.getPMT() < second.getPMT();
6997 } else
6998 return first.getModuleID() < second.getModuleID();
6999 }
7000
7001
7002
7003 /**
7004 * Equal operator for DAQ hits.
7005 *
7006 * The equal operator is applied to the module idientifier, to the PMT channel and to the time of the hits.
7007 *
7008 * \param first hit
7009 * \param second hit
7010 * \result t rue if first hit equal to second; else false
7011 */
7012 inline bool operator==(const JDAQKeyHit& first,
7013 const JDAQKeyHit& second)
7014 {
7015 return (first.getModuleID() == second.getModuleID() &&
7016 first.getPMT() == second.getPMT() &&
7017 first.getT() == second.getT());
7018 }
7019
7020
7021 /**
7022 * Not-equal operator for DAQ hits.
7023 *
7024 * \param first hit
7025 * \param second hit
7026 * \result true if first hit not equal to second; else false
7027 */
7028 inline bool operator!=(const JDAQKeyHit& first,
7029 const JDAQKeyHit& second)
7030 {
7031 return !(first == second);
7032 }
7033}
7034
7035#endif
7036#ifndef __JDAQMODULEIDENTIFIER__
7037#define __JDAQMODULEIDENTIFIER__
7038
7039#include <istream>
7040#include <ostream>
7041
7042#include "km3net-dataformat/online/JDAQRoot.hh"
7043
7044
7045/**
7046 * \author mdejong
7047 */
7048
7049namespace KM3NETDAQ {
7050
7051 /**
7052 * Module identifier.
7053 */
7054 class JDAQModuleIdentifier
7055 {
7056 public:
7057
7058 friend size_t getSizeof<JDAQModuleIdentifier>();
7059 friend JReader& operator>>(JReader&, JDAQModuleIdentifier&);
7060 friend JWriter& operator<<(JWriter&, const JDAQModuleIdentifier&);
7061
7062 /**
7063 * Default constructor.
7064 */
7065 JDAQModuleIdentifier() :
7066 id(-1)
7067 {}
7068
7069
7070 /**
7071 * Constructor.
7072 *
7073 * \param __id module identifier
7074 */
7075 JDAQModuleIdentifier(const int __id) :
7076 id(__id)
7077 {}
7078
7079
7080 /**
7081 * Get Module identifier.
7082 *
7083 * \return Module identifier
7084 */
7085 const JDAQModuleIdentifier& getModuleIdentifier() const
7086 {
7087 return *this;
7088 }
7089
7090
7091 /**
7092 * Set Module identifier.
7093 *
7094 * \param module Module identifier
7095 */
7096 void setModuleIdentifier(const JDAQModuleIdentifier& module)
7097 {
7098 *this = module;
7099 }
7100
7101
7102 /**
7103 * Get module identifier.
7104 *
7105 * \return module identifier
7106 */
7107 int getModuleID() const
7108 {
7109 return id;
7110 }
7111
7112
7113 /**
7114 * Read DAQ ModuleIdentifier from input.
7115 *
7116 * \param in input stream
7117 * \param module module identifier
7118 * \return input stream
7119 */
7120 friend inline std::istream& operator>>(std::istream& in, JDAQModuleIdentifier& module)
7121 {
7122 in >> module.id;
7123
7124 return in;
7125 }
7126
7127
7128 /**
7129 * Write DAQ ModuleIdentifier to output.
7130 *
7131 * \param out output stream
7132 * \param module module identifier
7133 * \return output stream
7134 */
7135 friend inline std::ostream& operator<<(std::ostream& out, const JDAQModuleIdentifier& module)
7136 {
7137 out << module.id;
7138
7139 return out;
7140 }
7141
7142
7143 ClassDefNV(JDAQModuleIdentifier,1);
7144
7145
7146 protected:
7147 int id;
7148 };
7149
7150
7151 /**
7152 * Equal operator.
7153 *
7154 * \param first first module identifier
7155 * \param second second module identifier
7156 * \return true if identifiers are equal; else false
7157 */
7158 inline bool operator==(const JDAQModuleIdentifier& first, const JDAQModuleIdentifier& second)
7159 {
7160 return first.getModuleID() == second.getModuleID();
7161 }
7162
7163
7164 /**
7165 * Not equal operator.
7166 *
7167 * \param first first module identifier
7168 * \param second second module identifier
7169 * \return true if identifiers are different; else false
7170 */
7171 inline bool operator!=(const JDAQModuleIdentifier& first, const JDAQModuleIdentifier& second)
7172 {
7173 return first.getModuleID() != second.getModuleID();
7174 }
7175
7176
7177 /**
7178 * Equal operator.
7179 *
7180 * \param module module identifier
7181 * \param id identifier
7182 * \return true if identifiers are equal; else false
7183 */
7184 inline bool operator==(const JDAQModuleIdentifier& module, const int id)
7185 {
7186 return module.getModuleID() == id;
7187 }
7188
7189
7190 /**
7191 * Not equal operator.
7192 *
7193 * \param module module identifier
7194 * \param id identifier
7195 * \return true if identifiers are different; else false
7196 */
7197 inline bool operator!=(const JDAQModuleIdentifier& module, const int id)
7198 {
7199 return module.getModuleID() != id;
7200 }
7201
7202
7203 /**
7204 * Less than operator.
7205 *
7206 * \param first first module identifier
7207 * \param second second module identifier
7208 * \return true if first identifier less than second eidentifier; else false
7209 */
7210 inline bool operator<(const JDAQModuleIdentifier& first, const JDAQModuleIdentifier& second)
7211 {
7212 return first.getModuleID() < second.getModuleID();
7213 }
7214
7215
7216 /**
7217 * Less than operator.
7218 *
7219 * \param module module identifier
7220 * \param id identifier
7221 * \return true if module identifier less than identifier; else false
7222 */
7223 inline bool operator<(const JDAQModuleIdentifier& module, const int id)
7224 {
7225 return module.getModuleID() < id;
7226 }
7227
7228
7229 /**
7230 * Auxiliary class to compare modules.
7231 */
7232 struct JDAQModuleComparator {
7233 /*
7234 * Default constructor.
7235 */
7236 JDAQModuleComparator()
7237 {}
7238
7239
7240 /**
7241 * Compare modules.
7242 *
7243 * \param first first module
7244 * \param second second module
7245 * \return true if first module identifier less than that of second; else false
7246 */
7247 bool operator()(const JDAQModuleIdentifier& first, const JDAQModuleIdentifier& second) const
7248 {
7249 return first.getModuleID() < second.getModuleID();
7250 }
7251 };
7252}
7253
7254#endif
7255#ifndef __JDAQPMTIDENTIFIER__
7256#define __JDAQPMTIDENTIFIER__
7257
7258#include <istream>
7259#include <ostream>
7260
7261#include "km3net-dataformat/online/JDAQModuleIdentifier.hh"
7262#include "km3net-dataformat/online/JDAQRoot.hh"
7263
7264
7265/**
7266 * \author mdejong
7267 */
7268
7269namespace KM3NETDAQ {
7270
7271 /**
7272 * PMT identifier.
7273 */
7274 class JDAQPMTIdentifier :
7275 public JDAQModuleIdentifier
7276 {
7277 public:
7278
7279 friend size_t getSizeof<JDAQPMTIdentifier>();
7280 friend JReader& operator>>(JReader&, JDAQPMTIdentifier&);
7281 friend JWriter& operator<<(JWriter&, const JDAQPMTIdentifier&);
7282
7283 /**
7284 * Default constructor.
7285 */
7286 JDAQPMTIdentifier() :
7287 JDAQModuleIdentifier(),
7288 address (0)
7289 {}
7290
7291
7292 /**
7293 * Constructor.
7294 *
7295 * \param id module identifier
7296 * \param pmt_address PMT address
7297 */
7298 JDAQPMTIdentifier(const JDAQModuleIdentifier& id,
7299 const int pmt_address) :
7300 JDAQModuleIdentifier(id),
7301 address (pmt_address)
7302 {}
7303
7304
7305 /**
7306 * Get PMT identifier.
7307 *
7308 * \return PMT identifier
7309 */
7310 const JDAQPMTIdentifier& getPMTIdentifier() const
7311 {
7312 return *this;
7313 }
7314
7315
7316 /**
7317 * Set PMT identifier.
7318 *
7319 * \param pmt PMT identifier
7320 */
7321 void setPMTIdentifier(const JDAQPMTIdentifier& pmt)
7322 {
7323 *this = pmt;
7324 }
7325
7326
7327 /**
7328 * Get PMT identifier.
7329 *
7330 * \return PMT identifier
7331 */
7332 int getPMTAddress() const
7333 {
7334 return address;
7335 }
7336
7337
7338 /**
7339 * Read PMT identifier from input.
7340 *
7341 * \param in input stream
7342 * \param pmt PMT identifier
7343 * \return input stream
7344 */
7345 friend inline std::istream& operator>>(std::istream& in, JDAQPMTIdentifier& pmt)
7346 {
7347 in >> static_cast<JDAQModuleIdentifier&>(pmt);
7348 in >> pmt.address;
7349
7350 return in;
7351 }
7352
7353
7354 /**
7355 * Write PMT identifier to output.
7356 *
7357 * \param out output stream
7358 * \param pmt PMT identifier
7359 * \return output stream
7360 */
7361 friend inline std::ostream& operator<<(std::ostream& out, const JDAQPMTIdentifier& pmt)
7362 {
7363 out << static_cast<const JDAQModuleIdentifier&>(pmt) << ' ';
7364 out << pmt.address;
7365
7366 return out;
7367 }
7368
7369
7370 /**
7371 * Compare PMT identifiers.
7372 *
7373 * The comparison is applied to the module identifer and to the PMT address.
7374 * If the module identifier or PMT address is <tt>-1</tt>, the corresponding comparison evaluates to <tt>true</tt>.
7375 *
7376 * \param first PMT identifier
7377 * \param second PMT identifier
7378 * \result true if first PMT equal second PMT; else false
7379 */
7380 static inline bool compare(const JDAQPMTIdentifier& first, const JDAQPMTIdentifier& second)
7381 {
7382 return ((first .getModuleIdentifier() == second.getModuleIdentifier() ||
7383 first .getModuleIdentifier() == -1 ||
7384 second.getModuleIdentifier() == -1) &&
7385 (first .getPMTAddress() == second.getPMTAddress() ||
7386 first .getPMTAddress() == -1 ||
7387 second.getPMTAddress() == -1));
7388 }
7389
7390
7391 ClassDefNV(JDAQPMTIdentifier,1);
7392
7393
7394 protected:
7395 int address;
7396 };
7397
7398
7399 /**
7400 * Less than operator for PMT identifiers.
7401 *
7402 * The less than operator is applied first to the module identifer and then to the PMT address.
7403 *
7404 * \param first PMT identifier
7405 * \param second PMT identifier
7406 * \result true if first PMT lower than second PMT; else false
7407 */
7408 inline bool operator<(const JDAQPMTIdentifier& first, const JDAQPMTIdentifier& second)
7409 {
7410 if (first.getModuleIdentifier() == second.getModuleIdentifier())
7411 return first.getPMTAddress() < second.getPMTAddress();
7412 else
7413 return first.getModuleIdentifier() < second.getModuleIdentifier();
7414 }
7415
7416
7417 /**
7418 * Equal operator for PMT identifiers.
7419 *
7420 * The equal operator is applied to the module identifer and to the PMT address.
7421 *
7422 * \param first PMT identifier
7423 * \param second PMT identifier
7424 * \result true if first PMT equal second PMT; else false
7425 */
7426 inline bool operator==(const JDAQPMTIdentifier& first, const JDAQPMTIdentifier& second)
7427 {
7428 return (first.getModuleIdentifier() == second.getModuleIdentifier() &&
7429 first.getPMTAddress() == second.getPMTAddress());
7430 }
7431
7432
7433 /**
7434 * Not-equal operator for PMT identifiers.
7435 *
7436 * \param first PMT identifier
7437 * \param second PMT identifier
7438 * \result true if first PMT identifier not equal to second; else false
7439 */
7440 inline bool operator!=(const JDAQPMTIdentifier& first,
7441 const JDAQPMTIdentifier& second)
7442 {
7443 return !(first == second);
7444 }
7445}
7446
7447#endif
7448#ifndef __JDAQPREAMBLE__
7449#define __JDAQPREAMBLE__
7450
7451#include <ostream>
7452#include <iomanip>
7453
7454#include "km3net-dataformat/online/JDAQRoot.hh"
7455#include "km3net-dataformat/online/JDAQDataTypes.hh"
7456#include "km3net-dataformat/online/JDAQAbstractPreamble.hh"
7457
7458
7459/**
7460 * \author mdejong
7461 */
7462
7463namespace KM3NETDAQ {
7464
7465 /**
7466 * DAQ preamble.
7467 *
7468 * The data type is determined by the return value of method getDataType().\n
7469 * This method should be overloaded so that each data type is uniquely mapped to an integer value.
7470 *
7471 * The size and type information of this object can be used for RTTI.
7472 */
7473 class JDAQPreamble :
7474 public JDAQAbstractPreamble,
7475 public TObject
7476 {
7477 protected:
7478
7479 /**
7480 * Constructor.
7481 *
7482 * \param type data type of derived class
7483 */
7484 template<class T>
7485 JDAQPreamble(const JDAQType<T>& type) :
7486 JDAQAbstractPreamble(type)
7487 {}
7488
7489 public:
7490
7491 friend size_t getSizeof<JDAQPreamble>();
7492 friend JReader& operator>>(JReader&, JDAQPreamble&);
7493 friend JWriter& operator<<(JWriter&, const JDAQPreamble&);
7494
7495 /**
7496 * Default constructor.
7497 */
7498 JDAQPreamble() :
7499 JDAQAbstractPreamble()
7500 {}
7501
7502
7503 /**
7504 * Virtual destructor.
7505 */
7506 virtual ~JDAQPreamble()
7507 {}
7508
7509
7510 /**
7511 * Get DAQ preamble.
7512 *
7513 * This method should be used for binary I/O to get the actual data for the given object.\n
7514 * To this end, the following method should be overloaded for the corresponding data type.
7515 * <pre>
7516 * size_t getSizeof(const T&);
7517 * </pre>
7518 *
7519 * \param object object
7520 * \return preamble
7521 */
7522 template<class T>
7523 static JDAQPreamble getDAQPreamble(const T& object)
7524 {
7525 static JDAQPreamble preamble;
7526
7527 preamble.length = getSizeof(object);
7528 preamble.type = KM3NETDAQ::getDataType<T>();
7529
7530 return preamble;
7531 }
7532
7533
7534 /**
7535 * Print DAQ preamble.
7536 *
7537 * \param out output stream
7538 * \param preamble JDAQPreamble
7539 * \return output stream
7540 */
7541 friend inline std::ostream& operator<<(std::ostream& out, const JDAQPreamble& preamble)
7542 {
7543 using namespace std;
7544
7545 out << setw(8) << preamble.length;
7546 out << ' ';
7547 out << setw(6) << preamble.type;
7548
7549 return out;
7550 }
7551
7552
7553 ClassDef(JDAQPreamble,1);
7554 };
7555}
7556
7557#endif
7558#ifndef __JDAQPRINT__
7559#define __JDAQPRINT__
7560
7561/**
7562 * \author mdejong
7563 */
7564
7565namespace KM3NETDAQ {
7566
7567 /**
7568 * Get DAQ print option.
7569 *
7570 * \return print option
7571 */
7572 inline bool& getDAQLongprint()
7573 {
7574 static bool option;
7575
7576 return option;
7577 }
7578
7579
7580 /**
7581 * Set DAQ print option.
7582 *
7583 * \param option print option
7584 */
7585 inline void setDAQLongprint(const bool option)
7586 {
7587 getDAQLongprint() = option;
7588 }
7589}
7590
7591#endif
7592#ifndef __JDAQROOT__
7593#define __JDAQROOT__
7594
7595#include <TObject.h>
7596#include <TBuffer.h>
7597
7598#include "km3net-dataformat/online/JDAQException.hh"
7599
7600
7601/**
7602 * \author mdejong
7603 */
7604
7605namespace JIO {
7606 class JReader; // forward declaration for friend
7607 class JWriter; // forward declaration for friend
7608}
7609
7610namespace KM3NETDAQ {
7611
7612 /**
7613 * Definition of method to get size of data type.
7614 *
7615 * This method should be specialised for each desired data type with fixed length.
7616 *
7617 * \return number of bytes
7618 */
7619 template<class T>
7620 inline size_t getSizeof();
7621
7622
7623 using JIO::JReader;
7624 using JIO::JWriter;
7625}
7626
7627namespace JPP {
7628}
7629
7630using namespace KM3NETDAQ;
7631
7632#endif
7633#ifndef __JDAQSUMMARYFRAME__
7634#define __JDAQSUMMARYFRAME__
7635
7636#include <limits>
7637#include <cmath>
7638#include <vector>
7639
7640#include "km3net-dataformat/online/JDAQException.hh"
7641#include "km3net-dataformat/online/JDAQ.hh"
7642#include "km3net-dataformat/online/JDAQClock.hh"
7643#include "km3net-dataformat/online/JDAQModuleIdentifier.hh"
7644#include "km3net-dataformat/online/JDAQFrameStatus.hh"
7645#include "km3net-dataformat/online/JDAQSuperFrame.hh"
7646
7647
7648/**
7649 * \author mdejong
7650 */
7651
7652namespace KM3NETDAQ {
7653
7654
7655 /**
7656 * Forward declaration for friend declaration of JDAQSummaryFrame inside JDAQRate.
7657 */
7658 class JDAQSummaryFrame;
7659
7660
7661 /**
7662 * Data storage class for rate measurement of one PMT.
7663 *
7664 * Note that the rate value is compressed.
7665 * The number of bins and corresponding abscissa values can be obtained with
7666 * methods JDAQRare::getN and JDAQRate::getData, respectively.
7667 */
7668 class JDAQRate {
7669 public:
7670
7671 friend class JDAQSummaryFrame;
7672
7673
7674 typedef unsigned char JRate_t; // type of value to store rate
7675
7676
7677 /**
7678 * Get minimal rate (below this, value is set to zero)
7679 *
7680 * \return rate [Hz]
7681 */
7682 static double getMinimalRate()
7683 {
7684 return 2.0e3;
7685 }
7686
7687
7688 /**
7689 * Get maximal rate (above this, value is set to maximum)
7690 *
7691 * \return rate [Hz]
7692 */
7693 static double getMaximalRate()
7694 {
7695 return 2.0e6;
7696 }
7697
7698
7699 /**
7700 * Get value.
7701 *
7702 * \param numberOfHits number of hits
7703 * \param frameTime_ns frame time [ns]
7704 * \return value
7705 */
7706 static JRate_t getValue(const int numberOfHits, const double frameTime_ns)
7707 {
7708 return getValue(numberOfHits * 1.0e9 / frameTime_ns);
7709 }
7710
7711
7712 /**
7713 * Get value.
7714 *
7715 * \param rate_Hz rate [Hz]
7716 * \return value
7717 */
7718 static JRate_t getValue(const double rate_Hz)
7719 {
7720 if (rate_Hz <= getMinimalRate())
7721 return 0;
7722 else if (rate_Hz >= getMaximalRate())
7723 return std::numeric_limits<JRate_t>::max();
7724 else
7725 return (JRate_t) (log(rate_Hz/getMinimalRate()) / getFactor() + 0.5);
7726 }
7727
7728
7729 /**
7730 * Get count rate.
7731 *
7732 * \param value value
7733 * \return rate [Hz]
7734 */
7735 static double getRate(const JRate_t value)
7736 {
7737 if (value == 0)
7738 return 0.0;
7739 else
7740 return get_rate(value);
7741 }
7742
7743
7744 /**
7745 * Get weight.
7746 *
7747 * \param value value
7748 * \return weight [Hz^-1]
7749 */
7750 static double getWeight(const JRate_t value)
7751 {
7752 double W = 1.0;
7753
7754 if (value == 0)
7755 W = get_rate(0.5) - getMinimalRate();
7756 else if (value == std::numeric_limits<JRate_t>::max())
7757 W = getMaximalRate() - get_rate(std::numeric_limits<JRate_t>::max() - 0.5);
7758 else
7759 W = get_rate((double) value + 0.5) - get_rate((double) value - 0.5);
7760
7761 return 1.0 / W;
7762 }
7763
7764
7765 /**
7766 * Get number of bins.
7767 *
7768 * \return number of bins
7769 */
7770 static int getN()
7771 {
7772 return (int) std::numeric_limits<JRate_t>::max() + 1;
7773 }
7774
7775
7776 /**
7777 * Get abscissa values.
7778 *
7779 * \param factor scaling factor
7780 * \return abscissa values
7781 */
7782 static const double* getData(const double factor = 1.0)
7783 {
7784 static std::vector<double> buffer;
7785
7786 buffer.clear();
7787
7788 buffer.push_back(getMinimalRate() * factor);
7789
7790 for (int i = 1; i != JDAQRate::getN(); ++i) {
7791 buffer.push_back(get_rate(i - 0.5) * factor);
7792 }
7793
7794 buffer.push_back(getMaximalRate() * factor);
7795
7796 return buffer.data();
7797 }
7798
7799
7800 /**
7801 * Default constructor.
7802 */
7803 JDAQRate() :
7804 value(0)
7805 {}
7806
7807
7808 /**
7809 * Get value.
7810 *
7811 * \return value
7812 */
7813 JRate_t getValue() const
7814 {
7815 return value;
7816 }
7817
7818
7819 /**
7820 * Set value.
7821 *
7822 * \param numberOfHits number of hits
7823 * \param frameTime_ns frame time [ns]
7824 */
7825 void setValue(const int numberOfHits, const double frameTime_ns)
7826 {
7827 value = getValue(numberOfHits, frameTime_ns);
7828 }
7829
7830
7831 /**
7832 * Set value.
7833 *
7834 * \param rate_Hz rate [Hz]
7835 */
7836 void setValue(const double rate_Hz)
7837 {
7838 value = getValue(rate_Hz);
7839 }
7840
7841
7842 /**
7843 * Get count rate.
7844 *
7845 * \return rate [Hz]
7846 */
7847 double getRate() const
7848 {
7849 return getRate(value);
7850 }
7851
7852
7853 /**
7854 * Get weight.
7855 *
7856 * \return weight [Hz^-1]
7857 */
7858 double getWeight() const
7859 {
7860 return getWeight(value);
7861 }
7862
7863
7864 /**
7865 * Scale rate.
7866 *
7867 * \param factor multiplication factor
7868 * \return this rate
7869 */
7870 JDAQRate& mul(const double factor)
7871 {
7872 setValue(getRate() * factor);
7873
7874 return *this;
7875 }
7876
7877
7878 /**
7879 * Scale rate.
7880 *
7881 * \param factor multiplication factor
7882 * \return this rate
7883 */
7884 JDAQRate& div(const double factor)
7885 {
7886 setValue(getRate() / factor);
7887
7888 return *this;
7889 }
7890
7891
7892 /**
7893 * Check validity of rate.
7894 * The rate is considered valid if it is between the minimal and the maximal rate.
7895 *
7896 * \return true if valid; else false
7897 */
7898 bool is_valid() const
7899 {
7900 return (value != 0 && value != std::numeric_limits<JRate_t>::max());
7901 }
7902
7903
7904 protected:
7905 JRate_t value;
7906
7907
7908 private:
7909 /**
7910 * Get conversion factor.
7911 *
7912 * \return factor
7913 */
7914 static const double getFactor()
7915 {
7916 return std::log(getMaximalRate() / getMinimalRate()) / std::numeric_limits<JRate_t>::max();
7917 }
7918
7919
7920 /**
7921 * Get count rate.
7922 *
7923 * \param value value
7924 * \return rate [Hz]
7925 */
7926 static double get_rate(const double value)
7927 {
7928 return getMinimalRate() * std::exp(value * getFactor());
7929 }
7930 };
7931
7932
7933 /**
7934 * Equal operator for DAQ rates.
7935 *
7936 * \param first rate
7937 * \param second rate
7938 * \result true if first rate equal to second; else false
7939 */
7940 inline bool operator==(const JDAQRate& first,
7941 const JDAQRate& second)
7942 {
7943 return (first.getValue() == second.getValue());
7944 }
7945
7946
7947 /**
7948 * Not-equal operator for DAQ rates.
7949 *
7950 * \param first rate
7951 * \param second rate
7952 * \result true if first rate not equal to second; else false
7953 */
7954 inline bool operator!=(const JDAQRate& first,
7955 const JDAQRate& second)
7956 {
7957 return (first.getValue() != second.getValue());
7958 }
7959
7960
7961 /**
7962 * Data storage class for rate measurements of all PMTs in one module.
7963 */
7964 class JDAQSummaryFrame :
7965 public JDAQModuleIdentifier,
7966 public JDAQFrameStatus
7967 {
7968 public:
7969
7970 typedef JDAQRate::JRate_t JRate_t;
7971
7972 friend size_t getSizeof<JDAQSummaryFrame>();
7973 friend JReader& operator>>(JReader&, JDAQSummaryFrame&);
7974 friend JWriter& operator<<(JWriter&, const JDAQSummaryFrame&);
7975
7976 /**
7977 * Default constructor.
7978 */
7979 JDAQSummaryFrame() :
7980 JDAQModuleIdentifier(),
7981 JDAQFrameStatus()
7982 {}
7983
7984
7985 /**
7986 * Constructor.
7987 *
7988 * \param id module identifier
7989 */
7990 JDAQSummaryFrame(const JDAQModuleIdentifier& id) :
7991 JDAQModuleIdentifier(id),
7992 JDAQFrameStatus(JDAQFrameStatus::getInstance())
7993 {}
7994
7995
7996 /**
7997 * Constructor.
7998 *
7999 * Note that normally the rate is set to the number of hits per unit frame time
8000 * but if either the high-rate veto or FIFO (almost) full bit is on,
8001 * the rate is set to the number of hits divided by the time of the last hit.
8002 *
8003 * \param input super frame
8004 */
8005 JDAQSummaryFrame(const JDAQSuperFrame& input) :
8006 JDAQModuleIdentifier(input.getModuleID()),
8007 JDAQFrameStatus (input.getDAQFrameStatus())
8008 {
8009 using namespace std;
8010
8011 typedef JDAQHit::JPMT_t JPMT_t;
8012 typedef JDAQHit::JTDC_t JTDC_t;
8013
8014 vector<int> counter(numeric_limits<JPMT_t>::max(), 0);
8015
8016 int n = input.size();
8017
8018 for (JDAQSuperFrame::const_iterator i = input.begin(); n != 0; --n, ++i) {
8019 ++counter[i->getPMT()];
8020 }
8021
8022 for (int i = 0; i != NUMBER_OF_PMTS; ++i) {
8023 data[i].setValue(counter[i], getFrameTime());
8024 }
8025
8026 if (input.testHighRateVeto() || input.testFIFOStatus()) {
8027
8028 // determine last hit for each PMT
8029
8030 vector<JTDC_t> limit(numeric_limits<JPMT_t>::max(), 0);
8031
8032 int n = input.size();
8033
8034 for (JDAQSuperFrame::const_iterator i = input.begin(); n != 0; --n, ++i) {
8035 if (i->getT() > limit[i->getPMT()]) {
8036 limit[i->getPMT()] = i->getT();
8037 }
8038 }
8039
8040 for (int i = 0; i != NUMBER_OF_PMTS; ++i) {
8041 if (input.testHighRateVeto(i) || input.testFIFOStatus(i)) {
8042 if (limit[i] != 0) {
8043 data[i].setValue((double) counter[i] * 1.0e9 / (double) limit[i]);
8044 }
8045 }
8046 }
8047 }
8048 }
8049
8050
8051 /**
8052 * Get DAQ rate of given PMT.
8053 *
8054 * \param tdc TDC
8055 * \return JDAQRate
8056 */
8057 const JDAQRate& operator[](const int tdc) const
8058 {
8059 if (tdc >= 0 && tdc < NUMBER_OF_PMTS)
8060 return data[tdc];
8061 else
8062 throw JDAQException("TDC out of range.");
8063 }
8064
8065
8066 /**
8067 * Get DAQ rate of given PMT.
8068 *
8069 * \param tdc TDC
8070 * \return JDAQRate
8071 */
8072 JDAQRate& operator[](const int tdc)
8073 {
8074 if (tdc >= 0 && tdc < NUMBER_OF_PMTS)
8075 return data[tdc];
8076 else
8077 throw JDAQException("TDC out of range.");
8078 }
8079
8080
8081 /**
8082 * Get value.
8083 *
8084 * \param tdc TDC
8085 * \return value
8086 */
8087 JRate_t getValue(const int tdc) const
8088 {
8089 return data[tdc].getValue();
8090 }
8091
8092
8093 /**
8094 * Get count rate.
8095 *
8096 * \param tdc TDC
8097 * \param factor scaling factor
8098 * \return rate x scaling factor [Hz]
8099 */
8100 double getRate(const int tdc, const double factor = 1.0) const
8101 {
8102 return data[tdc].getRate() * factor;
8103 }
8104
8105
8106 /**
8107 * Get weight.
8108 *
8109 * \param tdc TDC
8110 * \param factor scaling factor
8111 * \return weight / scaling factor [Hz^-1]
8112 */
8113 double getWeight(const int tdc, const double factor = 1.0) const
8114 {
8115 return data[tdc].getWeight() / factor;
8116 }
8117
8118
8119 /**
8120 * Set count rate.
8121 *
8122 * \param tdc TDC
8123 * \param rate_Hz rate [Hz]
8124 */
8125 void setRate(const int tdc, const double rate_Hz)
8126 {
8127 return data[tdc].setValue(rate_Hz);
8128 }
8129
8130
8131 static int ROOT_IO_VERSION; //!< Streamer version of JDAQSummaryslice as obtained from ROOT file.
8132
8133
8134 ClassDefNV(JDAQSummaryFrame,2);
8135
8136
8137 protected:
8138
8139 JDAQRate data[NUMBER_OF_PMTS];
8140 };
8141
8142
8143 /**
8144 * Equal operator for DAQ summary frames.
8145 *
8146 * \param first summary frame
8147 * \param second summary frame
8148 * \result true if first summary frame equal to second; else false
8149 */
8150 inline bool operator==(const JDAQSummaryFrame& first,
8151 const JDAQSummaryFrame& second)
8152 {
8153 if (first.getModuleIdentifier() == second.getModuleIdentifier() &&
8154 first.getDAQFrameStatus() == second.getDAQFrameStatus()) {
8155
8156 for (int i = 0; i != NUMBER_OF_PMTS; ++i) {
8157 if (first[i] != second[i]) {
8158 return false;
8159 }
8160 }
8161
8162 return true;
8163
8164 } else {
8165
8166 return false;
8167 }
8168 }
8169
8170
8171 /**
8172 * Not-equal operator for DAQ summary frames.
8173 *
8174 * \param first summary frame
8175 * \param second summary frame
8176 * \result true if first summary frame not equal to second; else false
8177 */
8178 inline bool operator!=(const JDAQSummaryFrame& first,
8179 const JDAQSummaryFrame& second)
8180 {
8181 return !(first == second);
8182 }
8183}
8184
8185#endif
8186#ifndef __JDAQSUMMARYSLICE__
8187#define __JDAQSUMMARYSLICE__
8188
8189#include <ostream>
8190#include <iomanip>
8191#include <vector>
8192
8193#include "km3net-dataformat/online/JDAQRoot.hh"
8194#include "km3net-dataformat/online/JDAQPreamble.hh"
8195#include "km3net-dataformat/online/JDAQSummaryFrame.hh"
8196#include "km3net-dataformat/online/JDAQSummarysliceHeader.hh"
8197#include "km3net-dataformat/online/JDAQTimeslice.hh"
8198#include "km3net-dataformat/online/JDAQClock.hh"
8199
8200
8201/**
8202 * \author mdejong
8203 */
8204
8205namespace KM3NETDAQ {
8206
8207 /**
8208 * Data summary slice.
8209 */
8210 class JDAQSummaryslice :
8211 public JDAQPreamble,
8212 public JDAQSummarysliceHeader,
8213 public std::vector<JDAQSummaryFrame>
8214 {
8215 public:
8216
8217 friend size_t getSizeof(const JDAQSummaryslice&);
8218 friend JReader& operator>>(JReader&, JDAQSummaryslice&);
8219 friend JWriter& operator<<(JWriter&, const JDAQSummaryslice&);
8220
8221 /**
8222 * Default constructor.
8223 */
8224 JDAQSummaryslice() :
8225 JDAQPreamble(JDAQType<JDAQSummaryslice>()),
8226 JDAQSummarysliceHeader(),
8227 std::vector<JDAQSummaryFrame>()
8228 {}
8229
8230
8231 /**
8232 * Constructor.
8233 *
8234 * \param chronometer DAQ chronometer
8235 */
8236 JDAQSummaryslice(const JDAQChronometer& chronometer) :
8237 JDAQPreamble(JDAQType<JDAQSummaryslice>()),
8238 JDAQSummarysliceHeader(chronometer),
8239 std::vector<JDAQSummaryFrame>()
8240 {}
8241
8242
8243 /**
8244 * Constructor.
8245 *
8246 * \param timeslice time slice
8247 */
8248 JDAQSummaryslice(const JDAQTimeslice& timeslice) :
8249 JDAQPreamble(JDAQType<JDAQSummaryslice>()),
8250 JDAQSummarysliceHeader(timeslice),
8251 std::vector<JDAQSummaryFrame>()
8252 {
8253 for (JDAQTimeslice::const_iterator i = timeslice.begin(); i != timeslice.end(); ++i) {
8254 this->push_back(JDAQSummaryFrame(*i));
8255 }
8256 }
8257
8258
8259 /**
8260 * Virtual destructor.
8261 */
8262 virtual ~JDAQSummaryslice()
8263 {}
8264
8265
8266 /**
8267 * Print DAQ summary.
8268 *
8269 * \param out output stream
8270 * \param lpr long print
8271 * \return output stream
8272 */
8273 std::ostream& print(std::ostream& out, const bool lpr = false) const
8274 {
8275 using namespace std;
8276
8277 out << this->ClassName() << endl;
8278 out << dynamic_cast<const JDAQPreamble&> (*this) << endl;
8279 out << dynamic_cast<const JDAQChronometer&>(*this) << endl;
8280
8281 for (JDAQSummaryslice::const_iterator module = this->begin(); module != this->end(); ++module) {
8282
8283 out << ' ' << setw(10) << module->getModuleID();
8284 out << ' ' << setw(8) << setfill('0') << hex << module->getStatus() << dec << setfill(' ');
8285 out << '|' << setw(8) << setfill('0') << hex << module->getFIFOStatus() << dec << setfill(' ');
8286 out << ' ' << setw(2) << module->getUDPNumberOfReceivedPackets();
8287 out << ' ' << setw(2) << module->getUDPMaximalSequenceNumber();
8288
8289 if (lpr) {
8290 for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
8291 out << ' ' << fixed << showpoint << setw(4) << setprecision(1) << module->getRate(pmt) * 1.0e-3;
8292 }
8293 }
8294
8295 out << endl;
8296 }
8297
8298 return out;
8299 }
8300
8301
8302 /**
8303 * Action method at file open.
8304 *
8305 * \param version version
8306 */
8307 static void actionAtFileOpen(int version)
8308 {
8309 JDAQSummaryFrame::ROOT_IO_VERSION = version;
8310 }
8311
8312
8313 ClassDef(JDAQSummaryslice,6);
8314 };
8315
8316
8317 /**
8318 * Print DAQ summary.
8319 *
8320 * \param out output stream
8321 * \param summary summary
8322 * \return output stream
8323 */
8324 inline std::ostream& operator<<(std::ostream& out, const KM3NETDAQ::JDAQSummaryslice& summary)
8325 {
8326 return summary.print(out, getDAQLongprint());
8327 }
8328
8329
8330 /**
8331 * Equal operator for DAQ summary slices.
8332 *
8333 * \param first summary slice
8334 * \param second summary slice
8335 * \result true if first summary slice equal to second; else false
8336 */
8337 inline bool operator==(const JDAQSummaryslice& first,
8338 const JDAQSummaryslice& second)
8339 {
8340 return (first.getDAQSummarysliceHeader() == second.getDAQSummarysliceHeader() &&
8341 static_cast<const std::vector<JDAQSummaryFrame>&>(first) == static_cast<const std::vector<JDAQSummaryFrame>&>(second));
8342 }
8343
8344
8345 /**
8346 * Not-equal operator for DAQ summary slices.
8347 *
8348 * \param first summary slice
8349 * \param second summary slice
8350 * \result true if first summary slice not equal to second; else false
8351 */
8352 inline bool operator!=(const JDAQSummaryslice& first,
8353 const JDAQSummaryslice& second)
8354 {
8355 return !(first == second);
8356 }
8357}
8358
8359#endif
8360#ifndef __JDAQSUMMARYSLICEHEADER__
8361#define __JDAQSUMMARYSLICEHEADER__
8362
8363#include "km3net-dataformat/online/JDAQRoot.hh"
8364#include "km3net-dataformat/online/JDAQHeader.hh"
8365
8366
8367/**
8368 * \author mdejong
8369 */
8370
8371namespace KM3NETDAQ {
8372
8373 /**
8374 * JDAQ summaryslice header.
8375 */
8376 class JDAQSummarysliceHeader :
8377 public JDAQHeader
8378 {
8379 public:
8380 /**
8381 * Default constructor.
8382 */
8383 JDAQSummarysliceHeader() :
8384 JDAQHeader()
8385 {}
8386
8387
8388 /**
8389 * Constructor.
8390 *
8391 * \param chronometer DAQ chronometer
8392 */
8393 JDAQSummarysliceHeader(const JDAQChronometer& chronometer) :
8394 JDAQHeader(chronometer)
8395 {}
8396
8397
8398 /**
8399 * Get DAQ summary slice header.
8400 *
8401 * \return DAQ summary slice header
8402 */
8403 const JDAQSummarysliceHeader& getDAQSummarysliceHeader() const
8404 {
8405 return static_cast<const JDAQSummarysliceHeader&>(*this);
8406 }
8407
8408
8409 ClassDef(JDAQSummarysliceHeader,2);
8410 };
8411
8412
8413 /**
8414 * Equal operator for DAQ summary slice headers.
8415 *
8416 * \param first summary slice header
8417 * \param second summary slice header
8418 * \result true if first summaryslice header equal to second; else false
8419 */
8420 inline bool operator==(const JDAQSummarysliceHeader& first,
8421 const JDAQSummarysliceHeader& second)
8422 {
8423 return (first.getDAQHeader() == second.getDAQHeader());
8424 }
8425
8426
8427 /**
8428 * Not-equal operator for DAQ summary slice headers.
8429 *
8430 * \param first summary slice header
8431 * \param second summary slice header
8432 * \result true if first summary slice header not equal to second; else false
8433 */
8434 inline bool operator!=(const JDAQSummarysliceHeader& first,
8435 const JDAQSummarysliceHeader& second)
8436 {
8437 return !(first == second);
8438 }
8439}
8440
8441#endif
8442#ifndef __JDAQSUPERFRAME__
8443#define __JDAQSUPERFRAME__
8444
8445#include "km3net-dataformat/online/JDAQ.hh"
8446#include "km3net-dataformat/online/JDAQPreamble.hh"
8447#include "km3net-dataformat/online/JDAQSuperFrameHeader.hh"
8448#include "km3net-dataformat/online/JDAQFrame.hh"
8449#include "km3net-dataformat/online/JDAQHit.hh"
8450#include "km3net-dataformat/online/JDAQRoot.hh"
8451#include "km3net-dataformat/online/JDAQException.hh"
8452
8453
8454/**
8455 * \author mdejong
8456 */
8457
8458namespace KM3NETDAQ {
8459
8460 /**
8461 * Data frame of one optical module.
8462 */
8463 class JDAQSuperFrame :
8464 public JDAQPreamble,
8465 public JDAQSuperFrameHeader,
8466 public JDAQFrame
8467 {
8468 public:
8469
8470 typedef JDAQFrame::const_iterator const_iterator;
8471 typedef JDAQFrame::iterator iterator;
8472 typedef JDAQFrame::const_reverse_iterator const_reverse_iterator;
8473 typedef JDAQFrame::reverse_iterator reverse_iterator;
8474
8475 friend size_t getSizeof(const JDAQSuperFrame&);
8476 friend JReader& operator>>(JReader&, JDAQSuperFrame&);
8477 friend JWriter& operator<<(JWriter&, const JDAQSuperFrame&);
8478
8479 /**
8480 * Default constructor.
8481 */
8482 JDAQSuperFrame() :
8483 JDAQPreamble(JDAQType<JDAQSuperFrame>()),
8484 JDAQSuperFrameHeader(),
8485 JDAQFrame()
8486 {}
8487
8488
8489 /**
8490 * Constructor.
8491 *
8492 * \param header JDAQ super frame header
8493 */
8494 JDAQSuperFrame(const JDAQSuperFrameHeader& header) :
8495 JDAQPreamble(JDAQType<JDAQSuperFrame>()),
8496 JDAQSuperFrameHeader(header),
8497 JDAQFrame()
8498 {}
8499
8500
8501 /**
8502 * Copy constructor.
8503 *
8504 * \param super_frame JDAQ super frame
8505 */
8506 JDAQSuperFrame(const JDAQSuperFrame& super_frame) :
8507 JDAQPreamble(JDAQType<JDAQSuperFrame>()),
8508 JDAQSuperFrameHeader(super_frame.getDAQSuperFrameHeader()),
8509 JDAQFrame(super_frame)
8510 {}
8511
8512
8513 /**
8514 * Add data from same optical module.
8515 *
8516 * \param super_frame JDAQ super frame
8517 * \return this JDAQ super frame
8518 */
8519 JDAQSuperFrame& add(const JDAQSuperFrame& super_frame)
8520 {
8521 if (this->getModuleID() != super_frame.getModuleID())
8522 throw JDAQException("JDAQSuperFrame::add(): Different module identifiers.");
8523
8524 return add(static_cast<const JDAQFrame&>(super_frame));
8525 }
8526
8527
8528 /**
8529 * Add hit.
8530 *
8531 * \param hit JDAQ hit
8532 * \return this JDAQ frame
8533 */
8534 JDAQSuperFrame& add(const JDAQHit& hit)
8535 {
8536 return add(1, &hit);
8537 }
8538
8539
8540 /**
8541 * Add data.
8542 *
8543 * \param frame JDAQ frame
8544 * \return this JDAQ frame
8545 */
8546 JDAQSuperFrame& add(const JDAQFrame& frame)
8547 {
8548 return add(frame.numberOfHits, frame.buffer);
8549 }
8550
8551
8552 /**
8553 * Add data.
8554 *
8555 * \param number_of_hits number of hits
8556 * \param data pointer to data
8557 * \return this data frame
8558 */
8559 JDAQSuperFrame& add(const int number_of_hits, const JDAQHit* data)
8560 {
8561 JDAQFrame::add(number_of_hits, data);
8562
8563 return *this;
8564 }
8565
8566
8567 ClassDef(JDAQSuperFrame,3);
8568 };
8569
8570
8571 /**
8572 * Equal operator for DAQ super frames.
8573 *
8574 * \param first super frame
8575 * \param second super frame
8576 * \result true if first super frame equal to second; else false
8577 */
8578 inline bool operator==(const JDAQSuperFrame& first,
8579 const JDAQSuperFrame& second)
8580 {
8581 if (first.getDAQSuperFrameHeader() == second.getDAQSuperFrameHeader() &&
8582 first.size() == second.size()) {
8583
8584 for (JDAQSuperFrame::const_iterator p = first.begin(), q = second.begin(); p != first.end(); ++p, ++q) {
8585 if (*p != *q) {
8586 return false;
8587 }
8588 }
8589
8590 return true;
8591
8592 } else {
8593
8594 return false;
8595 }
8596 }
8597
8598
8599 /**
8600 * Not-equal operator for DAQ super frames.
8601 *
8602 * \param first super frame
8603 * \param second super frame
8604 * \result true if first super frame not equal to second; else false
8605 */
8606 inline bool operator!=(const JDAQSuperFrame& first,
8607 const JDAQSuperFrame& second)
8608 {
8609 return !(first == second);
8610 }
8611}
8612
8613#endif
8614#ifndef __JDAQSUPERFRAMEHEADER__
8615#define __JDAQSUPERFRAMEHEADER__
8616
8617#include "km3net-dataformat/online/JDAQ.hh"
8618#include "km3net-dataformat/online/JDAQHeader.hh"
8619#include "km3net-dataformat/online/JDAQModuleIdentifier.hh"
8620#include "km3net-dataformat/online/JDAQFrameStatus.hh"
8621#include "km3net-dataformat/online/JDAQRoot.hh"
8622
8623
8624/**
8625 * \author mdejong
8626 */
8627namespace KM3NETDAQ {
8628
8629 /**
8630 * DAQ super frame header.
8631 */
8632 class JDAQSuperFrameHeader :
8633 public JDAQHeader,
8634 public JDAQModuleIdentifier,
8635 public JDAQFrameStatus
8636 {
8637 public:
8638
8639 friend size_t getSizeof<JDAQSuperFrameHeader>();
8640 friend JReader& operator>>(JReader&, JDAQSuperFrameHeader&);
8641 friend JWriter& operator<<(JWriter&, const JDAQSuperFrameHeader&);
8642
8643 /**
8644 * Default constructor.
8645 */
8646 JDAQSuperFrameHeader() :
8647 JDAQHeader (),
8648 JDAQModuleIdentifier(),
8649 JDAQFrameStatus ()
8650 {}
8651
8652
8653 /**
8654 * Constructor.
8655 *
8656 * \param chronometer chronometer
8657 * \param id module identifier
8658 */
8659 JDAQSuperFrameHeader(const JDAQChronometer& chronometer,
8660 const int id) :
8661 JDAQHeader (chronometer),
8662 JDAQModuleIdentifier(id),
8663 JDAQFrameStatus (JDAQFrameStatus::getInstance())
8664 {}
8665
8666
8667 /**
8668 * Constructor.
8669 *
8670 * \param chronometer chronometer
8671 * \param id module identifier
8672 * \param status frame status
8673 */
8674 JDAQSuperFrameHeader(const JDAQChronometer& chronometer,
8675 const int id,
8676 const JDAQFrameStatus& status) :
8677 JDAQHeader (chronometer),
8678 JDAQModuleIdentifier(id),
8679 JDAQFrameStatus (status)
8680 {}
8681
8682
8683 /**
8684 * Get DAQ super frame header.
8685 *
8686 * \return DAQ super frame header
8687 */
8688 const JDAQSuperFrameHeader& getDAQSuperFrameHeader() const
8689 {
8690 return static_cast<const JDAQSuperFrameHeader&>(*this);
8691 }
8692
8693
8694 /**
8695 * Set DAQ super frame header.
8696 *
8697 * \param header DAQ super frame header
8698 */
8699 void setDAQSuperFrameHeader(const JDAQSuperFrameHeader& header)
8700 {
8701 static_cast<JDAQSuperFrameHeader&>(*this) = header;
8702 }
8703
8704
8705 ClassDef(JDAQSuperFrameHeader,2);
8706 };
8707
8708
8709 /**
8710 * Equal operator for DAQ super frame headers.
8711 *
8712 * \param first super frame header
8713 * \param second super frame header
8714 * \result true if first super frame header equal to second; else false
8715 */
8716 inline bool operator==(const JDAQSuperFrameHeader& first,
8717 const JDAQSuperFrameHeader& second)
8718 {
8719 return (first.getDAQHeader() == second.getDAQHeader() &&
8720 first.getModuleIdentifier() == second.getModuleIdentifier() &&
8721 first.getDAQFrameStatus() == second.getDAQFrameStatus());
8722 }
8723
8724
8725 /**
8726 * Not-equal operator for DAQ super frame headers.
8727 *
8728 * \param first super frame header
8729 * \param second super frame header
8730 * \result true if first super frame header not equal to second; else false
8731 */
8732 inline bool operator!=(const JDAQSuperFrameHeader& first,
8733 const JDAQSuperFrameHeader& second)
8734 {
8735 return !(first == second);
8736 }
8737}
8738
8739#endif
8740#ifndef __JDAQTIMESLICE__
8741#define __JDAQTIMESLICE__
8742
8743#include <ostream>
8744#include <iomanip>
8745#include <vector>
8746#include <map>
8747
8748#include "km3net-dataformat/online/JDAQRoot.hh"
8749#include "km3net-dataformat/online/JDAQPreamble.hh"
8750#include "km3net-dataformat/online/JDAQTimesliceHeader.hh"
8751#include "km3net-dataformat/online/JDAQSuperFrame.hh"
8752#include "km3net-dataformat/online/JDAQException.hh"
8753#include "km3net-dataformat/online/JDAQPrint.hh"
8754
8755
8756/**
8757 * \author mdejong
8758 */
8759
8760namespace KM3NETDAQ {
8761
8762 class JDAQEvent;
8763 class JDAQSummaryslice;
8764
8765
8766 /**
8767 * Data time slice.
8768 */
8769 class JDAQTimeslice :
8770 public JDAQPreamble,
8771 public JDAQTimesliceHeader,
8772 public std::vector<JDAQSuperFrame>
8773 {
8774 public:
8775
8776 friend size_t getSizeof(const JDAQTimeslice&);
8777 friend JReader& operator>>(JReader&, JDAQTimeslice&);
8778 friend JWriter& operator<<(JWriter&, const JDAQTimeslice&);
8779
8780 /**
8781 * Default constructor.
8782 */
8783 JDAQTimeslice() :
8784 JDAQPreamble(JDAQType<JDAQTimeslice>()),
8785 JDAQTimesliceHeader(),
8786 std::vector<JDAQSuperFrame>()
8787 {}
8788
8789
8790 /**
8791 * Constructor.
8792 *
8793 * \param chronometer DAQ chronometer
8794 */
8795 JDAQTimeslice(const JDAQChronometer& chronometer) :
8796 JDAQPreamble(JDAQType<JDAQTimeslice>()),
8797 JDAQTimesliceHeader(chronometer),
8798 std::vector<JDAQSuperFrame>()
8799 {}
8800
8801
8802 /**
8803 * Constructor.
8804 *
8805 * \param event DAQ event
8806 * \param snapshot use shapshot hits (else use triggered hits)
8807 */
8808 JDAQTimeslice(const JDAQEvent& event,
8809 const bool snapshot = true);
8810
8811
8812 /**
8813 * Constructor.
8814 *
8815 * \param event DAQ event
8816 * \param summary summary
8817 * \param snapshot use shapshot hits (else use triggered hits)
8818 */
8819 JDAQTimeslice(const JDAQEvent& event,
8820 const JDAQSummaryslice& summary,
8821 const bool snapshot = true);
8822
8823
8824 /**
8825 * Virtual destructor.
8826 */
8827 virtual ~JDAQTimeslice()
8828 {
8829 clear();
8830 }
8831
8832
8833 /**
8834 * Clear data.
8835 */
8836 void clear()
8837 {
8838 for (iterator i = this->begin(); i != this->end(); ++i) {
8839 i->clear();
8840 }
8841
8842 std::vector<JDAQSuperFrame>::clear();
8843 }
8844
8845
8846 /**
8847 * Assignment operator.
8848 *
8849 * \param timeslice timeslice
8850 * \return this timeslice
8851 */
8852 JDAQTimeslice& operator=(const JDAQTimeslice& timeslice)
8853 {
8854 clear();
8855
8856 setDAQChronometer(timeslice.getDAQChronometer());
8857
8858 for (const_iterator i = timeslice.begin(); i != timeslice.end(); ++i) {
8859 push_back(*i);
8860 }
8861
8862 return *this;
8863 }
8864
8865
8866 /**
8867 * Add another timeslice.
8868 *
8869 * \param timeslice timeslice
8870 * \return this timeslice
8871 */
8872 JDAQTimeslice& add(const JDAQTimeslice& timeslice)
8873 {
8874 using namespace std;
8875
8876 map<JDAQModuleIdentifier, int> buffer;
8877
8878 for (const_iterator i = this->begin(); i != this->end(); ++i) {
8879 buffer[i->getModuleIdentifier()] = distance(static_cast<const JDAQTimeslice&>(*this).begin(),i);
8880 }
8881
8882 for (JDAQTimeslice::const_iterator i = timeslice.begin(); i != timeslice.end(); ++i) {
8883
8884 map<JDAQModuleIdentifier, int>::const_iterator p = buffer.find(i->getModuleIdentifier());
8885
8886 if (p != buffer.end()) {
8887
8888 JDAQSuperFrame& frame = this->at(p->second);
8889
8890 frame.add(*i);
8891
8892 sort(frame.begin(), frame.end());
8893
8894 } else {
8895
8896 this->push_back(*i);
8897 }
8898 }
8899
8900 return *this;
8901 }
8902
8903
8904 /**
8905 * Print DAQ Timeslice.
8906 *
8907 * \param out output stream
8908 * \param lpr long print
8909 * \return output stream
8910 */
8911 std::ostream& print(std::ostream& out, const bool lpr = false) const
8912 {
8913 using namespace std;
8914
8915 out << this->ClassName() << endl;
8916 out << dynamic_cast<const JDAQPreamble&> (*this) << endl;
8917 out << dynamic_cast<const JDAQChronometer&>(*this) << endl;
8918
8919 for (JDAQTimeslice::const_iterator frame = this->begin(); frame != this->end(); ++frame) {
8920
8921 out << ' ' << setw(10) << frame->getModuleID();
8922 out << ' ' << setw(6) << frame->getLength();
8923 out << ' ' << setw(6) << frame->getDataType();
8924 out << ' ' << setw(6) << frame->getTimesliceStart();
8925 out << ' ' << setw(8) << setfill('0') << hex << frame->getStatus() << dec << setfill(' ');
8926 out << '|' << setw(8) << setfill('0') << hex << frame->getFIFOStatus() << dec << setfill(' ');
8927 out << ' ' << setw(2) << frame->getUDPNumberOfReceivedPackets();
8928 out << '/' << setw(2) << frame->getUDPMaximalSequenceNumber();
8929 out << ' ' << setw(6) << frame->size();
8930
8931 if (!lpr) {
8932
8933 if (!frame->empty()) {
8934
8935 out << ' ' << setw(10) << frame-> begin()->getT();
8936 out << " ... ";
8937 out << ' ' << setw(10) << frame->rbegin()->getT();
8938 }
8939
8940 out << endl;
8941
8942 } else {
8943
8944 out << endl;
8945
8946 int n = 1;
8947
8948 for (JDAQFrame::const_iterator hit = frame->begin(); hit != frame->end(); ++hit, ++n) {
8949 out << setw(2) << (int) hit->getPMT() << ' '
8950 << setw(8) << (int) hit->getT() << ' '
8951 << setw(3) << (int) hit->getToT() << (n%10 == 0 ? '\n' : ' ');
8952 }
8953
8954 out << endl;
8955 }
8956 }
8957
8958 return out;
8959 }
8960
8961
8962 ClassDef(JDAQTimeslice,4);
8963 };
8964
8965
8966 /**
8967 * Equal operator for DAQ time slices.
8968 *
8969 * \param first time slice
8970 * \param second time slice
8971 * \result true if first time slice equal to second; else false
8972 */
8973 inline bool operator==(const JDAQTimeslice& first,
8974 const JDAQTimeslice& second)
8975 {
8976 return (first.getDAQTimesliceHeader() == second.getDAQTimesliceHeader() &&
8977 static_cast<const std::vector<JDAQSuperFrame>&>(first) == static_cast<const std::vector<JDAQSuperFrame>&>(second));
8978 }
8979
8980
8981 /**
8982 * Not-equal operator for DAQ time slices.
8983 *
8984 * \param first time slice
8985 * \param second time slice
8986 * \result true if first time slice not equal to second; else false
8987 */
8988 inline bool operator!=(const JDAQTimeslice& first,
8989 const JDAQTimeslice& second)
8990 {
8991 return !(first == second);
8992 }
8993
8994
8995 /**
8996 * Timeslice data structure for L0 data.
8997 */
8998 struct JDAQTimesliceL0 : public JDAQTimeslice { ClassDef(JDAQTimesliceL0,1); };
8999
9000
9001 /**
9002 * Timeslice data structure for L1 data.
9003 */
9004 struct JDAQTimesliceL1 : public JDAQTimeslice { ClassDef(JDAQTimesliceL1,1); };
9005
9006
9007 /**
9008 * Timeslice data structure for L2 data.
9009 */
9010 struct JDAQTimesliceL2 : public JDAQTimeslice { ClassDef(JDAQTimesliceL2,1); };
9011
9012
9013 /**
9014 * Timeslice data structure for SN data.
9015 */
9016 struct JDAQTimesliceSN : public JDAQTimeslice { ClassDef(JDAQTimesliceSN,1); };
9017
9018
9019 /**
9020 * Print DAQ Timeslice.
9021 *
9022 * \param out output stream
9023 * \param timeslice timeslice
9024 * \return output stream
9025 */
9026 inline std::ostream& operator<<(std::ostream& out, const JDAQTimeslice& timeslice)
9027 {
9028 return timeslice.print(out, getDAQLongprint());
9029 }
9030}
9031
9032#endif
9033#ifndef __JDAQTIMESLICEHEADER__
9034#define __JDAQTIMESLICEHEADER__
9035
9036#include "km3net-dataformat/online/JDAQRoot.hh"
9037#include "km3net-dataformat/online/JDAQHeader.hh"
9038
9039
9040/**
9041 * \author mdejong
9042 */
9043namespace KM3NETDAQ {
9044
9045 /**
9046 * JDAQ timeslice header.
9047 */
9048 class JDAQTimesliceHeader :
9049 public JDAQHeader
9050 {
9051 public:
9052 /**
9053 * Default constructor.
9054 */
9055 JDAQTimesliceHeader() :
9056 JDAQHeader()
9057 {}
9058
9059
9060 /**
9061 * Constructor.
9062 *
9063 * \param chronometer DAQ chronometer
9064 */
9065 JDAQTimesliceHeader(const JDAQChronometer& chronometer) :
9066 JDAQHeader(chronometer)
9067 {}
9068
9069
9070 /**
9071 * Get DAQ time slice header.
9072 *
9073 * \return DAQ time slice header
9074 */
9075 const JDAQTimesliceHeader& getDAQTimesliceHeader() const
9076 {
9077 return static_cast<const JDAQTimesliceHeader&>(*this);
9078 }
9079
9080
9081 ClassDef(JDAQTimesliceHeader,2);
9082 };
9083
9084
9085 /**
9086 * Equal operator for DAQ time slice headers.
9087 *
9088 * \param first time slice header
9089 * \param second time slice header
9090 * \result true if first timeslice header equal to second; else false
9091 */
9092 inline bool operator==(const JDAQTimesliceHeader& first,
9093 const JDAQTimesliceHeader& second)
9094 {
9095 return (first.getDAQHeader() == second.getDAQHeader());
9096 }
9097
9098
9099 /**
9100 * Not-equal operator for DAQ time slice headers.
9101 *
9102 * \param first time slice header
9103 * \param second time slice header
9104 * \result true if first time slice header not equal to second; else false
9105 */
9106 inline bool operator!=(const JDAQTimesliceHeader& first,
9107 const JDAQTimesliceHeader& second)
9108 {
9109 return !(first == second);
9110 }
9111}
9112
9113#endif
9114#ifndef __JDAQTRIGGERCOUNTER__
9115#define __JDAQTRIGGERCOUNTER__
9116
9117#include "km3net-dataformat/online/JDAQRoot.hh"
9118
9119
9120/**
9121 * \author mdejong
9122 */
9123
9124namespace KM3NETDAQ {
9125
9126
9127 /**
9128 * Type definition of trigger counter.
9129 */
9130 typedef unsigned long long int JTriggerCounter_t;
9131
9132
9133 /**
9134 * Auxiliary class to count triggers.
9135 */
9136 class JDAQTriggerCounter {
9137 private:
9138 /**
9139 * Constructor.
9140 *
9141 * \param counter counter value
9142 */
9143 JDAQTriggerCounter(const JTriggerCounter_t counter)
9144 {
9145 this->trigger_counter = counter;
9146 }
9147
9148
9149 public:
9150
9151 friend size_t getSizeof<JDAQTriggerCounter>();
9152 friend JReader& operator>>(JReader&, JDAQTriggerCounter&);
9153 friend JWriter& operator<<(JWriter&, const JDAQTriggerCounter&);
9154
9155 /**
9156 * Default constructor.
9157 *
9158 * This constructor increments the counter of the unique instance
9159 * of this class and stores the result in this object.
9160 */
9161 JDAQTriggerCounter()
9162 {
9163 trigger_counter = getInstance().next();
9164 }
9165
9166
9167 /**
9168 * Virtual destructor.
9169 */
9170 virtual ~JDAQTriggerCounter()
9171 {}
9172
9173
9174 /**
9175 * Get reference to unique instance of this class object.
9176 *
9177 * \return reference to this class object
9178 */
9179 static JDAQTriggerCounter& getInstance()
9180 {
9181 static JDAQTriggerCounter counter(0);
9182
9183 return counter;
9184 }
9185
9186
9187 /**
9188 * Get DAQ trigger counter.
9189 *
9190 * \return DAQ trigger counter
9191 */
9192 const JDAQTriggerCounter& getDAQTriggerCounter() const
9193 {
9194 return static_cast<const JDAQTriggerCounter&>(*this);
9195 }
9196
9197
9198 /**
9199 * Reset counter of unique instance of this class object.
9200 */
9201 static void reset()
9202 {
9203 getInstance().trigger_counter = 0;
9204 }
9205
9206
9207 /**
9208 * Get trigger counter.
9209 *
9210 * \return counter value
9211 */
9212 JTriggerCounter_t getCounter() const
9213 {
9214 return trigger_counter;
9215 }
9216
9217
9218 /**
9219 * Set trigger counter.
9220 *
9221 * \param counter counter value
9222 */
9223 void setCounter(const JTriggerCounter_t counter)
9224 {
9225 this->trigger_counter = counter;
9226 }
9227
9228
9229 /**
9230 * Increment trigger counter.
9231 *
9232 * \return counter value
9233 */
9234 JTriggerCounter_t next()
9235 {
9236 return trigger_counter++;
9237 }
9238
9239
9240 ClassDef(JDAQTriggerCounter,1);
9241
9242
9243 protected:
9244 JTriggerCounter_t trigger_counter;
9245 };
9246
9247
9248 /**
9249 * Equal operator for DAQ trigger counters.
9250 *
9251 * \param first trigger counter
9252 * \param second trigger counter
9253 * \result true if first trigger counter equal to second; else false
9254 */
9255 inline bool operator==(const JDAQTriggerCounter& first,
9256 const JDAQTriggerCounter& second)
9257 {
9258 return (first.getCounter() == second.getCounter());
9259 }
9260
9261
9262 /**
9263 * Not-equal operator for DAQ trigger counters.
9264 *
9265 * \param first trigger counter
9266 * \param second trigger counter
9267 * \result true if first trigger counter not equal to second; else false
9268 */
9269 inline bool operator!=(const JDAQTriggerCounter& first,
9270 const JDAQTriggerCounter& second)
9271 {
9272 return !(first == second);
9273 }
9274}
9275
9276#endif
9277#ifndef __JDAQTRIGGERMASK__
9278#define __JDAQTRIGGERMASK__
9279
9280#include <string>
9281#include <istream>
9282#include <ostream>
9283
9284#include "km3net-dataformat/online/JDAQRoot.hh"
9285
9286
9287/**
9288 * \author mdejong
9289 */
9290
9291namespace KM3NETDAQ {
9292
9293
9294 /**
9295 * Type definition of trigger mask.
9296 */
9297 typedef unsigned long long int JTriggerMask_t;
9298
9299
9300 /**
9301 * Number of trigger bits.
9302 */
9303 static const unsigned int NUMBER_OF_TRIGGER_BITS = sizeof(JTriggerMask_t) * 8;
9304
9305
9306 /**
9307 * Convert trigger bit to trigger mask.
9308 *
9309 * \param bit trigger bit
9310 * \return trigger mask
9311 */
9312 inline JTriggerMask_t getTriggerMask(const unsigned int bit)
9313 {
9314 if (bit < NUMBER_OF_TRIGGER_BITS)
9315 return JTriggerMask_t(1) << bit;
9316 else
9317 return 0;
9318 }
9319
9320
9321 /**
9322 * Auxiliary class for trigger mask.
9323 */
9324 class JDAQTriggerMask {
9325 public:
9326
9327 friend size_t getSizeof<JDAQTriggerMask>();
9328 friend JReader& operator>>(JReader&, JDAQTriggerMask&);
9329 friend JWriter& operator<<(JWriter&, const JDAQTriggerMask&);
9330
9331 /**
9332 * Default constructor.
9333 */
9334 JDAQTriggerMask() :
9335 trigger_mask(0)
9336 {}
9337
9338
9339 /**
9340 * Constructor.
9341 *
9342 * \param mask trigger mask
9343 */
9344 JDAQTriggerMask(const JTriggerMask_t mask) :
9345 trigger_mask(mask)
9346 {}
9347
9348
9349 /**
9350 * Constructor.
9351 *
9352 * \param buffer trigger bit pattern (i.e. sequence of '0' and '1').
9353 */
9354 JDAQTriggerMask(const std::string& buffer) :
9355 trigger_mask(valueOf(buffer).getTriggerMask())
9356 {}
9357
9358
9359 /**
9360 * Virtual destructor.
9361 */
9362 virtual ~JDAQTriggerMask()
9363 {}
9364
9365
9366 /**
9367 * Get DAQ trigger mask.
9368 *
9369 * \return DAQ trigger mask
9370 */
9371 const JDAQTriggerMask& getDAQTriggerMask() const
9372 {
9373 return static_cast<const JDAQTriggerMask&>(*this);
9374 }
9375
9376
9377 /**
9378 * Get trigger mask.
9379 *
9380 * \return trigger mask
9381 */
9382 JTriggerMask_t getTriggerMask() const
9383 {
9384 return trigger_mask;
9385 }
9386
9387
9388 /**
9389 * Set trigger mask.
9390 *
9391 * \param mask trigger mask
9392 */
9393 void setDAQTriggerMask(const JDAQTriggerMask& mask)
9394 {
9395 trigger_mask = mask.trigger_mask;
9396 }
9397
9398
9399 /**
9400 * Set trigger mask.
9401 *
9402 * \param mask trigger mask
9403 */
9404 void setTriggerMask(const JTriggerMask_t mask)
9405 {
9406 trigger_mask = mask;
9407 }
9408
9409
9410 /**
9411 * Add trigger bit pattern.
9412 *
9413 * \param mask trigger mask
9414 * \return trigger mask
9415 */
9416 JDAQTriggerMask& addTriggerMask(const JDAQTriggerMask& mask)
9417 {
9418 trigger_mask |= mask.trigger_mask;
9419
9420 return *this;
9421 }
9422
9423
9424 /**
9425 * Has trigger bit pattern.
9426 *
9427 * \param mask trigger mask
9428 * \return true if one of the bits is set; else false
9429 */
9430 inline bool hasTriggerMask(const JDAQTriggerMask& mask) const
9431 {
9432 return trigger_mask & mask.trigger_mask;
9433 }
9434
9435
9436 /**
9437 * Add trigger bit.
9438 *
9439 * \param bit trigger bit
9440 * \return trigger mask
9441 */
9442 inline JDAQTriggerMask& addTriggerBit(const unsigned int bit)
9443 {
9444 trigger_mask |= KM3NETDAQ::getTriggerMask(bit);
9445
9446 return *this;
9447 }
9448
9449
9450 /**
9451 * Check trigger bit.
9452 *
9453 * \param bit trigger bit
9454 * \return true if bit is set; else false
9455 */
9456 inline bool hasTriggerBit(const unsigned int bit) const
9457 {
9458 return trigger_mask & KM3NETDAQ::getTriggerMask(bit);
9459 }
9460
9461
9462 /**
9463 * Extract trigger mask.
9464 *
9465 * \param buffer trigger bit pattern (i.e. sequence of '0' and '1').
9466 * \return trigger mask
9467 */
9468 static JDAQTriggerMask valueOf(const std::string& buffer)
9469 {
9470 JDAQTriggerMask trigger_mask;
9471
9472 unsigned int bit = 0;
9473
9474 for (std::string::const_reverse_iterator i = buffer.rbegin(); i != buffer.rend() && bit != NUMBER_OF_TRIGGER_BITS; ++i, ++bit) {
9475 if (*i == '1') {
9476 trigger_mask.addTriggerBit(bit);
9477 }
9478 }
9479
9480 return trigger_mask;
9481 }
9482
9483
9484 /**
9485 * Convert trigger mask.
9486 *
9487 * \return trigger bit pattern (i.e. sequence of '0' and '1').
9488 */
9489 std::string toString() const
9490 {
9491 std::string buffer(NUMBER_OF_TRIGGER_BITS, '0');
9492
9493 unsigned int bit = 0;
9494
9495 for (std::string::reverse_iterator i = buffer.rbegin(); i != buffer.rend() && bit != NUMBER_OF_TRIGGER_BITS; ++i, ++bit) {
9496 if (hasTriggerBit(bit)) {
9497 *i = '1';
9498 }
9499 }
9500
9501 return buffer;
9502 }
9503
9504
9505 /**
9506 * Read JDAQTriggerMask from input stream.
9507 *
9508 * \param in input stream
9509 * \param mask JDAQTriggerMask
9510 * \return input stream
9511 */
9512 friend inline std::istream& operator>>(std::istream& in, JDAQTriggerMask& mask)
9513 {
9514 std::string buffer;
9515
9516 if (in >> buffer) {
9517 mask= JDAQTriggerMask::valueOf(buffer);
9518 }
9519
9520 return in;
9521 }
9522
9523
9524 /**
9525 * Write JDAQTriggerMask to output stream.
9526 *
9527 * \param out output stream
9528 * \param mask JDAQTriggerMask
9529 * \return output stream
9530 */
9531 friend inline std::ostream& operator<<(std::ostream& out, const JDAQTriggerMask& mask)
9532 {
9533 out << mask.toString();
9534
9535 return out;
9536 }
9537
9538
9539 ClassDef(JDAQTriggerMask,1);
9540
9541
9542 protected:
9543 JTriggerMask_t trigger_mask;
9544 };
9545
9546
9547 static const JDAQTriggerMask TRIGGER_MASK_ON = JDAQTriggerMask(~JTriggerMask_t(0)); //!< Trigger mask on;
9548 static const JDAQTriggerMask TRIGGER_MASK_OFF = JDAQTriggerMask( JTriggerMask_t(0)); //!< Trigger mask off;
9549
9550
9551 /**
9552 * Equal operator for DAQ trigger masks.
9553 *
9554 * \param first trigger mask
9555 * \param second trigger mask
9556 * \result true if first trigger mask equal to second; else false
9557 */
9558 inline bool operator==(const JDAQTriggerMask& first,
9559 const JDAQTriggerMask& second)
9560 {
9561 return (first.getTriggerMask() == second.getTriggerMask());
9562 }
9563
9564
9565 /**
9566 * Not-equal operator for DAQ trigger masks.
9567 *
9568 * \param first trigger mask
9569 * \param second trigger mask
9570 * \result true if first trigger mask not equal to second; else false
9571 */
9572 inline bool operator!=(const JDAQTriggerMask& first,
9573 const JDAQTriggerMask& second)
9574 {
9575 return !(first == second);
9576 }
9577}
9578
9579#endif
9580#ifndef __JDAQTRIGGEREDHIT__
9581#define __JDAQTRIGGEREDHIT__
9582
9583#include "km3net-dataformat/online/JDAQRoot.hh"
9584#include "km3net-dataformat/online/JDAQModuleIdentifier.hh"
9585#include "km3net-dataformat/online/JDAQHit.hh"
9586#include "km3net-dataformat/online/JDAQKeyHit.hh"
9587#include "km3net-dataformat/online/JDAQTriggerMask.hh"
9588
9589
9590/**
9591 * \author mdejong
9592 */
9593
9594namespace KM3NETDAQ {
9595
9596 /**
9597 * DAQ triggered hit
9598 */
9599 class JDAQTriggeredHit :
9600 public JDAQKeyHit,
9601 public JDAQTriggerMask
9602 {
9603 public:
9604
9605 friend size_t getSizeof<JDAQTriggeredHit>();
9606 friend JReader& operator>>(JReader&, JDAQTriggeredHit&);
9607 friend JWriter& operator<<(JWriter&, const JDAQTriggeredHit&);
9608
9609 /**
9610 * Default constructor.
9611 */
9612 JDAQTriggeredHit() :
9613 JDAQKeyHit (),
9614 JDAQTriggerMask()
9615 {}
9616
9617
9618 /**
9619 * Constructor.
9620 *
9621 * \param ID module identifier
9622 * \param hit PMT hit
9623 * \param mask trigger mask
9624 */
9625 JDAQTriggeredHit(const JDAQModuleIdentifier& ID,
9626 const JDAQHit& hit,
9627 const JDAQTriggerMask& mask) :
9628 JDAQKeyHit(ID,hit),
9629 JDAQTriggerMask(mask)
9630 {}
9631
9632
9633 /**
9634 * Virtual destructor.
9635 */
9636 virtual ~JDAQTriggeredHit()
9637 {}
9638
9639
9640 ClassDef(JDAQTriggeredHit,2);
9641 };
9642
9643
9644 /**
9645 * Equal operator for DAQ triggered hits.
9646 *
9647 * \param first triggered hit
9648 * \param second triggered hit
9649 * \result true if first triggered hit equal to second; else false
9650 */
9651 inline bool operator==(const JDAQTriggeredHit& first,
9652 const JDAQTriggeredHit& second)
9653 {
9654 return (static_cast<const JDAQKeyHit&> (first) == static_cast<const JDAQKeyHit&> (second) &&
9655 static_cast<const JDAQTriggerMask&>(first) == static_cast<const JDAQTriggerMask&>(second));
9656 }
9657
9658
9659 /**
9660 * Not-equal operator for DAQ triggered hits.
9661 *
9662 * \param first triggered hit
9663 * \param second triggered hit
9664 * \result true if first triggered hit not equal to second; else false
9665 */
9666 inline bool operator!=(const JDAQTriggeredHit& first,
9667 const JDAQTriggeredHit& second)
9668 {
9669 return !(first == second);
9670 }
9671}
9672
9673#endif
9674#ifndef __JDAQUTCEXTENDED__
9675#define __JDAQUTCEXTENDED__
9676
9677/**
9678 * \author rbruijn
9679 */
9680
9681#include <cstdint>
9682#include <istream>
9683#include <ostream>
9684#include <iomanip>
9685#include <limits>
9686
9687#include "km3net-dataformat/online/JDAQRoot.hh"
9688
9689
9690namespace KM3NETDAQ {
9691
9692 /**
9693 * Data structure for UTC time.
9694 */
9695 class JDAQUTCExtended
9696 {
9697 public:
9698
9699 friend size_t getSizeof<JDAQUTCExtended>();
9700 friend JReader& operator>>(JReader&, JDAQUTCExtended&);
9701 friend JWriter& operator<<(JWriter&, const JDAQUTCExtended&);
9702
9703
9704 /**
9705 * Default constructor.
9706 */
9707 JDAQUTCExtended() :
9708 UTC_seconds(0),
9709 UTC_16nanosecondcycles(0)
9710 {}
9711
9712
9713 /**
9714 * Constructor.
9715 *
9716 * \param seconds seconds [s]
9717 * \param cycles cycles [16 ns]
9718 */
9719 JDAQUTCExtended(const uint32_t seconds,
9720 const uint32_t cycles):
9721 UTC_seconds(seconds),
9722 UTC_16nanosecondcycles(cycles)
9723 {}
9724
9725
9726 /**
9727 * Constructor.
9728 *
9729 * \param nanoseconds time [ns]
9730 */
9731 JDAQUTCExtended(const double nanoseconds)
9732 {
9733 setTimeNanoSecond(nanoseconds);
9734 }
9735
9736
9737 /**
9738 * Virtual destructor.
9739 */
9740 virtual ~JDAQUTCExtended()
9741 {}
9742
9743
9744 /**
9745 * Get White Rabbit status.
9746 *
9747 * \return true if okay; else false
9748 */
9749 bool getWRStatus() const
9750 {
9751 return (UTC_seconds & ~getMask()) != 0;
9752 }
9753
9754
9755 /**
9756 * Get major time.
9757 *
9758 * \return time [s]
9759 */
9760 uint32_t getUTCseconds() const
9761 {
9762 return (UTC_seconds & getMask());
9763 }
9764
9765
9766 /**
9767 * Get minor time.
9768 *
9769 * \return time [16 ns]
9770 */
9771 uint32_t getUTC16nanosecondcycles() const
9772 {
9773 return UTC_16nanosecondcycles;
9774 }
9775
9776
9777 /**
9778 * Get time (limited to 16 ns cycles).
9779 *
9780 * \return time [ns]
9781 */
9782 double getTimeNanoSecond() const
9783 {
9784 return getUTCseconds() * 1.0e9 + getUTC16nanosecondcycles() * getTick();
9785 }
9786
9787
9788 /**
9789 * Set time.
9790 *
9791 * \param utc_ns time [ns]
9792 */
9793 void setTimeNanoSecond(const double utc_ns)
9794 {
9795 UTC_seconds = (uint32_t) ( utc_ns * 1.0e-9);
9796 UTC_16nanosecondcycles = (uint32_t) ((utc_ns - UTC_seconds*1.0e9) / getTick());
9797 }
9798
9799
9800 /**
9801 * Add time.
9802 *
9803 * \param t_ns time [ns]
9804 */
9805 void addTimeNanoSecond(const double t_ns)
9806 {
9807 const double x_ns = (double) getUTC16nanosecondcycles() * (double) getTick() + t_ns;
9808 const uint32_t t_s = (uint32_t) (x_ns * 1.0e-9);
9809
9810 UTC_seconds += t_s;
9811 UTC_16nanosecondcycles = (uint32_t) ((x_ns - t_s*1.0e9) / getTick());
9812 }
9813
9814
9815 /**
9816 * Get minimum possible value.
9817 *
9818 * \return minimum possible value
9819 */
9820 static JDAQUTCExtended min()
9821 {
9822 return JDAQUTCExtended(0,0);
9823 }
9824
9825
9826 /**
9827 * Get maximum possible value.
9828 *
9829 * \return maximum possible value
9830 */
9831 static JDAQUTCExtended max()
9832 {
9833 return JDAQUTCExtended(std::numeric_limits<uint32_t>::max(),
9834 std::numeric_limits<uint32_t>::max());
9835 }
9836
9837
9838 /**
9839 * Get mask for seconds data.
9840 *
9841 * \return mask
9842 */
9843 static uint32_t getMask()
9844 {
9845 return 0x7FFFFFFF;
9846 }
9847
9848
9849 /**
9850 * Get number of nano-seconds per tick.
9851 *
9852 * \return time [ns]
9853 */
9854 static double getTick()
9855 {
9856 return 16.0;
9857 }
9858
9859
9860 /**
9861 * Get arbitrary offset (e.g. for accuracy of time differences).
9862 *
9863 * \return UTC time
9864 */
9865 static const JDAQUTCExtended& getInstance()
9866 {
9867 static JDAQUTCExtended utc(1600000000, 0);
9868
9869 return utc;
9870 }
9871
9872
9873 /**
9874 * Read UTC time.
9875 *
9876 * \param in intput stream
9877 * \param utc UTC extended time
9878 * \return intput stream
9879 */
9880 friend inline std::istream& operator>>(std::istream& in, JDAQUTCExtended& utc)
9881 {
9882 in >> utc.UTC_seconds;
9883 in.get();
9884 in >> utc.UTC_16nanosecondcycles;
9885
9886 return in;
9887 }
9888
9889
9890 /**
9891 * Write UTC time.
9892 *
9893 * \param out output stream
9894 * \param utc UTC extended time
9895 * \return output stream
9896 */
9897 friend inline std::ostream& operator<<(std::ostream& out, const JDAQUTCExtended& utc)
9898 {
9899 using namespace std;
9900
9901 const char c = out.fill();
9902
9903 out << setw(10) << utc.getUTCseconds();
9904 out << ':';
9905 out << setw(10) << setfill('0') << utc.getUTC16nanosecondcycles() << setfill(c);
9906
9907 return out;
9908 }
9909
9910
9911 ClassDef(JDAQUTCExtended,1);
9912
9913
9914 protected:
9915 uint32_t UTC_seconds;
9916 uint32_t UTC_16nanosecondcycles;
9917 };
9918
9919
9920 /**
9921 * Less than operator for UTC times.
9922 *
9923 * \param first UTC time
9924 * \param second UTC time
9925 * \result true if first UTC time earlier than second UTC time; else false
9926 */
9927 inline bool operator<(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
9928 {
9929 if (first.getUTCseconds() == second.getUTCseconds())
9930 return first.getUTC16nanosecondcycles() < second.getUTC16nanosecondcycles();
9931 else
9932 return first.getUTCseconds() < second.getUTCseconds();
9933 }
9934
9935
9936 /**
9937 * Greater than operator for UTC times.
9938 *
9939 * \param first UTC time
9940 * \param second UTC time
9941 * \result true if first UTC time later than second UTC time; else false
9942 */
9943 inline bool operator>(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
9944 {
9945 return (second < first);
9946 }
9947
9948
9949 /**
9950 * Less than or equal operator for UTC times.
9951 *
9952 * \param first UTC time
9953 * \param second UTC time
9954 * \result true if first UTC time earlier than second UTC time; else false
9955 */
9956 inline bool operator<=(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
9957 {
9958 return !(second < first);
9959 }
9960
9961
9962 /**
9963 * Greater than or equal operator for UTC times.
9964 *
9965 * \param first UTC time
9966 * \param second UTC time
9967 * \result true if first UTC time earlier than second UTC time; else false
9968 */
9969 inline bool operator>=(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
9970 {
9971 return !(first < second);
9972 }
9973
9974
9975 /**
9976 * Equal operator for UTC times.
9977 *
9978 * \param first UTC time
9979 * \param second UTC time
9980 * \result true if first UTC time equal second UTC time; else false
9981 */
9982 inline bool operator==(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
9983 {
9984 return (first.getUTCseconds() == second.getUTCseconds() &&
9985 first.getUTC16nanosecondcycles() == second.getUTC16nanosecondcycles());
9986 }
9987
9988
9989 /**
9990 * Not equal operator for UTC times.
9991 *
9992 * \param first UTC time
9993 * \param second UTC time
9994 * \result true if first UTC time not equal second UTC time; else false
9995 */
9996 inline bool operator!=(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
9997 {
9998 return !(first == second);
9999 }
10000
10001
10002 /**
10003 * Get time difference between two UTC times.
10004 *
10005 * \param first UTC time
10006 * \param second UTC time
10007 * \result time difference [s]
10008 */
10009 inline double getTimeDifference(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
10010 {
10011 const double utc_s = ((double) second.getUTCseconds() - (double) first.getUTCseconds());
10012 const double utc_ns = ((double) second.getUTC16nanosecondcycles() - (double) first.getUTC16nanosecondcycles()) * JDAQUTCExtended::getTick();
10013
10014 return utc_s + utc_ns*1.0e-9;
10015 }
10016}
10017
10018#endif
10019#ifndef AAOBJECTINCLUDED
10020#define AAOBJECTINCLUDED
10021
10022#include "TObject.h"
10023
10024#include <iostream>
10025#include <iomanip>
10026#include <string>
10027#include <algorithm>
10028
10029#include "km3net-dataformat/offline/Exception.hh"
10030
10031
10032/*! \brief AAObject is a base class for I/O-classes that adds the possibility
10033 to add 'user' information which will also be stored in the ROOT file.
10034*/
10035
10036struct AAObject : public TObject
10037{
10038 std::vector<double> usr; ///< user data
10039 std::vector<std::string> usr_names; ///< user keys
10040
10041 /**
10042 * Get index in user data of the item with given key.
10043 *
10044 * \param key key
10045 * \return index (-1 if key does not exists)
10046 */
10047 int idx( const std::string& key ) const
10048 {
10049 auto i = std::find (usr_names.begin(), usr_names.end(), key );
10050 if (i == usr_names.end()) return -1;
10051 return i - usr_names.begin();
10052 }
10053
10054 /**
10055 * Check availability of user data of the item with given key.
10056 *
10057 * \param key key
10058 * \return true if available; else false
10059 */
10060 bool haveusr( const std::string& key ) const
10061 {
10062 return idx( key ) >= 0;
10063 }
10064
10065 /**
10066 * Get index in user data of the item with given key.\n
10067 * This method throws a run-time exception if no user data are available.
10068 *
10069 * \param key key
10070 * \return index (-1 if key does not exists)
10071 */
10072 int idxusr_checked( const std::string& key ) const
10073 {
10074 int r = idx( key );
10075 if (r < 0)
10076 {
10077 THROW(Exception, "No user data for key " << key << " in aanet object of type " << this -> ClassName());
10078 }
10079 return r;
10080 }
10081
10082
10083 /**
10084 * Get user data item with given key.\n
10085 * This method throws a run-time exception if no user data are available.
10086 *
10087 * \param key key
10088 * \return value
10089 */
10090 double getusr(const std::string& key) const
10091 {
10092 const int i = idx( key );
10093
10094 if ( i < 0 )
10095 {
10096 THROW(Exception, "No user data for key " << key << " in aanet object of type " << this -> ClassName());
10097 }
10098
10099 if ( unsigned(i) >= usr.size() )
10100 {
10101 THROW(Exception, "Warning: inconsistent user data " << i << " >= " << usr.size());
10102 }
10103
10104 return usr[i];
10105 }
10106
10107 /**
10108 * Set user data item with given key.\n
10109 *
10110 * \param key key
10111 * \param value value
10112 */
10113 void setusr(const std::string & key, double value )
10114 {
10115 int i = idx( key );
10116 if (i < 0)
10117 {
10118 if ( usr.size() < usr_names.size() )
10119 {
10120 // this should not happen, but let's just add empty data
10121 usr.resize( usr_names.size() );
10122 }
10123 else
10124 {
10125 // this is possible, add empty ("") names
10126 usr_names.resize( usr.size() );
10127 }
10128
10129 usr_names.push_back( key );
10130 usr.push_back( value );
10131 }
10132 else
10133 {
10134 usr[i] = value;
10135 }
10136 }
10137
10138 /**
10139 * Remove (first) user data item with given key.\n
10140 *
10141 * \param key key
10142 * \return true if data have been removed; else false
10143 */
10144 bool delusr( const std::string& key )
10145 {
10146 int i = idx( key );
10147 if ( i < 0 ) return false;
10148
10149 usr.erase ( usr.begin() + i );
10150 usr_names.erase( usr_names.begin() + i );
10151 return true;
10152 }
10153
10154 /**
10155 * Clear user data.
10156 */
10157 void clearusr()
10158 {
10159 usr.resize(0);
10160 usr_names.resize(0);
10161 }
10162
10163 /**
10164 * Print user data (i.e. list of all pairs of keys and values).
10165 *
10166 * \param out output stream
10167 */
10168 void printusr(std::ostream& out = std::cout )
10169 {
10170 unsigned n = std::max( usr.size(), usr_names.size() );
10171
10172 for (unsigned i = 0; i < n ; i++)
10173 {
10174 std::string name = "(unnamed)";
10175 if ( i < usr_names.size() && usr_names[i] != "" ) name = usr_names[i];
10176 out << i << " \t " << name << " : \t ";
10177 if ( i < usr.size() ) out << usr[i] << std::endl;
10178 else out << "(none)" << std::endl;
10179 }
10180 }
10181
10182 /**
10183 * Default constructor.
10184 */
10185 AAObject() : any(NULL) {}
10186 ~AAObject() {}
10187
10188
10189 TObject* any; ///< Pointer to "any" user data.
10190
10191 ClassDef(AAObject, 6)
10192};
10193
10194#endif
10195#ifndef EVT_HH_INCLUDED
10196#define EVT_HH_INCLUDED
10197
10198#include "km3net-dataformat/offline/AAObject.hh"
10199#include "km3net-dataformat/offline/Hit.hh"
10200#include "km3net-dataformat/offline/Trk.hh"
10201#include "km3net-dataformat/offline/Hit.hh"
10202#include "km3net-dataformat/offline/Exception.hh"
10203
10204#include "TTimeStamp.h"
10205
10206#include <uuid/uuid.h>
10207#include <vector>
10208
10209/**
10210 * The Evt class respresent a Monte Carlo (MC) event as well as an offline event.\n
10211 * Some data from the online (DAQ) event are copied.
10212 */
10213
10214struct Evt: public AAObject
10215{
10216 int id; ///< offline event identifier
10217 int det_id; ///< detector identifier from DAQ
10218 int mc_id; ///< identifier of the MC event (as found in ascii or antcc file).
10219
10220 int run_id; ///< DAQ run identifier
10221 int mc_run_id; ///< MC run identifier
10222
10223 int frame_index; ///< from the raw data
10224 ULong64_t trigger_mask; ///< trigger mask from raw data (i.e. the trigger bits)
10225 ULong64_t trigger_counter; ///< trigger counter
10226 unsigned int overlays; ///< number of overlaying triggered events
10227 TTimeStamp t; ///< UTC time of the timeslice, or the event_time for MC. (default: 01 Jan 1970 00:00:00)
10228
10229 uuid_t header_uuid; ///< UUID of header containing the event-weight information
10230
10231 //hits and tracks
10232 std::vector<Hit> hits; ///< list of hits
10233 std::vector<Trk> trks; ///< list of reconstructed tracks (can be several because of prefits,showers, etc).
10234
10235 //Monte carlo
10236 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)
10237 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)
10238 std::vector<double> w3list; ///< MC: atmospheric flux information
10239
10240 TTimeStamp mc_event_time; ///< MC: true generation time (UTC) of the event, (default: 01 Jan 1970 00:00:00)
10241 double mc_t; ///< MC: time where the mc-event was put in the timeslice, since start of run (offset+frameidx*timeslice_duration)
10242 std::vector<Hit> mc_hits; ///< MC: list of MC truth hits
10243 std::vector<Trk> mc_trks; ///< MC: list of MC truth tracks
10244
10245 // --- place to store user info ---
10246 TString comment; ///< user can use this as he/she likes
10247 int index; ///< user can use this as he/she likes
10248 int flags; ///< user can use this as he/she likes
10249
10250
10251 /**
10252 * Default constructor.
10253 */
10254 Evt() :
10255 id(0), det_id(0), mc_id(0), run_id(0), mc_run_id(0), frame_index(0),
10256 trigger_mask(0), trigger_counter(0),
10257 overlays(0), t(0), mc_event_time(0), mc_t(0), index(0), flags(0)
10258 {
10259 uuid_clear(this->header_uuid);
10260 }
10261
10262
10263 /**
10264 * Print event.
10265 *
10266 * \param out output stream
10267 */
10268 void print(std::ostream& out = std::cout) const
10269 {
10270 out << "Evt: id=" << id <<
10271 " run_id=" << run_id <<
10272 " #hits=" << hits.size() <<
10273 " #mc_hits=" << mc_hits.size() <<
10274 " #trks=" << trks.size() <<
10275 " #mc_trks=" << mc_trks.size() << std::endl;
10276 }
10277
10278
10279 /**
10280 * Reset event.
10281 */
10282 void clear()
10283 {
10284 *this = Evt();
10285 }
10286
10287
10288 /**
10289 * Clear the hit vectors and all the references to hits in the tracks
10290 */
10291 void clear_hits()
10292 {
10293 hits.clear();
10294 mc_hits.clear();
10295 for (auto& t : trks ) t.hit_ids.clear();
10296 for (auto& t : mc_trks ) t.hit_ids.clear();
10297 }
10298
10299
10300 /**
10301 * Return a vector with const pointers to the tracks that are 'primary'.\n
10302 * Here, primary means the tracks have no parents.
10303 *
10304 * This method only works if MC parent-child relations are availabe.
10305 *
10306 * \return list of pointers to primary tracks
10307 */
10308 std::vector<const Trk*> primary_trks() const
10309 {
10310 std::vector<const Trk*> r;
10311 for (auto& t : mc_trks )
10312 {
10313 if ( t.is_primary() ) r.push_back(&t);
10314 }
10315 return r;
10316 }
10317
10318
10319 /**
10320 * Return a vector of pointers to tracks that are 'primary'.\n
10321 * Here, primary means the tracks have no parents.
10322 *
10323 * \return list of pointers to primary tracks
10324 */
10325 std::vector<Trk*> primary_trks()
10326 {
10327 std::vector<Trk*> r;
10328 for (auto& t : mc_trks )
10329 {
10330 if ( t.is_primary() ) r.push_back(&t);
10331 }
10332 return r;
10333 }
10334
10335
10336 /**
10337 * Get a const pointer to the (first) neutrino from the MC track list.
10338 *
10339 * \return pointer to neutrino (nullptr if no neutrino is in the list)
10340 */
10341 const Trk* neutrino() const
10342 {
10343 for (auto& t : mc_trks )
10344 {
10345 if ( t.is_neutrino() ) return &t;
10346 }
10347 return nullptr;
10348 }
10349
10350 /**
10351 * Get a pointer to the (first) neutrino from the MC track list.
10352 *
10353 * \return const pointer to neutrino (nullptr if no neutrino is in the list)
10354 */
10355
10356 Trk* neutrino()
10357 {
10358 // see Effective C++, Scott Meyers, ISBN-13: 9780321334879.
10359 return const_cast<Trk *>(static_cast<const Evt &>(*this).neutrino() );
10360 }
10361
10362
10363 /**
10364 * Get a const pointer to primary neutrino from the MC track list.
10365 *
10366 * Only works if MC parent-child relations are availabe.
10367 *
10368 * \return const pointer to primary neutrino (may be nullptr)
10369 */
10370 const Trk* primary_neutrino() const
10371 {
10372 for ( auto& t : mc_trks )
10373 {
10374 if ( t.is_neutrino() and t.is_primary() ) return &t;
10375 }
10376 return nullptr;
10377 }
10378
10379 /**
10380 * Get a pointer to primary neutrino from the MC track list.
10381 *
10382 * Only works if MC parent-child relations are availabe.
10383 *
10384 * \return pointer to primary neutrino
10385 */
10386 Trk* primary_neutrino()
10387 {
10388 return const_cast<Trk *>(static_cast<const Evt &>(*this).primary_neutrino() );
10389 }
10390
10391
10392 /**
10393 * Get a const pointer to the first leading lepton from the MC track list.
10394 * Here, leading means the lepton that has a neutrino as mother.
10395 *
10396 * Only works if MC parent-child relations are availabe.
10397 *
10398 * \return pointer to leadig lepton (may be nullptr in case not found)
10399 */
10400 const Trk* leading_lepton() const
10401 {
10402 const Trk* nu = primary_neutrino();
10403 if (!nu) return nullptr;
10404
10405 for (auto& t : mc_trks )
10406 {
10407 if ( t.is_lepton() &&
10408 t.mother_id == nu->id &&
10409 !t.is_orphan() ) return &t;
10410 }
10411 return nullptr;
10412 }
10413
10414 /**
10415 * Get a pointer to leading lepton from the MC track list.
10416 * Here, leading means the lepton that has a neutrino as mother.
10417 *
10418 * Only works if MC parent-child relations are availabe.
10419 *
10420 * \return pointer to leadig lepton (may be nullptr in case not found)
10421 */
10422 Trk* leading_lepton()
10423 {
10424 return const_cast<Trk *>(static_cast<const Evt &>(*this).leading_lepton() );
10425 }
10426
10427 /**
10428 * Get a const pointer to the (first) parent of the track 'child'.\n
10429 * This method return nullptr if no parent is found.
10430 *
10431 * \param child child particle
10432 * \return pointer to parent
10433 */
10434 const Trk * get_parent_of( const Trk & child ) const
10435 {
10436 for (auto& t : mc_trks )
10437 {
10438 if (child.mother_id == t.id ) return &t;
10439 }
10440 return nullptr;
10441 }
10442
10443
10444 /**
10445 * Get a pointer ot the (first) parent of the track 'child'.\n
10446 * This method return nullptr if no parent is found.
10447 *
10448 * \param child child particle
10449 * \return pointer to parent
10450 */
10451
10452 Trk* get_parent_of( const Trk & child )
10453 {
10454 return const_cast<Trk *>(static_cast<const Evt &>(*this).get_parent_of(child) );
10455 }
10456
10457
10458 /**
10459 * Action method at file open.
10460 *
10461 * \param version version
10462 */
10463 static void actionAtFileOpen(int version)
10464 {
10465 ROOT_IO_VERSION = version;
10466 }
10467
10468 static int ROOT_IO_VERSION; //!< Streamer version as obtained from ROOT file.
10469
10470 ClassDef(Evt, 16)
10471};
10472
10473#endif
10474#ifndef EXCEPTION_HH_INCLUDED
10475#define EXCEPTION_HH_INCLUDED
10476
10477#include <exception>
10478#include <string>
10479#include <ostream>
10480#include <sstream>
10481
10482
10483/**
10484 * General exception
10485 */
10486class Exception : public std::exception {
10487public:
10488 /**
10489 * Constructor.
10490 *
10491 * \param error error message
10492 */
10493 Exception(const std::string& error) :
10494 std::exception(),
10495 buffer(error)
10496 {}
10497
10498
10499 /**
10500 * Destructor.
10501 */
10502 ~Exception() throw()
10503 {}
10504
10505
10506 /**
10507 * Get error message.
10508 *
10509 * \return error message
10510 */
10511 virtual const char* what() const throw()
10512 {
10513 return buffer.c_str();
10514 }
10515
10516
10517 /**
10518 * Print error message of JException.
10519 *
10520 * \param out output stream
10521 * \param exception exception
10522 */
10523 friend inline std::ostream& operator<<(std::ostream& out, const Exception& exception)
10524 {
10525 return out << exception.what();
10526 }
10527
10528
10529 /**
10530 * Get output stream for conversion of exception.
10531 *
10532 * Note that the ostream is emptied before use.
10533 *
10534 * \return ostream
10535 */
10536 static inline std::ostream& getOstream()
10537 {
10538 static std::ostringstream buffer;
10539
10540 buffer.str("");
10541
10542 return buffer;
10543 }
10544
10545private:
10546 const std::string buffer;
10547};
10548
10549
10550/**
10551 * Marco for throwing exception with std::ostream compatible message.
10552 *
10553 * \param Exception_t exception
10554 * \param A message
10555 */
10556#ifndef THROW
10557#define THROW(Exception_t, A) do { throw Exception_t(static_cast<std::ostringstream&>(Exception::getOstream() << __FILE__ << ':' << __LINE__ << std::endl << A).str()); } while(0)
10558#endif
10559
10560#endif
10561#ifndef HEAD_HH_INCLUDED
10562#define HEAD_HH_INCLUDED
10563
10564#include "km3net-dataformat/offline/Vec.hh"
10565#include "km3net-dataformat/offline/Exception.hh"
10566
10567#include "TObject.h"
10568
10569#include <string>
10570#include <sstream>
10571#include <iostream>
10572#include <map>
10573#include <algorithm>
10574#include <vector>
10575
10576
10577/**
10578 * Trim a string in place
10579 *
10580 * \param s input string
10581 */
10582static inline void trimstring(std::string &s)
10583{
10584 // from the left
10585 s.erase( s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
10586 return !std::isspace(ch);
10587 }));
10588
10589 // from the right
10590 s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
10591 return !std::isspace(ch);
10592 }).base(), s.end());
10593}
10594
10595/**
10596 * Split string at delimiter. Trailing and leading whitespace is removed from each token.
10597 * Empty tokens are not put in the output list.
10598 *
10599 * \param str input string
10600 * \param delim token delimiter
10601 * \return list of tokens
10602 */
10603inline std::vector<std::string> splitstring(const std::string& str, char delim = ' ')
10604{
10605 using namespace std;
10606
10607 vector<string> r;
10608
10609 stringstream ss(str);
10610 string token;
10611 while (getline(ss, token, delim))
10612 {
10613 trimstring(token);
10614 if (token != "") r.push_back(token);
10615 }
10616
10617 return r;
10618}
10619
10620
10621/**
10622 * The Head class reflects the header of Monte-Carlo event files, which consists of keys (also referred to as "tags") and values.
10623 */
10624struct Head : public TObject, std::map<std::string, std::string>
10625{
10626 struct tags {
10627 static constexpr const char* const UUID = "UUID";
10628 };
10629
10630
10631 /**
10632 * Check availability of data with the given key.
10633 *
10634 * \param key key
10635 * \return true if data are available; else false
10636 */
10637 bool have_line (std::string key ) const
10638 {
10639 return count( key ) != 0;
10640 }
10641
10642 /**
10643 * Get data with the given key.\n
10644 * This method throws a run-time exception if no data are available.
10645 *
10646 * \param key key
10647 * \return data
10648 */
10649 const std::string& get_line( std::string key ) const
10650 {
10651 return this->at(key);
10652 }
10653
10654 /**
10655 * Get data with the given key.\n
10656 * This method throws a run-time exception if no data are available.
10657 *
10658 * \param key key
10659 * \return data
10660 */
10661 std::string& get_line( std::string key )
10662 {
10663 return this->at(key);
10664 }
10665
10666
10667 /**
10668 * In case of duplicate keys, they are internally stored in the map
10669 * with a suffix "_n". This function returns all the keys that start
10670 * with 'key' and end in "_n", with n an integer
10671 *
10672 * \param tag tag (without suffix)
10673 */
10674
10675 std::vector< std::string> matching_keys( const std::string& tag ) const
10676 {
10677 std::vector< std::string> r;
10678
10679 auto match = [&] (const std::string & key) {
10680
10681 if (key == tag) return true;
10682
10683 if ( key.find( tag ) != 0 ) return false;
10684
10685 // what is left should be of the form _d(ddd)
10686 std::string left = key.substr( tag.length(), key.length() );
10687 if (left.length() < 2 || left[0] != '_' ) return false ;
10688 for ( unsigned i = 1; i < left.length(); i++ )
10689 {
10690 if (!std::isdigit( left[i] )) return false ;
10691 }
10692 return true;
10693 };
10694
10695 for ( auto& p : *this )
10696 {
10697 if ( match( p.first ) ) r.push_back( p.first );
10698 }
10699
10700 return r;
10701 }
10702
10703
10704
10705
10706 /**
10707 * Get all data compatible with the given key. This means all data
10708 * that is internally stored with "key_n", with n an integer \n
10709 * This method throws a run-time exception if no data are available.
10710 *
10711 * \param tag tag (without suffix)
10712 * \return data
10713 */
10714 std::vector< std::string > get_lines( const std::string& tag ) const
10715 {
10716 std::vector< std::string > r;
10717
10718 for ( auto& key : matching_keys( tag ) ) {
10719 r.push_back( get_line( key ) );
10720 }
10721
10722 return r;
10723 }
10724
10725
10726 /**
10727 * Set data with the given tag. The function will return the actual key that
10728 * is used internally to store the result, which is equal to the tag with an
10729 * optional "_n" added to ensure uniqueness.
10730 *
10731 * \param tag tag
10732 * \param line data
10733 * \param ensure_unique add '_n' (with n an integer) to the tag if it would overwrite an existing key.
10734 */
10735
10736 std::string set_line( std::string tag, std::string line , bool ensure_unique = true )
10737 {
10738 std::string k = tag;
10739
10740 if (ensure_unique)
10741 for (int i = 1; find(k) != end() ; i++)
10742 {
10743 k = tag + "_" + std::to_string(i);
10744 }
10745
10746 std::map<std::string, std::string>::operator[]( k ) = line;
10747 return k;
10748 }
10749
10750 /**
10751 * Get data with the given key at given index.\n
10752 * This method throws a run-time exception if no data are available.
10753 *
10754 * \param key key
10755 * \param idx index
10756 * \return data
10757 */
10758 std::string get_field( std::string key, int idx ) const
10759 {
10760 using namespace std;
10761
10762 vector<string> v = splitstring( get_line(key) );
10763
10764 if ( idx < 0 || idx >= int ( v.size() ) )
10765 {
10766 THROW(Exception, "Cannot find word number " << idx << " in line " << get_line(key) << " for key: " << key);
10767 }
10768 return v[idx];
10769 }
10770
10771 /**
10772 * Get index of data with the given key at given field.\n
10773 *
10774 * Note that this method uses the dictionary define in method Head::_hdr_dict.
10775 *
10776 * \param key key
10777 * \param field field
10778 * \return index (-1 if not present)
10779 */
10780 int get_index_of_field(std::string key, std::string field) const
10781 {
10782 auto& d = _hdr_dict();
10783 if ( d.count(key) == 0 ) return -1;
10784 auto v = d.at(key);
10785 auto i = std::find (v.begin(), v.end(), field );
10786 if (i == v.end()) return -1;
10787 return i - v.begin();
10788 }
10789
10790 /**
10791 * Get data with the given key at given field.\n
10792 * This method throws a run-time exception if no field is available.
10793 *
10794 * Note that this method uses the dictionary define in method Head::_hdr_dict.
10795 *
10796 * \param key key
10797 * \param field field
10798 * \return data
10799 */
10800 std::string get_field( std::string key, std::string field ) const
10801 {
10802 int idx = get_index_of_field(key, field);
10803
10804 if ( idx == -1 )
10805 {
10806 THROW(Exception, "Failed to find" << key << " " << field);
10807 }
10808
10809 return get_field( key, idx );
10810 }
10811
10812
10813 /**
10814 * Set data with the given key at given field.\n
10815 * This method throws a run-time exception if no field available.
10816 *
10817 * Note that this method uses the dictionary define in method Head::_hdr_dict.
10818 *
10819 * \param key key
10820 * \param field field
10821 * \param value vakue
10822 */
10823 void set_field( std::string key, std::string field, std::string value )
10824 {
10825 using namespace std;
10826
10827 if ( field == "" ) get_line( key ) = value;
10828
10829 int idx = get_index_of_field( key, field );
10830
10831 if ( idx < 0 )
10832 {
10833 THROW(Exception, "GFailed to find field in header line: " << key << " " << field);
10834 }
10835
10836 vector<string> vals = splitstring( get_line( key ) );
10837
10838 // if the fields before do not exist, add padding
10839 while ( int( vals.size() ) <= idx ) vals.push_back("0");
10840
10841 vals[idx] = value;
10842 ostringstream ss;
10843
10844 for (unsigned i = 0; i < vals.size() ; i++ )
10845 {
10846 ss << vals[i];
10847 if ( i != vals.size() - 1) ss << " ";
10848 }
10849 set_line( key, ss.str() );
10850
10851 }
10852
10853 /**
10854 * Print header.
10855 *
10856 * \param out output stream
10857 */
10858 void print ( std::ostream& out = std::cout ) const
10859 {
10860 if (count("start_run")) out << "start_run: " << at("start_run") << std::endl;
10861
10862 for ( auto& p : *this )
10863 {
10864 if ( p.first == "start_run" || p.first == "end_event" ) continue;
10865 out << p.first << ": " << p.second << std::endl ;
10866 }
10867 out << "end_event:" << std::endl;
10868 }
10869
10870 /**
10871 * Get internal description of the known lines in header.
10872 *
10873 * \return internal dictionary
10874 */
10875 static const std::map<std::string, std::vector<std::string> >& _hdr_dict()
10876 {
10877 using namespace std;
10878
10879 // map with, for each tag (key), a vector of field-names
10880
10881 static map<string, vector<string> > r;
10882 if ( r.size() > 0 ) return r;
10883
10884 string desc =
10885 "DAQ:livetime\n"
10886 "cut_primary cut_seamuon cut_in cut_nu:Emin Emax cosTmin cosTmax\n"
10887 "generator physics simul:program version date time\n"
10888 "seed:program level iseed\n"
10889 "PM1_type_area:type area TTS\n"
10890 "PDF:i1 i2\n"
10891 "model:interaction muon scattering numberOfEnergyBins\n"
10892 "can:zmin zmax r\n"
10893 "genvol:zmin zmax r volume numberOfEvents\n"
10894 "merge:time gain\n"
10895 "coord_origin:x y z\n"
10896 "translate:x y z\n"
10897 "genhencut:gDir Emin\n"
10898 "k40:rate time\n" // note lower-case k
10899 "K40:livetime\n" // note capital K
10900 "norma:primaryFlux numberOfPrimaries\n"
10901 "livetime:numberOfSeconds errorOfSeconds\n"
10902 "flux:type key file_1 file_2\n"
10903 "spectrum:alpha\n"
10904 "fixedcan:xcenter ycenter zmin zmax radius\n"
10905 "start_run:run_id";
10906
10907 for ( auto line : splitstring(desc, '\n') )
10908 {
10909 auto v = splitstring( line, ':');
10910
10911 vector< string > fields = splitstring( v[1] );
10912 for ( auto key : splitstring( v[0] ) )
10913 {
10914 r[key] = fields;
10915 }
10916 }
10917 return r;
10918 }
10919
10920
10921 /**
10922 * Get the number of generated events needed for computing event rates.
10923 *
10924 * \return number of events
10925 */
10926 double ngen() const
10927 {
10928 return stod ( get_field("genvol", "numberOfEvents") );
10929 }
10930
10931 /**
10932 * Get the the live time provided by the DAQ sytstem (=number of processed timeslices * frametime).
10933 *
10934 * \return live time [s]
10935 */
10936 double daq_livetime() const
10937 {
10938 return stod ( get_field("DAQ", "livetime") );
10939 }
10940
10941
10942 /**
10943 * Get the Monte Carlo live time
10944 *
10945 * \return live time [s]
10946 */
10947 double mc_livetime() const
10948 {
10949 return stod ( get_field("livetime", "numberOfSeconds") );
10950 }
10951
10952 /**
10953 * Get coordinate origin.
10954 *
10955 * \return position
10956 */
10957 Vec coord_origin() const
10958 {
10959 return Vec( stod( get_field("coord_origin", "x") ),
10960 stod( get_field("coord_origin", "y") ),
10961 stod( get_field("coord_origin", "z") ));
10962 }
10963
10964 /**
10965 * Get coordinate translation.
10966 *
10967 * \return translation
10968 */
10969 Vec translate() const
10970 {
10971 return Vec( stod( get_field("translate", "x") ),
10972 stod( get_field("translate", "y") ),
10973 stod( get_field("translate", "z") ));
10974 }
10975
10976 virtual ~Head() {}
10977
10978 /**
10979 * Action method at file open.
10980 *
10981 * \param version version
10982 */
10983 static void actionAtFileOpen(int version)
10984 {
10985 ROOT_IO_VERSION = version;
10986 }
10987
10988 static int ROOT_IO_VERSION; //!< Streamer version as obtained from ROOT file.
10989
10990 ClassDef(Head, 2 );
10991};
10992
10993
10994/**
10995 * Print header.
10996 *
10997 * \param out output stream
10998 * \param h header
10999 * \return output stream
11000 */
11001inline std::ostream& operator<<(std::ostream& out, const Head& h)
11002{
11003 h.print(out);
11004 return out;
11005}
11006
11007
11008#endif
11009#ifndef HIT_HH_INCLUDED
11010#define HIT_HH_INCLUDED
11011
11012#include "TObject.h"
11013#include "TString.h"
11014#include "km3net-dataformat/offline/Vec.hh"
11015
11016struct Hit :
11017 public TObject
11018{
11019 int id;
11020
11021 // straight from the data
11022 int dom_id; ///< module identifier from the data (unique in the detector).
11023 unsigned int channel_id; ///< PMT channel id {0,1, .., 30} local to moduke
11024 unsigned int tdc; ///< hit tdc (=time in ns)
11025 unsigned int tot; ///< tot value as stored in raw data (int for pyroot)
11026 ULong64_t trig; ///< non-zero if the hit is a trigger hit.
11027
11028 int pmt_id; ///< global PMT identifier as found in evt files
11029
11030 // values after calibration
11031 double t; ///< hit time (from tdc+calibration or MC truth)
11032 double a; ///< hit amplitude (in p.e.)
11033 Vec pos; ///< hit position
11034 Vec dir; ///< hit direction; i.e. direction of the PMT
11035
11036 int type; ///< particle type or parametrisation used for hit (mc only)
11037 int origin; ///< track id of the track that created this hit (mc only)
11038
11039 unsigned pattern_flags; ///< some number that you can use to flag the hit
11040
11041 /**
11042 * Default constructor.
11043 */
11044 Hit(): id(0), dom_id(0), channel_id(0), tdc(0), tot(0), trig(0), pmt_id(0),
11045 t(0), a(0), type(0), origin(0), pattern_flags(0) {}
11046 //virtual ~Hit() {}
11047
11048
11049 /**
11050 * Read hit (useful in python).
11051 *
11052 * \param h hit
11053 */
11054 void read(const Hit& h) { *this = h;}
11055
11056 /**
11057 * Write hit (useful in python).
11058 *
11059 * \param h hit
11060 */
11061 void write(Hit& h) const { h = *this;}
11062
11063 /**
11064 * Print hit.
11065 *
11066 * \param out output stream
11067 */
11068 void print( std::ostream& out = std::cout ) const
11069 {
11070 out << "Hit: id=" << id << " dom=" << dom_id << " channel=" << channel_id;
11071 out << " pmt=" << pmt_id << " t=" << t << " tot=" << tot;
11072 out << " pos="; pos.print(out);
11073 out << " dir="; dir.print(out);
11074 }
11075
11076 ClassDefNV(Hit, 106) // reserve <100 for antcc class of the same name
11077};
11078
11079#endif
11080#ifndef MULTIHEAD_HH_INCLUDED
11081#define MULTIHEAD_HH_INCLUDED
11082
11083#include <vector>
11084#include <uuid/uuid.h>
11085
11086#include "km3net-dataformat/offline/Evt.hh"
11087#include "km3net-dataformat/offline/Head.hh"
11088
11089#include "TObject.h"
11090
11091
11092/**
11093 * \author bjung
11094 */
11095
11096struct MultiHead :
11097 public std::vector<Head>,
11098 public TObject
11099{
11100 /**
11101 * Default constructor.
11102 */
11103 MultiHead() :
11104 std::vector<Head>(),
11105 TObject()
11106 {}
11107
11108
11109 /**
11110 * Virtual destructor.
11111 */
11112 virtual ~MultiHead()
11113 {}
11114
11115
11116 /**
11117 * Find header with given UUID.\n
11118 * Note: The parameter useCache can be toggled on for faster lookup.\n
11119 * This should not be used if your `MultiHead` object is modified between look-ups.
11120 *
11121 *
11122 * \param uuid header UUID
11123 * \param useCache use caching for faster look-up
11124 * \return header with given UUID
11125 */
11126 const_iterator find(const uuid_t& uuid,
11127 const bool useCache = false) const
11128 {
11129 using namespace std;
11130
11131 static struct Cache
11132 {
11133 Cache() { uuid_clear(this->uuid); }
11134
11135 const_iterator it;
11136 uuid_t uuid;
11137 } cache;
11138
11139 if (!useCache) {
11140
11141 for (cache.it = this->cbegin(); cache.it != this->cend(); ++cache.it) {
11142
11143 const Head& head = *cache.it;
11144 string uuid_str = head.at(Head::tags::UUID);
11145
11146 uuid_str.erase(remove_if(uuid_str.begin(), uuid_str.end(), ::isspace), uuid_str.end());
11147
11148 uuid_parse(uuid_str.c_str(), cache.uuid);
11149
11150 if (uuid_compare(uuid, cache.uuid) == 0) {
11151 return cache.it;
11152 }
11153 }
11154
11155 return this->end();
11156
11157 } else {
11158
11159 if (uuid_compare(uuid, cache.uuid) == 0) {
11160 return cache.it;
11161 } else {
11162 return find(uuid, false);
11163 }
11164 }
11165 }
11166
11167
11168 /**
11169 * Find the header corresponding to the given event.
11170 * Note: The parameter useCache can be toggled on for faster lookup.\n
11171 * This should not be used if your `MultiHead` object is modified between look-ups.
11172 *
11173 * \param event event
11174 * \param useCache use caching for faster look-up
11175 * \return header corresponding to the given event
11176 */
11177 const_iterator find(const Evt& event,
11178 const bool useCache = false) const
11179 {
11180 return find(event.header_uuid, useCache);
11181 }
11182
11183
11184 /**
11185 * Insert the given header.
11186 *
11187 * \param header header
11188 * \return true if insertion was successful; else false
11189 */
11190 bool insert(const Head& header)
11191 {
11192 using namespace std;
11193
11194 string uuid_str = header.at(Head::tags::UUID);
11195 uuid_str.erase(remove_if(uuid_str.begin(), uuid_str.end(), ::isspace), uuid_str.end());
11196
11197 uuid_t uuid;
11198 uuid_parse(uuid_str.c_str(), uuid);
11199
11200 if (uuid_is_null(uuid) == 0 && find(uuid) == this->cend()) {
11201
11202 this->push_back(header);
11203
11204 return true;
11205 }
11206
11207 return false;
11208 }
11209
11210
11211 /**
11212 * Join given `MultiHead` object with this `MultiHead` object.
11213 *
11214 * \param multiHead `MultiHead` object
11215 * \return number of inserted headers
11216 */
11217 size_t join(const MultiHead& multiHead)
11218 {
11219 using namespace std;
11220
11221 size_t n = 0;
11222
11223 for (const_iterator i = multiHead.cbegin(); i != multiHead.cend(); ++i) {
11224 n += (size_t) this->insert(*i);
11225 }
11226
11227 return n;
11228 }
11229
11230
11231 /**
11232 * Action method at file open.
11233 *
11234 * \param version version
11235 */
11236 static void actionAtFileOpen(int version)
11237 {
11238 ROOT_IO_VERSION = version;
11239 }
11240
11241
11242 static int ROOT_IO_VERSION; //!< Streamer version as obtained from ROOT file.
11243
11244 ClassDef(MultiHead, 1);
11245};
11246
11247#endif
11248#ifndef TRK_HH_INCLUDED
11249#define TRK_HH_INCLUDED
11250
11251#include <vector>
11252#include "TDatabasePDG.h"
11253#include "TPDGCode.h"
11254#include "km3net-dataformat/offline/AAObject.hh"
11255#include "km3net-dataformat/offline/Vec.hh"
11256#include "km3net-dataformat/definitions/trkmembers.hh"
11257
11258/**
11259 * The Trk class represents a Monte Carlo (MC) particle as well as a reconstructed track/shower.
11260 */
11261struct Trk: public AAObject
11262{
11263 int id; ///< track identifier
11264 Vec pos; ///< postion [m] of the track at time t
11265 Vec dir; ///< track direction
11266 double t; ///< track time [ns] (when the particle is at pos )
11267 double E; ///< Energy [GeV] (either MC truth or reconstructed)
11268
11269 double len; ///< length, if applicable [m]
11270 double lik; ///< likelihood or lambda value (for aafit, lambda)
11271 int type; ///< MC: particle type in PDG encoding
11272 int rec_type; ///< identifier of the fitting algorithm/chain/strategy, see km3net-dataformat/definitions/reconstruction.csv
11273 std::vector<int> rec_stages; ///< list of identifyers of succesfull fitting stages resulting in this track
11274
11275 int status; ///< MC status code, see km3net-dataformat/definitions/trkmembers.csv for values
11276 int mother_id; ///< MC id of the parent particle
11277 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>
11278
11279 std::vector<double> fitinf; ///< place to store additional fit info, see km3net-dataformat/definitions/fitparameters.csv
11280 std::vector<int> hit_ids; ///< list of associated hit-ids (corresponds to Hit::id).
11281 std::vector<double> error_matrix; ///< (NxN) error covariance matrix for fit parameters (stored as linear vector)
11282 std::string comment; ///< use as you like
11283
11284 /**
11285 * Default constructor.
11286 */
11287 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) {}
11288
11289
11290
11291
11292 /**
11293 * Read track (useful in python).
11294 *
11295 * \param t track
11296 */
11297 void read(const Trk& t) { *this = t;}
11298
11299 /**
11300 * Write track (useful in python).
11301 *
11302 * \param t track
11303 */
11304 void write(Trk& t) const { t = *this; }
11305
11306
11307 /**
11308 * Get the name of the MC particle type.
11309 *
11310 * \return name
11311 */
11312 std::string name() const
11313 {
11314 TParticlePDG* p = TDatabasePDG::Instance()->GetParticle( type );
11315 if (!p) return "unnamed state ("+ std::to_string(type)+")";
11316 return p->GetName();
11317 }
11318
11319 /**
11320 * Check if this is a primary particle.
11321 *
11322 * \return true if primary; else false
11323 */
11324 bool is_primary() const
11325 {
11326 return status==TRK_ST_PRIMARYNEUTRINO || status==TRK_ST_PRIMARYCOSMIC;
11327 }
11328
11329 /**
11330 * Test whether given particle is a final state inside the detector.
11331 *
11332 * \return true if particle is final state; else false
11333 */
11334 bool is_finalstate() const
11335 {
11336 return status==TRK_ST_FINALSTATE;
11337 }
11338
11339 /**
11340 * Check if this is a netrino.
11341 *
11342 * Note that its is checked if the PDG type is a nu-e, nu-mu or nu-tau.
11343 *
11344 * \return true if neutrino; else false
11345 */
11346 bool is_neutrino() const
11347 {
11348 return type == kNuE || type == kNuEBar || type == kNuMu || type == kNuMuBar || type == kNuTau || type == kNuTauBar;
11349 }
11350
11351 /**
11352 * Check if this is an electron or positron.
11353 *
11354 * \return true if this is an electron or positron
11355 */
11356 bool is_e() const
11357 {
11358 return type == kElectron || type == kPositron;
11359 }
11360
11361 /**
11362 * Check if this is a muon.
11363 *
11364 * Note that its is checked if the PDG type is a (anti-)muon.
11365 *
11366 * \return true if muon; else false
11367 */
11368 bool is_muon() const
11369 {
11370 return type == kMuonMinus || type == kMuonPlus;
11371 }
11372
11373 /**
11374 * Check if this is a tau.
11375 *
11376 * Note that its is checked if the PDG type is a (anti-)tau.
11377 *
11378 * \return true if tau; else false
11379 */
11380 bool is_tau() const
11381 {
11382 return type == kTauMinus || type == kTauPlus;
11383 }
11384
11385 /**
11386 * Check if this is a charged lepton.
11387 *
11388 * Note that its is checked if the PDG type is a (anti-)electron, (anti-)muon or (anti-)tua.
11389 *
11390 * \return true if charged lepton; else false
11391 */
11392 bool is_lepton() const
11393 {
11394 return is_e() || is_muon() || is_tau();
11395 }
11396
11397 /**
11398 * Check if this is an orphan (i.e. no mother).
11399 *
11400 * \return true if orphan; else false
11401 */
11402 bool is_orphan() const
11403 {
11404 return mother_id == TRK_MOTHER_NONE;
11405 }
11406
11407 /**
11408 * Get list of of pointers to tracks, all of which have their mother identifier set to identifier of this track.
11409 *
11410 * \param mctrks list of input tracks
11411 * \return list of pointers to tracks
11412 */
11413 std::vector< Trk* > get_daughters ( std::vector<Trk>& mctrks )
11414 {
11415 std::vector<Trk*> r;
11416
11417 for( auto& t : mctrks )
11418 {
11419 if ( t.mother_id == id ) r.push_back( &t );
11420 }
11421 return r;
11422 }
11423
11424 /**
11425 * Print track.
11426 *
11427 * \param out output stream
11428 */
11429 void print(std::ostream& out=std::cout) const
11430 {
11431 out << "Trk: id=" << id << " pos="; pos.print(out);
11432 out << " dir="; dir.print(out);
11433 out << " t=" << t << " E=" << E << " pdg-type=" << type;
11434 }
11435
11436 ClassDef(Trk,12)
11437};
11438
11439#endif
11440#ifndef VEC_HH_INCLUDED
11441#define VEC_HH_INCLUDED
11442
11443#include <cmath>
11444#include <iostream>
11445#include <sstream>
11446#include "Rtypes.h"
11447
11448/**
11449 * The Vec class is a straightforward 3-d vector, which also works in pyroot.
11450 */
11451struct Vec
11452{
11453 double x,y,z;
11454
11455 /**
11456 * Constructor.
11457 *
11458 * \param x_ x position
11459 * \param y_ y position
11460 * \param z_ z position
11461 */
11462 Vec(double x_, double y_, double z_) : x(x_), y(y_), z(z_) {}
11463
11464 /**
11465 * Default constructor.
11466 */
11467 Vec():x(0),y(0),z(0) {}
11468
11469 /**
11470 * Get dot product.
11471 *
11472 * \param v vector
11473 * \return dot product
11474 */
11475 double dot(const Vec& v) const { return v.x*x + v.y*y+ v.z*z;}
11476
11477 /**
11478 * Get cross product.
11479 *
11480 * \param r vector
11481 * \return cross product
11482 */
11483 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);}
11484
11485 /**
11486 * Add vector.
11487 *
11488 * \param v vector
11489 * \return this vector
11490 */
11491 Vec& operator+=(const Vec& v) { x+=v.x; y+=v.y; z+=v.z; return *this;}
11492
11493 /**
11494 * Subtract vector.
11495 *
11496 * \param v vector
11497 * \return this vector
11498 */
11499 Vec& operator-=(const Vec& v) { x-=v.x; y-=v.y; z-=v.z; return *this;}
11500
11501 /**
11502 * Multiply vector.
11503 *
11504 * \param d factor
11505 * \return this vector
11506 */
11507 Vec& operator*=(double d) { x*=d; y*=d; z*=d; return *this;}
11508
11509 /**
11510 * Divide vector.
11511 *
11512 * \param d factor
11513 * \return this vector
11514 */
11515 Vec& operator/=(double d) { return operator*=( 1.0 / d ); }
11516
11517 /**
11518 * Negate vector.
11519 *
11520 * \return vector
11521 */
11522 Vec operator-() const { return Vec(-x,-y,-z); }
11523
11524 /**
11525 * Check equality with given vector.
11526 *
11527 * \param v vector
11528 * \return true if (x,y,z) positions of two vectors are equal; else false
11529 */
11530 bool operator==( const Vec& v ) const { return x==v.x && y==v.y && z==v.z ; }
11531
11532 /**
11533 * Check in-equality with given vector.
11534 *
11535 * \param v vector
11536 * \return true if one of (x,y,z) positions of two vectors are not equal; else false
11537 */
11538 bool operator!=( const Vec& v ) const { return x!=v.x || y!=v.y || z!=v.z ; }
11539
11540 /**
11541 * Set vector.
11542 *
11543 * \param xx x position
11544 * \param yy y position
11545 * \param zz z position
11546 * \return this vector
11547 */
11548 Vec& set(double xx, double yy, double zz) { x=xx; y=yy; z=zz; return *this;}
11549
11550 /**
11551 * Set vector according given zenith and azimuth angles.
11552 *
11553 * \param theta zenith angle [rad]
11554 * \param phi azimuth angle [rad]
11555 * \return this vector
11556 */
11557 Vec& set_angles(double theta, double phi)
11558 {
11559 x = sin ( theta ) * cos( phi );
11560 y = sin ( theta ) * sin( phi );
11561 z = cos ( theta );
11562 return *this;
11563 }
11564
11565 /**
11566 * Get azimuth angle.
11567 *
11568 * \return angle [rad]
11569 */
11570 double phi() const { return atan2( y,x ); }
11571
11572 /**
11573 * Get zenith angle.
11574 *
11575 * \return angle [rad]
11576 */
11577 double theta() const { return acos(z); }
11578
11579 /**
11580 * Get length.
11581 *
11582 * \return length
11583 */
11584 double len() const { double l = dot(*this); return (l > 0)? sqrt(l) : 0; }
11585
11586 /**
11587 * Get length of (x,y) component.
11588 *
11589 * \return length
11590 */
11591 double lenxy() const { const double r2 = x*x + y*y; return (r2>0) ? sqrt(r2) :0; }
11592
11593 /**
11594 * Normalise this vector.
11595 *
11596 * \return this vector
11597 */
11598 Vec& normalize() { return operator/=( len() ); }
11599
11600 /**
11601 * Print vector.
11602 *
11603 * \param out output stream
11604 */
11605 void print( std::ostream& out = std::cout ) const
11606 {
11607 out << "Vec:" << x << " " << y << " " << z;
11608 }
11609
11610 /**
11611 * Get string representation of this vector
11612 *
11613 * \return string
11614 */
11615 const char* __repr__() const
11616 {
11617 static std::string buffer;
11618
11619 std::ostringstream s;
11620
11621 print(s);
11622
11623 buffer = s.str();
11624
11625 return buffer.c_str();
11626 }
11627
11628 /**
11629 * Add vector.
11630 *
11631 * \param v vector
11632 * \return vector
11633 */
11634 Vec __add__(const Vec& v) const { Vec r=*this; return r+=v; }
11635
11636 /**
11637 * Subtract vector.
11638 *
11639 * \param v vector
11640 * \return vector
11641 */
11642 Vec __sub__(const Vec& v) const { Vec r=*this; return r-=v; }
11643
11644 /**
11645 * Multiply vector.
11646 *
11647 * \param d factor
11648 * \return vector
11649 */
11650 Vec __mul__(double d ) const { Vec r=*this; return r*=d; }
11651
11652 /**
11653 * Multiply vector.
11654 *
11655 * \param d factor
11656 * \return vector
11657 */
11658 Vec __rmul__(double d ) const { return __mul__(d); }
11659
11660 /**
11661 * Divide vector.
11662 *
11663 * \param d factor
11664 * \return vector
11665 */
11666 Vec __div__(double d ) const { Vec r=*this; return r/=d; }
11667
11668 /**
11669 * Rotate around z-axis with given angle.
11670 *
11671 * \param ang angle [rad]
11672 * \return this vector
11673 */
11674 Vec& rotate_z(double ang)
11675 {
11676 const Vec o = *this;
11677 x = o.x *cos(ang) - o.y * sin(ang);
11678 y = o.x *sin(ang) + o.y * cos(ang);
11679 z = o.z;
11680 return *this;
11681 }
11682
11683 /**
11684 * Rotate around x-axis with given angle.
11685 *
11686 * \param ang angle [rad]
11687 * \return this vector
11688 */
11689 Vec& rotate_x(double ang)
11690 {
11691 const Vec o = *this;
11692 x = o.x;
11693 y = o.y *cos(ang) + o.z * -sin(ang);
11694 z = o.y *sin(ang) + o.z * cos(ang);
11695 return *this;
11696 }
11697
11698 /**
11699 * Rotate around y-axis with given angle.
11700 *
11701 * \param ang angle [rad]
11702 * \return this vector
11703 */
11704 Vec& rotate_y(double ang)
11705 {
11706 const Vec o = *this;
11707 x = o.x *cos(ang) + o.z * sin(ang);
11708 y = o.y;
11709 z = -o.x *sin(ang) + o.z * cos(ang);
11710 return *this;
11711 }
11712
11713 ClassDefNV(Vec,3)
11714};
11715
11716/**
11717 * Write vector to output stream.
11718 *
11719 * \param out output stream
11720 * \param v vector
11721 * \return output stream
11722 */
11723inline std::ostream& operator<<( std::ostream& out , const Vec& v )
11724{
11725 out << v.x << " " << v.y << " " << v.z << " ";
11726 return out;
11727}
11728
11729/**
11730 * Read vector from input stream.
11731 *
11732 * \param in input stream
11733 * \param v vector
11734 * \return input stream
11735 */
11736inline std::istream& operator>>(std::istream& in, Vec& v)
11737{
11738 in >> v.x >> v.y >> v.z ; return in;
11739}
11740
11741/**
11742 * Get cosine of space angle between two vectors.
11743 *
11744 * \param a first vector
11745 * \param b second vector
11746 * \return cosine
11747 */
11748inline double cos_angle_between( const Vec& a, const Vec& b)
11749{
11750 const double n = a.len() * b.len();
11751 return a.dot(b) / n;
11752}
11753
11754/**
11755 * Get space angle between two vectors.
11756 *
11757 * \param a first vector
11758 * \param b second vector
11759 * \return angle [rad]
11760 */
11761inline double angle_between( const Vec& a, const Vec& b )
11762{
11763 double c = cos_angle_between( a, b );
11764 if ( c < -1 ) return M_PI;
11765 if ( c > 1 ) return 0;
11766 return acos( c );
11767}
11768
11769/**
11770 * Add two vectors.
11771 *
11772 * \param a first vector
11773 * \param b second vector
11774 * \return vector
11775 */
11776inline Vec operator+(const Vec& a, const Vec& b) { Vec r(a); return r+=b;}
11777
11778/**
11779 * Subtract two vectors.
11780 *
11781 * \param a first vector
11782 * \param b second vector
11783 * \return vector
11784 */
11785inline Vec operator-(const Vec& a, const Vec& b) { Vec r(a); return r-=b;}
11786
11787/**
11788 * Multiply vector.
11789 *
11790 * \param a factor
11791 * \param v vector
11792 * \return vector
11793 */
11794inline Vec operator*(double a, const Vec& v) { return Vec(a*v.x,a*v.y,a*v.z);}
11795
11796/**
11797 * Multiply vector.
11798 *
11799 * \param v vector
11800 * \param a factor
11801 * \return vector
11802 */
11803inline Vec operator*(const Vec& v, double a) { return Vec(a*v.x,a*v.y,a*v.z);}
11804
11805/**
11806 * Divide vector.
11807 *
11808 * \param v vector
11809 * \param a factor
11810 * \return vector
11811 */
11812inline Vec operator/(const Vec& v, double a) { return Vec(v.x/a,v.y/a,v.z/a);}
11813
11814#endif
11815#ifndef IO_ASCII_INCLUDED
11816#define IO_ASCII_INCLUDED
11817
11818#include <string>
11819#include <istream>
11820#include <ostream>
11821#include <sstream>
11822
11823#include "km3net-dataformat/offline/Evt.hh"
11824#include "km3net-dataformat/offline/Hit.hh"
11825#include "km3net-dataformat/offline/Trk.hh"
11826#include "km3net-dataformat/offline/Head.hh"
11827#include "km3net-dataformat/offline/Exception.hh"
11828#include "km3net-dataformat/definitions/w2list_gseagen.hh"
11829#include "km3net-dataformat/definitions/trkmembers.hh"
11830
11831#include "TDatabasePDG.h"
11832
11833namespace mc_keys
11834{
11835const char* const auto_t = "auto";
11836const char* const start_run_t = "start_run:";
11837const char* const start_event_t = "start_event:";
11838const char* const hit_t = "hit:";
11839const char* const hit_raw_t = "hit_raw:";
11840const char* const track_in_t = "track_in:";
11841const char* const track_t = "track:";
11842const char* const track_fit_t = "track_fit:";
11843const char* const neutrino_t = "neutrino:";
11844const char* const track_primary_t = "track_primary:";
11845const char* const track_bundle_t = "track_bundle:";
11846//const char* const primarylepton_t = "primarylepton:";
11847const char* const weights_t = "weights:";
11848const char* const w2list_t = "w2list:";
11849const char* const w3list_t = "w3list:";
11850const char* const hourangle_t = "hourangle:";
11851const char* const eventtime_t = "eventtime:";
11852const char* const center_on_can_t = "center_on_can:";
11853const char* const muon_decay_t = "muon_decay:";
11854const char* const end_event_t = "end_event:";
11855}
11856
11857namespace mc_usr_keys
11858{
11859// track-level quantities
11860const char* const energy_lost_in_can = "energy_lost_in_can";
11861
11862
11863// event-level corsika variables
11864const char* const muon_decay_x = "muon_decay_x";
11865const char* const muon_decay_y = "muon_decay_y";
11866const char* const muon_decay_z = "muon_decay_z";
11867
11868const char* const center_on_can_x = "center_on_can_x";
11869const char* const center_on_can_y = "center_on_can_y";
11870const char* const center_on_can_z = "center_on_can_z";
11871const char* const hourangle = "hourangle";
11872}
11873
11874
11875namespace io_stringutil
11876{
11877/**
11878 * Check if string starts with given text.
11879 *
11880 * \param a input string
11881 * \param b text
11882 * \return true if string start with text; else false
11883 */
11884inline bool startswith( const std::string& a, const std::string& b )
11885{
11886 if ( a.find( b ) == 0 ) return true;
11887 return false;
11888}
11889
11890/**
11891 * Remove leading and trailing white spaces.
11892 *
11893 * \param s input string
11894 * \return trimmed string
11895 */
11896inline std::string trim(const std::string& s)
11897{
11898 using namespace std;
11899
11900 if ( s == "" ) return s;
11901
11902 string::size_type i1;
11903 string::size_type i2;
11904
11905 for (i1 = 0; i1 < s.length(); i1++)
11906 {
11907 if ( !isspace (s[i1]) ) break;
11908 }
11909 for (i2 = s.length() - 1 ; i2 > i1 ; i2--)
11910 {
11911 if ( !isspace (s[i2]) ) break;
11912 }
11913 return s.substr( i1, i2 - i1 + 1 );
11914}
11915
11916}
11917
11918
11919/**
11920 * Convert Geant3 to PDG particle type.
11921 *
11922 * \param geant3_code Geant3 code
11923 * \return PDG code
11924 */
11925inline int pdg_code( int geant3_code )
11926{
11927 if ( geant3_code == -1 ) return -1; // used for k40 hits
11928 if ( geant3_code < 0 ) return pdg_code( -geant3_code ); // used for scattered
11929
11930 return TDatabasePDG::Instance()->ConvertGeant3ToPdg( geant3_code );
11931}
11932
11933/**
11934 * Convert PDG to Geant3 particle type.
11935 *
11936 * \param pdg_code PDG code
11937 * \return Geant3 code
11938 */
11939inline int geant3_code( int pdg_code )
11940{
11941 if (pdg_code == -1 ) return -1;
11942 if (pdg_code == +311 ) return geant3_code( 130 ); // K0 -> K0long
11943 if (pdg_code == -311 ) return geant3_code( 130 ); // K0bar -> K0long
11944
11945 return TDatabasePDG::Instance()->ConvertPdgToGeant3( pdg_code );
11946}
11947
11948
11949/**
11950 * Read a Vec(tor) from a stream.
11951 *
11952 * \param v vector
11953 * \param is input stream
11954 * \return true if correctly read; else false
11955 */
11956inline bool read ( Vec& v, std::istream& is)
11957{
11958 is >> v.x >> v.y >> v.z;
11959 return !is.fail();
11960}
11961
11962/**
11963 * Write a Vec(tor) to a stream.
11964 *
11965 * \param v vector
11966 * \param os output stream
11967 * \return true if correctly written; else false
11968 */
11969inline bool write( const Vec& v, std::ostream& os)
11970{
11971 os << v.x << ' ' << v.y << ' ' << v.z;
11972 return !os.fail();
11973}
11974
11975/**
11976 * Read a hit from a stream.
11977 *
11978 * \param h hit
11979 * \param is input stream
11980 * \param read_mc option to read also type and origin
11981 * \return true if correctly read; else false
11982 */
11983inline bool read ( Hit& h, std::istream& is, bool read_mc = false )
11984{
11985 h.dom_id = 0; // need a proper det file to
11986 h.channel_id = 0; // set these.
11987
11988 is >> h.id >> h.pmt_id >> h.a >> h.t;
11989 if ( !read_mc )
11990 {
11991 return !is.fail();
11992 }
11993 else
11994 {
11995 is >> h.type >> h.origin;
11996 }
11997
11998 // at this point, an additional pure_a and pure_t may be present,
11999 // but we do not read them.
12000
12001 return !is.fail();
12002}
12003
12004
12005/**
12006 * Write a hit to a stream.
12007 *
12008 * \param h hit
12009 * \param os output stream
12010 * \param tag tag
12011 * \return true if correctly written; else false
12012 */
12013inline bool write( const Hit& h, std::ostream& os, const std::string& tag = mc_keys::hit_t)
12014{
12015 int om_id = h.pmt_id; // todo: deal with this better.
12016
12017 os << tag << ' ' << h.id << ' ' << om_id << ' ' << h.a << ' ' << h.t;
12018 if ( tag != mc_keys::hit_raw_t ) {
12019 os << ' ' << h.type << ' ' << h.origin; // not writing pure_a and pure_t
12020 }
12021 os << std::endl;
12022 return !os.fail();
12023}
12024
12025
12026/**
12027 * Read data.
12028 *
12029 * \param is input stream
12030 * \return data
12031 */
12032inline std::vector<double> read_line_to_vector( std::istream& is )
12033{
12034 using namespace std;
12035
12036 vector<double> r;
12037
12038 string ss;
12039 getline(is, ss);
12040 istringstream il(ss);
12041 for ( double x; il >> x ; ) r.push_back( x );
12042
12043 return r;
12044}
12045
12046
12047/**
12048 * Put value in front of data.
12049 *
12050 * \param vec data
12051 * \param value value
12052 */
12053template<typename T>
12054inline void push_front( std::vector<T>& vec, const T& value )
12055{
12056 vec.insert( vec.begin(), value );
12057}
12058
12059
12060/**
12061 * Read event from a stream.
12062 *
12063 * \param evt event
12064 * \param is input stream
12065 * \param skip_hits option to skip reading of hits
12066 * \return true if correctly read; else false
12067 */
12068inline bool read ( Evt& evt, std::istream& is, bool skip_hits = false )
12069{
12070 using namespace std;
12071
12072 string w;
12073
12074 // find next start_event
12075
12076 while ( w != mc_keys::start_event_t && is.good() ) is >> w;
12077
12078 int mc_event_type; // dummy - this is always 1 in all files.
12079 is >> evt.mc_id >> mc_event_type;
12080
12081 Trk trk_nu, trk_primary;
12082 bool have_trk_nu(false), have_trk_primary(false);
12083
12084
12085 evt.mc_trks.clear();
12086 evt.hits.clear();
12087 evt.mc_hits.clear();
12088
12089 string w_old;
12090
12091 while ( is )
12092 {
12093 static Hit h;
12094 static Trk t;
12095
12096 is >> w;
12097
12098 if (skip_hits && ( w == mc_keys::hit_t || w == mc_keys::hit_raw_t)) {
12099 is.ignore( 1000, '\n' );
12100 continue;
12101 }
12102
12103 if ( w == mc_keys::hit_t ) {
12104
12105 read( h, is, true );
12106 evt.mc_hits.push_back( h );
12107
12108 } else if ( w == mc_keys::hit_raw_t ) {
12109
12110 read( h, is, false);
12111 evt.hits.push_back( h );
12112
12113 } else if ( w == mc_keys::track_in_t ||
12114 w == mc_keys::track_t ||
12115 w == mc_keys::neutrino_t ||
12116 w == mc_keys::track_bundle_t ||
12117 w == mc_keys::track_primary_t ) {
12118
12119 t.id = 0;
12120 t.len = 0.0;
12121 t.clearusr();
12122 t.comment = w;
12123
12124 string line;
12125 getline( is, line );
12126 istringstream ii(line);
12127
12128 if ( w != mc_keys::track_bundle_t ) {
12129 ii >> t.id;
12130 } else {
12131 ii >> t.len;
12132 }
12133
12134 ii >> t.pos >> t.dir >> t.E;
12135
12136 if (!ii.fail()) {
12137
12138 if ( w == mc_keys::track_in_t) {
12139
12140 t.status = TRK_ST_FINALSTATE;
12141
12142 ii >> t.t >> t.type;
12143
12144 if (!ii.fail()) {
12145
12146 t.type = pdg_code( t.type );
12147
12148 ii >> t.len;
12149
12150 if ( ii.fail() ) { // missing length is not an error
12151 evt.mc_trks.push_back( t );
12152 continue;
12153 }
12154
12155 double eloss = 0;
12156 ii >> eloss;
12157
12158 if ( ii.fail() ) { // missing eloss is not an error
12159 evt.mc_trks.push_back( t );
12160 continue;
12161 }
12162
12163 t.setusr( mc_usr_keys::energy_lost_in_can, eloss);
12164
12165 evt.mc_trks.push_back( t );
12166 }
12167
12168 } else if ( w == mc_keys::track_t ) {
12169
12170 ii >> t.t;
12171
12172 evt.trks.push_back( t );
12173
12174 } else if ( w == mc_keys::neutrino_t ) {
12175
12176 t.status = TRK_ST_PRIMARYNEUTRINO;
12177
12178 // the last item we will read is W2LIST_GSEAGEN_CC, make enough space;
12179 if (evt.w2list.size() < W2LIST_GSEAGEN_CC+1 ) evt.w2list.resize(W2LIST_GSEAGEN_CC+1);
12180
12181 ii >> t.t >>
12182 evt.w2list[W2LIST_GSEAGEN_BX] >>
12183 evt.w2list[W2LIST_GSEAGEN_BY] >>
12184 evt.w2list[W2LIST_GSEAGEN_ICHAN] >>
12185 t.type >>
12186 evt.w2list[W2LIST_GSEAGEN_CC];
12187
12188 trk_nu = t;
12189 have_trk_nu = true;
12190
12191 } else if ( w == mc_keys::track_primary_t ) {
12192
12193 t.status = TRK_ST_PRIMARYCOSMIC;
12194
12195 ii >> t.t >> trk_primary.type; // nucleus id (in pdg format or not?)
12196
12197 trk_primary = t;
12198 have_trk_primary = true;
12199
12200 } else if ( w == mc_keys::track_bundle_t ) {
12201
12202 t.type = PDG_MUONBUNDLE;
12203 t.status = TRK_ST_MUONBUNDLE;
12204
12205 evt.mc_trks.push_back( t );
12206
12207 } else {
12208
12209 ostream& out = Exception::getOstream();
12210 out << "Unknown tag " << w << " for trk ";
12211 t.print(out);
12212 throw Exception(static_cast<ostringstream&>(out).str());
12213 }
12214 }
12215
12216 if ( ii.fail() ) {
12217 ostream& out = Exception::getOstream();
12218 out << "Error reading trk ";
12219 t.print(out);
12220 throw Exception(static_cast<ostringstream&>(out).str());
12221 }
12222
12223 } else if ( w == mc_keys::weights_t) {
12224
12225 evt.w = read_line_to_vector( is );
12226
12227 } else if ( w == mc_keys::w2list_t) {
12228
12229 auto v = read_line_to_vector( is );
12230 evt.w2list.resize( std::max( evt.w2list.size(), v.size()));
12231 std::copy( v.begin(), v.end() , evt.w2list.begin() );
12232
12233 } else if ( w == mc_keys::w3list_t) {
12234
12235 evt.w3list = read_line_to_vector( is );
12236
12237 } else if ( w == mc_keys::hourangle_t ) {
12238
12239 double ha;
12240 is >> ha;
12241 evt.setusr(mc_usr_keys::hourangle, ha );
12242
12243 } else if ( w == mc_keys::center_on_can_t) {
12244
12245 // in corsika files, there is the (undocumented?) center_on_can tag,
12246 // which denoets the projection of the primary on the can. The direction
12247 // of the center_on_can 'track' is by defintion the direction of the
12248 // primary. We record the position in the usr data.
12249
12250 vector<double> v = read_line_to_vector( is );
12251
12252 if ( v.size() > 3 ) {
12253 evt.setusr(mc_usr_keys::center_on_can_x, v[1] );
12254 evt.setusr(mc_usr_keys::center_on_can_y, v[2] );
12255 evt.setusr(mc_usr_keys::center_on_can_z, v[3] );
12256 }
12257
12258 } else if ( w == mc_keys::eventtime_t ) {
12259
12260 unsigned nsec, n16ns_ticks;
12261 is >> nsec >> n16ns_ticks;
12262 evt.mc_event_time.SetSec( nsec );
12263 evt.mc_event_time.SetNanoSec( n16ns_ticks * 16 );
12264
12265 } else if ( w == mc_keys::muon_decay_t) {
12266
12267 // in km3sim files, there are additional tags, including this one
12268 vector<double> v = read_line_to_vector( is );
12269 if ( v.size() > 4 )
12270 {
12271 evt.setusr(mc_usr_keys::muon_decay_x, v[2] );
12272 evt.setusr(mc_usr_keys::muon_decay_y, v[3] );
12273 evt.setusr(mc_usr_keys::muon_decay_z, v[4] );
12274 }
12275
12276 } else if ( w == mc_keys::end_event_t) {
12277
12278 // finalize the mc_tracks -- as best we can.
12279
12280 // If there is both a primary, and a neutrino, then the primary
12281 // will go second (mc_trks[1]) with id=-1 and the neutrino will
12282 // be mc_trks[0] with id=0. Unless they are same particle (identical
12283 // pos,dir,E); in that case the primary is skipped.
12284 // The primarylepton tag is not stored as a seperate Trk.
12285
12286 if ( have_trk_primary && have_trk_nu ) {
12287
12288 bool same = trk_nu.pos == trk_primary.pos &&
12289 trk_nu.dir == trk_primary.dir &&
12290 trk_nu.E == trk_primary.E;
12291
12292 if (!same) {
12293 trk_primary.id = -1;
12294 push_front( evt.mc_trks, trk_primary);
12295 }
12296
12297 trk_nu.id = 0;
12298 push_front( evt.mc_trks, trk_nu);
12299
12300 } else if ( have_trk_primary ) {
12301
12302 trk_primary.id = 0;
12303 push_front( evt.mc_trks, trk_primary);
12304
12305 } else if ( have_trk_nu ) {
12306
12307 trk_nu.id = 0;
12308 push_front( evt.mc_trks, trk_nu);
12309 }
12310
12311 return true;
12312
12313 } else {
12314 is.ignore( 1000, '\n' );
12315 }
12316
12317 w_old = w;
12318 }
12319
12320 if (!is.eof()) {
12321 THROW(Exception, "Error while reading ascii event" << w << ' ' << evt.id);
12322 }
12323
12324 return false;
12325}
12326
12327
12328/**
12329 * Write event to a stream.
12330 *
12331 * \param evt event
12332 * \param os output stream
12333 * \return true if correctly read; else false
12334 */
12335inline bool write( const Evt& evt, std::ostream& os )
12336{
12337 using namespace std;
12338
12339 // set precision to 12 digits.
12340 const int precision = 12;
12341 auto old_flags = os.flags();
12342 auto old_precision = os.precision( precision );
12343 os.unsetf( std::ios_base::scientific | std::ios_base::fixed ); // default behaviour
12344
12345 os << mc_keys::start_event_t << ' ' << evt.mc_id << ' ' << 1 << endl;
12346
12347 for ( auto& trk : evt.mc_trks ) {
12348
12349 const std::string& tag = trk.comment;
12350
12351 os << tag << ' '
12352 << (tag != mc_keys::track_bundle_t ? trk.id : trk.len) << ' '
12353 << trk.pos << ' '
12354 << trk.dir << ' '
12355 << trk.E;
12356
12357 if ( tag == mc_keys::track_in_t ) {
12358
12359 os << ' ' << trk.t << ' ' << geant3_code(trk.type) << ' ' << trk.len;
12360
12361 if ( trk.haveusr( mc_usr_keys::energy_lost_in_can ) ) {
12362 os << ' ' << trk.getusr( mc_usr_keys::energy_lost_in_can );
12363 }
12364
12365 os << endl;
12366
12367 } else if ( tag == mc_keys::track_primary_t ) {
12368
12369 os << ' ' << trk.t << ' ' << trk.type << endl;
12370
12371 } else if ( tag == mc_keys::neutrino_t ) {
12372
12373 double bx(0), by(0);
12374 int ichan(0), cc(0);
12375
12376 if ( evt.w2list.size() > W2LIST_GSEAGEN_CC ) {
12377 bx = evt.w2list[W2LIST_GSEAGEN_BX];
12378 by = evt.w2list[W2LIST_GSEAGEN_BY];
12379 ichan = evt.w2list[W2LIST_GSEAGEN_ICHAN];
12380 cc = evt.w2list[W2LIST_GSEAGEN_CC];
12381 }
12382
12383 os << ' ' << trk.t
12384 << ' ' << bx
12385 << ' ' << by
12386 << ' ' << ichan
12387 << ' ' << trk.type
12388 << ' ' << cc
12389 << endl;
12390
12391 } else {
12392
12393 os << endl;
12394 }
12395 }
12396
12397 for ( auto& trk : evt.trks ) {
12398 os << mc_keys::track_fit_t << ' ' << trk.id << ' ' << trk.pos << ' ' << trk.dir << ' ' << trk.E << ' ' << trk.t << endl;
12399 }
12400
12401 for ( auto& hit : evt.mc_hits ) write ( hit, os, mc_keys::hit_t);
12402 for ( auto& hit : evt.hits ) write ( hit, os, mc_keys::hit_raw_t);
12403
12404 os << mc_keys::weights_t; for (auto& w : evt.w ) os << ' ' << w; os << endl;
12405 os << mc_keys::w2list_t; for (auto& w : evt.w2list ) os << ' ' << w; os << endl;
12406 os << mc_keys::w3list_t; for (auto& w : evt.w3list ) os << ' ' << w; os << endl;
12407
12408 os << mc_keys::eventtime_t << evt.mc_event_time.GetSec() << " "
12409 << evt.mc_event_time.GetNanoSec() / 16 << endl;
12410
12411 os << mc_keys::end_event_t << endl;
12412
12413 // restore os to how we found it.
12414 os.flags( old_flags );
12415 os.precision( old_precision );
12416
12417 return true;
12418}
12419
12420
12421
12422/**
12423 * Read header from a stream.
12424 *
12425 * The stream may be positioned at any point before the tag mc_keys::start_run_t,
12426 * which marks the beginning of the header.
12427 * Information before the header (if any) is disgarded.
12428 *
12429 * \param hdr header
12430 * \param is input stream
12431 * \return true if correctly read; else false
12432 */
12433inline bool read( Head& hdr, std::istream& is )
12434{
12435 using namespace std;
12436
12437 string line;
12438
12439 bool start = false;
12440
12441 while (getline( is, line ))
12442 {
12443 if ( io_stringutil::startswith(line, mc_keys::end_event_t))
12444 {
12445 break;
12446 }
12447
12448 if ( io_stringutil::startswith(line, mc_keys::start_run_t))
12449 {
12450 start = true;
12451 }
12452
12453 if ( io_stringutil::startswith(line, mc_keys::start_event_t))
12454 {
12455 THROW(Exception, "Unexpected tag " << mc_keys::start_event_t << " found while reading header at " << line << " (could mean the evt file has no header)");
12456 }
12457
12458 if (!start) continue;
12459
12460 vector<string> v = splitstring( line, ':' );
12461 if (v.size() < 2 )
12462 {
12463 std::cout << "Warning: line with empty tag found when reading header" << endl;
12464 std::cout << " "<< line << endl;
12465 std::cout << " will be skipped" << endl;
12466 continue;
12467 }
12468
12469 // the following with unsure key in the map is unique by adding _1 _2 etc.
12470 hdr.set_line( io_stringutil::trim(v[0]), io_stringutil::trim(v[1]) );
12471
12472 }
12473
12474 if (!start)
12475 {
12476 THROW(Exception, "Reading of MC header terminated before finding a start_run: tag. Please check your file");
12477 }
12478
12479 return start;
12480}
12481
12482
12483/**
12484 * Write header to a stream.
12485 *
12486 * \param hdr header
12487 * \param os output stream
12488 * \return true if correctly written; else false
12489 */
12490inline bool write( const Head& hdr, std::ostream& os )
12491{
12492 hdr.print(os);
12493 return true;
12494}
12495
12496#endif
12497#ifndef IOONLINEINCLUDED
12498#define IOONLINEINCLUDED
12499
12500#include "km3net-dataformat/offline/Evt.hh"
12501#include "km3net-dataformat/offline/Hit.hh"
12502#include "km3net-dataformat/offline/Trk.hh"
12503#include "km3net-dataformat/offline/Exception.hh"
12504
12505#include "km3net-dataformat/online/JDAQEvent.hh"
12506#include "km3net-dataformat/online/JDAQKeyHit.hh"
12507#include "km3net-dataformat/online/JDAQTimeslice.hh"
12508#include "km3net-dataformat/online/JDAQSummaryslice.hh"
12509
12510#include "TStreamerInfo.h"
12511#include "TFile.h"
12512#include "TTree.h"
12513#include "km3net-dataformat/definitions/root.hh"
12514
12515#include <map>
12516#include <vector>
12517
12518
12519using namespace KM3NETDAQ;
12520
12521/**
12522 * Read a hit from a DAQ hit.
12523 *
12524 * \param hit hit
12525 * \param daqhit DAQ hit
12526 */
12527inline void read(Hit& hit, const JDAQHit& daqhit )
12528{
12529 hit.channel_id = daqhit.getPMT();
12530 hit.tot = daqhit.getToT();
12531 hit.tdc = daqhit.getT(); // GetT() just return the bare TDC
12532}
12533
12534/**
12535 * Read a hit from a DAQ key hit.
12536 *
12537 * \param hit hit
12538 * \param daqhit DAQ key hit
12539 */
12540inline void read(Hit& hit, const JDAQKeyHit& daqhit )
12541{
12542 hit.id = hit.pmt_id = 0;
12543
12544 hit.dom_id = daqhit.getModuleID();
12545 hit.channel_id = daqhit.getPMT();
12546 hit.tot = daqhit.getToT();
12547 hit.tdc = daqhit.getT(); // GetT() just return the bare TDC
12548}
12549
12550/**
12551 * Read an event from a DAQ event.
12552 *
12553 * \param evt evt
12554 * \param de DAQ event
12555 */
12556inline void read(Evt& evt, const JDAQEvent& de)
12557{
12558 evt.run_id = de.getRunNumber();
12559 evt.det_id = de.getDetectorID();
12560 evt.frame_index = de.getFrameIndex();
12561 evt.trigger_counter = de.getCounter();
12562 evt.overlays = de.getOverlays();
12563 evt.trigger_mask = de.getTriggerMask();
12564 evt.t.SetSec( de.getTimesliceStart().getUTCseconds() );
12565 evt.t.SetNanoSec( de.getTimesliceStart().getUTC16nanosecondcycles() * 16 );
12566
12567 // The only way to know the hits that are also in the triggeredhits collection
12568 // is by dom and channel id and time.
12569
12570 Hit h;
12571 std::map<int, std::map< int, std::map < unsigned int, Hit*> > > M;
12572
12573 const std::vector<JDAQSnapshotHit>& snapshotHits = de.getHits<JDAQSnapshotHit>();
12574 const std::vector<JDAQTriggeredHit>& triggeredHits = de.getHits<JDAQTriggeredHit>();
12575
12576 // http://stackoverflow.com/questions/10735135/reallocation-in-stdvector-after-stdvector-reserve
12577 evt.hits.clear();
12578 evt.hits.reserve(snapshotHits.size());
12579
12580 for (auto& daqhit : snapshotHits ) // JDAQSnapshotHit
12581 {
12582 read( h, daqhit );
12583 h.trig = 0;
12584 evt.hits.push_back( h );
12585 M[ h.dom_id ][ h.channel_id ][ h.tdc ] = &(*evt.hits.rbegin());
12586 }
12587
12588 for (auto& daqtrighit : triggeredHits)
12589 {
12590 Hit* g = M[daqtrighit.getModuleID()][daqtrighit.getPMT()][daqtrighit.getT()];
12591
12592 if (g)
12593 g->trig = daqtrighit.getTriggerMask ();
12594 else
12595 THROW(Exception, "Failed to flag snaphot hit " << (int) daqtrighit.getModuleID() << "." << (int) daqtrighit.getPMT() << " " << daqtrighit.getT());
12596 }
12597}
12598
12599/**
12600 * Read an event from a DAQ time slice.
12601 *
12602 * \param evt evt
12603 * \param ts DAQ time slice
12604 */
12605
12606inline void read( Evt& evt, const JDAQTimeslice& ts )
12607{
12608 evt.run_id = ts.getRunNumber();
12609 evt.det_id = ts.getDetectorID();
12610 evt.frame_index = ts.getFrameIndex();
12611 evt.t.SetSec( ts.getTimesliceStart().getUTCseconds() );
12612 evt.t.SetNanoSec( ts.getTimesliceStart().getUTC16nanosecondcycles() * 16 );
12613 evt.hits.clear();
12614
12615 // a timeslice is a vector of JDAQSuperFrame's, which is a JDAQFrame, which
12616 // is an stl::vector-like object (supporting stl-like iteration.)
12617
12618 Hit h; h.id = 0; h.pmt_id = 0;
12619
12620 for (auto& sf : ts )
12621 {
12622 for (auto& daqhit : sf )
12623 {
12624 read( h, daqhit);
12625 h.dom_id = sf.getModuleID();
12626 evt.hits.push_back(h);
12627 }
12628 }
12629}
12630
12631
12632/**
12633 * Get summary slice from given file with given frame index. This function will
12634 * (re)build an index each time it encounters a new TFile as input.
12635 *
12636 * \param f pointer to ROOT file
12637 * \param frame_index frame index
12638 * \return pointer to summary slice
12639 */
12640
12641inline JDAQSummaryslice* get_summary_slice( TFile* f , int frame_index )
12642{
12643 static TFile* _f = 0;
12644 static TTree* S = 0;
12645 static TBranch* BS = 0;
12646 JDAQSummaryslice *r = 0 ;
12647
12648 if (!f) THROW(Exception, "get_summary_slice called with TFile pointer that is null");
12649
12650
12651 // in principle, event if the pointer-value is the same, we could have been given a new file
12652
12653 if ( !_f || _f->GetUUID().Compare( f->GetUUID() ) != 0 ) // setup for tree reading and build tree index
12654 {
12655 _f = f;
12656
12657 // first we have to deal with the following....
12658 // The streamer of JDAQSummaryFrame needs to know what to do since
12659 // this information is not written to root file.
12660
12661 const char* name = JDAQSummaryslice::Class()->GetName();
12662
12663 JDAQSummaryFrame::ROOT_IO_VERSION = ((TStreamerInfo*)_f -> GetStreamerInfoList()->FindObject(name))->GetClassVersion();
12664
12665 S = (TTree*) _f->Get( TTREE_ONLINE_SUMMARYSLICE );
12666
12667 if (!S)
12668 {
12669 THROW(Exception, "Failed to get summary slice TTree : " << TTREE_ONLINE_SUMMARYSLICE );
12670 }
12671
12672 BS = S->GetBranch( TBRANCH_ONLINE_SUMMARYSLICE );
12673
12674 if (!BS)
12675 {
12676 THROW(Exception, "Failed to get brach :" << TBRANCH_ONLINE_SUMMARYSLICE );
12677 }
12678
12679 std::cout << "building index to lookup summary slices..." << std::endl;
12680 int n = S->BuildIndex("frame_index");
12681 (void) n;
12682 BS->SetAddress( &r );
12683 }
12684
12685 int nbytes = S->GetEntryWithIndex( frame_index ); // returns -1 if not found
12686 if ( nbytes <= 0 )
12687 {
12688 THROW(Exception, "Failed to find summary slice entry with frame_index " << frame_index);
12689 }
12690 return r;
12691}
12692
12693
12694#endif
12695#ifndef __TOOLS_MULTIPLICITY__
12696#define __TOOLS_MULTIPLICITY__
12697
12698#include "km3net-dataformat/offline/Evt.hh"
12699#include "km3net-dataformat/offline/Trk.hh"
12700
12701
12702/**
12703 * Retrieve bundle multiplicity of given event.
12704 *
12705 * \param event event
12706 */
12707inline int get_multiplicity(const Evt& event)
12708{
12709 using namespace std;
12710
12711 // Bundle multiplicity is stored in the `len` member variable for `track_bundle`s.
12712
12713 for ( auto& t : event.mc_trks ) {
12714 if ( t.status == TRK_ST_MUONBUNDLE ) { return (int) t.len; }
12715 }
12716
12717 ostream& out = Exception::getOstream();
12718 out << "get_multiplicity(): The following event does not correspond to a muon bundle:" << endl;
12719 event.print(out);
12720 throw Exception(static_cast<ostringstream&>(out).str());
12721}
12722
12723#endif
12724#ifndef __TOOLS_RECONSTRUCTION__
12725#define __TOOLS_RECONSTRUCTION__
12726
12727#include <limits>
12728#include <algorithm>
12729
12730#include "km3net-dataformat/offline/Hit.hh"
12731#include "km3net-dataformat/offline/Vec.hh"
12732#include "km3net-dataformat/offline/Trk.hh"
12733#include "km3net-dataformat/offline/Evt.hh"
12734#include "km3net-dataformat/offline/Exception.hh"
12735#include "km3net-dataformat/definitions/reconstruction.hh"
12736
12737
12738/**
12739 * \file
12740 *
12741 * Auxiliary methods for selection of reconstructed tracks.
12742 * \author mdejong
12743 */
12744
12745
12746/**
12747 * Range of reconstruction stages.
12748 */
12749struct rec_stages_range {
12750 /**
12751 * Defaut constructor.
12752 */
12753 rec_stages_range() :
12754 lower(0),
12755 upper(std::numeric_limits<int>::max())
12756 {}
12757
12758
12759 /**
12760 * Constructor.
12761 *
12762 * \param lower lower reconstruction stage
12763 * \param upper upper reconstruction stage
12764 */
12765 rec_stages_range(const int lower, const int upper) :
12766 lower(lower),
12767 upper(upper)
12768 {}
12769
12770
12771 /**
12772 * Constructor.
12773 *
12774 * \param stage reconstruction stage
12775 */
12776 rec_stages_range(const int stage) :
12777 lower(stage),
12778 upper(stage)
12779 {}
12780
12781
12782 /**
12783 * Test if given reconstruction stage is within range.
12784 *
12785 * \param stage reconstruction stage
12786 * \return true if within range; else false
12787 */
12788 inline bool operator()(const int stage) const
12789 {
12790 return (stage >= lower && stage <= upper);
12791 }
12792
12793 int lower;
12794 int upper;
12795};
12796
12797
12798/**
12799 * Reconstruction type dependent comparison of track quality.
12800 *
12801 * The specialisation of this class should implement the function object operator
12802 * <pre>
12803 * inline bool operator()(const Trk& first, const Trk& second) const
12804 * </pre>
12805 * and return true if the first track is better then the second track.
12806 */
12807template<int reconstruction_type>
12808struct quality_sorter {
12809 /**
12810 * The default comparison is based on:
12811 * -# number of reconstruction stages, i.e. <tt>Trk::rec_stages.size()</tt> (the larger the better);
12812 * -# likelihood of the final track, i.e. <tt>Trk::lik</tt> (the larger the better).
12813 *
12814 * \param first first track
12815 * \param second second track
12816 * \return true if first track has better quality than second; else false
12817 */
12818 inline bool operator()(const Trk& first, const Trk& second) const
12819 {
12820 if (first.rec_stages.size() == second.rec_stages.size())
12821 return first.lik > second.lik;
12822 else
12823 return first.rec_stages.size() > second.rec_stages.size();
12824 }
12825};
12826
12827
12828/**
12829 * Auxiliary class to test whether given track has specified history.\n
12830 * The history of a track consists of a reconstruction type and a range of application types.
12831 */
12832struct has_history {
12833 /**
12834 * Constructor.
12835 *
12836 * \param type reconstruction type
12837 * \param range range of application types
12838 */
12839 has_history(const int type, const rec_stages_range range) :
12840 type (type),
12841 range(range)
12842 {}
12843
12844 /**
12845 * \param track track
12846 * \return true if given track has specified history; else false
12847 */
12848 inline bool operator()(const Trk& track) const
12849 {
12850 if (track.rec_type == type)
12851 return std::find_if(track.rec_stages.begin(), track.rec_stages.end(), range) != track.rec_stages.end();
12852 else
12853 return false;
12854 }
12855
12856 const int type; //!< reconstruction type
12857 const rec_stages_range range; //!< range of application types
12858};
12859
12860
12861/**
12862 * Test whether given track has muon prefit in history.
12863 *
12864 * \param track track
12865 * \return true if muon prefit in history; else false
12866 */
12867inline bool has_jppmuon_prefit(const Trk& track)
12868{
12869 return ::has_history(JPP_RECONSTRUCTION_TYPE, JMUONPREFIT)(track);
12870}
12871
12872
12873/**
12874 * Test whether given track has muon simplex fit in history.
12875 *
12876 * \param track track
12877 * \return true if muon simplex fit in history; else false
12878 */
12879inline bool has_jppmuon_simplex(const Trk& track)
12880{
12881 return ::has_history(JPP_RECONSTRUCTION_TYPE, JMUONSIMPLEX)(track);
12882}
12883
12884
12885/**
12886 * Test whether given track has muon gandalf fit in history.
12887 *
12888 * \param track track
12889 * \return true if muon gandalf fit in history; else false
12890 */
12891inline bool has_jppmuon_gandalf(const Trk& track)
12892{
12893 return ::has_history(JPP_RECONSTRUCTION_TYPE, JMUONGANDALF)(track);
12894}
12895
12896
12897/**
12898 * Test whether given track has muon energy fit in history.
12899 *
12900 * \param track track
12901 * \return true if muon energy fit in history; else false
12902 */
12903inline bool has_jppmuon_energy(const Trk& track)
12904{
12905 return ::has_history(JPP_RECONSTRUCTION_TYPE, JMUONENERGY)(track);
12906}
12907
12908
12909/**
12910 * Test whether given track has muon start fit in history.
12911 *
12912 * \param track track
12913 * \return true if muon start fit in history; else false
12914 */
12915inline bool has_jppmuon_start(const Trk& track)
12916{
12917 return ::has_history(JPP_RECONSTRUCTION_TYPE, JMUONSTART)(track);
12918}
12919
12920
12921/**
12922 * Test whether given track has default muon fit in history.
12923 *
12924 * \param track track
12925 * \return true if muon fit in history; else false
12926 */
12927inline bool has_jppmuon_fit(const Trk& track)
12928{
12929 return ::has_history(JPP_RECONSTRUCTION_TYPE, rec_stages_range(JMUONBEGIN, JMUONEND))(track);
12930}
12931
12932
12933/**
12934 * Test whether given track has shower prefit in history.
12935 *
12936 * \param track track
12937 * \return true if shower prefit in history; else false
12938 */
12939inline bool has_shower_prefit(const Trk& track)
12940{
12941 return ::has_history(JPP_RECONSTRUCTION_TYPE, JSHOWERPREFIT)(track);
12942}
12943
12944
12945/**
12946 * Test whether given track has shower position fit in history.
12947 *
12948 * \param track track
12949 * \return true if shower position fit in history; else false
12950 */
12951inline bool has_shower_positionfit(const Trk& track)
12952{
12953 return ::has_history(JPP_RECONSTRUCTION_TYPE, JSHOWERPOSITIONFIT)(track);
12954}
12955
12956
12957/**
12958 * Test whether given track has shower complete fit in history.
12959 *
12960 * \param track track
12961 * \return true if shower complete fit in history; else false
12962 */
12963inline bool has_shower_completefit(const Trk& track)
12964{
12965 return ::has_history(JPP_RECONSTRUCTION_TYPE, JSHOWERCOMPLETEFIT)(track);
12966}
12967
12968
12969/**
12970 * Test whether given track has default shower fit in history.
12971 *
12972 * \param track track
12973 * \return true if shower fit in history; else false
12974 */
12975inline bool has_shower_fit(const Trk& track)
12976{
12977 return ::has_history(JPP_RECONSTRUCTION_TYPE, rec_stages_range(JSHOWERBEGIN, JSHOWEREND))(track);
12978}
12979
12980
12981/**
12982 * Test whether given track has default shower fit in history.
12983 *
12984 * \param track track
12985 * \return true if shower fit in history; else false
12986 */
12987inline bool has_aashower_fit(const Trk& track)
12988{
12989 return ::has_history(AANET_RECONSTRUCTION_TYPE, rec_stages_range(AASHOWERBEGIN, AASHOWEREND))(track);
12990}
12991
12992
12993/**
12994 * Test whether given event has a track according selection.\n
12995 * The track selector corresponds to the function operator <tt>bool selector(const Trk&);</tt>.
12996 *
12997 * \param evt event
12998 * \param selector track selector
12999 * \return true if at least one corresponding track; else false
13000 */
13001template<class JTrackSelector_t>
13002inline bool has_reconstructed_track(const Evt& evt, JTrackSelector_t selector)
13003{
13004 return std::find_if(evt.trks.begin(), evt.trks.end(), selector) != evt.trks.end();
13005}
13006
13007
13008/**
13009 * Test whether given event has a track according selection.
13010 *
13011 * \param evt event
13012 * \param range range of application types
13013 * \return true if at least one corresponding track; else false
13014 */
13015template<int reconstruction_type>
13016inline bool has_reconstructed_track(const Evt& evt, const rec_stages_range range = rec_stages_range())
13017{
13018 return ::has_reconstructed_track(evt, ::has_history(reconstruction_type, range));
13019}
13020
13021
13022/**
13023 * Test whether given event has a track with muon reconstruction.
13024 *
13025 * \param evt event
13026 * \return true if at least one reconstructed muon; else false
13027 */
13028inline bool has_reconstructed_jppmuon(const Evt& evt)
13029{
13030 return ::has_reconstructed_track(evt, has_jppmuon_fit);
13031}
13032
13033
13034/**
13035 * Test whether given event has a track with shower reconstruction.
13036 *
13037 * \param evt event
13038 * \return true if at least one reconstructed shower; else false
13039 */
13040inline bool has_reconstructed_jppshower(const Evt& evt)
13041{
13042 return ::has_reconstructed_track(evt, ::has_shower_fit);
13043}
13044
13045
13046/**
13047 * Test whether given event has a track with aashower reconstruction.
13048 *
13049 * \param evt event
13050 * \return true if at least one reconstructed shower; else false
13051 */
13052inline bool has_reconstructed_aashower(const Evt& evt)
13053{
13054 return ::has_reconstructed_track(evt, has_aashower_fit);
13055}
13056
13057
13058/**
13059 * Get best reconstructed track.\n
13060 * The track selector corresponds to the function operator <tt>bool selector(const Trk&);</tt> and
13061 * the track comparator to <tt>bool comparator(const Trk&, const Trk&);</tt>.\n
13062 * This method throws an exception in case no track is present.\n
13063 * The method <tt>has_reconstructed_track</tt> can be used to avoid this exception.
13064 *
13065 * \param evt event
13066 * \param selector track selector
13067 * \param comparator track comparator
13068 * \return track
13069 */
13070template<class JTrackSelector_t, class JQualitySorter_t>
13071inline const Trk& get_best_reconstructed_track(const Evt& evt,
13072 JTrackSelector_t selector,
13073 JQualitySorter_t comparator)
13074{
13075 std::vector<Trk>::const_iterator p = std::find_if(evt.trks.begin(), evt.trks.end(), selector);
13076
13077 for (std::vector<Trk>::const_iterator i = p; i != evt.trks.end(); ++i) {
13078 if (selector(*i) && comparator(*i, *p)) {
13079 p = i;
13080 }
13081 }
13082
13083 if (p != evt.trks.end())
13084 return *p;
13085 else
13086 THROW(Exception, "This event has no reconstructed track with given selector.");
13087}
13088
13089
13090/**
13091 * Get best reconstructed track.
13092 *
13093 * \param evt event
13094 * \param range range of application types
13095 * \return track
13096 */
13097template<int reconstruction_type>
13098inline const Trk& get_best_reconstructed_track(const Evt& evt, const rec_stages_range range = rec_stages_range())
13099{
13100 return get_best_reconstructed_track(evt, ::has_history(reconstruction_type, range), quality_sorter<reconstruction_type>());
13101}
13102
13103
13104/**
13105 * Get best reconstructed muon.
13106 *
13107 * \param evt event
13108 * \return track
13109 */
13110inline const Trk& get_best_reconstructed_jppmuon(const Evt& evt)
13111{
13112 return get_best_reconstructed_track(evt, has_jppmuon_fit, quality_sorter<JPP_RECONSTRUCTION_TYPE>());
13113}
13114
13115
13116/**
13117 * Get best reconstructed shower.
13118 *
13119 * \param evt event
13120 * \return track
13121 */
13122inline const Trk& get_best_reconstructed_jppshower(const Evt& evt)
13123{
13124 return get_best_reconstructed_track(evt, ::has_shower_fit, quality_sorter<JPP_RECONSTRUCTION_TYPE>());
13125}
13126
13127
13128/**
13129 * Get best reconstructed aashower.
13130 *
13131 * \param evt event
13132 * \return track
13133 */
13134inline const Trk& get_best_reconstructed_aashower(const Evt& evt)
13135{
13136 return get_best_reconstructed_track(evt, ::has_aashower_fit, quality_sorter<AANET_RECONSTRUCTION_TYPE>());
13137}
13138
13139#endif
13140#ifndef __TOOLS__TIME_CONVERTER__
13141#define __TOOLS__TIME_CONVERTER__
13142
13143#include "km3net-dataformat/offline/Evt.hh"
13144#include "km3net-dataformat/online/JDAQClock.hh"
13145#include "km3net-dataformat/online/JDAQChronometer.hh"
13146
13147
13148/**
13149 * \file
13150 * Auxiliary include file for time conversion between DAQ/trigger hit and Monte Carlo hit.
13151 *
13152 * \author mdejong
13153 */
13154
13155/**
13156 * Auxiliary class to convert DAQ hit time to/from Monte Carlo hit time.
13157 */
13158class time_converter
13159{
13160public:
13161 /**
13162 * Default constructor.
13163 */
13164 time_converter() :
13165 __t0(0.0),
13166 __t1(0.0)
13167 {}
13168
13169
13170 /**
13171 * Constructor.
13172 * Note that this constructor should only be used after incorporation of KM3NETDAQ::JDAQEvent.
13173 *
13174 * \param event event
13175 */
13176 time_converter(const Evt& event) :
13177 __t0(event.mc_t),
13178 __t1(getTimeOfRTS(event.frame_index))
13179 {}
13180
13181
13182 /**
13183 * Constructor.
13184 *
13185 * \param event Monte Carlo event
13186 * \param chronometer DAQ chronometer
13187 */
13188 time_converter(const Evt& event,
13189 const JDAQChronometer& chronometer) :
13190 __t0(event.mc_t),
13191 __t1(getTimeOfRTS(chronometer))
13192 {}
13193
13194
13195 /**
13196 * Get DAQ/trigger time minus Monte Carlo time.
13197 *
13198 * \return time difference [ns]
13199 */
13200 double getTime() const
13201 {
13202 return __t1 - __t0;
13203 }
13204
13205
13206 /**
13207 * Get Monte Carlo time minus DAQ/trigger time.
13208 *
13209 * \return time difference [ns]
13210 */
13211 double putTime() const
13212 {
13213 return __t0 - __t1;
13214 }
13215
13216
13217 /**
13218 * Get Monte Carlo hit time.
13219 *
13220 * \param t0 DAQ/trigger hit time [ns]
13221 * \return Monte Carlo hit time [ns]
13222 */
13223 double getTime(const double t0) const
13224 {
13225 return t0 + __t1 - __t0;
13226 }
13227
13228
13229 /**
13230 * Get DAQ hit time.
13231 *
13232 * \param t0 Monte Carlo hit time [ns]
13233 * \return DAQ/trigger hit time [ns]
13234 */
13235 double putTime(const double t0) const
13236 {
13237 return t0 - __t1 + __t0;
13238 }
13239
13240protected:
13241 double __t0; // Monte Carlo event time [ns]
13242 double __t1; // DAQ RTS [ns]
13243};
13244
13245#endif
13246
13247#undef _BACKWARD_BACKWARD_WARNING_H
13248)DICTPAYLOAD";
13249 static const char* classesHeaders[] = {
13250"AAObject", payloadCode, "@",
13251"Evt", payloadCode, "@",
13252"Head", payloadCode, "@",
13253"Hit", payloadCode, "@",
13254"KM3NETDAQ::JDAQAbstractPreamble", payloadCode, "@",
13255"KM3NETDAQ::JDAQChronometer", payloadCode, "@",
13256"KM3NETDAQ::JDAQEvent", payloadCode, "@",
13257"KM3NETDAQ::JDAQEventHeader", payloadCode, "@",
13258"KM3NETDAQ::JDAQFrame", payloadCode, "@",
13259"KM3NETDAQ::JDAQFrameStatus", payloadCode, "@",
13260"KM3NETDAQ::JDAQHeader", payloadCode, "@",
13261"KM3NETDAQ::JDAQHit", payloadCode, "@",
13262"KM3NETDAQ::JDAQKeyHit", payloadCode, "@",
13263"KM3NETDAQ::JDAQModuleIdentifier", payloadCode, "@",
13264"KM3NETDAQ::JDAQPMTIdentifier", payloadCode, "@",
13265"KM3NETDAQ::JDAQPreamble", payloadCode, "@",
13266"KM3NETDAQ::JDAQRate", payloadCode, "@",
13267"KM3NETDAQ::JDAQSummaryFrame", payloadCode, "@",
13268"KM3NETDAQ::JDAQSummaryslice", payloadCode, "@",
13269"KM3NETDAQ::JDAQSummarysliceHeader", payloadCode, "@",
13270"KM3NETDAQ::JDAQSuperFrame", payloadCode, "@",
13271"KM3NETDAQ::JDAQSuperFrameHeader", payloadCode, "@",
13272"KM3NETDAQ::JDAQTimeslice", payloadCode, "@",
13273"KM3NETDAQ::JDAQTimesliceHeader", payloadCode, "@",
13274"KM3NETDAQ::JDAQTimesliceL0", payloadCode, "@",
13275"KM3NETDAQ::JDAQTimesliceL1", payloadCode, "@",
13276"KM3NETDAQ::JDAQTimesliceL2", payloadCode, "@",
13277"KM3NETDAQ::JDAQTimesliceSN", payloadCode, "@",
13278"KM3NETDAQ::JDAQTriggerCounter", payloadCode, "@",
13279"KM3NETDAQ::JDAQTriggerMask", payloadCode, "@",
13280"KM3NETDAQ::JDAQTriggeredHit", payloadCode, "@",
13281"KM3NETDAQ::JDAQUTCExtended", payloadCode, "@",
13282"MultiHead", payloadCode, "@",
13283"Trk", payloadCode, "@",
13284"Vec", payloadCode, "@",
13285nullptr
13286};
13287 static bool isInitialized = false;
13288 if (!isInitialized) {
13289 TROOT::RegisterModule("G__KM3NeTROOT",
13290 headers, includePaths, payloadCode, fwdDeclCode,
13291 TriggerDictionaryInitialization_G__KM3NeTROOT_Impl, {}, classesHeaders, /*hasCxxModule*/false);
13292 isInitialized = true;
13293 }
13294 }
13295 static struct DictInit {
13296 DictInit() {
13297 TriggerDictionaryInitialization_G__KM3NeTROOT_Impl();
13298 }
13299 } __TheDictionaryInitializer;
13300}
13301void TriggerDictionaryInitialization_G__KM3NeTROOT() {
13302 TriggerDictionaryInitialization_G__KM3NeTROOT_Impl();
13303}
KM3NETDAQ::JDAQAbstractPreamble
Simple data structure for the DAQ preamble required for a correct calculation of the object size for ...
Definition JDAQAbstractPreamble.hh:21
KM3NETDAQ::JDAQHit
Hit data structure.
Definition JDAQHit.hh:35
KM3NETDAQ::JDAQRate
Data storage class for rate measurement of one PMT.
Definition JDAQSummaryFrame.hh:36
KM3NETDAQ::JDAQSummaryFrame
Data storage class for rate measurements of all PMTs in one module.
Definition JDAQSummaryFrame.hh:335
KM3NETDAQ::JDAQSuperFrame
Data frame of one optical module.
Definition JDAQSuperFrame.hh:26
KM3NETDAQ::JDAQTriggerCounter
Auxiliary class to count triggers.
Definition JDAQTriggerCounter.hh:23
KM3NETDAQ::JDAQTriggerMask
Auxiliary class for trigger mask.
Definition JDAQTriggerMask.hh:48
KM3NETDAQ::JDAQUTCExtended
Data structure for UTC time.
Definition JDAQUTCExtended.hh:23
KM3NETDAQ
KM3NeT DAQ data structures and auxiliaries.
Definition DataQueue.cc:39
ROOT::GenerateInitInstanceLocal
static TGenericClassInfo * GenerateInitInstanceLocal(const ::KM3NETDAQ::JDAQAbstractPreamble *)
Definition G__KM3NeTROOT.cc:95
ROOT::destruct_KM3NETDAQcLcLJDAQKeyHit
static void destruct_KM3NETDAQcLcLJDAQKeyHit(void *p)
Definition G__KM3NeTROOT.cc:2829
ROOT::deleteArray_KM3NETDAQcLcLJDAQHeader
static void deleteArray_KM3NETDAQcLcLJDAQHeader(void *p)
Definition G__KM3NeTROOT.cc:2625
ROOT::destruct_KM3NETDAQcLcLJDAQTimeslice
static void destruct_KM3NETDAQcLcLJDAQTimeslice(void *p)
Definition G__KM3NeTROOT.cc:3184
ROOT::deleteArray_Vec
static void deleteArray_Vec(void *p)
Definition G__KM3NeTROOT.cc:3422
ROOT::destruct_KM3NETDAQcLcLJDAQFrame
static void destruct_KM3NETDAQcLcLJDAQFrame(void *p)
Definition G__KM3NeTROOT.cc:2928
ROOT::streamer_KM3NETDAQcLcLJDAQSummaryFrame
static void streamer_KM3NETDAQcLcLJDAQSummaryFrame(TBuffer &buf, void *obj)
Definition G__KM3NeTROOT.cc:3080
ROOT::destruct_KM3NETDAQcLcLJDAQTimesliceL1
static void destruct_KM3NETDAQcLcLJDAQTimesliceL1(void *p)
Definition G__KM3NeTROOT.cc:3254
ROOT::destruct_Hit
static void destruct_Hit(void *p)
Definition G__KM3NeTROOT.cc:3458
ROOT::destruct_Vec
static void destruct_Vec(void *p)
Definition G__KM3NeTROOT.cc:3425
ROOT::newArray_KM3NETDAQcLcLJDAQSummaryslice
static void * newArray_KM3NETDAQcLcLJDAQSummaryslice(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3349
ROOT::new_KM3NETDAQcLcLJDAQSummaryFrame
static void * new_KM3NETDAQcLcLJDAQSummaryFrame(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3062
ROOT::deleteArray_AAObject
static void deleteArray_AAObject(void *p)
Definition G__KM3NeTROOT.cc:3389
ROOT::deleteArray_KM3NETDAQcLcLJDAQChronometer
static void deleteArray_KM3NETDAQcLcLJDAQChronometer(void *p)
Definition G__KM3NeTROOT.cc:2565
ROOT::delete_KM3NETDAQcLcLJDAQHit
static void delete_KM3NETDAQcLcLJDAQHit(void *p)
Definition G__KM3NeTROOT.cc:2748
ROOT::new_vectorlEHitgR
static void * new_vectorlEHitgR(void *p=nullptr)
Definition G__KM3NeTROOT.cc:4162
ROOT::new_vectorlEKM3NETDAQcLcLJDAQSuperFramegR
static void * new_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3967
ROOT::newArray_KM3NETDAQcLcLJDAQEvent
static void * newArray_KM3NETDAQcLcLJDAQEvent(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:2883
ROOT::new_KM3NETDAQcLcLJDAQFrame
static void * new_KM3NETDAQcLcLJDAQFrame(void *p=nullptr)
Definition G__KM3NeTROOT.cc:2915
ROOT::newArray_KM3NETDAQcLcLJDAQTriggerCounter
static void * newArray_KM3NETDAQcLcLJDAQTriggerCounter(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:2653
ROOT::new_KM3NETDAQcLcLJDAQUTCExtended
static void * new_KM3NETDAQcLcLJDAQUTCExtended(void *p=nullptr)
Definition G__KM3NeTROOT.cc:2520
ROOT::new_maplEstringcOstringgR
static void * new_maplEstringcOstringgR(void *p=nullptr)
Definition G__KM3NeTROOT.cc:4292
ROOT::new_vectorlETrkgR
static void * new_vectorlETrkgR(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3837
ROOT::delete_AAObject
static void delete_AAObject(void *p)
Definition G__KM3NeTROOT.cc:3386
ROOT::new_Vec
static void * new_Vec(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3412
ROOT::deleteArray_vectorlETrkgR
static void deleteArray_vectorlETrkgR(void *p)
Definition G__KM3NeTROOT.cc:3847
ROOT::newArray_Trk
static void * newArray_Trk(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3481
ROOT::delete_KM3NETDAQcLcLJDAQSuperFrame
static void delete_KM3NETDAQcLcLJDAQSuperFrame(void *p)
Definition G__KM3NeTROOT.cc:3027
ROOT::delete_KM3NETDAQcLcLJDAQKeyHit
static void delete_KM3NETDAQcLcLJDAQKeyHit(void *p)
Definition G__KM3NeTROOT.cc:2823
ROOT::newArray_KM3NETDAQcLcLJDAQPreamble
static void * newArray_KM3NETDAQcLcLJDAQPreamble(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:2579
ROOT::new_KM3NETDAQcLcLJDAQPreamble
static void * new_KM3NETDAQcLcLJDAQPreamble(void *p=nullptr)
Definition G__KM3NeTROOT.cc:2576
ROOT::new_KM3NETDAQcLcLJDAQKeyHit
static void * new_KM3NETDAQcLcLJDAQKeyHit(void *p=nullptr)
Definition G__KM3NeTROOT.cc:2816
ROOT::destruct_vectorlEstringgR
static void destruct_vectorlEstringgR(void *p)
Definition G__KM3NeTROOT.cc:3655
ROOT::vectorlEstringgR_TClassManip
static void vectorlEstringgR_TClassManip(TClass *)
Definition G__KM3NeTROOT.cc:3635
ROOT::destruct_Trk
static void destruct_Trk(void *p)
Definition G__KM3NeTROOT.cc:3491
ROOT::newArray_KM3NETDAQcLcLJDAQTriggeredHit
static void * newArray_KM3NETDAQcLcLJDAQTriggeredHit(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:2844
ROOT::deleteArray_KM3NETDAQcLcLJDAQAbstractPreamble
static void deleteArray_KM3NETDAQcLcLJDAQAbstractPreamble(void *p)
Definition G__KM3NeTROOT.cc:2491
ROOT::vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_TClassManip
static void vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_TClassManip(TClass *)
Definition G__KM3NeTROOT.cc:4025
ROOT::streamer_KM3NETDAQcLcLJDAQPreamble
static void streamer_KM3NETDAQcLcLJDAQPreamble(TBuffer &buf, void *obj)
Definition G__KM3NeTROOT.cc:2594
ROOT::newArray_vectorlETrkgR
static void * newArray_vectorlETrkgR(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3840
ROOT::newArray_KM3NETDAQcLcLJDAQPMTIdentifier
static void * newArray_KM3NETDAQcLcLJDAQPMTIdentifier(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:2794
ROOT::newArray_KM3NETDAQcLcLJDAQTimesliceL0
static void * newArray_KM3NETDAQcLcLJDAQTimesliceL0(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3209
ROOT::destruct_KM3NETDAQcLcLJDAQTimesliceHeader
static void destruct_KM3NETDAQcLcLJDAQTimesliceHeader(void *p)
Definition G__KM3NeTROOT.cc:3149
ROOT::KM3NETDAQcLcLJDAQRate_Dictionary
static TClass * KM3NETDAQcLcLJDAQRate_Dictionary()
Definition G__KM3NeTROOT.cc:710
ROOT::newArray_KM3NETDAQcLcLJDAQSuperFrame
static void * newArray_KM3NETDAQcLcLJDAQSuperFrame(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3023
ROOT::KM3NETDAQcLcLJDAQRate_TClassManip
static void KM3NETDAQcLcLJDAQRate_TClassManip(TClass *)
Definition G__KM3NeTROOT.cc:716
ROOT::maplEstringcOstringgR_Dictionary
static TClass * maplEstringcOstringgR_Dictionary()
Definition G__KM3NeTROOT.cc:4279
ROOT::vectorlEHitgR_TClassManip
static void vectorlEHitgR_TClassManip(TClass *)
Definition G__KM3NeTROOT.cc:4155
ROOT::delete_vectorlEKM3NETDAQcLcLJDAQSuperFramegR
static void delete_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p)
Definition G__KM3NeTROOT.cc:3974
ROOT::destruct_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR
static void destruct_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p)
Definition G__KM3NeTROOT.cc:4045
ROOT::delete_KM3NETDAQcLcLJDAQTimeslice
static void delete_KM3NETDAQcLcLJDAQTimeslice(void *p)
Definition G__KM3NeTROOT.cc:3178
ROOT::newArray_vectorlEHitgR
static void * newArray_vectorlEHitgR(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:4165
ROOT::maplEstringcOstringgR_TClassManip
static void maplEstringcOstringgR_TClassManip(TClass *)
Definition G__KM3NeTROOT.cc:4285
ROOT::deleteArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR
static void deleteArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p)
Definition G__KM3NeTROOT.cc:3977
ROOT::newArray_Vec
static void * newArray_Vec(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3415
ROOT::deleteArray_KM3NETDAQcLcLJDAQHit
static void deleteArray_KM3NETDAQcLcLJDAQHit(void *p)
Definition G__KM3NeTROOT.cc:2751
ROOT::deleteArray_KM3NETDAQcLcLJDAQEventHeader
static void deleteArray_KM3NETDAQcLcLJDAQEventHeader(void *p)
Definition G__KM3NeTROOT.cc:2730
ROOT::deleteArray_KM3NETDAQcLcLJDAQSuperFrame
static void deleteArray_KM3NETDAQcLcLJDAQSuperFrame(void *p)
Definition G__KM3NeTROOT.cc:3030
ROOT::deleteArray_KM3NETDAQcLcLJDAQTimesliceL0
static void deleteArray_KM3NETDAQcLcLJDAQTimesliceL0(void *p)
Definition G__KM3NeTROOT.cc:3216
ROOT::newArray_KM3NETDAQcLcLJDAQAbstractPreamble
static void * newArray_KM3NETDAQcLcLJDAQAbstractPreamble(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:2484
ROOT::newArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR
static void * newArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3905
ROOT::deleteArray_KM3NETDAQcLcLJDAQPreamble
static void deleteArray_KM3NETDAQcLcLJDAQPreamble(void *p)
Definition G__KM3NeTROOT.cc:2586
ROOT::R__UseDummy
R__UseDummy(_R__UNIQUE_DICT_(Init))
ROOT::newArray_KM3NETDAQcLcLJDAQRate
static void * newArray_KM3NETDAQcLcLJDAQRate(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3044
ROOT::destruct_KM3NETDAQcLcLJDAQHit
static void destruct_KM3NETDAQcLcLJDAQHit(void *p)
Definition G__KM3NeTROOT.cc:2754
ROOT::deleteArray_vectorlEstringgR
static void deleteArray_vectorlEstringgR(void *p)
Definition G__KM3NeTROOT.cc:3652
ROOT::destruct_KM3NETDAQcLcLJDAQTimesliceL2
static void destruct_KM3NETDAQcLcLJDAQTimesliceL2(void *p)
Definition G__KM3NeTROOT.cc:3289
ROOT::destruct_KM3NETDAQcLcLJDAQSummarysliceHeader
static void destruct_KM3NETDAQcLcLJDAQSummarysliceHeader(void *p)
Definition G__KM3NeTROOT.cc:3114
ROOT::newArray_KM3NETDAQcLcLJDAQSummarysliceHeader
static void * newArray_KM3NETDAQcLcLJDAQSummarysliceHeader(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3104
ROOT::deleteArray_KM3NETDAQcLcLJDAQPMTIdentifier
static void deleteArray_KM3NETDAQcLcLJDAQPMTIdentifier(void *p)
Definition G__KM3NeTROOT.cc:2801
ROOT::newArray_KM3NETDAQcLcLJDAQHit
static void * newArray_KM3NETDAQcLcLJDAQHit(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:2744
ROOT::deleteArray_KM3NETDAQcLcLJDAQTimeslice
static void deleteArray_KM3NETDAQcLcLJDAQTimeslice(void *p)
Definition G__KM3NeTROOT.cc:3181
ROOT::delete_KM3NETDAQcLcLJDAQSummaryslice
static void delete_KM3NETDAQcLcLJDAQSummaryslice(void *p)
Definition G__KM3NeTROOT.cc:3353
ROOT::deleteArray_KM3NETDAQcLcLJDAQUTCExtended
static void deleteArray_KM3NETDAQcLcLJDAQUTCExtended(void *p)
Definition G__KM3NeTROOT.cc:2530
ROOT::destruct_KM3NETDAQcLcLJDAQRate
static void destruct_KM3NETDAQcLcLJDAQRate(void *p)
Definition G__KM3NeTROOT.cc:3054
ROOT::vectorlEHitgR_Dictionary
static TClass * vectorlEHitgR_Dictionary()
Definition G__KM3NeTROOT.cc:4149
ROOT::new_KM3NETDAQcLcLJDAQSummarysliceHeader
static void * new_KM3NETDAQcLcLJDAQSummarysliceHeader(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3101
ROOT::delete_KM3NETDAQcLcLJDAQChronometer
static void delete_KM3NETDAQcLcLJDAQChronometer(void *p)
Definition G__KM3NeTROOT.cc:2562
ROOT::newArray_MultiHead
static void * newArray_MultiHead(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3580
ROOT::delete_vectorlEdoublegR
static void delete_vectorlEdoublegR(void *p)
Definition G__KM3NeTROOT.cc:3779
ROOT::vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR_TClassManip
static void vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR_TClassManip(TClass *)
Definition G__KM3NeTROOT.cc:3895
ROOT::delete_MultiHead
static void delete_MultiHead(void *p)
Definition G__KM3NeTROOT.cc:3584
ROOT::delete_KM3NETDAQcLcLJDAQUTCExtended
static void delete_KM3NETDAQcLcLJDAQUTCExtended(void *p)
Definition G__KM3NeTROOT.cc:2527
ROOT::streamer_KM3NETDAQcLcLJDAQModuleIdentifier
static void streamer_KM3NETDAQcLcLJDAQModuleIdentifier(TBuffer &buf, void *obj)
Definition G__KM3NeTROOT.cc:2784
ROOT::new_KM3NETDAQcLcLJDAQEvent
static void * new_KM3NETDAQcLcLJDAQEvent(void *p=nullptr)
Definition G__KM3NeTROOT.cc:2880
ROOT::delete_maplEstringcOstringgR
static void delete_maplEstringcOstringgR(void *p)
Definition G__KM3NeTROOT.cc:4299
ROOT::deleteArray_KM3NETDAQcLcLJDAQTimesliceL1
static void deleteArray_KM3NETDAQcLcLJDAQTimesliceL1(void *p)
Definition G__KM3NeTROOT.cc:3251
ROOT::streamer_KM3NETDAQcLcLJDAQAbstractPreamble
static void streamer_KM3NETDAQcLcLJDAQAbstractPreamble(TBuffer &buf, void *obj)
Definition G__KM3NeTROOT.cc:2499
ROOT::delete_Evt
static void delete_Evt(void *p)
Definition G__KM3NeTROOT.cc:3518
ROOT::destruct_vectorlEHeadgR
static void destruct_vectorlEHeadgR(void *p)
Definition G__KM3NeTROOT.cc:4240
ROOT::deleteArray_KM3NETDAQcLcLJDAQKeyHit
static void deleteArray_KM3NETDAQcLcLJDAQKeyHit(void *p)
Definition G__KM3NeTROOT.cc:2826
ROOT::newArray_KM3NETDAQcLcLJDAQTimesliceL1
static void * newArray_KM3NETDAQcLcLJDAQTimesliceL1(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3244
ROOT::destruct_KM3NETDAQcLcLJDAQAbstractPreamble
static void destruct_KM3NETDAQcLcLJDAQAbstractPreamble(void *p)
Definition G__KM3NeTROOT.cc:2494
ROOT::new_Trk
static void * new_Trk(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3478
ROOT::newArray_AAObject
static void * newArray_AAObject(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3382
ROOT::destruct_KM3NETDAQcLcLJDAQFrameStatus
static void destruct_KM3NETDAQcLcLJDAQFrameStatus(void *p)
Definition G__KM3NeTROOT.cc:2963
ROOT::new_KM3NETDAQcLcLJDAQSuperFrame
static void * new_KM3NETDAQcLcLJDAQSuperFrame(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3020
ROOT::deleteArray_Evt
static void deleteArray_Evt(void *p)
Definition G__KM3NeTROOT.cc:3521
ROOT::delete_KM3NETDAQcLcLJDAQTimesliceL1
static void delete_KM3NETDAQcLcLJDAQTimesliceL1(void *p)
Definition G__KM3NeTROOT.cc:3248
ROOT::new_KM3NETDAQcLcLJDAQModuleIdentifier
static void * new_KM3NETDAQcLcLJDAQModuleIdentifier(void *p=nullptr)
Definition G__KM3NeTROOT.cc:2766
ROOT::new_KM3NETDAQcLcLJDAQRate
static void * new_KM3NETDAQcLcLJDAQRate(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3041
ROOT::new_KM3NETDAQcLcLJDAQEventHeader
static void * new_KM3NETDAQcLcLJDAQEventHeader(void *p=nullptr)
Definition G__KM3NeTROOT.cc:2720
ROOT::newArray_maplEstringcOstringgR
static void * newArray_maplEstringcOstringgR(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:4295
ROOT::delete_KM3NETDAQcLcLJDAQFrameStatus
static void delete_KM3NETDAQcLcLJDAQFrameStatus(void *p)
Definition G__KM3NeTROOT.cc:2957
ROOT::GenerateInitInstance
TGenericClassInfo * GenerateInitInstance(const ::KM3NETDAQ::JDAQAbstractPreamble *)
Definition G__KM3NeTROOT.cc:112
ROOT::delete_Head
static void delete_Head(void *p)
Definition G__KM3NeTROOT.cc:3551
ROOT::vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR_Dictionary
static TClass * vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR_Dictionary()
Definition G__KM3NeTROOT.cc:3889
ROOT::destruct_KM3NETDAQcLcLJDAQEvent
static void destruct_KM3NETDAQcLcLJDAQEvent(void *p)
Definition G__KM3NeTROOT.cc:2893
ROOT::deleteArray_KM3NETDAQcLcLJDAQTimesliceL2
static void deleteArray_KM3NETDAQcLcLJDAQTimesliceL2(void *p)
Definition G__KM3NeTROOT.cc:3286
ROOT::delete_KM3NETDAQcLcLJDAQEvent
static void delete_KM3NETDAQcLcLJDAQEvent(void *p)
Definition G__KM3NeTROOT.cc:2887
ROOT::vectorlEdoublegR_TClassManip
static void vectorlEdoublegR_TClassManip(TClass *)
Definition G__KM3NeTROOT.cc:3765
ROOT::newArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR
static void * newArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:4100
ROOT::new_vectorlEstringgR
static void * new_vectorlEstringgR(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3642
ROOT::newArray_KM3NETDAQcLcLJDAQTimeslice
static void * newArray_KM3NETDAQcLcLJDAQTimeslice(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3174
ROOT::streamer_KM3NETDAQcLcLJDAQHit
static void streamer_KM3NETDAQcLcLJDAQHit(TBuffer &buf, void *obj)
Definition G__KM3NeTROOT.cc:2759
ROOT::delete_Vec
static void delete_Vec(void *p)
Definition G__KM3NeTROOT.cc:3419
ROOT::delete_KM3NETDAQcLcLJDAQSuperFrameHeader
static void delete_KM3NETDAQcLcLJDAQSuperFrameHeader(void *p)
Definition G__KM3NeTROOT.cc:2992
ROOT::deleteArray_KM3NETDAQcLcLJDAQTimesliceHeader
static void deleteArray_KM3NETDAQcLcLJDAQTimesliceHeader(void *p)
Definition G__KM3NeTROOT.cc:3146
ROOT::destruct_KM3NETDAQcLcLJDAQChronometer
static void destruct_KM3NETDAQcLcLJDAQChronometer(void *p)
Definition G__KM3NeTROOT.cc:2568
ROOT::vectorlEKM3NETDAQcLcLJDAQSuperFramegR_TClassManip
static void vectorlEKM3NETDAQcLcLJDAQSuperFramegR_TClassManip(TClass *)
Definition G__KM3NeTROOT.cc:3960
ROOT::delete_vectorlEintgR
static void delete_vectorlEintgR(void *p)
Definition G__KM3NeTROOT.cc:3714
ROOT::newArray_KM3NETDAQcLcLJDAQTimesliceHeader
static void * newArray_KM3NETDAQcLcLJDAQTimesliceHeader(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3139
ROOT::delete_Trk
static void delete_Trk(void *p)
Definition G__KM3NeTROOT.cc:3485
ROOT::vectorlEstringgR_Dictionary
static TClass * vectorlEstringgR_Dictionary()
Definition G__KM3NeTROOT.cc:3629
ROOT::delete_vectorlEHeadgR
static void delete_vectorlEHeadgR(void *p)
Definition G__KM3NeTROOT.cc:4234
ROOT::new_KM3NETDAQcLcLJDAQAbstractPreamble
static void * new_KM3NETDAQcLcLJDAQAbstractPreamble(void *p=nullptr)
Definition G__KM3NeTROOT.cc:2481
ROOT::newArray_Hit
static void * newArray_Hit(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3448
ROOT::deleteArray_Hit
static void deleteArray_Hit(void *p)
Definition G__KM3NeTROOT.cc:3455
ROOT::new_KM3NETDAQcLcLJDAQTimesliceL2
static void * new_KM3NETDAQcLcLJDAQTimesliceL2(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3276
ROOT::destruct_KM3NETDAQcLcLJDAQSuperFrameHeader
static void destruct_KM3NETDAQcLcLJDAQSuperFrameHeader(void *p)
Definition G__KM3NeTROOT.cc:2998
ROOT::delete_vectorlEHitgR
static void delete_vectorlEHitgR(void *p)
Definition G__KM3NeTROOT.cc:4169
ROOT::deleteArray_vectorlEintgR
static void deleteArray_vectorlEintgR(void *p)
Definition G__KM3NeTROOT.cc:3717
ROOT::destruct_maplEstringcOstringgR
static void destruct_maplEstringcOstringgR(void *p)
Definition G__KM3NeTROOT.cc:4305
ROOT::new_KM3NETDAQcLcLJDAQTimesliceSN
static void * new_KM3NETDAQcLcLJDAQTimesliceSN(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3311
ROOT::destruct_KM3NETDAQcLcLJDAQSummaryslice
static void destruct_KM3NETDAQcLcLJDAQSummaryslice(void *p)
Definition G__KM3NeTROOT.cc:3359
ROOT::deleteArray_KM3NETDAQcLcLJDAQSummarysliceHeader
static void deleteArray_KM3NETDAQcLcLJDAQSummarysliceHeader(void *p)
Definition G__KM3NeTROOT.cc:3111
ROOT::newArray_vectorlEintgR
static void * newArray_vectorlEintgR(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3710
ROOT::delete_Hit
static void delete_Hit(void *p)
Definition G__KM3NeTROOT.cc:3452
ROOT::delete_KM3NETDAQcLcLJDAQModuleIdentifier
static void delete_KM3NETDAQcLcLJDAQModuleIdentifier(void *p)
Definition G__KM3NeTROOT.cc:2773
ROOT::new_vectorlEdoublegR
static void * new_vectorlEdoublegR(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3772
ROOT::destruct_KM3NETDAQcLcLJDAQSuperFrame
static void destruct_KM3NETDAQcLcLJDAQSuperFrame(void *p)
Definition G__KM3NeTROOT.cc:3033
ROOT::delete_KM3NETDAQcLcLJDAQTriggerMask
static void delete_KM3NETDAQcLcLJDAQTriggerMask(void *p)
Definition G__KM3NeTROOT.cc:2692
ROOT::deleteArray_MultiHead
static void deleteArray_MultiHead(void *p)
Definition G__KM3NeTROOT.cc:3587
ROOT::destruct_Head
static void destruct_Head(void *p)
Definition G__KM3NeTROOT.cc:3557
ROOT::new_vectorlEKM3NETDAQcLcLJDAQKeyHitgR
static void * new_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p=nullptr)
Definition G__KM3NeTROOT.cc:4097
ROOT::new_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR
static void * new_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3902
ROOT::new_KM3NETDAQcLcLJDAQTriggerCounter
static void * new_KM3NETDAQcLcLJDAQTriggerCounter(void *p=nullptr)
Definition G__KM3NeTROOT.cc:2650
ROOT::delete_KM3NETDAQcLcLJDAQRate
static void delete_KM3NETDAQcLcLJDAQRate(void *p)
Definition G__KM3NeTROOT.cc:3048
ROOT::delete_KM3NETDAQcLcLJDAQEventHeader
static void delete_KM3NETDAQcLcLJDAQEventHeader(void *p)
Definition G__KM3NeTROOT.cc:2727
ROOT::destruct_MultiHead
static void destruct_MultiHead(void *p)
Definition G__KM3NeTROOT.cc:3590
ROOT::streamer_KM3NETDAQcLcLJDAQKeyHit
static void streamer_KM3NETDAQcLcLJDAQKeyHit(TBuffer &buf, void *obj)
Definition G__KM3NeTROOT.cc:2834
ROOT::newArray_Evt
static void * newArray_Evt(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3514
ROOT::newArray_KM3NETDAQcLcLJDAQTimesliceL2
static void * newArray_KM3NETDAQcLcLJDAQTimesliceL2(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3279
ROOT::deleteArray_vectorlEdoublegR
static void deleteArray_vectorlEdoublegR(void *p)
Definition G__KM3NeTROOT.cc:3782
ROOT::destruct_KM3NETDAQcLcLJDAQTimesliceL0
static void destruct_KM3NETDAQcLcLJDAQTimesliceL0(void *p)
Definition G__KM3NeTROOT.cc:3219
ROOT::new_vectorlEHeadgR
static void * new_vectorlEHeadgR(void *p=nullptr)
Definition G__KM3NeTROOT.cc:4227
ROOT::streamer_KM3NETDAQcLcLJDAQTriggeredHit
static void streamer_KM3NETDAQcLcLJDAQTriggeredHit(TBuffer &buf, void *obj)
Definition G__KM3NeTROOT.cc:2859
ROOT::destruct_vectorlETrkgR
static void destruct_vectorlETrkgR(void *p)
Definition G__KM3NeTROOT.cc:3850
ROOT::new_Hit
static void * new_Hit(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3445
ROOT::deleteArray_maplEstringcOstringgR
static void deleteArray_maplEstringcOstringgR(void *p)
Definition G__KM3NeTROOT.cc:4302
ROOT::newArray_KM3NETDAQcLcLJDAQTriggerMask
static void * newArray_KM3NETDAQcLcLJDAQTriggerMask(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:2688
ROOT::vectorlETrkgR_Dictionary
static TClass * vectorlETrkgR_Dictionary()
Definition G__KM3NeTROOT.cc:3824
ROOT::new_Evt
static void * new_Evt(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3511
ROOT::_R__UNIQUE_DICT_
::ROOT::TGenericClassInfo * _R__UNIQUE_DICT_(Init)
ROOT::new_KM3NETDAQcLcLJDAQTriggeredHit
static void * new_KM3NETDAQcLcLJDAQTriggeredHit(void *p=nullptr)
Definition G__KM3NeTROOT.cc:2841
ROOT::vectorlETrkgR_TClassManip
static void vectorlETrkgR_TClassManip(TClass *)
Definition G__KM3NeTROOT.cc:3830
ROOT::new_KM3NETDAQcLcLJDAQTriggerMask
static void * new_KM3NETDAQcLcLJDAQTriggerMask(void *p=nullptr)
Definition G__KM3NeTROOT.cc:2685
ROOT::destruct_vectorlEdoublegR
static void destruct_vectorlEdoublegR(void *p)
Definition G__KM3NeTROOT.cc:3785
ROOT::vectorlEintgR_TClassManip
static void vectorlEintgR_TClassManip(TClass *)
Definition G__KM3NeTROOT.cc:3700
ROOT::deleteArray_KM3NETDAQcLcLJDAQRate
static void deleteArray_KM3NETDAQcLcLJDAQRate(void *p)
Definition G__KM3NeTROOT.cc:3051
ROOT::destruct_vectorlEHitgR
static void destruct_vectorlEHitgR(void *p)
Definition G__KM3NeTROOT.cc:4175
ROOT::destruct_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR
static void destruct_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p)
Definition G__KM3NeTROOT.cc:3915
ROOT::deleteArray_vectorlEHeadgR
static void deleteArray_vectorlEHeadgR(void *p)
Definition G__KM3NeTROOT.cc:4237
ROOT::newArray_KM3NETDAQcLcLJDAQSuperFrameHeader
static void * newArray_KM3NETDAQcLcLJDAQSuperFrameHeader(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:2988
ROOT::new_KM3NETDAQcLcLJDAQHit
static void * new_KM3NETDAQcLcLJDAQHit(void *p=nullptr)
Definition G__KM3NeTROOT.cc:2741
ROOT::vectorlEKM3NETDAQcLcLJDAQKeyHitgR_TClassManip
static void vectorlEKM3NETDAQcLcLJDAQKeyHitgR_TClassManip(TClass *)
Definition G__KM3NeTROOT.cc:4090
ROOT::newArray_KM3NETDAQcLcLJDAQTimesliceSN
static void * newArray_KM3NETDAQcLcLJDAQTimesliceSN(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3314
ROOT::destruct_KM3NETDAQcLcLJDAQTriggerMask
static void destruct_KM3NETDAQcLcLJDAQTriggerMask(void *p)
Definition G__KM3NeTROOT.cc:2698
ROOT::new_KM3NETDAQcLcLJDAQTimesliceL0
static void * new_KM3NETDAQcLcLJDAQTimesliceL0(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3206
ROOT::streamer_KM3NETDAQcLcLJDAQPMTIdentifier
static void streamer_KM3NETDAQcLcLJDAQPMTIdentifier(TBuffer &buf, void *obj)
Definition G__KM3NeTROOT.cc:2809
ROOT::newArray_vectorlEstringgR
static void * newArray_vectorlEstringgR(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3645
ROOT::new_Head
static void * new_Head(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3544
ROOT::newArray_KM3NETDAQcLcLJDAQEventHeader
static void * newArray_KM3NETDAQcLcLJDAQEventHeader(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:2723
ROOT::delete_KM3NETDAQcLcLJDAQTimesliceL0
static void delete_KM3NETDAQcLcLJDAQTimesliceL0(void *p)
Definition G__KM3NeTROOT.cc:3213
ROOT::deleteArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR
static void deleteArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p)
Definition G__KM3NeTROOT.cc:4042
ROOT::delete_KM3NETDAQcLcLJDAQPMTIdentifier
static void delete_KM3NETDAQcLcLJDAQPMTIdentifier(void *p)
Definition G__KM3NeTROOT.cc:2798
ROOT::newArray_KM3NETDAQcLcLJDAQKeyHit
static void * newArray_KM3NETDAQcLcLJDAQKeyHit(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:2819
ROOT::delete_KM3NETDAQcLcLJDAQPreamble
static void delete_KM3NETDAQcLcLJDAQPreamble(void *p)
Definition G__KM3NeTROOT.cc:2583
ROOT::deleteArray_KM3NETDAQcLcLJDAQTriggerMask
static void deleteArray_KM3NETDAQcLcLJDAQTriggerMask(void *p)
Definition G__KM3NeTROOT.cc:2695
ROOT::delete_vectorlEstringgR
static void delete_vectorlEstringgR(void *p)
Definition G__KM3NeTROOT.cc:3649
ROOT::deleteArray_Trk
static void deleteArray_Trk(void *p)
Definition G__KM3NeTROOT.cc:3488
ROOT::new_KM3NETDAQcLcLJDAQChronometer
static void * new_KM3NETDAQcLcLJDAQChronometer(void *p=nullptr)
Definition G__KM3NeTROOT.cc:2555
ROOT::newArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR
static void * newArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:4035
ROOT::new_KM3NETDAQcLcLJDAQTimesliceHeader
static void * new_KM3NETDAQcLcLJDAQTimesliceHeader(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3136
ROOT::destruct_KM3NETDAQcLcLJDAQUTCExtended
static void destruct_KM3NETDAQcLcLJDAQUTCExtended(void *p)
Definition G__KM3NeTROOT.cc:2533
ROOT::new_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR
static void * new_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p=nullptr)
Definition G__KM3NeTROOT.cc:4032
ROOT::deleteArray_KM3NETDAQcLcLJDAQTriggeredHit
static void deleteArray_KM3NETDAQcLcLJDAQTriggeredHit(void *p)
Definition G__KM3NeTROOT.cc:2851
ROOT::new_KM3NETDAQcLcLJDAQSummaryslice
static void * new_KM3NETDAQcLcLJDAQSummaryslice(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3346
ROOT::delete_vectorlETrkgR
static void delete_vectorlETrkgR(void *p)
Definition G__KM3NeTROOT.cc:3844
ROOT::delete_KM3NETDAQcLcLJDAQSummaryFrame
static void delete_KM3NETDAQcLcLJDAQSummaryFrame(void *p)
Definition G__KM3NeTROOT.cc:3069
ROOT::deleteArray_KM3NETDAQcLcLJDAQTimesliceSN
static void deleteArray_KM3NETDAQcLcLJDAQTimesliceSN(void *p)
Definition G__KM3NeTROOT.cc:3321
ROOT::destruct_Evt
static void destruct_Evt(void *p)
Definition G__KM3NeTROOT.cc:3524
ROOT::destruct_vectorlEintgR
static void destruct_vectorlEintgR(void *p)
Definition G__KM3NeTROOT.cc:3720
ROOT::delete_KM3NETDAQcLcLJDAQFrame
static void delete_KM3NETDAQcLcLJDAQFrame(void *p)
Definition G__KM3NeTROOT.cc:2922
ROOT::delete_KM3NETDAQcLcLJDAQTimesliceL2
static void delete_KM3NETDAQcLcLJDAQTimesliceL2(void *p)
Definition G__KM3NeTROOT.cc:3283
ROOT::destruct_vectorlEKM3NETDAQcLcLJDAQSuperFramegR
static void destruct_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p)
Definition G__KM3NeTROOT.cc:3980
ROOT::destruct_KM3NETDAQcLcLJDAQPreamble
static void destruct_KM3NETDAQcLcLJDAQPreamble(void *p)
Definition G__KM3NeTROOT.cc:2589
ROOT::vectorlEintgR_Dictionary
static TClass * vectorlEintgR_Dictionary()
Definition G__KM3NeTROOT.cc:3694
ROOT::new_KM3NETDAQcLcLJDAQTimeslice
static void * new_KM3NETDAQcLcLJDAQTimeslice(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3171
ROOT::destruct_KM3NETDAQcLcLJDAQTriggeredHit
static void destruct_KM3NETDAQcLcLJDAQTriggeredHit(void *p)
Definition G__KM3NeTROOT.cc:2854
ROOT::newArray_KM3NETDAQcLcLJDAQFrame
static void * newArray_KM3NETDAQcLcLJDAQFrame(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:2918
ROOT::vectorlEHeadgR_Dictionary
static TClass * vectorlEHeadgR_Dictionary()
Definition G__KM3NeTROOT.cc:4214
ROOT::delete_KM3NETDAQcLcLJDAQTimesliceSN
static void delete_KM3NETDAQcLcLJDAQTimesliceSN(void *p)
Definition G__KM3NeTROOT.cc:3318
ROOT::new_KM3NETDAQcLcLJDAQHeader
static void * new_KM3NETDAQcLcLJDAQHeader(void *p=nullptr)
Definition G__KM3NeTROOT.cc:2615
ROOT::newArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR
static void * newArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3970
ROOT::vectorlEKM3NETDAQcLcLJDAQSuperFramegR_Dictionary
static TClass * vectorlEKM3NETDAQcLcLJDAQSuperFramegR_Dictionary()
Definition G__KM3NeTROOT.cc:3954
ROOT::new_MultiHead
static void * new_MultiHead(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3577
ROOT::deleteArray_KM3NETDAQcLcLJDAQTriggerCounter
static void deleteArray_KM3NETDAQcLcLJDAQTriggerCounter(void *p)
Definition G__KM3NeTROOT.cc:2660
ROOT::delete_KM3NETDAQcLcLJDAQTimesliceHeader
static void delete_KM3NETDAQcLcLJDAQTimesliceHeader(void *p)
Definition G__KM3NeTROOT.cc:3143
ROOT::new_KM3NETDAQcLcLJDAQTimesliceL1
static void * new_KM3NETDAQcLcLJDAQTimesliceL1(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3241
ROOT::destruct_KM3NETDAQcLcLJDAQEventHeader
static void destruct_KM3NETDAQcLcLJDAQEventHeader(void *p)
Definition G__KM3NeTROOT.cc:2733
ROOT::destruct_KM3NETDAQcLcLJDAQHeader
static void destruct_KM3NETDAQcLcLJDAQHeader(void *p)
Definition G__KM3NeTROOT.cc:2628
ROOT::newArray_Head
static void * newArray_Head(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3547
ROOT::vectorlEdoublegR_Dictionary
static TClass * vectorlEdoublegR_Dictionary()
Definition G__KM3NeTROOT.cc:3759
ROOT::deleteArray_KM3NETDAQcLcLJDAQFrameStatus
static void deleteArray_KM3NETDAQcLcLJDAQFrameStatus(void *p)
Definition G__KM3NeTROOT.cc:2960
ROOT::destruct_vectorlEKM3NETDAQcLcLJDAQKeyHitgR
static void destruct_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p)
Definition G__KM3NeTROOT.cc:4110
ROOT::newArray_KM3NETDAQcLcLJDAQFrameStatus
static void * newArray_KM3NETDAQcLcLJDAQFrameStatus(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:2953
ROOT::vectorlEHeadgR_TClassManip
static void vectorlEHeadgR_TClassManip(TClass *)
Definition G__KM3NeTROOT.cc:4220
ROOT::deleteArray_KM3NETDAQcLcLJDAQSuperFrameHeader
static void deleteArray_KM3NETDAQcLcLJDAQSuperFrameHeader(void *p)
Definition G__KM3NeTROOT.cc:2995
ROOT::delete_KM3NETDAQcLcLJDAQHeader
static void delete_KM3NETDAQcLcLJDAQHeader(void *p)
Definition G__KM3NeTROOT.cc:2622
ROOT::destruct_KM3NETDAQcLcLJDAQTriggerCounter
static void destruct_KM3NETDAQcLcLJDAQTriggerCounter(void *p)
Definition G__KM3NeTROOT.cc:2663
ROOT::deleteArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR
static void deleteArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p)
Definition G__KM3NeTROOT.cc:3912
ROOT::newArray_vectorlEdoublegR
static void * newArray_vectorlEdoublegR(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3775
ROOT::delete_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR
static void delete_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p)
Definition G__KM3NeTROOT.cc:3909
ROOT::destruct_KM3NETDAQcLcLJDAQModuleIdentifier
static void destruct_KM3NETDAQcLcLJDAQModuleIdentifier(void *p)
Definition G__KM3NeTROOT.cc:2779
ROOT::delete_KM3NETDAQcLcLJDAQAbstractPreamble
static void delete_KM3NETDAQcLcLJDAQAbstractPreamble(void *p)
Definition G__KM3NeTROOT.cc:2488
ROOT::new_AAObject
static void * new_AAObject(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3379
ROOT::delete_KM3NETDAQcLcLJDAQTriggerCounter
static void delete_KM3NETDAQcLcLJDAQTriggerCounter(void *p)
Definition G__KM3NeTROOT.cc:2657
ROOT::new_KM3NETDAQcLcLJDAQFrameStatus
static void * new_KM3NETDAQcLcLJDAQFrameStatus(void *p=nullptr)
Definition G__KM3NeTROOT.cc:2950
ROOT::deleteArray_Head
static void deleteArray_Head(void *p)
Definition G__KM3NeTROOT.cc:3554
ROOT::newArray_KM3NETDAQcLcLJDAQModuleIdentifier
static void * newArray_KM3NETDAQcLcLJDAQModuleIdentifier(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:2769
ROOT::destruct_KM3NETDAQcLcLJDAQPMTIdentifier
static void destruct_KM3NETDAQcLcLJDAQPMTIdentifier(void *p)
Definition G__KM3NeTROOT.cc:2804
ROOT::deleteArray_vectorlEHitgR
static void deleteArray_vectorlEHitgR(void *p)
Definition G__KM3NeTROOT.cc:4172
ROOT::deleteArray_KM3NETDAQcLcLJDAQModuleIdentifier
static void deleteArray_KM3NETDAQcLcLJDAQModuleIdentifier(void *p)
Definition G__KM3NeTROOT.cc:2776
ROOT::delete_KM3NETDAQcLcLJDAQTriggeredHit
static void delete_KM3NETDAQcLcLJDAQTriggeredHit(void *p)
Definition G__KM3NeTROOT.cc:2848
ROOT::newArray_KM3NETDAQcLcLJDAQHeader
static void * newArray_KM3NETDAQcLcLJDAQHeader(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:2618
ROOT::vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_Dictionary
static TClass * vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_Dictionary()
Definition G__KM3NeTROOT.cc:4019
ROOT::delete_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR
static void delete_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p)
Definition G__KM3NeTROOT.cc:4039
ROOT::deleteArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR
static void deleteArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p)
Definition G__KM3NeTROOT.cc:4107
ROOT::deleteArray_KM3NETDAQcLcLJDAQFrame
static void deleteArray_KM3NETDAQcLcLJDAQFrame(void *p)
Definition G__KM3NeTROOT.cc:2925
ROOT::newArray_KM3NETDAQcLcLJDAQSummaryFrame
static void * newArray_KM3NETDAQcLcLJDAQSummaryFrame(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3065
ROOT::destruct_AAObject
static void destruct_AAObject(void *p)
Definition G__KM3NeTROOT.cc:3392
ROOT::newArray_KM3NETDAQcLcLJDAQUTCExtended
static void * newArray_KM3NETDAQcLcLJDAQUTCExtended(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:2523
ROOT::deleteArray_KM3NETDAQcLcLJDAQSummaryFrame
static void deleteArray_KM3NETDAQcLcLJDAQSummaryFrame(void *p)
Definition G__KM3NeTROOT.cc:3072
ROOT::newArray_KM3NETDAQcLcLJDAQChronometer
static void * newArray_KM3NETDAQcLcLJDAQChronometer(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:2558
ROOT::destruct_KM3NETDAQcLcLJDAQSummaryFrame
static void destruct_KM3NETDAQcLcLJDAQSummaryFrame(void *p)
Definition G__KM3NeTROOT.cc:3075
ROOT::delete_KM3NETDAQcLcLJDAQSummarysliceHeader
static void delete_KM3NETDAQcLcLJDAQSummarysliceHeader(void *p)
Definition G__KM3NeTROOT.cc:3108
ROOT::new_vectorlEintgR
static void * new_vectorlEintgR(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3707
ROOT::new_KM3NETDAQcLcLJDAQPMTIdentifier
static void * new_KM3NETDAQcLcLJDAQPMTIdentifier(void *p=nullptr)
Definition G__KM3NeTROOT.cc:2791
ROOT::new_KM3NETDAQcLcLJDAQSuperFrameHeader
static void * new_KM3NETDAQcLcLJDAQSuperFrameHeader(void *p=nullptr)
Definition G__KM3NeTROOT.cc:2985
ROOT::destruct_KM3NETDAQcLcLJDAQTimesliceSN
static void destruct_KM3NETDAQcLcLJDAQTimesliceSN(void *p)
Definition G__KM3NeTROOT.cc:3324
ROOT::deleteArray_KM3NETDAQcLcLJDAQSummaryslice
static void deleteArray_KM3NETDAQcLcLJDAQSummaryslice(void *p)
Definition G__KM3NeTROOT.cc:3356
ROOT::vectorlEKM3NETDAQcLcLJDAQKeyHitgR_Dictionary
static TClass * vectorlEKM3NETDAQcLcLJDAQKeyHitgR_Dictionary()
Definition G__KM3NeTROOT.cc:4084
ROOT::newArray_vectorlEHeadgR
static void * newArray_vectorlEHeadgR(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:4230
ROOT::delete_vectorlEKM3NETDAQcLcLJDAQKeyHitgR
static void delete_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p)
Definition G__KM3NeTROOT.cc:4104
ROOT::deleteArray_KM3NETDAQcLcLJDAQEvent
static void deleteArray_KM3NETDAQcLcLJDAQEvent(void *p)
Definition G__KM3NeTROOT.cc:2890
AAObject
AAObject is a base class for I/O-classes that adds the possibility to add 'user' information which wi...
Definition AAObject.hh:19
Evt
The Evt class respresent a Monte Carlo (MC) event as well as an offline event.
Definition Evt.hh:21
Head
The Head class reflects the header of Monte-Carlo event files, which consists of keys (also referred ...
Definition Head.hh:65
Hit
Definition Hit.hh:10
KM3NETDAQ::JDAQTimesliceL0
Timeslice data structure for L0 data.
Definition JDAQTimeslice.hh:259
KM3NETDAQ::JDAQTimesliceL1
Timeslice data structure for L1 data.
Definition JDAQTimeslice.hh:265
KM3NETDAQ::JDAQTimesliceL2
Timeslice data structure for L2 data.
Definition JDAQTimeslice.hh:271
KM3NETDAQ::JDAQTimesliceSN
Timeslice data structure for SN data.
Definition JDAQTimeslice.hh:277
TBuffer::IsReading
bool IsReading()
Definition JROOT_t.hh:23
Trk
The Trk class represents a Monte Carlo (MC) particle as well as a reconstructed track/shower.
Definition Trk.hh:15
Vec
The Vec class is a straightforward 3-d vector, which also works in pyroot.
Definition Vec.hh:13
Generated by doxygen 1.12.0