Jpp 21.0.0-rc.1
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(), "", 6281,
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(), "", 6755,
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 *vectorlEVecgR_Dictionary();
3793 static void vectorlEVecgR_TClassManip(TClass*);
3794 static void *new_vectorlEVecgR(void *p = nullptr);
3795 static void *newArray_vectorlEVecgR(Long_t size, void *p);
3796 static void delete_vectorlEVecgR(void *p);
3797 static void deleteArray_vectorlEVecgR(void *p);
3798 static void destruct_vectorlEVecgR(void *p);
3799
3800 // Function generating the singleton type initializer
3801 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<Vec>*)
3802 {
3803 vector<Vec> *ptr = nullptr;
3804 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<Vec>));
3805 static ::ROOT::TGenericClassInfo
3806 instance("vector<Vec>", -2, "vector", 389,
3807 typeid(vector<Vec>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3808 &vectorlEVecgR_Dictionary, isa_proxy, 4,
3809 sizeof(vector<Vec>) );
3810 instance.SetNew(&new_vectorlEVecgR);
3811 instance.SetNewArray(&newArray_vectorlEVecgR);
3812 instance.SetDelete(&delete_vectorlEVecgR);
3813 instance.SetDeleteArray(&deleteArray_vectorlEVecgR);
3814 instance.SetDestructor(&destruct_vectorlEVecgR);
3815 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<Vec> >()));
3816
3817 instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<Vec>","std::vector<Vec, std::allocator<Vec> >"));
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<Vec>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
3822
3823 // Dictionary for non-ClassDef classes
3824 static TClass *vectorlEVecgR_Dictionary() {
3825 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<Vec>*>(nullptr))->GetClass();
3826 vectorlEVecgR_TClassManip(theClass);
3827 return theClass;
3828 }
3829
3830 static void vectorlEVecgR_TClassManip(TClass* ){
3831 }
3832
3833} // end of namespace ROOT
3834
3835namespace ROOT {
3836 // Wrappers around operator new
3837 static void *new_vectorlEVecgR(void *p) {
3838 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<Vec> : new vector<Vec>;
3839 }
3840 static void *newArray_vectorlEVecgR(Long_t nElements, void *p) {
3841 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<Vec>[nElements] : new vector<Vec>[nElements];
3842 }
3843 // Wrapper around operator delete
3844 static void delete_vectorlEVecgR(void *p) {
3845 delete (static_cast<vector<Vec>*>(p));
3846 }
3847 static void deleteArray_vectorlEVecgR(void *p) {
3848 delete [] (static_cast<vector<Vec>*>(p));
3849 }
3850 static void destruct_vectorlEVecgR(void *p) {
3851 typedef vector<Vec> current_t;
3852 (static_cast<current_t*>(p))->~current_t();
3853 }
3854} // end of namespace ROOT for class vector<Vec>
3855
3856namespace ROOT {
3857 static TClass *vectorlETrkgR_Dictionary();
3858 static void vectorlETrkgR_TClassManip(TClass*);
3859 static void *new_vectorlETrkgR(void *p = nullptr);
3860 static void *newArray_vectorlETrkgR(Long_t size, void *p);
3861 static void delete_vectorlETrkgR(void *p);
3862 static void deleteArray_vectorlETrkgR(void *p);
3863 static void destruct_vectorlETrkgR(void *p);
3864
3865 // Function generating the singleton type initializer
3866 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<Trk>*)
3867 {
3868 vector<Trk> *ptr = nullptr;
3869 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<Trk>));
3870 static ::ROOT::TGenericClassInfo
3871 instance("vector<Trk>", -2, "vector", 389,
3872 typeid(vector<Trk>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3873 &vectorlETrkgR_Dictionary, isa_proxy, 0,
3874 sizeof(vector<Trk>) );
3875 instance.SetNew(&new_vectorlETrkgR);
3876 instance.SetNewArray(&newArray_vectorlETrkgR);
3877 instance.SetDelete(&delete_vectorlETrkgR);
3878 instance.SetDeleteArray(&deleteArray_vectorlETrkgR);
3879 instance.SetDestructor(&destruct_vectorlETrkgR);
3880 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<Trk> >()));
3881
3882 instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<Trk>","std::vector<Trk, std::allocator<Trk> >"));
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<Trk>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
3887
3888 // Dictionary for non-ClassDef classes
3889 static TClass *vectorlETrkgR_Dictionary() {
3890 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<Trk>*>(nullptr))->GetClass();
3891 vectorlETrkgR_TClassManip(theClass);
3892 return theClass;
3893 }
3894
3895 static void vectorlETrkgR_TClassManip(TClass* ){
3896 }
3897
3898} // end of namespace ROOT
3899
3900namespace ROOT {
3901 // Wrappers around operator new
3902 static void *new_vectorlETrkgR(void *p) {
3903 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<Trk> : new vector<Trk>;
3904 }
3905 static void *newArray_vectorlETrkgR(Long_t nElements, void *p) {
3906 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<Trk>[nElements] : new vector<Trk>[nElements];
3907 }
3908 // Wrapper around operator delete
3909 static void delete_vectorlETrkgR(void *p) {
3910 delete (static_cast<vector<Trk>*>(p));
3911 }
3912 static void deleteArray_vectorlETrkgR(void *p) {
3913 delete [] (static_cast<vector<Trk>*>(p));
3914 }
3915 static void destruct_vectorlETrkgR(void *p) {
3916 typedef vector<Trk> current_t;
3917 (static_cast<current_t*>(p))->~current_t();
3918 }
3919} // end of namespace ROOT for class vector<Trk>
3920
3921namespace ROOT {
3922 static TClass *vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR_Dictionary();
3923 static void vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR_TClassManip(TClass*);
3924 static void *new_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p = nullptr);
3925 static void *newArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(Long_t size, void *p);
3926 static void delete_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p);
3927 static void deleteArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p);
3928 static void destruct_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p);
3929
3930 // Function generating the singleton type initializer
3931 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<KM3NETDAQ::JDAQTriggeredHit>*)
3932 {
3933 vector<KM3NETDAQ::JDAQTriggeredHit> *ptr = nullptr;
3934 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<KM3NETDAQ::JDAQTriggeredHit>));
3935 static ::ROOT::TGenericClassInfo
3936 instance("vector<KM3NETDAQ::JDAQTriggeredHit>", -2, "vector", 389,
3937 typeid(vector<KM3NETDAQ::JDAQTriggeredHit>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3938 &vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR_Dictionary, isa_proxy, 0,
3939 sizeof(vector<KM3NETDAQ::JDAQTriggeredHit>) );
3940 instance.SetNew(&new_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR);
3941 instance.SetNewArray(&newArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR);
3942 instance.SetDelete(&delete_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR);
3943 instance.SetDeleteArray(&deleteArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR);
3944 instance.SetDestructor(&destruct_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR);
3945 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<KM3NETDAQ::JDAQTriggeredHit> >()));
3946
3947 instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<KM3NETDAQ::JDAQTriggeredHit>","std::vector<KM3NETDAQ::JDAQTriggeredHit, std::allocator<KM3NETDAQ::JDAQTriggeredHit> >"));
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::JDAQTriggeredHit>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
3952
3953 // Dictionary for non-ClassDef classes
3954 static TClass *vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR_Dictionary() {
3955 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<KM3NETDAQ::JDAQTriggeredHit>*>(nullptr))->GetClass();
3956 vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR_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_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p) {
3968 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQTriggeredHit> : new vector<KM3NETDAQ::JDAQTriggeredHit>;
3969 }
3970 static void *newArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(Long_t nElements, void *p) {
3971 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQTriggeredHit>[nElements] : new vector<KM3NETDAQ::JDAQTriggeredHit>[nElements];
3972 }
3973 // Wrapper around operator delete
3974 static void delete_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p) {
3975 delete (static_cast<vector<KM3NETDAQ::JDAQTriggeredHit>*>(p));
3976 }
3977 static void deleteArray_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p) {
3978 delete [] (static_cast<vector<KM3NETDAQ::JDAQTriggeredHit>*>(p));
3979 }
3980 static void destruct_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p) {
3981 typedef vector<KM3NETDAQ::JDAQTriggeredHit> current_t;
3982 (static_cast<current_t*>(p))->~current_t();
3983 }
3984} // end of namespace ROOT for class vector<KM3NETDAQ::JDAQTriggeredHit>
3985
3986namespace ROOT {
3987 static TClass *vectorlEKM3NETDAQcLcLJDAQSuperFramegR_Dictionary();
3988 static void vectorlEKM3NETDAQcLcLJDAQSuperFramegR_TClassManip(TClass*);
3989 static void *new_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p = nullptr);
3990 static void *newArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(Long_t size, void *p);
3991 static void delete_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p);
3992 static void deleteArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p);
3993 static void destruct_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p);
3994
3995 // Function generating the singleton type initializer
3996 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<KM3NETDAQ::JDAQSuperFrame>*)
3997 {
3998 vector<KM3NETDAQ::JDAQSuperFrame> *ptr = nullptr;
3999 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<KM3NETDAQ::JDAQSuperFrame>));
4000 static ::ROOT::TGenericClassInfo
4001 instance("vector<KM3NETDAQ::JDAQSuperFrame>", -2, "vector", 389,
4002 typeid(vector<KM3NETDAQ::JDAQSuperFrame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4003 &vectorlEKM3NETDAQcLcLJDAQSuperFramegR_Dictionary, isa_proxy, 0,
4004 sizeof(vector<KM3NETDAQ::JDAQSuperFrame>) );
4005 instance.SetNew(&new_vectorlEKM3NETDAQcLcLJDAQSuperFramegR);
4006 instance.SetNewArray(&newArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR);
4007 instance.SetDelete(&delete_vectorlEKM3NETDAQcLcLJDAQSuperFramegR);
4008 instance.SetDeleteArray(&deleteArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR);
4009 instance.SetDestructor(&destruct_vectorlEKM3NETDAQcLcLJDAQSuperFramegR);
4010 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<KM3NETDAQ::JDAQSuperFrame> >()));
4011
4012 instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<KM3NETDAQ::JDAQSuperFrame>","std::vector<KM3NETDAQ::JDAQSuperFrame, std::allocator<KM3NETDAQ::JDAQSuperFrame> >"));
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::JDAQSuperFrame>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
4017
4018 // Dictionary for non-ClassDef classes
4019 static TClass *vectorlEKM3NETDAQcLcLJDAQSuperFramegR_Dictionary() {
4020 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<KM3NETDAQ::JDAQSuperFrame>*>(nullptr))->GetClass();
4021 vectorlEKM3NETDAQcLcLJDAQSuperFramegR_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_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p) {
4033 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQSuperFrame> : new vector<KM3NETDAQ::JDAQSuperFrame>;
4034 }
4035 static void *newArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(Long_t nElements, void *p) {
4036 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQSuperFrame>[nElements] : new vector<KM3NETDAQ::JDAQSuperFrame>[nElements];
4037 }
4038 // Wrapper around operator delete
4039 static void delete_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p) {
4040 delete (static_cast<vector<KM3NETDAQ::JDAQSuperFrame>*>(p));
4041 }
4042 static void deleteArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p) {
4043 delete [] (static_cast<vector<KM3NETDAQ::JDAQSuperFrame>*>(p));
4044 }
4045 static void destruct_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p) {
4046 typedef vector<KM3NETDAQ::JDAQSuperFrame> current_t;
4047 (static_cast<current_t*>(p))->~current_t();
4048 }
4049} // end of namespace ROOT for class vector<KM3NETDAQ::JDAQSuperFrame>
4050
4051namespace ROOT {
4052 static TClass *vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_Dictionary();
4053 static void vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_TClassManip(TClass*);
4054 static void *new_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p = nullptr);
4055 static void *newArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(Long_t size, void *p);
4056 static void delete_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p);
4057 static void deleteArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p);
4058 static void destruct_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p);
4059
4060 // Function generating the singleton type initializer
4061 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<KM3NETDAQ::JDAQSummaryFrame>*)
4062 {
4063 vector<KM3NETDAQ::JDAQSummaryFrame> *ptr = nullptr;
4064 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<KM3NETDAQ::JDAQSummaryFrame>));
4065 static ::ROOT::TGenericClassInfo
4066 instance("vector<KM3NETDAQ::JDAQSummaryFrame>", -2, "vector", 389,
4067 typeid(vector<KM3NETDAQ::JDAQSummaryFrame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4068 &vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_Dictionary, isa_proxy, 0,
4069 sizeof(vector<KM3NETDAQ::JDAQSummaryFrame>) );
4070 instance.SetNew(&new_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR);
4071 instance.SetNewArray(&newArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR);
4072 instance.SetDelete(&delete_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR);
4073 instance.SetDeleteArray(&deleteArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR);
4074 instance.SetDestructor(&destruct_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR);
4075 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<KM3NETDAQ::JDAQSummaryFrame> >()));
4076
4077 instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<KM3NETDAQ::JDAQSummaryFrame>","std::vector<KM3NETDAQ::JDAQSummaryFrame, std::allocator<KM3NETDAQ::JDAQSummaryFrame> >"));
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::JDAQSummaryFrame>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
4082
4083 // Dictionary for non-ClassDef classes
4084 static TClass *vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_Dictionary() {
4085 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<KM3NETDAQ::JDAQSummaryFrame>*>(nullptr))->GetClass();
4086 vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_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_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p) {
4098 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQSummaryFrame> : new vector<KM3NETDAQ::JDAQSummaryFrame>;
4099 }
4100 static void *newArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(Long_t nElements, void *p) {
4101 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQSummaryFrame>[nElements] : new vector<KM3NETDAQ::JDAQSummaryFrame>[nElements];
4102 }
4103 // Wrapper around operator delete
4104 static void delete_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p) {
4105 delete (static_cast<vector<KM3NETDAQ::JDAQSummaryFrame>*>(p));
4106 }
4107 static void deleteArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p) {
4108 delete [] (static_cast<vector<KM3NETDAQ::JDAQSummaryFrame>*>(p));
4109 }
4110 static void destruct_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p) {
4111 typedef vector<KM3NETDAQ::JDAQSummaryFrame> current_t;
4112 (static_cast<current_t*>(p))->~current_t();
4113 }
4114} // end of namespace ROOT for class vector<KM3NETDAQ::JDAQSummaryFrame>
4115
4116namespace ROOT {
4117 static TClass *vectorlEKM3NETDAQcLcLJDAQKeyHitgR_Dictionary();
4118 static void vectorlEKM3NETDAQcLcLJDAQKeyHitgR_TClassManip(TClass*);
4119 static void *new_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p = nullptr);
4120 static void *newArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(Long_t size, void *p);
4121 static void delete_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p);
4122 static void deleteArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p);
4123 static void destruct_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p);
4124
4125 // Function generating the singleton type initializer
4126 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<KM3NETDAQ::JDAQKeyHit>*)
4127 {
4128 vector<KM3NETDAQ::JDAQKeyHit> *ptr = nullptr;
4129 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<KM3NETDAQ::JDAQKeyHit>));
4130 static ::ROOT::TGenericClassInfo
4131 instance("vector<KM3NETDAQ::JDAQKeyHit>", -2, "vector", 389,
4132 typeid(vector<KM3NETDAQ::JDAQKeyHit>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4133 &vectorlEKM3NETDAQcLcLJDAQKeyHitgR_Dictionary, isa_proxy, 0,
4134 sizeof(vector<KM3NETDAQ::JDAQKeyHit>) );
4135 instance.SetNew(&new_vectorlEKM3NETDAQcLcLJDAQKeyHitgR);
4136 instance.SetNewArray(&newArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR);
4137 instance.SetDelete(&delete_vectorlEKM3NETDAQcLcLJDAQKeyHitgR);
4138 instance.SetDeleteArray(&deleteArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR);
4139 instance.SetDestructor(&destruct_vectorlEKM3NETDAQcLcLJDAQKeyHitgR);
4140 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<KM3NETDAQ::JDAQKeyHit> >()));
4141
4142 instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<KM3NETDAQ::JDAQKeyHit>","std::vector<KM3NETDAQ::JDAQKeyHit, std::allocator<KM3NETDAQ::JDAQKeyHit> >"));
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<KM3NETDAQ::JDAQKeyHit>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
4147
4148 // Dictionary for non-ClassDef classes
4149 static TClass *vectorlEKM3NETDAQcLcLJDAQKeyHitgR_Dictionary() {
4150 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<KM3NETDAQ::JDAQKeyHit>*>(nullptr))->GetClass();
4151 vectorlEKM3NETDAQcLcLJDAQKeyHitgR_TClassManip(theClass);
4152 return theClass;
4153 }
4154
4157
4158} // end of namespace ROOT
4159
4160namespace ROOT {
4161 // Wrappers around operator new
4162 static void *new_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p) {
4163 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQKeyHit> : new vector<KM3NETDAQ::JDAQKeyHit>;
4164 }
4165 static void *newArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(Long_t nElements, void *p) {
4166 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<KM3NETDAQ::JDAQKeyHit>[nElements] : new vector<KM3NETDAQ::JDAQKeyHit>[nElements];
4167 }
4168 // Wrapper around operator delete
4169 static void delete_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p) {
4170 delete (static_cast<vector<KM3NETDAQ::JDAQKeyHit>*>(p));
4171 }
4172 static void deleteArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p) {
4173 delete [] (static_cast<vector<KM3NETDAQ::JDAQKeyHit>*>(p));
4174 }
4175 static void destruct_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p) {
4176 typedef vector<KM3NETDAQ::JDAQKeyHit> current_t;
4177 (static_cast<current_t*>(p))->~current_t();
4178 }
4179} // end of namespace ROOT for class vector<KM3NETDAQ::JDAQKeyHit>
4180
4181namespace ROOT {
4182 static TClass *vectorlEHitgR_Dictionary();
4183 static void vectorlEHitgR_TClassManip(TClass*);
4184 static void *new_vectorlEHitgR(void *p = nullptr);
4185 static void *newArray_vectorlEHitgR(Long_t size, void *p);
4186 static void delete_vectorlEHitgR(void *p);
4187 static void deleteArray_vectorlEHitgR(void *p);
4188 static void destruct_vectorlEHitgR(void *p);
4189
4190 // Function generating the singleton type initializer
4191 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<Hit>*)
4192 {
4193 vector<Hit> *ptr = nullptr;
4194 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<Hit>));
4195 static ::ROOT::TGenericClassInfo
4196 instance("vector<Hit>", -2, "vector", 389,
4197 typeid(vector<Hit>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4198 &vectorlEHitgR_Dictionary, isa_proxy, 0,
4199 sizeof(vector<Hit>) );
4200 instance.SetNew(&new_vectorlEHitgR);
4201 instance.SetNewArray(&newArray_vectorlEHitgR);
4202 instance.SetDelete(&delete_vectorlEHitgR);
4203 instance.SetDeleteArray(&deleteArray_vectorlEHitgR);
4204 instance.SetDestructor(&destruct_vectorlEHitgR);
4205 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<Hit> >()));
4206
4207 instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<Hit>","std::vector<Hit, std::allocator<Hit> >"));
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<Hit>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
4212
4213 // Dictionary for non-ClassDef classes
4214 static TClass *vectorlEHitgR_Dictionary() {
4215 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<Hit>*>(nullptr))->GetClass();
4216 vectorlEHitgR_TClassManip(theClass);
4217 return theClass;
4218 }
4219
4220 static void vectorlEHitgR_TClassManip(TClass* ){
4221 }
4222
4223} // end of namespace ROOT
4224
4225namespace ROOT {
4226 // Wrappers around operator new
4227 static void *new_vectorlEHitgR(void *p) {
4228 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<Hit> : new vector<Hit>;
4229 }
4230 static void *newArray_vectorlEHitgR(Long_t nElements, void *p) {
4231 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<Hit>[nElements] : new vector<Hit>[nElements];
4232 }
4233 // Wrapper around operator delete
4234 static void delete_vectorlEHitgR(void *p) {
4235 delete (static_cast<vector<Hit>*>(p));
4236 }
4237 static void deleteArray_vectorlEHitgR(void *p) {
4238 delete [] (static_cast<vector<Hit>*>(p));
4239 }
4240 static void destruct_vectorlEHitgR(void *p) {
4241 typedef vector<Hit> current_t;
4242 (static_cast<current_t*>(p))->~current_t();
4243 }
4244} // end of namespace ROOT for class vector<Hit>
4245
4246namespace ROOT {
4247 static TClass *vectorlEHeadgR_Dictionary();
4248 static void vectorlEHeadgR_TClassManip(TClass*);
4249 static void *new_vectorlEHeadgR(void *p = nullptr);
4250 static void *newArray_vectorlEHeadgR(Long_t size, void *p);
4251 static void delete_vectorlEHeadgR(void *p);
4252 static void deleteArray_vectorlEHeadgR(void *p);
4253 static void destruct_vectorlEHeadgR(void *p);
4254
4255 // Function generating the singleton type initializer
4256 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<Head>*)
4257 {
4258 vector<Head> *ptr = nullptr;
4259 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<Head>));
4260 static ::ROOT::TGenericClassInfo
4261 instance("vector<Head>", -2, "vector", 389,
4262 typeid(vector<Head>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4263 &vectorlEHeadgR_Dictionary, isa_proxy, 0,
4264 sizeof(vector<Head>) );
4265 instance.SetNew(&new_vectorlEHeadgR);
4266 instance.SetNewArray(&newArray_vectorlEHeadgR);
4267 instance.SetDelete(&delete_vectorlEHeadgR);
4268 instance.SetDeleteArray(&deleteArray_vectorlEHeadgR);
4269 instance.SetDestructor(&destruct_vectorlEHeadgR);
4270 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<Head> >()));
4271
4272 instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<Head>","std::vector<Head, std::allocator<Head> >"));
4273 return &instance;
4274 }
4275 // Static variable to force the class initialization
4276 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<Head>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
4277
4278 // Dictionary for non-ClassDef classes
4279 static TClass *vectorlEHeadgR_Dictionary() {
4280 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<Head>*>(nullptr))->GetClass();
4281 vectorlEHeadgR_TClassManip(theClass);
4282 return theClass;
4283 }
4284
4285 static void vectorlEHeadgR_TClassManip(TClass* ){
4286 }
4287
4288} // end of namespace ROOT
4289
4290namespace ROOT {
4291 // Wrappers around operator new
4292 static void *new_vectorlEHeadgR(void *p) {
4293 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<Head> : new vector<Head>;
4294 }
4295 static void *newArray_vectorlEHeadgR(Long_t nElements, void *p) {
4296 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<Head>[nElements] : new vector<Head>[nElements];
4297 }
4298 // Wrapper around operator delete
4299 static void delete_vectorlEHeadgR(void *p) {
4300 delete (static_cast<vector<Head>*>(p));
4301 }
4302 static void deleteArray_vectorlEHeadgR(void *p) {
4303 delete [] (static_cast<vector<Head>*>(p));
4304 }
4305 static void destruct_vectorlEHeadgR(void *p) {
4306 typedef vector<Head> current_t;
4307 (static_cast<current_t*>(p))->~current_t();
4308 }
4309} // end of namespace ROOT for class vector<Head>
4310
4311namespace ROOT {
4312 static TClass *maplEstringcOstringgR_Dictionary();
4313 static void maplEstringcOstringgR_TClassManip(TClass*);
4314 static void *new_maplEstringcOstringgR(void *p = nullptr);
4315 static void *newArray_maplEstringcOstringgR(Long_t size, void *p);
4316 static void delete_maplEstringcOstringgR(void *p);
4317 static void deleteArray_maplEstringcOstringgR(void *p);
4318 static void destruct_maplEstringcOstringgR(void *p);
4319
4320 // Function generating the singleton type initializer
4321 static TGenericClassInfo *GenerateInitInstanceLocal(const map<string,string>*)
4322 {
4323 map<string,string> *ptr = nullptr;
4324 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<string,string>));
4325 static ::ROOT::TGenericClassInfo
4326 instance("map<string,string>", -2, "map", 100,
4327 typeid(map<string,string>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4328 &maplEstringcOstringgR_Dictionary, isa_proxy, 0,
4329 sizeof(map<string,string>) );
4330 instance.SetNew(&new_maplEstringcOstringgR);
4331 instance.SetNewArray(&newArray_maplEstringcOstringgR);
4332 instance.SetDelete(&delete_maplEstringcOstringgR);
4333 instance.SetDeleteArray(&deleteArray_maplEstringcOstringgR);
4334 instance.SetDestructor(&destruct_maplEstringcOstringgR);
4335 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<string,string> >()));
4336
4337 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> > > > >"));
4338 return &instance;
4339 }
4340 // Static variable to force the class initialization
4341 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const map<string,string>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
4342
4343 // Dictionary for non-ClassDef classes
4344 static TClass *maplEstringcOstringgR_Dictionary() {
4345 TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const map<string,string>*>(nullptr))->GetClass();
4346 maplEstringcOstringgR_TClassManip(theClass);
4347 return theClass;
4348 }
4349
4350 static void maplEstringcOstringgR_TClassManip(TClass* ){
4351 }
4352
4353} // end of namespace ROOT
4354
4355namespace ROOT {
4356 // Wrappers around operator new
4357 static void *new_maplEstringcOstringgR(void *p) {
4358 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map<string,string> : new map<string,string>;
4359 }
4360 static void *newArray_maplEstringcOstringgR(Long_t nElements, void *p) {
4361 return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map<string,string>[nElements] : new map<string,string>[nElements];
4362 }
4363 // Wrapper around operator delete
4364 static void delete_maplEstringcOstringgR(void *p) {
4365 delete (static_cast<map<string,string>*>(p));
4366 }
4367 static void deleteArray_maplEstringcOstringgR(void *p) {
4368 delete [] (static_cast<map<string,string>*>(p));
4369 }
4370 static void destruct_maplEstringcOstringgR(void *p) {
4371 typedef map<string,string> current_t;
4372 (static_cast<current_t*>(p))->~current_t();
4373 }
4374} // end of namespace ROOT for class map<string,string>
4375
4376namespace {
4377 void TriggerDictionaryInitialization_G__KM3NeTROOT_Impl() {
4378 static const char* headers[] = {
4379"0",
4380nullptr
4381 };
4382 static const char* includePaths[] = {
4383"/builds/common/jpp/externals/km3net-dataformat/build",
4384"/usr/include",
4385"/usr/local/include/",
4386"/builds/common/jpp/externals/km3net-dataformat/build/src/",
4387nullptr
4388 };
4389 static const char* fwdDeclCode = R"DICTFWDDCLS(
4390#line 1 "G__KM3NeTROOT dictionary forward declarations' payload"
4391#pragma clang diagnostic ignored "-Wkeyword-compat"
4392#pragma clang diagnostic ignored "-Wignored-attributes"
4393#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
4394extern int __Cling_AutoLoading_Map;
4395struct __attribute__((annotate("$clingAutoload$km3net-dataformat/offline/Vec.hh"))) __attribute__((annotate("$clingAutoload$km3net-dataformat/offline/Hit.hh"))) Vec;
4396namespace std{template <typename _Tp> class __attribute__((annotate("$clingAutoload$bits/allocator.h"))) __attribute__((annotate("$clingAutoload$string"))) allocator;
4397}
4398namespace KM3NETDAQ{class JDAQAbstractPreamble;}
4399namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQUTCExtended.hh"))) JDAQUTCExtended;}
4400namespace KM3NETDAQ{class JDAQChronometer;}
4401namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQPreamble.hh"))) JDAQPreamble;}
4402namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQHeader.hh"))) __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQEventHeader.hh"))) JDAQHeader;}
4403namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTriggerCounter.hh"))) __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQEventHeader.hh"))) JDAQTriggerCounter;}
4404namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTriggerMask.hh"))) __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQEventHeader.hh"))) JDAQTriggerMask;}
4405namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQEventHeader.hh"))) JDAQEventHeader;}
4406namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQHit.hh"))) JDAQHit;}
4407namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQModuleIdentifier.hh"))) __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQKeyHit.hh"))) JDAQModuleIdentifier;}
4408namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQPMTIdentifier.hh"))) __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQKeyHit.hh"))) JDAQPMTIdentifier;}
4409namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQKeyHit.hh"))) JDAQKeyHit;}
4410namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTriggeredHit.hh"))) JDAQTriggeredHit;}
4411namespace KM3NETDAQ{class JDAQEvent;}
4412namespace KM3NETDAQ{class JDAQFrame;}
4413namespace KM3NETDAQ{class JDAQFrameStatus;}
4414namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQSuperFrameHeader.hh"))) __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQSuperFrame.hh"))) JDAQSuperFrameHeader;}
4415namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQSuperFrame.hh"))) JDAQSuperFrame;}
4416namespace KM3NETDAQ{class JDAQRate;}
4417namespace KM3NETDAQ{class JDAQSummaryFrame;}
4418namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQSummarysliceHeader.hh"))) JDAQSummarysliceHeader;}
4419namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimesliceHeader.hh"))) __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimeslice.hh"))) JDAQTimesliceHeader;}
4420namespace KM3NETDAQ{class __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimeslice.hh"))) JDAQTimeslice;}
4421namespace KM3NETDAQ{struct __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimeslice.hh"))) JDAQTimesliceL0;}
4422namespace KM3NETDAQ{struct __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimeslice.hh"))) JDAQTimesliceL1;}
4423namespace KM3NETDAQ{struct __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimeslice.hh"))) JDAQTimesliceL2;}
4424namespace KM3NETDAQ{struct __attribute__((annotate("$clingAutoload$km3net-dataformat/online/JDAQTimeslice.hh"))) JDAQTimesliceSN;}
4425namespace KM3NETDAQ{class JDAQSummaryslice;}
4426struct AAObject;
4427struct __attribute__((annotate("$clingAutoload$km3net-dataformat/offline/Hit.hh"))) Hit;
4428struct __attribute__((annotate("$clingAutoload$km3net-dataformat/offline/Trk.hh"))) Trk;
4429struct Evt;
4430struct Head;
4431struct MultiHead;
4432)DICTFWDDCLS";
4433 static const char* payloadCode = R"DICTPAYLOAD(
4434#line 1 "G__KM3NeTROOT dictionary payload"
4435
4436
4437#define _BACKWARD_BACKWARD_WARNING_H
4438// Inline headers
4439#ifndef __JDAQ__
4440#define __JDAQ__
4441
4442#include "km3net-dataformat/online/JDAQException.hh"
4443
4444
4445/**
4446 * \file
4447 *
4448 * KM3NeT DAQ constants, bit handling, etc.
4449 * \author mdejong
4450 */
4451
4452
4453/**
4454 * %KM3NeT DAQ data structures and auxiliaries.
4455 */
4456namespace KM3NETDAQ {
4457
4458#define KM3NET 1
4459#define ANTARES 2
4460
4461#if NAMESPACE == ANTARES
4462 static const int NUMBER_OF_PMTS = 3; //!< Total number of PMTs in module
4463#else
4464 static const int NUMBER_OF_PMTS = 31; //!< Total number of PMTs in module
4465#endif
4466
4467#undef KM3NET
4468#undef ANTARES
4469
4470
4471 /**
4472 * Auxiliary data structure for single bit.
4473 */
4474 struct JBit {
4475 /**
4476 * Default constructor.
4477 */
4478 JBit() :
4479 bit(0)
4480 {}
4481
4482
4483 /**
4484 * Constructor.
4485 *
4486 * \param __bit bit [0, 31]
4487 */
4488 JBit(int __bit) :
4489 bit(__bit)
4490 {
4491 if (bit < 0 || bit > 31) {
4492 throw JDAQException("JBit: illegal bit range.");
4493 }
4494 }
4495
4496
4497 /**
4498 * Get bit mask.
4499 *
4500 * In the returned mask, the single bit at <tt>bit</tt> set to 1.
4501 *
4502 * \return bit mask
4503 */
4504 int get() const
4505 {
4506 return 1 << bit;
4507 }
4508
4509
4510 /**
4511 * Set bit in given bit mask.
4512 *
4513 * \param mask bit mask (I/O)
4514 */
4515 void set(int& mask) const
4516 {
4517 mask |= get();
4518 }
4519
4520
4521 /**
4522 * Unset bit in given bit mask.
4523 *
4524 * \param mask bit mask (I/O)
4525 */
4526 void unset(int& mask) const
4527 {
4528 mask &= ~get();
4529 }
4530
4531
4532 /**
4533 * Set bit in given bit mask.
4534 *
4535 * \param mask bit mask (I/0)
4536 * \param value bit status
4537 */
4538 void set(int& mask, const bool value) const
4539 {
4540 if (value)
4541 set (mask);
4542 else
4543 unset(mask);
4544 }
4545
4546
4547 /**
4548 * Write given value as bit mask.
4549 *
4550 * \param value value
4551 * \return bit mask
4552 */
4553 int write(const int value) const
4554 {
4555 return (value << bit) & get();
4556 }
4557
4558
4559 /**
4560 * Read given bit mask as value.
4561 *
4562 * \param mask bit mask
4563 * \return value
4564 */
4565 int read(const int mask) const
4566 {
4567 return (mask & get()) >> bit;
4568 }
4569
4570
4571 /**
4572 * Test bit.
4573 *
4574 * \param mask bit mask
4575 * \return true if bit set; else false
4576 */
4577 bool has(const int mask) const
4578 {
4579 return (mask & get()) != 0;
4580 }
4581
4582
4583 int bit; //!< bit
4584 };
4585
4586
4587 /**
4588 * Auxiliary data structure for range of bits.
4589 */
4590 struct JBits {
4591 /**
4592 * Default constructor.
4593 */
4594 JBits() :
4595 lsb(0),
4596 msb(0)
4597 {}
4598
4599
4600 /**
4601 * Constructor.
4602 *
4603 * \param __lsb least significant bit [0, 31]
4604 * \param __msb most significant bit [lsb, 31]
4605 */
4606 JBits(int __lsb, int __msb) :
4607 lsb(__lsb),
4608 msb(__msb)
4609 {
4610 if (lsb < 0 || lsb > 31 ||
4611 msb < lsb || msb > 31) {
4612 throw JDAQException("JBits: illegal bit range.");
4613 }
4614 }
4615
4616
4617 /**
4618 * Get bit mask.
4619 *
4620 * In the returned mask, the bits from <tt>lsb</tt> (included) to <tt>msb</tt> (included) are set to 1.
4621 *
4622 * \return bit mask
4623 */
4624 int get() const
4625 {
4626 static const unsigned int mask[] = { 0x00000001,
4627 0x00000003,
4628 0x00000007,
4629 0x0000000F,
4630
4631 0x0000001F,
4632 0x0000003F,
4633 0x0000007F,
4634 0x000000FF,
4635
4636 0x000001FF,
4637 0x000003FF,
4638 0x000007FF,
4639 0x00000FFF,
4640
4641 0x00001FFF,
4642 0x00003FFF,
4643 0x00007FFF,
4644 0x0000FFFF,
4645
4646 0x0001FFFF,
4647 0x0003FFFF,
4648 0x0007FFFF,
4649 0x000FFFFF,
4650
4651 0x001FFFFF,
4652 0x003FFFFF,
4653 0x007FFFFF,
4654 0x00FFFFFF,
4655
4656 0x01FFFFFF,
4657 0x03FFFFFF,
4658 0x07FFFFFF,
4659 0x0FFFFFFF,
4660
4661 0x1FFFFFFF,
4662 0x3FFFFFFF,
4663 0x7FFFFFFF,
4664 0xFFFFFFFF };
4665
4666 return (int) (mask[msb-lsb] << lsb);
4667 }
4668
4669
4670 /**
4671 * Write given value as bit mask.
4672 *
4673 * \param value value
4674 * \return bit mask
4675 */
4676 int write(const int value) const
4677 {
4678 return (value << lsb) & get();
4679 }
4680
4681
4682 /**
4683 * Read given bit mask as value.
4684 *
4685 * \param mask bit mask
4686 * \return value
4687 */
4688 int read(const int mask) const
4689 {
4690 return (mask & get()) >> lsb;
4691 }
4692
4693
4694 /**
4695 * Test bit mask.
4696 *
4697 * \param mask bit mask
4698 * \return true if at least one of the bits is set; else false
4699 */
4700 bool has(const int mask) const
4701 {
4702 return (get() & mask) != 0;
4703 }
4704
4705
4706 int lsb; //!< least significant bit
4707 int msb; //!< most significant bit
4708 };
4709
4710
4711 static const JBit DAQ_WHITE_RABBIT (31); //!< White Rabbit status
4712 static const JBits DAQ_TDC ( 0, 30); //!< TDC high-rate veto status
4713 static const JBits DAQ_FIFO ( 0, 30); //!< FIFO almost full bits
4714
4715 static const JBit DAQ_UDP_TRAILER (31); //!< UDP trailer
4716 static const JBits DAQ_UDP_RECEIVED_PACKETS( 0, 15); //!< Mask of UDP received packets
4717 static const JBits DAQ_UDP_SEQUENCE_NUMBER (16, 31); //!< Mask of UDP sequence number
4718}
4719
4720#endif
4721#ifndef __JDAQABSTRACTPREAMBLE__
4722#define __JDAQABSTRACTPREAMBLE__
4723
4724#include "km3net-dataformat/online/JDAQDataTypes.hh"
4725#include "km3net-dataformat/online/JDAQRoot.hh"
4726
4727
4728/**
4729 * \author rbruijn
4730 */
4731
4732namespace KM3NETDAQ {
4733
4734
4735 /**
4736 * Simple data structure for the DAQ preamble required for a correct calculation
4737 * of the object size for binary I/O.
4738 *
4739 * Note that JDAQPreamble derives from this and adds I/O and ROOT functionality.
4740 */
4741 class JDAQAbstractPreamble {
4742 protected:
4743 /**
4744 * Constructor.
4745 *
4746 * \param type data type of derived class
4747 */
4748 template<class T>
4749 JDAQAbstractPreamble(JDAQType<T> type) :
4750 length(0),
4751 type (KM3NETDAQ::getDataType(type))
4752 {}
4753
4754 public:
4755 /**
4756 * Default constuctor
4757 */
4758 JDAQAbstractPreamble() :
4759 length(0),
4760 type (0)
4761 {}
4762
4763
4764 /**
4765 * Get length.
4766 *
4767 * \return number of bytes
4768 */
4769 int getLength() const
4770 {
4771 return length;
4772 }
4773
4774
4775 /**
4776 * Get data type.
4777 *
4778 * \return data type
4779 */
4780 int getDataType() const
4781 {
4782 return type;
4783 }
4784
4785
4786 ClassDefNV(JDAQAbstractPreamble,1);
4787
4788 protected:
4789 int length;
4790 int type;
4791 };
4792}
4793
4794#endif
4795#ifndef __JDAQCHRONOMETER__
4796#define __JDAQCHRONOMETER__
4797
4798#include <ostream>
4799#include <iomanip>
4800
4801#include "km3net-dataformat/online/JDAQRoot.hh"
4802#include "km3net-dataformat/online/JDAQUTCExtended.hh"
4803#include "km3net-dataformat/online/JDAQClock.hh"
4804
4805
4806/**
4807 * \author mdejong
4808 */
4809
4810namespace KM3NETDAQ {
4811
4812 /**
4813 * DAQ chronometer.
4814 */
4815 class JDAQChronometer
4816 {
4817 public:
4818
4819 friend size_t getSizeof<JDAQChronometer>();
4820 friend JReader& operator>>(JReader&, JDAQChronometer&);
4821 friend JWriter& operator<<(JWriter&, const JDAQChronometer&);
4822
4823 /**
4824 * Default constructor.
4825 */
4826 JDAQChronometer() :
4827 detector_id(0),
4828 run (0),
4829 frame_index(0),
4830 timeslice_start()
4831 {}
4832
4833
4834 /**
4835 * Constructor.
4836 *
4837 * \param __detector_id detector identifier
4838 * \param __run run number
4839 * \param __frame_index frame index
4840 */
4841 JDAQChronometer(const int __detector_id,
4842 const int __run,
4843 const int __frame_index) :
4844 detector_id(__detector_id),
4845 run (__run),
4846 frame_index(__frame_index),
4847 timeslice_start(getTimeOfFrame(__frame_index))
4848 {}
4849
4850
4851 /**
4852 * Constructor.
4853 *
4854 * \param __detector_id detector identifier
4855 * \param __run run number
4856 * \param __frame_index frame index
4857 * \param __timeslice_start start of time slice
4858 */
4859 JDAQChronometer(const int __detector_id,
4860 const int __run,
4861 const int __frame_index,
4862 const JDAQUTCExtended& __timeslice_start) :
4863 detector_id(__detector_id),
4864 run (__run),
4865 frame_index(__frame_index),
4866 timeslice_start(__timeslice_start)
4867 {}
4868
4869
4870 /**
4871 * Virtual destructor.
4872 */
4873 virtual ~JDAQChronometer()
4874 {}
4875
4876
4877 /**
4878 * Get DAQ chronometer.
4879 *
4880 * \return DAQ chronometer
4881 */
4882 const JDAQChronometer& getDAQChronometer() const
4883 {
4884 return static_cast<const JDAQChronometer&>(*this);
4885 }
4886
4887
4888 /**
4889 * Set DAQ chronometer.
4890 *
4891 * \param chronometer DAQ chronometer
4892 */
4893 void setDAQChronometer(const JDAQChronometer& chronometer)
4894 {
4895 static_cast<JDAQChronometer&>(*this) = chronometer;
4896 }
4897
4898
4899 /**
4900 * Get detector identifier.
4901 *
4902 * \return detector identifier
4903 */
4904 int getDetectorID() const
4905 {
4906 return detector_id;
4907 }
4908
4909
4910 /**
4911 * Get run number.
4912 *
4913 * \return run number
4914 */
4915 int getRunNumber() const
4916 {
4917 return run;
4918 }
4919
4920
4921 /**
4922 * Get frame index.
4923 *
4924 * \return frame index
4925 */
4926 int getFrameIndex() const
4927 {
4928 return frame_index;
4929 }
4930
4931
4932 /**
4933 * Get start of timeslice
4934 *
4935 * \return timeslice start
4936 */
4937
4938 JDAQUTCExtended getTimesliceStart() const
4939 {
4940 return timeslice_start;
4941 }
4942
4943
4944 /**
4945 * Set run number.
4946 *
4947 * \param run run number
4948 */
4949 void setRunNumber(const int run)
4950 {
4951 this->run = run;
4952 }
4953
4954
4955 /**
4956 * Set frame index.
4957 *
4958 * \param frame_index frame index
4959 */
4960 void setFrameIndex(const int frame_index)
4961 {
4962 this->frame_index = frame_index;
4963 }
4964
4965
4966 /**
4967 * Set timeslice start time
4968 *
4969 * \param timeslice_start timeslice start time
4970 */
4971 void setTimesliceStart(const JDAQUTCExtended& timeslice_start)
4972 {
4973 this->timeslice_start = timeslice_start;
4974 }
4975
4976
4977 ClassDef(JDAQChronometer,3);
4978
4979
4980 protected:
4981 int detector_id;
4982 int run;
4983 int frame_index;
4984 JDAQUTCExtended timeslice_start;
4985 };
4986
4987
4988 /**
4989 * Print DAQ chronometer.
4990 *
4991 * \param out output stream
4992 * \param chronometer JDAQChronometer
4993 * \return output stream
4994 */
4995 inline std::ostream& operator<<(std::ostream& out, const JDAQChronometer& chronometer)
4996 {
4997 using namespace std;
4998
4999 out << setw(8) << chronometer.getDetectorID();
5000 out << ' ';
5001 out << setw(8) << chronometer.getRunNumber();
5002 out << ' ';
5003 out << setw(8) << chronometer.getFrameIndex();
5004 out << ' ';
5005 out << chronometer.getTimesliceStart();
5006
5007 return out;
5008 }
5009
5010
5011 /**
5012 * Get time of last RTS in ns since start of run for a given chronometer.
5013 *
5014 * \param chronometer chronometer
5015 * \return time [ns]
5016 */
5017 inline double getTimeOfRTS(const JDAQChronometer& chronometer)
5018 {
5019 return getTimeOfRTS(chronometer.getFrameIndex());
5020 }
5021
5022
5023 /**
5024 * Equal operator for DAQ chronometers.
5025 *
5026 * \param first chronometer
5027 * \param second chronometer
5028 * \result true if first chronometer equal to second; else false
5029 */
5030 inline bool operator==(const JDAQChronometer& first,
5031 const JDAQChronometer& second)
5032 {
5033 return (first.getDetectorID() == second.getDetectorID() &&
5034 first.getRunNumber() == second.getRunNumber() &&
5035 first.getFrameIndex() == second.getFrameIndex() &&
5036 first.getTimesliceStart() == second.getTimesliceStart());
5037 }
5038
5039
5040 /**
5041 * Not-equal operator for DAQ chronometers.
5042 *
5043 * \param first chronometer
5044 * \param second chronometer
5045 * \result true if first chronometer not equal to second; else false
5046 */
5047 inline bool operator!=(const JDAQChronometer& first,
5048 const JDAQChronometer& second)
5049 {
5050 return !(first == second);
5051 }
5052
5053
5054 /**
5055 * Get time difference between two chronometers.
5056 *
5057 * \param first chronometer
5058 * \param second chronometer
5059 * \result time difference [s]
5060 */
5061 inline double getTimeDifference(const JDAQChronometer& first, const JDAQChronometer& second)
5062 {
5063 return getTimeDifference(first.getTimesliceStart(), second.getTimesliceStart());
5064 }
5065}
5066
5067#endif
5068#ifndef __JDAQCLOCK__
5069#define __JDAQCLOCK__
5070
5071#include <istream>
5072#include <ostream>
5073#include <exception>
5074#include <cmath>
5075
5076#include "km3net-dataformat/online/JDAQException.hh"
5077
5078
5079/**
5080 * \author mdejong
5081 */
5082
5083namespace KM3NETDAQ {
5084
5085 namespace {
5086 static double FRAME_TIME_NS = 100000000.0; //!< Frame time [ns]
5087 static double RESET_TIME_NS = FRAME_TIME_NS; //!< TDC dynamic range [ns]
5088 }
5089
5090
5091 /**
5092 * Auxiliary class to set DAQ system clock parameters.
5093 */
5094 class JDAQClock {
5095 public:
5096 /**
5097 * Clock types.
5098 */
5099 enum JDAQClock_t { KM3NET = 1, PPM_DU = 3, ANTARES = 101 };
5100
5101
5102 /**
5103 * Constructor.
5104 *
5105 * \param clock clock type
5106 */
5107 JDAQClock(const JDAQClock_t clock = KM3NET)
5108 {
5109 this->clock = clock;
5110
5111 set();
5112 }
5113
5114
5115 /**
5116 * Get clock type.
5117 *
5118 * \return clock type
5119 */
5120 JDAQClock_t get() const
5121 {
5122 return clock;
5123 }
5124
5125
5126 /**
5127 * Set clock type.
5128 *
5129 * \param clock clock type
5130 */
5131 void set(const JDAQClock_t clock)
5132 {
5133 this->clock = clock;
5134
5135 set();
5136 }
5137
5138
5139 /**
5140 * Set DAQ clock parameters.
5141 */
5142 void set()
5143 {
5144 switch (this->clock) {
5145
5146 case KM3NET:
5147 FRAME_TIME_NS = 100000000.0;
5148 RESET_TIME_NS = FRAME_TIME_NS;
5149 break;
5150
5151 case PPM_DU:
5152 FRAME_TIME_NS = (1<<27);
5153 RESET_TIME_NS = FRAME_TIME_NS;
5154 break;
5155
5156 case ANTARES:
5157 FRAME_TIME_NS = 13107200.0 * 8;
5158 RESET_TIME_NS = 419430400.0;
5159 break;
5160
5161 default:
5162 throw JDAQException("Undefined clock.");
5163 }
5164 }
5165
5166
5167 /**
5168 * Read clock from input.
5169 *
5170 * \param in input stream
5171 * \param clock JClock
5172 * \return input stream
5173 */
5174 friend inline std::istream& operator>>(std::istream& in, JDAQClock& clock)
5175 {
5176 using namespace std;
5177
5178 int clk;
5179
5180 in >> clk;
5181
5182 try {
5183 clock.set((JDAQClock_t) clk);
5184 }
5185 catch(const std::exception& error) {
5186 in.setstate(ios_base::badbit);
5187 }
5188
5189 return in;
5190 }
5191
5192
5193 /**
5194 * Write clock to output.
5195 *
5196 * \param out output stream
5197 * \param clock JClock
5198 * \return output stream
5199 */
5200 friend inline std::ostream& operator<<(std::ostream& out, const JDAQClock& clock)
5201 {
5202 return out << clock.clock;
5203 }
5204
5205
5206 protected:
5207 JDAQClock_t clock;
5208 };
5209
5210
5211 /**
5212 * Equal operator for JDAQClock.
5213 *
5214 * \param first JDAQClock
5215 * \param second JDAQClock
5216 * \return true if both clock types are equal; else false
5217 */
5218 inline bool operator==(const JDAQClock& first, const JDAQClock& second)
5219 {
5220 return first.get() == second.get();
5221 }
5222
5223
5224 /**
5225 * Get frame time duration.
5226 *
5227 * \return frame time [ns]
5228 */
5229 inline double getFrameTime()
5230 {
5231 return FRAME_TIME_NS;
5232 }
5233
5234
5235 /**
5236 * Get TDC dynamic range.
5237 *
5238 * \return TDC dynamic range [ns]
5239 */
5240 inline double getRTS()
5241 {
5242 return RESET_TIME_NS;
5243 }
5244
5245
5246 /**
5247 * Get start time of frame in ns since start of run for a given frame index.
5248 *
5249 * \param frame_index frame index
5250 * \return time [ns]
5251 */
5252 inline double getTimeOfFrame(const int frame_index)
5253 {
5254 if (frame_index != 0)
5255 return (double) (frame_index - 1) * FRAME_TIME_NS;
5256 else
5257 return 0;
5258 }
5259
5260
5261 /**
5262 * Get start time of frame in ns since start of run for a given frame index.
5263 *
5264 * \param frame_index frame index
5265 * \return time [ns]
5266 */
5267 inline double getTimeOfFrame(const unsigned int frame_index)
5268 {
5269 if (frame_index != 0)
5270 return (double) (frame_index - 1) * FRAME_TIME_NS;
5271 else
5272 return 0;
5273 }
5274
5275
5276 /**
5277 * Get time of last RTS in ns since start of run for a given time.
5278 *
5279 * \param t_ns time [ns]
5280 * \return time [ns]
5281 */
5282 inline double getTimeOfRTS(const double t_ns)
5283 {
5284 return std::floor(t_ns/RESET_TIME_NS) * RESET_TIME_NS;
5285 }
5286
5287
5288 /**
5289 * Get time of last RTS in ns since start of run for a given frame index.
5290 *
5291 * \param frame_index frame index
5292 * \return time [ns]
5293 */
5294 inline double getTimeOfRTS(const int frame_index)
5295 {
5296 return std::floor(getTimeOfFrame(frame_index)/RESET_TIME_NS) * RESET_TIME_NS;
5297 }
5298
5299
5300 /**
5301 * Get time of last RTS in ns since start of run for a given frame index.
5302 *
5303 * \param frame_index frame index
5304 * \return time [ns]
5305 */
5306 inline double getTimeOfRTS(const unsigned int frame_index)
5307 {
5308 return std::floor(getTimeOfFrame(frame_index)/RESET_TIME_NS) * RESET_TIME_NS;
5309 }
5310
5311
5312 /**
5313 * Get frame index for a given time in ns.
5314 *
5315 * \param t_ns time [ns]
5316 * \return frame index
5317 */
5318 inline int getFrameIndex(const double t_ns)
5319 {
5320 return (int) (t_ns / FRAME_TIME_NS) + 1;
5321 }
5322
5323
5324 /**
5325 * Get time in ns since last RTS for a given frame index.
5326 *
5327 * \param frame_index frame index
5328 * \return time [ns]
5329 */
5330 inline double getTimeSinceRTS(const int frame_index)
5331 {
5332 return std::fmod(getTimeOfFrame(frame_index), RESET_TIME_NS);
5333 }
5334
5335
5336 /**
5337 * Get time in ns since last RTS for a given frame index.
5338 *
5339 * \param frame_index frame index
5340 * \return time [ns]
5341 */
5342 inline double getTimeSinceRTS(const unsigned int frame_index)
5343 {
5344 return std::fmod(getTimeOfFrame(frame_index), RESET_TIME_NS);
5345 }
5346
5347
5348 /**
5349 * Get time in ns since last RTS for a given time in ns.
5350 *
5351 * \param t_ns time [ns]
5352 * \return time [ns]
5353 */
5354 inline double getTimeSinceRTS(const double& t_ns)
5355 {
5356 return std::fmod(t_ns, RESET_TIME_NS);
5357 }
5358}
5359
5360namespace ANTARES {
5361 /**
5362 * Set clock.
5363 */
5364 inline void setClock()
5365 {
5366 KM3NETDAQ::JDAQClock clock(KM3NETDAQ::JDAQClock::ANTARES);
5367 }
5368
5369 using KM3NETDAQ::getFrameTime;
5370 using KM3NETDAQ::getRTS;
5371 using KM3NETDAQ::getTimeOfFrame;
5372 using KM3NETDAQ::getTimeOfRTS;
5373 using KM3NETDAQ::getFrameIndex;
5374 using KM3NETDAQ::getTimeSinceRTS;
5375}
5376
5377namespace KM3NET {
5378 /**
5379 * Set clock.
5380 */
5381 inline void setClock()
5382 {
5383 KM3NETDAQ::JDAQClock clock(KM3NETDAQ::JDAQClock::KM3NET);
5384 }
5385
5386 using KM3NETDAQ::getFrameTime;
5387 using KM3NETDAQ::getRTS;
5388 using KM3NETDAQ::getTimeOfFrame;
5389 using KM3NETDAQ::getTimeOfRTS;
5390 using KM3NETDAQ::getFrameIndex;
5391 using KM3NETDAQ::getTimeSinceRTS;
5392}
5393
5394#endif
5395#ifndef __JDAQDATATYPES__
5396#define __JDAQDATATYPES__
5397
5398#include "km3net-dataformat/definitions/daqdatatypes.hh"
5399
5400/**
5401 * \author mdejong
5402 */
5403
5404namespace KM3NETDAQ {
5405
5406 /**
5407 * Auxiliary class for a DAQ type holder.\n
5408 * This class can be used to transfer a template class to a method argument.
5409 */
5410 template<class T>
5411 struct JDAQType {
5412 typedef T data_type;
5413 };
5414
5415
5416 /**
5417 * Template definition for method returning data type.\n
5418 * The template argument refers to the data type for future I/O operations.
5419 */
5420 template<class T>
5421 inline int getDataType()
5422 {
5423 return getDataType(JDAQType<T>());
5424 }
5425
5426
5427 /**
5428 * Argument definition for method returning data type.\n
5429 * The method argument refers to the data type for future I/O operations.\n
5430 * This method should be overloaded for each corresponding class.
5431 *
5432 * \param type data type
5433 */
5434 template<class T>
5435 inline int getDataType(const JDAQType<T>& type);
5436
5437
5438 class JDAQSuperFrame;
5439 class JDAQSummaryFrame;
5440 class JDAQTimeslice;
5441 struct JDAQTimesliceL0;
5442 struct JDAQTimesliceL1;
5443 struct JDAQTimesliceL2;
5444 struct JDAQTimesliceSN;
5445 class JDAQSummaryslice;
5446 class JDAQEvent;
5447
5448
5449 inline int getDataType(const JDAQType<JDAQSuperFrame>&) { return DAQSUPERFRAME; }
5450 inline int getDataType(const JDAQType<JDAQSummaryFrame>&) { return DAQSUMMARYFRAME; }
5451 inline int getDataType(const JDAQType<JDAQTimeslice>&) { return DAQTIMESLICE; }
5452 inline int getDataType(const JDAQType<JDAQTimesliceL0>&) { return DAQTIMESLICEL0; }
5453 inline int getDataType(const JDAQType<JDAQTimesliceL1>&) { return DAQTIMESLICEL1; }
5454 inline int getDataType(const JDAQType<JDAQTimesliceL2>&) { return DAQTIMESLICEL2; }
5455 inline int getDataType(const JDAQType<JDAQTimesliceSN>&) { return DAQTIMESLICESN; }
5456 inline int getDataType(const JDAQType<JDAQSummaryslice>&) { return DAQSUMMARYSLICE; }
5457 inline int getDataType(const JDAQType<JDAQEvent>&) { return DAQEVENT; }
5458}
5459
5460#endif
5461#ifndef __JDAQEVENT__
5462#define __JDAQEVENT__
5463
5464#include <ostream>
5465#include <iomanip>
5466#include <vector>
5467
5468#include "km3net-dataformat/online/JDAQRoot.hh"
5469#include "km3net-dataformat/online/JDAQPreamble.hh"
5470#include "km3net-dataformat/online/JDAQEventHeader.hh"
5471#include "km3net-dataformat/online/JDAQHit.hh"
5472#include "km3net-dataformat/online/JDAQKeyHit.hh"
5473#include "km3net-dataformat/online/JDAQTriggeredHit.hh"
5474#include "km3net-dataformat/online/JDAQPrint.hh"
5475
5476
5477/**
5478 * \author mdejong
5479 */
5480
5481namespace KM3NETDAQ {
5482
5483
5484 typedef JDAQKeyHit JDAQSnapshotHit;
5485
5486
5487 /**
5488 * DAQ Event.
5489 */
5490 class JDAQEvent :
5491 public JDAQPreamble,
5492 public JDAQEventHeader
5493 {
5494 public:
5495
5496 using JDAQTriggerMask::getTriggerMask;
5497
5498 friend size_t getSizeof(const JDAQEvent&);
5499 friend JReader& operator>>(JReader&, JDAQEvent&);
5500 friend JWriter& operator<<(JWriter&, const JDAQEvent&);
5501
5502 /**
5503 * Default constructor.
5504 */
5505 JDAQEvent() :
5506 JDAQPreamble(JDAQType<JDAQEvent>()),
5507 JDAQEventHeader()
5508 {}
5509
5510
5511 /**
5512 * Constructor.
5513 *
5514 * \param header header
5515 */
5516 JDAQEvent(const JDAQEventHeader& header) :
5517 JDAQPreamble(JDAQType<JDAQEvent>()),
5518 JDAQEventHeader(header)
5519 {}
5520
5521
5522 /**
5523 * Template const_iterator
5524 */
5525 template<class T>
5526 class const_iterator :
5527 public std::vector<T>::const_iterator
5528 {
5529 public:
5530 /**
5531 * Default constructor.
5532 */
5533 const_iterator() :
5534 std::vector<T>::const_iterator()
5535 {}
5536
5537
5538 /**
5539 * Copy constructor.
5540 *
5541 * \param i iterator
5542 */
5543 const_iterator(const typename std::vector<T>::const_iterator& i) :
5544 std::vector<T>::const_iterator(i)
5545 {}
5546 };
5547
5548
5549 /**
5550 * Template const_reverse_iterator
5551 */
5552 template<class T>
5553 class const_reverse_iterator :
5554 public std::vector<T>::const_reverse_iterator
5555 {
5556 public:
5557 /**
5558 * Default constructor.
5559 */
5560 const_reverse_iterator() :
5561 std::vector<T>::const_reverse_iterator()
5562 {}
5563
5564
5565 /**
5566 * Copy constructor.
5567 *
5568 * \param i iterator
5569 */
5570 const_reverse_iterator(const typename std::vector<T>::const_reverse_iterator& i) :
5571 std::vector<T>::const_reverse_iterator(i)
5572 {}
5573 };
5574
5575
5576 /**
5577 * Get container with hits.
5578 *
5579 * \return container with hits
5580 */
5581 template<class T>
5582 const std::vector<T>& getHits() const;
5583
5584
5585 /**
5586 * Get container with hits.
5587 *
5588 * \return container with hits
5589 */
5590 template<class T>
5591 std::vector<T>& getHits();
5592
5593
5594 /**
5595 * Get begin of data.
5596 *
5597 * \return begin of data
5598 */
5599 template<class T>
5600 const_iterator<T> begin() const;
5601
5602
5603 /**
5604 * Get end of data.
5605 *
5606 * \return end of data
5607 */
5608 template<class T>
5609 const_iterator<T> end() const;
5610
5611
5612 /**
5613 * Get reverse begin of data.
5614 *
5615 * \return begin of data
5616 */
5617 template<class T>
5618 const_reverse_iterator<T> rbegin() const;
5619
5620
5621 /**
5622 * Get reverse end of data.
5623 *
5624 * \return end of data
5625 */
5626 template<class T>
5627 const_reverse_iterator<T> rend() const;
5628
5629
5630 /**
5631 * Get number of hits.
5632 *
5633 * \return number of hits
5634 */
5635 template<class T>
5636 unsigned int size() const;
5637
5638
5639 /**
5640 * Check emptyness of hit container.
5641 *
5642 * \return true if empty; else false
5643 */
5644 template<class T>
5645 bool empty() const;
5646
5647
5648 /**
5649 * Clear event.
5650 */
5651 void clear()
5652 {
5653 snapshotHits .clear();
5654 triggeredHits.clear();
5655 }
5656
5657
5658 /**
5659 * Add hit.
5660 *
5661 * \param hit hit
5662 */
5663 void push_back(const JDAQKeyHit& hit)
5664 {
5665 snapshotHits.push_back(hit);
5666 }
5667
5668
5669 /**
5670 * Add hit.
5671 *
5672 * \param hit hit
5673 */
5674 void push_back(const JDAQTriggeredHit& hit)
5675 {
5676 triggeredHits.push_back(hit);
5677 }
5678
5679
5680 /**
5681 * Get trigger mask of given hit.
5682 *
5683 * \param hit hit
5684 * \return trigger mask
5685 */
5686 static JTriggerMask_t getTriggerMask(const JDAQTriggeredHit& hit)
5687 {
5688 return hit.getTriggerMask();
5689 }
5690
5691
5692 /**
5693 * Get trigger mask of given hit.
5694 *
5695 * \param hit hit
5696 * \return trigger mask
5697 */
5698 JTriggerMask_t getTriggerMask(const JDAQSnapshotHit& hit) const
5699 {
5700 for (std::vector<JDAQTriggeredHit>::const_iterator i = triggeredHits.begin(); i != triggeredHits.end(); ++i) {
5701 if (*i == hit) {
5702 return i->getTriggerMask();
5703 }
5704 }
5705
5706 return JTriggerMask_t(0);
5707 }
5708
5709
5710 /**
5711 * Print DAQ Event.
5712 *
5713 * \param out output stream
5714 * \param lpr long print
5715 * \return output stream
5716 */
5717 std::ostream& print(std::ostream& out, const bool lpr = false) const;
5718
5719
5720 ClassDef(JDAQEvent,4);
5721
5722
5723 protected:
5724 std::vector<JDAQTriggeredHit> triggeredHits;
5725 std::vector<JDAQSnapshotHit> snapshotHits;
5726 };
5727
5728
5729 /**
5730 * Equal operator for DAQ events.
5731 *
5732 * \param first event
5733 * \param second event
5734 * \result true if first event equal to second; else false
5735 */
5736 bool operator==(const JDAQEvent& first,
5737 const JDAQEvent& second);
5738
5739
5740 /**
5741 * Not-equal operator for DAQ events.
5742 *
5743 * \param first event
5744 * \param second event
5745 * \result true if first event not equal to second; else false
5746 */
5747 inline bool operator!=(const JDAQEvent& first,
5748 const JDAQEvent& second)
5749 {
5750 return !(first == second);
5751 }
5752
5753
5754 /**
5755 * Print DAQ Event.
5756 *
5757 * \param out output stream
5758 * \param event event
5759 * \return output stream
5760 */
5761 inline std::ostream& operator<<(std::ostream& out, const JDAQEvent& event)
5762 {
5763 return event.print(out, getDAQLongprint());
5764 }
5765
5766
5767 /**
5768 * Get time difference between two events.
5769 *
5770 * \param first event
5771 * \param second event
5772 * \result time difference [s]
5773 */
5774 inline double getTimeDifference(const JDAQEvent& first, const JDAQEvent& second);
5775}
5776
5777#endif
5778#ifndef __JDAQEVENTHEADER__
5779#define __JDAQEVENTHEADER__
5780
5781#include "km3net-dataformat/online/JDAQRoot.hh"
5782#include "km3net-dataformat/online/JDAQHeader.hh"
5783#include "km3net-dataformat/online/JDAQTriggerCounter.hh"
5784#include "km3net-dataformat/online/JDAQTriggerMask.hh"
5785
5786
5787/**
5788 * \author mdejong
5789 */
5790
5791namespace KM3NETDAQ {
5792
5793 /**
5794 * JDAQ event header.
5795 */
5796 class JDAQEventHeader :
5797 public JDAQHeader,
5798 public JDAQTriggerCounter,
5799 public JDAQTriggerMask
5800 {
5801 public:
5802
5803 friend size_t getSizeof<JDAQEventHeader>();
5804 friend JReader& operator>>(JReader&, JDAQEventHeader&);
5805 friend JWriter& operator<<(JWriter&, const JDAQEventHeader&);
5806
5807 /**
5808 * Default constructor.
5809 */
5810 JDAQEventHeader() :
5811 JDAQHeader(),
5812 JDAQTriggerCounter(),
5813 JDAQTriggerMask(),
5814 overlays(0)
5815 {}
5816
5817
5818 /**
5819 * Get DAQ event header.
5820 *
5821 * \return DAQ event header
5822 */
5823 const JDAQEventHeader& getDAQEventHeader() const
5824 {
5825 return static_cast<const JDAQEventHeader&>(*this);
5826 }
5827
5828
5829 /**
5830 * Check if header is same.
5831 *
5832 * \param header DAQ event header
5833 * \return true if event headers are same; else false
5834 */
5835 inline bool is_same(const JDAQEventHeader& header) const
5836 {
5837 return (this->getDetectorID() == header.getDetectorID() &&
5838 this->getRunNumber() == header.getRunNumber() &&
5839 this->getFrameIndex() == header.getFrameIndex() &&
5840 this->getCounter() == header.getCounter());
5841 }
5842
5843
5844 /**
5845 * Get number of overlays.
5846 *
5847 * \return number of overlays
5848 */
5849 unsigned int getOverlays() const
5850 {
5851 return overlays;
5852 }
5853
5854
5855 ClassDef(JDAQEventHeader,3);
5856
5857
5858 protected:
5859 unsigned int overlays;
5860 };
5861
5862
5863 /**
5864 * Equal operator for DAQ event headers.
5865 *
5866 * \param first event header
5867 * \param second event header
5868 * \result true if first event header equal to second; else false
5869 */
5870 inline bool operator==(const JDAQEventHeader& first,
5871 const JDAQEventHeader& second)
5872 {
5873 return (first.getDAQHeader() == second.getDAQHeader() &&
5874 first.getDAQTriggerCounter() == second.getDAQTriggerCounter() &&
5875 first.getDAQTriggerMask() == second.getDAQTriggerMask());
5876 }
5877
5878
5879 /**
5880 * Not-equal operator for DAQ event headers.
5881 *
5882 * \param first event header
5883 * \param second event header
5884 * \result true if first event header not equal to second; else false
5885 */
5886 inline bool operator!=(const JDAQEventHeader& first,
5887 const JDAQEventHeader& second)
5888 {
5889 return !(first == second);
5890 }
5891}
5892
5893#endif
5894#ifndef __JDAQEXCEPTION__
5895#define __JDAQEXCEPTION__
5896
5897#include <exception>
5898#include <ostream>
5899
5900
5901/**
5902 * \author mdejong
5903 */
5904
5905namespace KM3NETDAQ {
5906
5907
5908 /**
5909 * General exception
5910 */
5911 class JDAQException : public std::exception {
5912 public:
5913 /**
5914 * Constructor.
5915 *
5916 * \param error error message
5917 */
5918 JDAQException(const std::string& error) :
5919 std::exception(),
5920 buffer(error)
5921 {}
5922
5923
5924 /**
5925 * Destructor.
5926 */
5927 ~JDAQException() throw()
5928 {}
5929
5930
5931 /**
5932 * Get error message.
5933 *
5934 * \return error message
5935 */
5936 virtual const char* what() const throw()
5937 {
5938 return buffer.c_str();
5939 }
5940
5941
5942 /**
5943 * Print error message of JDAQException.
5944 *
5945 * \param out output stream
5946 * \param exception exception
5947 */
5948 friend inline std::ostream& operator<<(std::ostream& out, const JDAQException& exception)
5949 {
5950 return out << exception.what();
5951 }
5952
5953 private:
5954 const std::string buffer;
5955 };
5956}
5957
5958#endif
5959#ifndef __JDAQFRAME__
5960#define __JDAQFRAME__
5961
5962#include <stdlib.h>
5963#include <string.h>
5964#include <string>
5965#include <iterator>
5966#include <algorithm>
5967
5968#include "km3net-dataformat/online/JDAQHit.hh"
5969#include "km3net-dataformat/online/JDAQRoot.hh"
5970#include "km3net-dataformat/online/JDAQException.hh"
5971
5972
5973/**
5974 * \author mdejong
5975 */
5976namespace KM3NETDAQ {
5977
5978 /**
5979 * Subset of data frame.
5980 **/
5981 class JDAQFrameSubset
5982 {
5983 public:
5984
5985 typedef const JDAQHit* const_iterator;
5986 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
5987
5988
5989 /**
5990 * Constructor.
5991 *
5992 * \param number_of_hits number of hits
5993 * \param data pointer to data
5994 */
5995 JDAQFrameSubset(const int number_of_hits, const JDAQHit* data) :
5996 numberOfHits(number_of_hits),
5997 buffer(data)
5998 {}
5999
6000
6001 const_iterator begin() const { return buffer; }
6002 const_iterator end() const { return buffer + numberOfHits; }
6003
6004 const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
6005 const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
6006
6007 bool empty() const { return numberOfHits == 0; }
6008
6009 int size() const { return numberOfHits; }
6010
6011 const JDAQHit* data() const { return buffer; }
6012
6013
6014 private:
6015 const int numberOfHits;
6016 const JDAQHit* buffer;
6017 };
6018
6019
6020 /**
6021 * Data frame.
6022 */
6023 class JDAQFrame
6024 {
6025 public:
6026
6027 typedef const JDAQHit* const_iterator;
6028 typedef JDAQHit* iterator;
6029 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
6030 typedef std::reverse_iterator<iterator> reverse_iterator;
6031
6032 friend size_t getSizeof(const JDAQFrame&);
6033 friend JReader& operator>>(JReader&, JDAQFrame&);
6034 friend JWriter& operator<<(JWriter&, const JDAQFrame&);
6035
6036 /**
6037 * Default constructor.
6038 */
6039 JDAQFrame() :
6040 numberOfHits(0),
6041 buffer(NULL)
6042 {}
6043
6044
6045 /**
6046 * Copy constructor.
6047 *
6048 * \param frame frame
6049 */
6050 JDAQFrame(const JDAQFrame& frame) :
6051 numberOfHits(0),
6052 buffer(NULL)
6053 {
6054 add(frame);
6055 }
6056
6057
6058 /**
6059 * Move constructor.
6060 *
6061 * \param frame frame
6062 */
6063 JDAQFrame(JDAQFrame&& frame) :
6064 numberOfHits(frame.numberOfHits),
6065 buffer (frame.buffer)
6066 {
6067 frame.numberOfHits = 0;
6068 frame.buffer = NULL;
6069 }
6070
6071
6072 /**
6073 * Constructor.
6074 *
6075 * \param number_of_hits number of hits
6076 * \param data pointer to data
6077 */
6078 JDAQFrame(const int number_of_hits, const JDAQHit* data) :
6079 numberOfHits(0),
6080 buffer(NULL)
6081 {
6082 add(number_of_hits, data);
6083 }
6084
6085
6086 /**
6087 * Destructor.
6088 */
6089 virtual ~JDAQFrame()
6090 {
6091 clear();
6092 }
6093
6094
6095 /**
6096 * Assignment operator.
6097 *
6098 * \param frame frame
6099 * \return this frame
6100 */
6101 JDAQFrame& operator=(const JDAQFrame& frame)
6102 {
6103 add(frame);
6104
6105 return *this;
6106 }
6107
6108
6109 /**
6110 * Clear data.
6111 */
6112 void clear()
6113 {
6114 if (buffer != NULL) {
6115 free(buffer);
6116 }
6117
6118 numberOfHits = 0;
6119 buffer = NULL;
6120 }
6121
6122
6123 const_iterator begin() const { return buffer; }
6124 const_iterator end() const { return buffer + numberOfHits; }
6125
6126
6127 iterator begin() { return buffer; }
6128 iterator end() { return buffer + numberOfHits; }
6129
6130
6131 const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
6132 const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
6133
6134
6135 reverse_iterator rbegin() { return reverse_iterator(end()); }
6136 reverse_iterator rend() { return reverse_iterator(begin()); }
6137
6138
6139 bool empty() const { return numberOfHits == 0; }
6140
6141 int size() const { return numberOfHits; }
6142
6143 const JDAQHit* data() const { return buffer; }
6144 JDAQHit* data() { return buffer; }
6145
6146
6147 /**
6148 * Get hit at given index.
6149 *
6150 * \param index index
6151 * \return hit
6152 */
6153 const JDAQHit& operator[](int index) const
6154 {
6155 return buffer[index];
6156 }
6157
6158 /**
6159 * Get subset of data.
6160 *
6161 * \param i1 first index of hit (included)
6162 * \param i2 last index of hit (excluded)
6163 * \return frame
6164 */
6165 JDAQFrameSubset subset(const int i1, const int i2) const
6166 {
6167 return JDAQFrameSubset(i2 - i1, buffer + i1);
6168 }
6169
6170
6171 /**
6172 * Add data.
6173 *
6174 * \param frame frame
6175 * \return this frame
6176 */
6177 JDAQFrame& add(const JDAQFrame& frame)
6178 {
6179 return add(frame.numberOfHits, frame.buffer);
6180 }
6181
6182
6183 /**
6184 * Add data.
6185 *
6186 * \param number_of_hits number of hits
6187 * \param data pointer to data
6188 * \return this data frame
6189 */
6190 JDAQFrame& add(const int number_of_hits, const JDAQHit* data)
6191 {
6192 if (number_of_hits > 0) {
6193
6194 resize(numberOfHits + number_of_hits);
6195
6196 memcpy(buffer + numberOfHits - number_of_hits, data, number_of_hits * sizeof(JDAQHit));
6197 }
6198
6199 return *this;
6200 }
6201
6202
6203 /**
6204 * Swap data.
6205 *
6206 * \param frame frame
6207 */
6208 void swap(JDAQFrame& frame)
6209 {
6210 std::swap(numberOfHits, frame.numberOfHits);
6211 std::swap(buffer, frame.buffer);
6212 }
6213
6214
6215 int numberOfHits; // following comment line is used by rootcint
6216 JDAQHit* buffer; // [numberOfHits]
6217
6218
6219 ClassDef(JDAQFrame,1);
6220
6221
6222 protected:
6223 /**
6224 * Resize internal buffer.
6225 *
6226 * This method increases the size of the buffer if necessary.
6227 * Otherwise, the current size is maintained.
6228 *
6229 * \param number_of_hits total number of hits to allocate
6230 */
6231 void resize(const int number_of_hits)
6232 {
6233 if (number_of_hits > numberOfHits) {
6234
6235 const int number_of_bytes = number_of_hits * sizeof(JDAQHit);
6236
6237 if (buffer == NULL)
6238 buffer = (JDAQHit*) malloc(number_of_bytes);
6239 else
6240 buffer = (JDAQHit*) realloc(buffer, number_of_bytes);
6241
6242 if (buffer == NULL) {
6243 throw JDAQException("JDAQFrame::resize(): Memory exception - number of hits = " + std::to_string(number_of_hits));
6244 }
6245
6246 numberOfHits = number_of_hits;
6247 }
6248 }
6249 };
6250
6251
6252 /**
6253 * Equal operator for DAQ frames.
6254 *
6255 * \param first frame
6256 * \param second frame
6257 * \result true if first frame equal to second; else false
6258 */
6259 inline bool operator==(const JDAQFrame& first,
6260 const JDAQFrame& second)
6261 {
6262 if (first.size() == second.size()) {
6263
6264 for (JDAQFrame::const_iterator p = first.begin(), q = second.begin(); p != first.end(); ++p, ++q) {
6265 if (*p != *q) {
6266 return false;
6267 }
6268 }
6269
6270 return true;
6271
6272 } else {
6273
6274 return false;
6275 }
6276 }
6277
6278
6279 /**
6280 * Not-equal operator for DAQ frames.
6281 *
6282 * \param first frame
6283 * \param second frame
6284 * \result true if first frame not equal to second; else false
6285 */
6286 inline bool operator!=(const JDAQFrame& first,
6287 const JDAQFrame& second)
6288 {
6289 return !(first == second);
6290 }
6291}
6292
6293#endif
6294#ifndef __JDAQFRAMESTATUS__
6295#define __JDAQFRAMESTATUS__
6296
6297#include "km3net-dataformat/online/JDAQ.hh"
6298#include "km3net-dataformat/online/JDAQException.hh"
6299#include "km3net-dataformat/online/JDAQRoot.hh"
6300
6301
6302/**
6303 * \author mdejong
6304 */
6305namespace KM3NETDAQ {
6306
6307 /**
6308 * DAQ frame status.
6309 */
6310 class JDAQFrameStatus {
6311 public:
6312
6313 friend size_t getSizeof<JDAQFrameStatus>();
6314 friend JReader& operator>>(JReader&, JDAQFrameStatus&);
6315 friend JWriter& operator<<(JWriter&, const JDAQFrameStatus&);
6316
6317 /**
6318 * Default constructor.
6319 */
6320 JDAQFrameStatus() :
6321 daq (0),
6322 status (0),
6323 fifo (0),
6324 status_3(0),
6325 status_4(0)
6326 {}
6327
6328
6329 /**
6330 * Constructor.
6331 *
6332 * \param __daq DAQ status
6333 * \param __status TDC status
6334 * \param __fifo FIFO status
6335 * \param __status_3 spare
6336 * \param __status_4 spare
6337 */
6338 JDAQFrameStatus(const int __daq,
6339 const int __status,
6340 const int __fifo,
6341 const int __status_3 = 0,
6342 const int __status_4 = 0) :
6343 daq (__daq),
6344 status (__status),
6345 fifo (__fifo),
6346 status_3(__status_3),
6347 status_4(__status_4)
6348 {}
6349
6350
6351 /**
6352 * Get reference to unique instance of this class object.
6353 *
6354 * This instance has default values which correspond to a valid DAQ frame status.
6355 *
6356 * \return reference to this class object
6357 */
6358 static const JDAQFrameStatus& getInstance()
6359 {
6360 static const JDAQFrameStatus status(DAQ_UDP_RECEIVED_PACKETS.write(2) | DAQ_UDP_SEQUENCE_NUMBER.write(1),
6361 DAQ_WHITE_RABBIT.write(1),
6362 DAQ_FIFO.write(0) | DAQ_UDP_TRAILER.write(1));
6363
6364 return status;
6365 }
6366
6367
6368 /**
6369 * Get DAQ frame status.
6370 *
6371 * \return DAQ frame status
6372 */
6373 const JDAQFrameStatus& getDAQFrameStatus() const
6374 {
6375 return static_cast<const JDAQFrameStatus&>(*this);
6376 }
6377
6378
6379 /**
6380 * Set DAQ frame status.
6381 *
6382 * \param status DAQ frame status
6383 */
6384 void setDAQFrameStatus(const JDAQFrameStatus& status)
6385 {
6386 static_cast<JDAQFrameStatus&>(*this) = status;
6387 }
6388
6389
6390 /**
6391 * Get DAQ status.
6392 *
6393 * \return DAQ status
6394 */
6395 int getDAQStatus() const
6396 {
6397 return this->daq;
6398 }
6399
6400
6401 /**
6402 * Get TDC and White Rabbit status.
6403 *
6404 * \return status
6405 */
6406 int getStatus() const
6407 {
6408 return this->status;
6409 }
6410
6411
6412 /**
6413 * Get FIFO status.
6414 *
6415 * \return FIFO status
6416 */
6417 int getFIFOStatus() const
6418 {
6419 return this->fifo;
6420 }
6421
6422
6423 /**
6424 * Test DAQ status of packets.
6425 *
6426 * \return true if okay; else false
6427 */
6428 bool testDAQStatus() const
6429 {
6430 return (getUDPNumberOfReceivedPackets() == (getUDPMaximalSequenceNumber() + 1)) && hasUDPTrailer();
6431 }
6432
6433
6434 /**
6435 * Test TDC and White Rabbit status.
6436 *
6437 * \return true if okay; else false
6438 */
6439 bool testStatus() const
6440 {
6441 return testWhiteRabbitStatus() && testTDCStatus();
6442 }
6443
6444
6445 /**
6446 * Get number of received UDP packets.
6447 *
6448 * \return UDP received packets
6449 */
6450 int getUDPNumberOfReceivedPackets() const
6451 {
6452 return DAQ_UDP_RECEIVED_PACKETS.read(this->daq);
6453 }
6454
6455
6456 /**
6457 * Get maximal sequence number of UDP packet.
6458 *
6459 * \return UDP sequence number
6460 */
6461 int getUDPMaximalSequenceNumber() const
6462 {
6463 return DAQ_UDP_SEQUENCE_NUMBER.read(this->daq);
6464 }
6465
6466
6467 /**
6468 * Test White Rabbit status.
6469 *
6470 * \return true if okay; else false
6471 */
6472 bool testWhiteRabbitStatus() const
6473 {
6474 return DAQ_WHITE_RABBIT.has(this->status);
6475 }
6476
6477
6478 /**
6479 * Test TDC status.
6480 *
6481 * \return true if okay; else false
6482 */
6483 bool testTDCStatus() const
6484 {
6485 return !testHighRateVeto();
6486 }
6487
6488
6489 /**
6490 * Test high-rate veto status.
6491 *
6492 * \return true if one of the TDCs is high-rate vetoed; else false
6493 */
6494 bool testHighRateVeto() const
6495 {
6496 return DAQ_TDC.has(this->status);
6497 }
6498
6499
6500 /**
6501 * Test high-rate veto status.
6502 *
6503 * \param tdc TDC
6504 * \return true if TDC is high-rate vetoed; else false
6505 */
6506 bool testHighRateVeto(const int tdc) const
6507 {
6508 return JBit(tdc).has(this->status);
6509 }
6510
6511
6512 /**
6513 * Count high-rate veto status.
6514 *
6515 * \return number of the TDCs with high-rate veto
6516 */
6517 int countHighRateVeto() const
6518 {
6519 int n = 0;
6520
6521 if (testHighRateVeto()) {
6522 for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
6523 if (JBit(pmt).has(this->status)) {
6524 ++n;
6525 }
6526 }
6527 }
6528
6529 return n;
6530 }
6531
6532
6533 /**
6534 * Test FIFO status.
6535 *
6536 * \return true if one of the TDCs has FIFO almost full; else false
6537 */
6538 bool testFIFOStatus() const
6539 {
6540 return DAQ_FIFO.has(this->fifo);
6541 }
6542
6543
6544 /**
6545 * Test FIFO status.
6546 *
6547 * \param tdc TDC
6548 * \return true if FIFO is almost full; else false
6549 */
6550 bool testFIFOStatus(const int tdc) const
6551 {
6552 return JBit(tdc).has(this->fifo);
6553 }
6554
6555
6556 /**
6557 * Count FIFO status.
6558 *
6559 * \return number of the TDCs with FIFO almost full
6560 */
6561 int countFIFOStatus() const
6562 {
6563 int n = 0;
6564
6565 if (testFIFOStatus()) {
6566 for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
6567 if (JBit(pmt).has(this->fifo)) {
6568 ++n;
6569 }
6570 }
6571 }
6572
6573 return n;
6574 }
6575
6576 /**
6577 * Count active channels.
6578 * \return number of TDCs without high rate veto or FIFO almost full
6579 */
6580 int countActiveChannels() const
6581 {
6582 int n = NUMBER_OF_PMTS;
6583
6584 if (testHighRateVeto() || testFIFOStatus()) {
6585 for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
6586 if ( JBit(pmt).has(this->status) || JBit(pmt).has(this->fifo) ) {
6587 --n;
6588 }
6589 }
6590 }
6591
6592 return n;
6593
6594 }
6595
6596
6597 /**
6598 * Get UDP trailer status.
6599 *
6600 * \return true if UDP trailer present; else false
6601 */
6602 bool hasUDPTrailer() const
6603 {
6604 return DAQ_UDP_TRAILER.has(this->fifo);
6605 }
6606
6607
6608 /**
6609 * Set high-rate veto.
6610 *
6611 * \param tdc TDC
6612 * \param value value
6613 */
6614 void setHighRateVeto(const int tdc, const bool value)
6615 {
6616 JBit(tdc).set(this->status, value);
6617 }
6618
6619
6620 ClassDefNV(JDAQFrameStatus,1);
6621
6622 protected:
6623 int daq; // DAQ status
6624 int status; // TDC status
6625 int fifo; // FIFO status
6626 int status_3; // spare
6627 int status_4; // spare
6628 };
6629
6630
6631 /**
6632 * Equal operator for DAQ frame status.
6633 *
6634 * \param first frame status
6635 * \param second frame status
6636 * \result true if first frame status equal to second; else false
6637 */
6638 inline bool operator==(const JDAQFrameStatus& first,
6639 const JDAQFrameStatus& second)
6640 {
6641 return (first.getDAQStatus() == second.getDAQStatus() &&
6642 first.getStatus() == second.getStatus() &&
6643 first.getFIFOStatus() == second.getFIFOStatus());
6644 }
6645
6646
6647 /**
6648 * Not-equal operator for DAQ frame status.
6649 *
6650 * \param first frame status
6651 * \param second frame status
6652 * \result true if first frame status not equal to second; else false
6653 */
6654 inline bool operator!=(const JDAQFrameStatus& first,
6655 const JDAQFrameStatus& second)
6656 {
6657 return !(first == second);
6658 }
6659}
6660
6661#endif
6662#ifndef __JDAQHEADER__
6663#define __JDAQHEADER__
6664
6665#include "km3net-dataformat/online/JDAQRoot.hh"
6666#include "km3net-dataformat/online/JDAQChronometer.hh"
6667
6668
6669/**
6670 * \author mdejong
6671 */
6672
6673namespace KM3NETDAQ {
6674
6675 /**
6676 * DAQ header.
6677 */
6678 class JDAQHeader :
6679 public JDAQChronometer
6680 {
6681 public:
6682
6683 friend size_t getSizeof<JDAQHeader>();
6684 friend JReader& operator>>(JReader&, JDAQHeader&);
6685 friend JWriter& operator<<(JWriter&, const JDAQHeader&);
6686
6687 /**
6688 * Default constructor.
6689 */
6690 JDAQHeader() :
6691 JDAQChronometer()
6692 {}
6693
6694
6695 /**
6696 * Constructor.
6697 *
6698 * \param chronometer chronometer
6699 */
6700 JDAQHeader(const JDAQChronometer& chronometer) :
6701 JDAQChronometer(chronometer)
6702 {}
6703
6704
6705 /**
6706 * Get DAQ header.
6707 *
6708 * \return DAQ header
6709 */
6710 const JDAQHeader& getDAQHeader() const
6711 {
6712 return static_cast<const JDAQHeader&>(*this);
6713 }
6714
6715
6716 /**
6717 * Set DAQ header.
6718 *
6719 * \param header DAQ header
6720 */
6721 void setDAQHeader(const JDAQHeader& header)
6722 {
6723 static_cast<JDAQHeader&>(*this) = header;
6724 }
6725
6726
6727 ClassDef(JDAQHeader,2);
6728 };
6729
6730
6731 /**
6732 * Equal operator for DAQ headers.
6733 *
6734 * \param first header
6735 * \param second header
6736 * \result true if first header equal to second; else false
6737 */
6738 inline bool operator==(const JDAQHeader& first,
6739 const JDAQHeader& second)
6740 {
6741 return (first.getDAQChronometer() == second.getDAQChronometer());
6742 }
6743
6744
6745 /**
6746 * Not-equal operator for DAQ headers.
6747 *
6748 * \param first header
6749 * \param second header
6750 * \result true if first header not equal to second; else false
6751 */
6752 inline bool operator!=(const JDAQHeader& first,
6753 const JDAQHeader& second)
6754 {
6755 return !(first == second);
6756 }
6757}
6758
6759#endif
6760#ifndef __JDAQHIT__
6761#define __JDAQHIT__
6762
6763#include <istream>
6764#include <ostream>
6765#include <iomanip>
6766
6767#ifndef __CINT__
6768#include <netinet/in.h>
6769#endif
6770
6771#include "km3net-dataformat/online/JDAQ.hh"
6772#include "km3net-dataformat/online/JDAQRoot.hh"
6773#include "km3net-dataformat/online/JDAQException.hh"
6774
6775
6776/**
6777 * \author mdejong
6778 */
6779
6780namespace KM3NETDAQ {
6781 /**
6782 * Hit data structure.
6783 *
6784 * N.B.
6785 * The size of this data structure (i.e. the value obtained with the <tt>sizeof()</tt> operator
6786 * should exactly match the preset number of bytes from the DAQ system.
6787 * The <tt>pragma</tt> statement is necessary to ensure the correct size of this object.
6788 * Furthermore, this data structure should have no virtual methods and no virtual destructor.
6789 * Consequently, the standard ROOT <tt>CLassDef()</tt> macro is replaced by
6790 * the designated <tt>ClassDefNV()</tt> macro.
6791 */
6792#pragma pack(push,1)
6793 class JDAQHit
6794 {
6795 public:
6796
6797 typedef unsigned char JPMT_t; //!< PMT channel in FPGA
6798 typedef unsigned int JTDC_t; //!< leading edge [ns]
6799 typedef unsigned char JTOT_t; //!< time over threshold [ns]
6800
6801 friend size_t getSizeof<JDAQHit>();
6802 friend JReader& operator>>(JReader&, JDAQHit&);
6803 friend JWriter& operator<<(JWriter&, const JDAQHit&);
6804
6805 /**
6806 * Default constructor.
6807 */
6808 JDAQHit()
6809 {}
6810
6811
6812 /**
6813 * Constructor.
6814 *
6815 * \param pmt_id PMT channel
6816 * \param tdc_ns time of hit [ns]
6817 * \param tot_ns time over threshold [ns]
6818 */
6819 JDAQHit(const JPMT_t pmt_id,
6820 const JTDC_t tdc_ns,
6821 const JTOT_t tot_ns) :
6822 pmt(pmt_id),
6823 tdc(htonl(tdc_ns)),
6824 //tdc(tdc_ns),
6825 tot(tot_ns)
6826 {}
6827
6828
6829 /**
6830 * Get PMT.
6831 *
6832 * \return PMT
6833 */
6834 inline JPMT_t getPMT() const
6835 {
6836 return pmt;
6837 }
6838
6839
6840 /**
6841 * Get time.
6842 *
6843 * \return time [ns]
6844 */
6845 inline JTDC_t getT() const
6846 {
6847 return ntohl(tdc);
6848 }
6849
6850
6851 /**
6852 * Get time-over-threshold.
6853 *
6854 * \return time-over-threshold [ns]
6855 */
6856 inline JTOT_t getToT() const
6857 {
6858 return tot;
6859 }
6860
6861
6862 /**
6863 * Get maximal time-over-threshold.
6864 *
6865 * \return time-over-threshold [ns]
6866 */
6867 static JTOT_t getMaximalToT()
6868 {
6869 return 0xFF;
6870 }
6871
6872
6873 /**
6874 * Read DAQ hit from input.
6875 *
6876 * \param in input stream
6877 * \param hit hit
6878 * \return input stream
6879 */
6880 friend inline std::istream& operator>>(std::istream& in, JDAQHit& hit)
6881 {
6882 int pmt;
6883 int tdc;
6884 int tot;
6885
6886 if (in >> pmt >> tdc >> tot) {
6887 hit = JDAQHit(pmt, tdc, tot);
6888 }
6889
6890 return in;
6891 }
6892
6893
6894 /**
6895 * Write DAQ hit to output.
6896 *
6897 * \param out output stream
6898 * \param hit hit
6899 * \return output stream
6900 */
6901 friend inline std::ostream& operator<<(std::ostream& out, const JDAQHit& hit)
6902 {
6903 using namespace std;
6904
6905 out << setw(2) << (int) hit.getPMT() << ' '
6906 << setw(8) << (int) hit.getT() << ' '
6907 << setw(3) << (int) hit.getToT();
6908
6909 return out;
6910 }
6911
6912
6913 ClassDefNV(JDAQHit,2);
6914
6915
6916 protected:
6917 JPMT_t pmt; //!< PMT readout channel in FPGA
6918 JTDC_t tdc; //!< leading edge [ns]
6919 JTOT_t tot; //!< time over threshold [ns]
6920 };
6921#pragma pack(pop)
6922
6923
6924 /**
6925 * Less than operator for DAQ hits.
6926 *
6927 * The less than operator is applied first to the time and then to the PMT channel of the hits.
6928 *
6929 * \param first hit
6930 * \param second hit
6931 * \result true if first hit earlier than second; else false
6932 */
6933 inline bool operator<(const JDAQHit& first,
6934 const JDAQHit& second)
6935 {
6936 if (first.getT() != second.getT())
6937 return first.getT() < second.getT();
6938 else
6939 return first.getPMT() < second.getPMT();
6940 }
6941
6942
6943 /**
6944 * Equal operator for DAQ hits.
6945 *
6946 * \param first hit
6947 * \param second hit
6948 * \result true if first hit equal to second; else false
6949 */
6950 inline bool operator==(const JDAQHit& first,
6951 const JDAQHit& second)
6952 {
6953 return (first.getPMT() == second.getPMT() &&
6954 first.getT() == second.getT() &&
6955 first.getToT() == second.getToT());
6956 }
6957
6958
6959 /**
6960 * Not-equal operator for DAQ hits.
6961 *
6962 * \param first hit
6963 * \param second hit
6964 * \result true if first hit not equal to second; else false
6965 */
6966 inline bool operator!=(const JDAQHit& first,
6967 const JDAQHit& second)
6968 {
6969 return !(first == second);
6970 }
6971}
6972
6973#endif
6974#ifndef __JDAQKEYHIT__
6975#define __JDAQKEYHIT__
6976
6977#include "km3net-dataformat/online/JDAQRoot.hh"
6978#include "km3net-dataformat/online/JDAQModuleIdentifier.hh"
6979#include "km3net-dataformat/online/JDAQHit.hh"
6980#include "km3net-dataformat/online/JDAQPMTIdentifier.hh"
6981
6982
6983/**
6984 * \author mdejong
6985 */
6986
6987namespace KM3NETDAQ {
6988
6989 /**
6990 * DAQ key hit
6991 */
6992 class JDAQKeyHit :
6993 public JDAQModuleIdentifier,
6994 public JDAQHit
6995 {
6996 public:
6997
6998 friend size_t getSizeof<JDAQKeyHit>();
6999 friend JReader& operator>>(JReader&, JDAQKeyHit&);
7000 friend JWriter& operator<<(JWriter&, const JDAQKeyHit&);
7001
7002 /**
7003 * Default constructor.
7004 */
7005 JDAQKeyHit() :
7006 JDAQModuleIdentifier(),
7007 JDAQHit()
7008 {}
7009
7010
7011 /**
7012 * Constructor.
7013 *
7014 * \param id module identifier
7015 * \param hit PMT hit
7016 */
7017 JDAQKeyHit(const JDAQModuleIdentifier& id,
7018 const JDAQHit& hit) :
7019 JDAQModuleIdentifier(id),
7020 JDAQHit(hit)
7021 {}
7022
7023
7024 /**
7025 * Virtual destructor.
7026 */
7027 virtual ~JDAQKeyHit()
7028 {}
7029
7030
7031 /**
7032 * Type conversion operator.
7033 *
7034 * \return axis
7035 */
7036 operator JDAQPMTIdentifier () const
7037 {
7038 return JDAQPMTIdentifier(this->getModuleID(), this->getPMT());
7039 }
7040
7041
7042 ClassDef(JDAQKeyHit,1);
7043 };
7044
7045
7046
7047 /**
7048 * Less than operator for DAQ hits.
7049 *
7050 * The less than operator is applied first to the module idientifier then to the PMT channel and then to the time of the hits.
7051 *
7052 * \param first hit
7053 * \param second hit
7054 * \result true if first hit before than second; else false
7055 */
7056 inline bool operator<(const JDAQKeyHit& first,
7057 const JDAQKeyHit& second)
7058 {
7059 if (first.getModuleID() == second.getModuleID()) {
7060 if (first.getPMT() == second.getPMT())
7061 return first.getT() < second.getT();
7062 else
7063 return first.getPMT() < second.getPMT();
7064 } else
7065 return first.getModuleID() < second.getModuleID();
7066 }
7067
7068
7069
7070 /**
7071 * Equal operator for DAQ hits.
7072 *
7073 * The equal operator is applied to the module idientifier, to the PMT channel and to the time of the hits.
7074 *
7075 * \param first hit
7076 * \param second hit
7077 * \result t rue if first hit equal to second; else false
7078 */
7079 inline bool operator==(const JDAQKeyHit& first,
7080 const JDAQKeyHit& second)
7081 {
7082 return (first.getModuleID() == second.getModuleID() &&
7083 first.getPMT() == second.getPMT() &&
7084 first.getT() == second.getT());
7085 }
7086
7087
7088 /**
7089 * Not-equal operator for DAQ hits.
7090 *
7091 * \param first hit
7092 * \param second hit
7093 * \result true if first hit not equal to second; else false
7094 */
7095 inline bool operator!=(const JDAQKeyHit& first,
7096 const JDAQKeyHit& second)
7097 {
7098 return !(first == second);
7099 }
7100}
7101
7102#endif
7103#ifndef __JDAQMODULEIDENTIFIER__
7104#define __JDAQMODULEIDENTIFIER__
7105
7106#include <istream>
7107#include <ostream>
7108
7109#include "km3net-dataformat/online/JDAQRoot.hh"
7110
7111
7112/**
7113 * \author mdejong
7114 */
7115
7116namespace KM3NETDAQ {
7117
7118 /**
7119 * Module identifier.
7120 */
7121 class JDAQModuleIdentifier
7122 {
7123 public:
7124
7125 friend size_t getSizeof<JDAQModuleIdentifier>();
7126 friend JReader& operator>>(JReader&, JDAQModuleIdentifier&);
7127 friend JWriter& operator<<(JWriter&, const JDAQModuleIdentifier&);
7128
7129 /**
7130 * Default constructor.
7131 */
7132 JDAQModuleIdentifier() :
7133 id(-1)
7134 {}
7135
7136
7137 /**
7138 * Constructor.
7139 *
7140 * \param __id module identifier
7141 */
7142 JDAQModuleIdentifier(const int __id) :
7143 id(__id)
7144 {}
7145
7146
7147 /**
7148 * Get Module identifier.
7149 *
7150 * \return Module identifier
7151 */
7152 const JDAQModuleIdentifier& getModuleIdentifier() const
7153 {
7154 return *this;
7155 }
7156
7157
7158 /**
7159 * Set Module identifier.
7160 *
7161 * \param module Module identifier
7162 */
7163 void setModuleIdentifier(const JDAQModuleIdentifier& module)
7164 {
7165 *this = module;
7166 }
7167
7168
7169 /**
7170 * Get module identifier.
7171 *
7172 * \return module identifier
7173 */
7174 int getModuleID() const
7175 {
7176 return id;
7177 }
7178
7179
7180 /**
7181 * Read DAQ ModuleIdentifier from input.
7182 *
7183 * \param in input stream
7184 * \param module module identifier
7185 * \return input stream
7186 */
7187 friend inline std::istream& operator>>(std::istream& in, JDAQModuleIdentifier& module)
7188 {
7189 in >> module.id;
7190
7191 return in;
7192 }
7193
7194
7195 /**
7196 * Write DAQ ModuleIdentifier to output.
7197 *
7198 * \param out output stream
7199 * \param module module identifier
7200 * \return output stream
7201 */
7202 friend inline std::ostream& operator<<(std::ostream& out, const JDAQModuleIdentifier& module)
7203 {
7204 out << module.id;
7205
7206 return out;
7207 }
7208
7209
7210 ClassDefNV(JDAQModuleIdentifier,1);
7211
7212
7213 protected:
7214 int id;
7215 };
7216
7217
7218 /**
7219 * Equal operator.
7220 *
7221 * \param first first module identifier
7222 * \param second second module identifier
7223 * \return true if identifiers are equal; else false
7224 */
7225 inline bool operator==(const JDAQModuleIdentifier& first, const JDAQModuleIdentifier& second)
7226 {
7227 return first.getModuleID() == second.getModuleID();
7228 }
7229
7230
7231 /**
7232 * Not equal operator.
7233 *
7234 * \param first first module identifier
7235 * \param second second module identifier
7236 * \return true if identifiers are different; else false
7237 */
7238 inline bool operator!=(const JDAQModuleIdentifier& first, const JDAQModuleIdentifier& second)
7239 {
7240 return first.getModuleID() != second.getModuleID();
7241 }
7242
7243
7244 /**
7245 * Equal operator.
7246 *
7247 * \param module module identifier
7248 * \param id identifier
7249 * \return true if identifiers are equal; else false
7250 */
7251 inline bool operator==(const JDAQModuleIdentifier& module, const int id)
7252 {
7253 return module.getModuleID() == id;
7254 }
7255
7256
7257 /**
7258 * Not equal operator.
7259 *
7260 * \param module module identifier
7261 * \param id identifier
7262 * \return true if identifiers are different; else false
7263 */
7264 inline bool operator!=(const JDAQModuleIdentifier& module, const int id)
7265 {
7266 return module.getModuleID() != id;
7267 }
7268
7269
7270 /**
7271 * Less than operator.
7272 *
7273 * \param first first module identifier
7274 * \param second second module identifier
7275 * \return true if first identifier less than second eidentifier; else false
7276 */
7277 inline bool operator<(const JDAQModuleIdentifier& first, const JDAQModuleIdentifier& second)
7278 {
7279 return first.getModuleID() < second.getModuleID();
7280 }
7281
7282
7283 /**
7284 * Less than operator.
7285 *
7286 * \param module module identifier
7287 * \param id identifier
7288 * \return true if module identifier less than identifier; else false
7289 */
7290 inline bool operator<(const JDAQModuleIdentifier& module, const int id)
7291 {
7292 return module.getModuleID() < id;
7293 }
7294
7295
7296 /**
7297 * Auxiliary class to compare modules.
7298 */
7299 struct JDAQModuleComparator {
7300 /*
7301 * Default constructor.
7302 */
7303 JDAQModuleComparator()
7304 {}
7305
7306
7307 /**
7308 * Compare modules.
7309 *
7310 * \param first first module
7311 * \param second second module
7312 * \return true if first module identifier less than that of second; else false
7313 */
7314 bool operator()(const JDAQModuleIdentifier& first, const JDAQModuleIdentifier& second) const
7315 {
7316 return first.getModuleID() < second.getModuleID();
7317 }
7318 };
7319}
7320
7321#endif
7322#ifndef __JDAQPMTIDENTIFIER__
7323#define __JDAQPMTIDENTIFIER__
7324
7325#include <istream>
7326#include <ostream>
7327
7328#include "km3net-dataformat/online/JDAQModuleIdentifier.hh"
7329#include "km3net-dataformat/online/JDAQRoot.hh"
7330
7331
7332/**
7333 * \author mdejong
7334 */
7335
7336namespace KM3NETDAQ {
7337
7338 /**
7339 * PMT identifier.
7340 */
7341 class JDAQPMTIdentifier :
7342 public JDAQModuleIdentifier
7343 {
7344 public:
7345
7346 friend size_t getSizeof<JDAQPMTIdentifier>();
7347 friend JReader& operator>>(JReader&, JDAQPMTIdentifier&);
7348 friend JWriter& operator<<(JWriter&, const JDAQPMTIdentifier&);
7349
7350 /**
7351 * Default constructor.
7352 */
7353 JDAQPMTIdentifier() :
7354 JDAQModuleIdentifier(),
7355 address (0)
7356 {}
7357
7358
7359 /**
7360 * Constructor.
7361 *
7362 * \param id module identifier
7363 * \param pmt_address PMT address
7364 */
7365 JDAQPMTIdentifier(const JDAQModuleIdentifier& id,
7366 const int pmt_address) :
7367 JDAQModuleIdentifier(id),
7368 address (pmt_address)
7369 {}
7370
7371
7372 /**
7373 * Get PMT identifier.
7374 *
7375 * \return PMT identifier
7376 */
7377 const JDAQPMTIdentifier& getPMTIdentifier() const
7378 {
7379 return *this;
7380 }
7381
7382
7383 /**
7384 * Set PMT identifier.
7385 *
7386 * \param pmt PMT identifier
7387 */
7388 void setPMTIdentifier(const JDAQPMTIdentifier& pmt)
7389 {
7390 *this = pmt;
7391 }
7392
7393
7394 /**
7395 * Get PMT identifier.
7396 *
7397 * \return PMT identifier
7398 */
7399 int getPMTAddress() const
7400 {
7401 return address;
7402 }
7403
7404
7405 /**
7406 * Read PMT identifier from input.
7407 *
7408 * \param in input stream
7409 * \param pmt PMT identifier
7410 * \return input stream
7411 */
7412 friend inline std::istream& operator>>(std::istream& in, JDAQPMTIdentifier& pmt)
7413 {
7414 in >> static_cast<JDAQModuleIdentifier&>(pmt);
7415 in >> pmt.address;
7416
7417 return in;
7418 }
7419
7420
7421 /**
7422 * Write PMT identifier to output.
7423 *
7424 * \param out output stream
7425 * \param pmt PMT identifier
7426 * \return output stream
7427 */
7428 friend inline std::ostream& operator<<(std::ostream& out, const JDAQPMTIdentifier& pmt)
7429 {
7430 out << static_cast<const JDAQModuleIdentifier&>(pmt) << ' ';
7431 out << pmt.address;
7432
7433 return out;
7434 }
7435
7436
7437 /**
7438 * Compare PMT identifiers.
7439 *
7440 * The comparison is applied to the module identifer and to the PMT address.
7441 * If the module identifier or PMT address is <tt>-1</tt>, the corresponding comparison evaluates to <tt>true</tt>.
7442 *
7443 * \param first PMT identifier
7444 * \param second PMT identifier
7445 * \result true if first PMT equal second PMT; else false
7446 */
7447 static inline bool compare(const JDAQPMTIdentifier& first, const JDAQPMTIdentifier& second)
7448 {
7449 return ((first .getModuleIdentifier() == second.getModuleIdentifier() ||
7450 first .getModuleIdentifier() == -1 ||
7451 second.getModuleIdentifier() == -1) &&
7452 (first .getPMTAddress() == second.getPMTAddress() ||
7453 first .getPMTAddress() == -1 ||
7454 second.getPMTAddress() == -1));
7455 }
7456
7457
7458 ClassDefNV(JDAQPMTIdentifier,1);
7459
7460
7461 protected:
7462 int address;
7463 };
7464
7465
7466 /**
7467 * Less than operator for PMT identifiers.
7468 *
7469 * The less than operator is applied first to the module identifer and then to the PMT address.
7470 *
7471 * \param first PMT identifier
7472 * \param second PMT identifier
7473 * \result true if first PMT lower than second PMT; else false
7474 */
7475 inline bool operator<(const JDAQPMTIdentifier& first, const JDAQPMTIdentifier& second)
7476 {
7477 if (first.getModuleIdentifier() == second.getModuleIdentifier())
7478 return first.getPMTAddress() < second.getPMTAddress();
7479 else
7480 return first.getModuleIdentifier() < second.getModuleIdentifier();
7481 }
7482
7483
7484 /**
7485 * Equal operator for PMT identifiers.
7486 *
7487 * The equal operator is applied to the module identifer and to the PMT address.
7488 *
7489 * \param first PMT identifier
7490 * \param second PMT identifier
7491 * \result true if first PMT equal second PMT; else false
7492 */
7493 inline bool operator==(const JDAQPMTIdentifier& first, const JDAQPMTIdentifier& second)
7494 {
7495 return (first.getModuleIdentifier() == second.getModuleIdentifier() &&
7496 first.getPMTAddress() == second.getPMTAddress());
7497 }
7498
7499
7500 /**
7501 * Not-equal operator for PMT identifiers.
7502 *
7503 * \param first PMT identifier
7504 * \param second PMT identifier
7505 * \result true if first PMT identifier not equal to second; else false
7506 */
7507 inline bool operator!=(const JDAQPMTIdentifier& first,
7508 const JDAQPMTIdentifier& second)
7509 {
7510 return !(first == second);
7511 }
7512}
7513
7514#endif
7515#ifndef __JDAQPREAMBLE__
7516#define __JDAQPREAMBLE__
7517
7518#include <ostream>
7519#include <iomanip>
7520
7521#include "km3net-dataformat/online/JDAQRoot.hh"
7522#include "km3net-dataformat/online/JDAQDataTypes.hh"
7523#include "km3net-dataformat/online/JDAQAbstractPreamble.hh"
7524
7525
7526/**
7527 * \author mdejong
7528 */
7529
7530namespace KM3NETDAQ {
7531
7532 /**
7533 * DAQ preamble.
7534 *
7535 * The data type is determined by the return value of method getDataType().\n
7536 * This method should be overloaded so that each data type is uniquely mapped to an integer value.
7537 *
7538 * The size and type information of this object can be used for RTTI.
7539 */
7540 class JDAQPreamble :
7541 public JDAQAbstractPreamble,
7542 public TObject
7543 {
7544 protected:
7545
7546 /**
7547 * Constructor.
7548 *
7549 * \param type data type of derived class
7550 */
7551 template<class T>
7552 JDAQPreamble(const JDAQType<T>& type) :
7553 JDAQAbstractPreamble(type)
7554 {}
7555
7556 public:
7557
7558 friend size_t getSizeof<JDAQPreamble>();
7559 friend JReader& operator>>(JReader&, JDAQPreamble&);
7560 friend JWriter& operator<<(JWriter&, const JDAQPreamble&);
7561
7562 /**
7563 * Default constructor.
7564 */
7565 JDAQPreamble() :
7566 JDAQAbstractPreamble()
7567 {}
7568
7569
7570 /**
7571 * Virtual destructor.
7572 */
7573 virtual ~JDAQPreamble()
7574 {}
7575
7576
7577 /**
7578 * Get DAQ preamble.
7579 *
7580 * This method should be used for binary I/O to get the actual data for the given object.\n
7581 * To this end, the following method should be overloaded for the corresponding data type.
7582 * <pre>
7583 * size_t getSizeof(const T&);
7584 * </pre>
7585 *
7586 * \param object object
7587 * \return preamble
7588 */
7589 template<class T>
7590 static JDAQPreamble getDAQPreamble(const T& object)
7591 {
7592 static JDAQPreamble preamble;
7593
7594 preamble.length = getSizeof(object);
7595 preamble.type = KM3NETDAQ::getDataType<T>();
7596
7597 return preamble;
7598 }
7599
7600
7601 /**
7602 * Print DAQ preamble.
7603 *
7604 * \param out output stream
7605 * \param preamble JDAQPreamble
7606 * \return output stream
7607 */
7608 friend inline std::ostream& operator<<(std::ostream& out, const JDAQPreamble& preamble)
7609 {
7610 using namespace std;
7611
7612 out << setw(8) << preamble.length;
7613 out << ' ';
7614 out << setw(6) << preamble.type;
7615
7616 return out;
7617 }
7618
7619
7620 ClassDef(JDAQPreamble,1);
7621 };
7622}
7623
7624#endif
7625#ifndef __JDAQPRINT__
7626#define __JDAQPRINT__
7627
7628/**
7629 * \author mdejong
7630 */
7631
7632namespace KM3NETDAQ {
7633
7634 /**
7635 * Get DAQ print option.
7636 *
7637 * \return print option
7638 */
7639 inline bool& getDAQLongprint()
7640 {
7641 static bool option;
7642
7643 return option;
7644 }
7645
7646
7647 /**
7648 * Set DAQ print option.
7649 *
7650 * \param option print option
7651 */
7652 inline void setDAQLongprint(const bool option)
7653 {
7654 getDAQLongprint() = option;
7655 }
7656}
7657
7658#endif
7659#ifndef __JDAQROOT__
7660#define __JDAQROOT__
7661
7662#include <TObject.h>
7663#include <TBuffer.h>
7664
7665#include "km3net-dataformat/online/JDAQException.hh"
7666
7667
7668/**
7669 * \author mdejong
7670 */
7671
7672namespace JIO {
7673 class JReader; // forward declaration for friend
7674 class JWriter; // forward declaration for friend
7675}
7676
7677namespace KM3NETDAQ {
7678
7679 /**
7680 * Definition of method to get size of data type.
7681 *
7682 * This method should be specialised for each desired data type with fixed length.
7683 *
7684 * \return number of bytes
7685 */
7686 template<class T>
7687 inline size_t getSizeof();
7688
7689
7690 using JIO::JReader;
7691 using JIO::JWriter;
7692}
7693
7694namespace JPP {
7695}
7696
7697using namespace KM3NETDAQ;
7698
7699#endif
7700#ifndef __JDAQSUMMARYFRAME__
7701#define __JDAQSUMMARYFRAME__
7702
7703#include <limits>
7704#include <cmath>
7705#include <vector>
7706
7707#include "km3net-dataformat/online/JDAQException.hh"
7708#include "km3net-dataformat/online/JDAQ.hh"
7709#include "km3net-dataformat/online/JDAQClock.hh"
7710#include "km3net-dataformat/online/JDAQModuleIdentifier.hh"
7711#include "km3net-dataformat/online/JDAQFrameStatus.hh"
7712#include "km3net-dataformat/online/JDAQSuperFrame.hh"
7713
7714
7715/**
7716 * \author mdejong
7717 */
7718
7719namespace KM3NETDAQ {
7720
7721
7722 /**
7723 * Forward declaration for friend declaration of JDAQSummaryFrame inside JDAQRate.
7724 */
7725 class JDAQSummaryFrame;
7726
7727
7728 /**
7729 * Data storage class for rate measurement of one PMT.
7730 *
7731 * Note that the rate value is compressed.
7732 * The number of bins and corresponding abscissa values can be obtained with
7733 * methods JDAQRare::getN and JDAQRate::getData, respectively.
7734 */
7735 class JDAQRate {
7736 public:
7737
7738 friend class JDAQSummaryFrame;
7739
7740
7741 typedef unsigned char JRate_t; // type of value to store rate
7742
7743
7744 /**
7745 * Get minimal rate (below this, value is set to zero)
7746 *
7747 * \return rate [Hz]
7748 */
7749 static double getMinimalRate()
7750 {
7751 return 2.0e3;
7752 }
7753
7754
7755 /**
7756 * Get maximal rate (above this, value is set to maximum)
7757 *
7758 * \return rate [Hz]
7759 */
7760 static double getMaximalRate()
7761 {
7762 return 2.0e6;
7763 }
7764
7765
7766 /**
7767 * Get value.
7768 *
7769 * \param numberOfHits number of hits
7770 * \param frameTime_ns frame time [ns]
7771 * \return value
7772 */
7773 static JRate_t getValue(const int numberOfHits, const double frameTime_ns)
7774 {
7775 return getValue(numberOfHits * 1.0e9 / frameTime_ns);
7776 }
7777
7778
7779 /**
7780 * Get value.
7781 *
7782 * \param rate_Hz rate [Hz]
7783 * \return value
7784 */
7785 static JRate_t getValue(const double rate_Hz)
7786 {
7787 if (rate_Hz <= getMinimalRate())
7788 return 0;
7789 else if (rate_Hz >= getMaximalRate())
7790 return std::numeric_limits<JRate_t>::max();
7791 else
7792 return (JRate_t) (log(rate_Hz/getMinimalRate()) / getFactor() + 0.5);
7793 }
7794
7795
7796 /**
7797 * Get count rate.
7798 *
7799 * \param value value
7800 * \return rate [Hz]
7801 */
7802 static double getRate(const JRate_t value)
7803 {
7804 if (value == 0)
7805 return 0.0;
7806 else
7807 return get_rate(value);
7808 }
7809
7810
7811 /**
7812 * Get weight.
7813 *
7814 * \param value value
7815 * \return weight [Hz^-1]
7816 */
7817 static double getWeight(const JRate_t value)
7818 {
7819 double W = 1.0;
7820
7821 if (value == 0)
7822 W = get_rate(0.5) - getMinimalRate();
7823 else if (value == std::numeric_limits<JRate_t>::max())
7824 W = getMaximalRate() - get_rate(std::numeric_limits<JRate_t>::max() - 0.5);
7825 else
7826 W = get_rate((double) value + 0.5) - get_rate((double) value - 0.5);
7827
7828 return 1.0 / W;
7829 }
7830
7831
7832 /**
7833 * Get number of bins.
7834 *
7835 * \return number of bins
7836 */
7837 static int getN()
7838 {
7839 return (int) std::numeric_limits<JRate_t>::max() + 1;
7840 }
7841
7842
7843 /**
7844 * Get abscissa values.
7845 *
7846 * \param factor scaling factor
7847 * \return abscissa values
7848 */
7849 static const double* getData(const double factor = 1.0)
7850 {
7851 static std::vector<double> buffer;
7852
7853 buffer.clear();
7854
7855 buffer.push_back(getMinimalRate() * factor);
7856
7857 for (int i = 1; i != JDAQRate::getN(); ++i) {
7858 buffer.push_back(get_rate(i - 0.5) * factor);
7859 }
7860
7861 buffer.push_back(getMaximalRate() * factor);
7862
7863 return buffer.data();
7864 }
7865
7866
7867 /**
7868 * Default constructor.
7869 */
7870 JDAQRate() :
7871 value(0)
7872 {}
7873
7874
7875 /**
7876 * Get value.
7877 *
7878 * \return value
7879 */
7880 JRate_t getValue() const
7881 {
7882 return value;
7883 }
7884
7885
7886 /**
7887 * Set value.
7888 *
7889 * \param numberOfHits number of hits
7890 * \param frameTime_ns frame time [ns]
7891 */
7892 void setValue(const int numberOfHits, const double frameTime_ns)
7893 {
7894 value = getValue(numberOfHits, frameTime_ns);
7895 }
7896
7897
7898 /**
7899 * Set value.
7900 *
7901 * \param rate_Hz rate [Hz]
7902 */
7903 void setValue(const double rate_Hz)
7904 {
7905 value = getValue(rate_Hz);
7906 }
7907
7908
7909 /**
7910 * Get count rate.
7911 *
7912 * \return rate [Hz]
7913 */
7914 double getRate() const
7915 {
7916 return getRate(value);
7917 }
7918
7919
7920 /**
7921 * Get weight.
7922 *
7923 * \return weight [Hz^-1]
7924 */
7925 double getWeight() const
7926 {
7927 return getWeight(value);
7928 }
7929
7930
7931 /**
7932 * Scale rate.
7933 *
7934 * \param factor multiplication factor
7935 * \return this rate
7936 */
7937 JDAQRate& mul(const double factor)
7938 {
7939 setValue(getRate() * factor);
7940
7941 return *this;
7942 }
7943
7944
7945 /**
7946 * Scale rate.
7947 *
7948 * \param factor multiplication factor
7949 * \return this rate
7950 */
7951 JDAQRate& div(const double factor)
7952 {
7953 setValue(getRate() / factor);
7954
7955 return *this;
7956 }
7957
7958
7959 /**
7960 * Check validity of rate.
7961 * The rate is considered valid if it is between the minimal and the maximal rate.
7962 *
7963 * \return true if valid; else false
7964 */
7965 bool is_valid() const
7966 {
7967 return (value != 0 && value != std::numeric_limits<JRate_t>::max());
7968 }
7969
7970
7971 protected:
7972 JRate_t value;
7973
7974
7975 private:
7976 /**
7977 * Get conversion factor.
7978 *
7979 * \return factor
7980 */
7981 static const double getFactor()
7982 {
7983 return std::log(getMaximalRate() / getMinimalRate()) / std::numeric_limits<JRate_t>::max();
7984 }
7985
7986
7987 /**
7988 * Get count rate.
7989 *
7990 * \param value value
7991 * \return rate [Hz]
7992 */
7993 static double get_rate(const double value)
7994 {
7995 return getMinimalRate() * std::exp(value * getFactor());
7996 }
7997 };
7998
7999
8000 /**
8001 * Equal operator for DAQ rates.
8002 *
8003 * \param first rate
8004 * \param second rate
8005 * \result true if first rate equal to second; else false
8006 */
8007 inline bool operator==(const JDAQRate& first,
8008 const JDAQRate& second)
8009 {
8010 return (first.getValue() == second.getValue());
8011 }
8012
8013
8014 /**
8015 * Not-equal operator for DAQ rates.
8016 *
8017 * \param first rate
8018 * \param second rate
8019 * \result true if first rate not equal to second; else false
8020 */
8021 inline bool operator!=(const JDAQRate& first,
8022 const JDAQRate& second)
8023 {
8024 return (first.getValue() != second.getValue());
8025 }
8026
8027
8028 /**
8029 * Data storage class for rate measurements of all PMTs in one module.
8030 */
8031 class JDAQSummaryFrame :
8032 public JDAQModuleIdentifier,
8033 public JDAQFrameStatus
8034 {
8035 public:
8036
8037 typedef JDAQRate::JRate_t JRate_t;
8038
8039 friend size_t getSizeof<JDAQSummaryFrame>();
8040 friend JReader& operator>>(JReader&, JDAQSummaryFrame&);
8041 friend JWriter& operator<<(JWriter&, const JDAQSummaryFrame&);
8042
8043 /**
8044 * Default constructor.
8045 */
8046 JDAQSummaryFrame() :
8047 JDAQModuleIdentifier(),
8048 JDAQFrameStatus()
8049 {}
8050
8051
8052 /**
8053 * Constructor.
8054 *
8055 * \param id module identifier
8056 */
8057 JDAQSummaryFrame(const JDAQModuleIdentifier& id) :
8058 JDAQModuleIdentifier(id),
8059 JDAQFrameStatus(JDAQFrameStatus::getInstance())
8060 {}
8061
8062
8063 /**
8064 * Constructor.
8065 *
8066 * Note that normally the rate is set to the number of hits per unit frame time
8067 * but if either the high-rate veto or FIFO (almost) full bit is on,
8068 * the rate is set to the number of hits divided by the time of the last hit.
8069 *
8070 * \param input super frame
8071 */
8072 JDAQSummaryFrame(const JDAQSuperFrame& input) :
8073 JDAQModuleIdentifier(input.getModuleID()),
8074 JDAQFrameStatus (input.getDAQFrameStatus())
8075 {
8076 using namespace std;
8077
8078 typedef JDAQHit::JPMT_t JPMT_t;
8079 typedef JDAQHit::JTDC_t JTDC_t;
8080
8081 vector<int> counter(numeric_limits<JPMT_t>::max(), 0);
8082
8083 int n = input.size();
8084
8085 for (JDAQSuperFrame::const_iterator i = input.begin(); n != 0; --n, ++i) {
8086 ++counter[i->getPMT()];
8087 }
8088
8089 for (int i = 0; i != NUMBER_OF_PMTS; ++i) {
8090 data[i].setValue(counter[i], getFrameTime());
8091 }
8092
8093 if (input.testHighRateVeto() || input.testFIFOStatus()) {
8094
8095 // determine last hit for each PMT
8096
8097 vector<JTDC_t> limit(numeric_limits<JPMT_t>::max(), 0);
8098
8099 int n = input.size();
8100
8101 for (JDAQSuperFrame::const_iterator i = input.begin(); n != 0; --n, ++i) {
8102 if (i->getT() > limit[i->getPMT()]) {
8103 limit[i->getPMT()] = i->getT();
8104 }
8105 }
8106
8107 for (int i = 0; i != NUMBER_OF_PMTS; ++i) {
8108 if (input.testHighRateVeto(i) || input.testFIFOStatus(i)) {
8109 if (limit[i] != 0) {
8110 data[i].setValue((double) counter[i] * 1.0e9 / (double) limit[i]);
8111 }
8112 }
8113 }
8114 }
8115 }
8116
8117
8118 /**
8119 * Get DAQ rate of given PMT.
8120 *
8121 * \param tdc TDC
8122 * \return JDAQRate
8123 */
8124 const JDAQRate& operator[](const int tdc) const
8125 {
8126 if (tdc >= 0 && tdc < NUMBER_OF_PMTS)
8127 return data[tdc];
8128 else
8129 throw JDAQException("TDC out of range.");
8130 }
8131
8132
8133 /**
8134 * Get DAQ rate of given PMT.
8135 *
8136 * \param tdc TDC
8137 * \return JDAQRate
8138 */
8139 JDAQRate& operator[](const int tdc)
8140 {
8141 if (tdc >= 0 && tdc < NUMBER_OF_PMTS)
8142 return data[tdc];
8143 else
8144 throw JDAQException("TDC out of range.");
8145 }
8146
8147
8148 /**
8149 * Get value.
8150 *
8151 * \param tdc TDC
8152 * \return value
8153 */
8154 JRate_t getValue(const int tdc) const
8155 {
8156 return data[tdc].getValue();
8157 }
8158
8159
8160 /**
8161 * Get count rate.
8162 *
8163 * \param tdc TDC
8164 * \param factor scaling factor
8165 * \return rate x scaling factor [Hz]
8166 */
8167 double getRate(const int tdc, const double factor = 1.0) const
8168 {
8169 return data[tdc].getRate() * factor;
8170 }
8171
8172
8173 /**
8174 * Get weight.
8175 *
8176 * \param tdc TDC
8177 * \param factor scaling factor
8178 * \return weight / scaling factor [Hz^-1]
8179 */
8180 double getWeight(const int tdc, const double factor = 1.0) const
8181 {
8182 return data[tdc].getWeight() / factor;
8183 }
8184
8185
8186 /**
8187 * Set count rate.
8188 *
8189 * \param tdc TDC
8190 * \param rate_Hz rate [Hz]
8191 */
8192 void setRate(const int tdc, const double rate_Hz)
8193 {
8194 return data[tdc].setValue(rate_Hz);
8195 }
8196
8197
8198 static int ROOT_IO_VERSION; //!< Streamer version of JDAQSummaryslice as obtained from ROOT file.
8199
8200
8201 ClassDefNV(JDAQSummaryFrame,2);
8202
8203
8204 protected:
8205
8206 JDAQRate data[NUMBER_OF_PMTS];
8207 };
8208
8209
8210 /**
8211 * Equal operator for DAQ summary frames.
8212 *
8213 * \param first summary frame
8214 * \param second summary frame
8215 * \result true if first summary frame equal to second; else false
8216 */
8217 inline bool operator==(const JDAQSummaryFrame& first,
8218 const JDAQSummaryFrame& second)
8219 {
8220 if (first.getModuleIdentifier() == second.getModuleIdentifier() &&
8221 first.getDAQFrameStatus() == second.getDAQFrameStatus()) {
8222
8223 for (int i = 0; i != NUMBER_OF_PMTS; ++i) {
8224 if (first[i] != second[i]) {
8225 return false;
8226 }
8227 }
8228
8229 return true;
8230
8231 } else {
8232
8233 return false;
8234 }
8235 }
8236
8237
8238 /**
8239 * Not-equal operator for DAQ summary frames.
8240 *
8241 * \param first summary frame
8242 * \param second summary frame
8243 * \result true if first summary frame not equal to second; else false
8244 */
8245 inline bool operator!=(const JDAQSummaryFrame& first,
8246 const JDAQSummaryFrame& second)
8247 {
8248 return !(first == second);
8249 }
8250}
8251
8252#endif
8253#ifndef __JDAQSUMMARYSLICE__
8254#define __JDAQSUMMARYSLICE__
8255
8256#include <ostream>
8257#include <iomanip>
8258#include <vector>
8259
8260#include "km3net-dataformat/online/JDAQRoot.hh"
8261#include "km3net-dataformat/online/JDAQPreamble.hh"
8262#include "km3net-dataformat/online/JDAQSummaryFrame.hh"
8263#include "km3net-dataformat/online/JDAQSummarysliceHeader.hh"
8264#include "km3net-dataformat/online/JDAQTimeslice.hh"
8265#include "km3net-dataformat/online/JDAQClock.hh"
8266
8267
8268/**
8269 * \author mdejong
8270 */
8271
8272namespace KM3NETDAQ {
8273
8274 /**
8275 * Data summary slice.
8276 */
8277 class JDAQSummaryslice :
8278 public JDAQPreamble,
8279 public JDAQSummarysliceHeader,
8280 public std::vector<JDAQSummaryFrame>
8281 {
8282 public:
8283
8284 friend size_t getSizeof(const JDAQSummaryslice&);
8285 friend JReader& operator>>(JReader&, JDAQSummaryslice&);
8286 friend JWriter& operator<<(JWriter&, const JDAQSummaryslice&);
8287
8288 /**
8289 * Default constructor.
8290 */
8291 JDAQSummaryslice() :
8292 JDAQPreamble(JDAQType<JDAQSummaryslice>()),
8293 JDAQSummarysliceHeader(),
8294 std::vector<JDAQSummaryFrame>()
8295 {}
8296
8297
8298 /**
8299 * Constructor.
8300 *
8301 * \param chronometer DAQ chronometer
8302 */
8303 JDAQSummaryslice(const JDAQChronometer& chronometer) :
8304 JDAQPreamble(JDAQType<JDAQSummaryslice>()),
8305 JDAQSummarysliceHeader(chronometer),
8306 std::vector<JDAQSummaryFrame>()
8307 {}
8308
8309
8310 /**
8311 * Constructor.
8312 *
8313 * \param timeslice time slice
8314 */
8315 JDAQSummaryslice(const JDAQTimeslice& timeslice) :
8316 JDAQPreamble(JDAQType<JDAQSummaryslice>()),
8317 JDAQSummarysliceHeader(timeslice),
8318 std::vector<JDAQSummaryFrame>()
8319 {
8320 for (JDAQTimeslice::const_iterator i = timeslice.begin(); i != timeslice.end(); ++i) {
8321 this->push_back(JDAQSummaryFrame(*i));
8322 }
8323 }
8324
8325
8326 /**
8327 * Virtual destructor.
8328 */
8329 virtual ~JDAQSummaryslice()
8330 {}
8331
8332
8333 /**
8334 * Print DAQ summary.
8335 *
8336 * \param out output stream
8337 * \param lpr long print
8338 * \return output stream
8339 */
8340 std::ostream& print(std::ostream& out, const bool lpr = false) const
8341 {
8342 using namespace std;
8343
8344 out << this->ClassName() << endl;
8345 out << dynamic_cast<const JDAQPreamble&> (*this) << endl;
8346 out << dynamic_cast<const JDAQChronometer&>(*this) << endl;
8347
8348 for (JDAQSummaryslice::const_iterator module = this->begin(); module != this->end(); ++module) {
8349
8350 out << ' ' << setw(10) << module->getModuleID();
8351 out << ' ' << setw(8) << setfill('0') << hex << module->getStatus() << dec << setfill(' ');
8352 out << '|' << setw(8) << setfill('0') << hex << module->getFIFOStatus() << dec << setfill(' ');
8353 out << ' ' << setw(2) << module->getUDPNumberOfReceivedPackets();
8354 out << ' ' << setw(2) << module->getUDPMaximalSequenceNumber();
8355
8356 if (lpr) {
8357 for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
8358 out << ' ' << fixed << showpoint << setw(4) << setprecision(1) << module->getRate(pmt) * 1.0e-3;
8359 }
8360 }
8361
8362 out << endl;
8363 }
8364
8365 return out;
8366 }
8367
8368
8369 /**
8370 * Action method at file open.
8371 *
8372 * \param version version
8373 */
8374 static void actionAtFileOpen(int version)
8375 {
8376 JDAQSummaryFrame::ROOT_IO_VERSION = version;
8377 }
8378
8379
8380 ClassDef(JDAQSummaryslice,6);
8381 };
8382
8383
8384 /**
8385 * Print DAQ summary.
8386 *
8387 * \param out output stream
8388 * \param summary summary
8389 * \return output stream
8390 */
8391 inline std::ostream& operator<<(std::ostream& out, const KM3NETDAQ::JDAQSummaryslice& summary)
8392 {
8393 return summary.print(out, getDAQLongprint());
8394 }
8395
8396
8397 /**
8398 * Equal operator for DAQ summary slices.
8399 *
8400 * \param first summary slice
8401 * \param second summary slice
8402 * \result true if first summary slice equal to second; else false
8403 */
8404 inline bool operator==(const JDAQSummaryslice& first,
8405 const JDAQSummaryslice& second)
8406 {
8407 return (first.getDAQSummarysliceHeader() == second.getDAQSummarysliceHeader() &&
8408 static_cast<const std::vector<JDAQSummaryFrame>&>(first) == static_cast<const std::vector<JDAQSummaryFrame>&>(second));
8409 }
8410
8411
8412 /**
8413 * Not-equal operator for DAQ summary slices.
8414 *
8415 * \param first summary slice
8416 * \param second summary slice
8417 * \result true if first summary slice not equal to second; else false
8418 */
8419 inline bool operator!=(const JDAQSummaryslice& first,
8420 const JDAQSummaryslice& second)
8421 {
8422 return !(first == second);
8423 }
8424}
8425
8426#endif
8427#ifndef __JDAQSUMMARYSLICEHEADER__
8428#define __JDAQSUMMARYSLICEHEADER__
8429
8430#include "km3net-dataformat/online/JDAQRoot.hh"
8431#include "km3net-dataformat/online/JDAQHeader.hh"
8432
8433
8434/**
8435 * \author mdejong
8436 */
8437
8438namespace KM3NETDAQ {
8439
8440 /**
8441 * JDAQ summaryslice header.
8442 */
8443 class JDAQSummarysliceHeader :
8444 public JDAQHeader
8445 {
8446 public:
8447 /**
8448 * Default constructor.
8449 */
8450 JDAQSummarysliceHeader() :
8451 JDAQHeader()
8452 {}
8453
8454
8455 /**
8456 * Constructor.
8457 *
8458 * \param chronometer DAQ chronometer
8459 */
8460 JDAQSummarysliceHeader(const JDAQChronometer& chronometer) :
8461 JDAQHeader(chronometer)
8462 {}
8463
8464
8465 /**
8466 * Get DAQ summary slice header.
8467 *
8468 * \return DAQ summary slice header
8469 */
8470 const JDAQSummarysliceHeader& getDAQSummarysliceHeader() const
8471 {
8472 return static_cast<const JDAQSummarysliceHeader&>(*this);
8473 }
8474
8475
8476 ClassDef(JDAQSummarysliceHeader,2);
8477 };
8478
8479
8480 /**
8481 * Equal operator for DAQ summary slice headers.
8482 *
8483 * \param first summary slice header
8484 * \param second summary slice header
8485 * \result true if first summaryslice header equal to second; else false
8486 */
8487 inline bool operator==(const JDAQSummarysliceHeader& first,
8488 const JDAQSummarysliceHeader& second)
8489 {
8490 return (first.getDAQHeader() == second.getDAQHeader());
8491 }
8492
8493
8494 /**
8495 * Not-equal operator for DAQ summary slice headers.
8496 *
8497 * \param first summary slice header
8498 * \param second summary slice header
8499 * \result true if first summary slice header not equal to second; else false
8500 */
8501 inline bool operator!=(const JDAQSummarysliceHeader& first,
8502 const JDAQSummarysliceHeader& second)
8503 {
8504 return !(first == second);
8505 }
8506}
8507
8508#endif
8509#ifndef __JDAQSUPERFRAME__
8510#define __JDAQSUPERFRAME__
8511
8512#include "km3net-dataformat/online/JDAQ.hh"
8513#include "km3net-dataformat/online/JDAQPreamble.hh"
8514#include "km3net-dataformat/online/JDAQSuperFrameHeader.hh"
8515#include "km3net-dataformat/online/JDAQFrame.hh"
8516#include "km3net-dataformat/online/JDAQHit.hh"
8517#include "km3net-dataformat/online/JDAQRoot.hh"
8518#include "km3net-dataformat/online/JDAQException.hh"
8519
8520
8521/**
8522 * \author mdejong
8523 */
8524
8525namespace KM3NETDAQ {
8526
8527 /**
8528 * Data frame of one optical module.
8529 */
8530 class JDAQSuperFrame :
8531 public JDAQPreamble,
8532 public JDAQSuperFrameHeader,
8533 public JDAQFrame
8534 {
8535 public:
8536
8537 typedef JDAQFrame::const_iterator const_iterator;
8538 typedef JDAQFrame::iterator iterator;
8539 typedef JDAQFrame::const_reverse_iterator const_reverse_iterator;
8540 typedef JDAQFrame::reverse_iterator reverse_iterator;
8541
8542 friend size_t getSizeof(const JDAQSuperFrame&);
8543 friend JReader& operator>>(JReader&, JDAQSuperFrame&);
8544 friend JWriter& operator<<(JWriter&, const JDAQSuperFrame&);
8545
8546 /**
8547 * Default constructor.
8548 */
8549 JDAQSuperFrame() :
8550 JDAQPreamble(JDAQType<JDAQSuperFrame>()),
8551 JDAQSuperFrameHeader(),
8552 JDAQFrame()
8553 {}
8554
8555
8556 /**
8557 * Constructor.
8558 *
8559 * \param header JDAQ super frame header
8560 */
8561 JDAQSuperFrame(const JDAQSuperFrameHeader& header) :
8562 JDAQPreamble(JDAQType<JDAQSuperFrame>()),
8563 JDAQSuperFrameHeader(header),
8564 JDAQFrame()
8565 {}
8566
8567
8568 /**
8569 * Copy constructor.
8570 *
8571 * \param super_frame JDAQ super frame
8572 */
8573 JDAQSuperFrame(const JDAQSuperFrame& super_frame) :
8574 JDAQPreamble(JDAQType<JDAQSuperFrame>()),
8575 JDAQSuperFrameHeader(super_frame.getDAQSuperFrameHeader()),
8576 JDAQFrame(super_frame)
8577 {}
8578
8579
8580 /**
8581 * Add data from same optical module.
8582 *
8583 * \param super_frame JDAQ super frame
8584 * \return this JDAQ super frame
8585 */
8586 JDAQSuperFrame& add(const JDAQSuperFrame& super_frame)
8587 {
8588 if (this->getModuleID() != super_frame.getModuleID())
8589 throw JDAQException("JDAQSuperFrame::add(): Different module identifiers.");
8590
8591 return add(static_cast<const JDAQFrame&>(super_frame));
8592 }
8593
8594
8595 /**
8596 * Add hit.
8597 *
8598 * \param hit JDAQ hit
8599 * \return this JDAQ frame
8600 */
8601 JDAQSuperFrame& add(const JDAQHit& hit)
8602 {
8603 return add(1, &hit);
8604 }
8605
8606
8607 /**
8608 * Add data.
8609 *
8610 * \param frame JDAQ frame
8611 * \return this JDAQ frame
8612 */
8613 JDAQSuperFrame& add(const JDAQFrame& frame)
8614 {
8615 return add(frame.numberOfHits, frame.buffer);
8616 }
8617
8618
8619 /**
8620 * Add data.
8621 *
8622 * \param number_of_hits number of hits
8623 * \param data pointer to data
8624 * \return this data frame
8625 */
8626 JDAQSuperFrame& add(const int number_of_hits, const JDAQHit* data)
8627 {
8628 JDAQFrame::add(number_of_hits, data);
8629
8630 return *this;
8631 }
8632
8633
8634 ClassDef(JDAQSuperFrame,3);
8635 };
8636
8637
8638 /**
8639 * Equal operator for DAQ super frames.
8640 *
8641 * \param first super frame
8642 * \param second super frame
8643 * \result true if first super frame equal to second; else false
8644 */
8645 inline bool operator==(const JDAQSuperFrame& first,
8646 const JDAQSuperFrame& second)
8647 {
8648 if (first.getDAQSuperFrameHeader() == second.getDAQSuperFrameHeader() &&
8649 first.size() == second.size()) {
8650
8651 for (JDAQSuperFrame::const_iterator p = first.begin(), q = second.begin(); p != first.end(); ++p, ++q) {
8652 if (*p != *q) {
8653 return false;
8654 }
8655 }
8656
8657 return true;
8658
8659 } else {
8660
8661 return false;
8662 }
8663 }
8664
8665
8666 /**
8667 * Not-equal operator for DAQ super frames.
8668 *
8669 * \param first super frame
8670 * \param second super frame
8671 * \result true if first super frame not equal to second; else false
8672 */
8673 inline bool operator!=(const JDAQSuperFrame& first,
8674 const JDAQSuperFrame& second)
8675 {
8676 return !(first == second);
8677 }
8678}
8679
8680#endif
8681#ifndef __JDAQSUPERFRAMEHEADER__
8682#define __JDAQSUPERFRAMEHEADER__
8683
8684#include "km3net-dataformat/online/JDAQ.hh"
8685#include "km3net-dataformat/online/JDAQHeader.hh"
8686#include "km3net-dataformat/online/JDAQModuleIdentifier.hh"
8687#include "km3net-dataformat/online/JDAQFrameStatus.hh"
8688#include "km3net-dataformat/online/JDAQRoot.hh"
8689
8690
8691/**
8692 * \author mdejong
8693 */
8694namespace KM3NETDAQ {
8695
8696 /**
8697 * DAQ super frame header.
8698 */
8699 class JDAQSuperFrameHeader :
8700 public JDAQHeader,
8701 public JDAQModuleIdentifier,
8702 public JDAQFrameStatus
8703 {
8704 public:
8705
8706 friend size_t getSizeof<JDAQSuperFrameHeader>();
8707 friend JReader& operator>>(JReader&, JDAQSuperFrameHeader&);
8708 friend JWriter& operator<<(JWriter&, const JDAQSuperFrameHeader&);
8709
8710 /**
8711 * Default constructor.
8712 */
8713 JDAQSuperFrameHeader() :
8714 JDAQHeader (),
8715 JDAQModuleIdentifier(),
8716 JDAQFrameStatus ()
8717 {}
8718
8719
8720 /**
8721 * Constructor.
8722 *
8723 * \param chronometer chronometer
8724 * \param id module identifier
8725 */
8726 JDAQSuperFrameHeader(const JDAQChronometer& chronometer,
8727 const int id) :
8728 JDAQHeader (chronometer),
8729 JDAQModuleIdentifier(id),
8730 JDAQFrameStatus (JDAQFrameStatus::getInstance())
8731 {}
8732
8733
8734 /**
8735 * Constructor.
8736 *
8737 * \param chronometer chronometer
8738 * \param id module identifier
8739 * \param status frame status
8740 */
8741 JDAQSuperFrameHeader(const JDAQChronometer& chronometer,
8742 const int id,
8743 const JDAQFrameStatus& status) :
8744 JDAQHeader (chronometer),
8745 JDAQModuleIdentifier(id),
8746 JDAQFrameStatus (status)
8747 {}
8748
8749
8750 /**
8751 * Get DAQ super frame header.
8752 *
8753 * \return DAQ super frame header
8754 */
8755 const JDAQSuperFrameHeader& getDAQSuperFrameHeader() const
8756 {
8757 return static_cast<const JDAQSuperFrameHeader&>(*this);
8758 }
8759
8760
8761 /**
8762 * Set DAQ super frame header.
8763 *
8764 * \param header DAQ super frame header
8765 */
8766 void setDAQSuperFrameHeader(const JDAQSuperFrameHeader& header)
8767 {
8768 static_cast<JDAQSuperFrameHeader&>(*this) = header;
8769 }
8770
8771
8772 ClassDef(JDAQSuperFrameHeader,2);
8773 };
8774
8775
8776 /**
8777 * Equal operator for DAQ super frame headers.
8778 *
8779 * \param first super frame header
8780 * \param second super frame header
8781 * \result true if first super frame header equal to second; else false
8782 */
8783 inline bool operator==(const JDAQSuperFrameHeader& first,
8784 const JDAQSuperFrameHeader& second)
8785 {
8786 return (first.getDAQHeader() == second.getDAQHeader() &&
8787 first.getModuleIdentifier() == second.getModuleIdentifier() &&
8788 first.getDAQFrameStatus() == second.getDAQFrameStatus());
8789 }
8790
8791
8792 /**
8793 * Not-equal operator for DAQ super frame headers.
8794 *
8795 * \param first super frame header
8796 * \param second super frame header
8797 * \result true if first super frame header not equal to second; else false
8798 */
8799 inline bool operator!=(const JDAQSuperFrameHeader& first,
8800 const JDAQSuperFrameHeader& second)
8801 {
8802 return !(first == second);
8803 }
8804}
8805
8806#endif
8807#ifndef __JDAQTIMESLICE__
8808#define __JDAQTIMESLICE__
8809
8810#include <ostream>
8811#include <iomanip>
8812#include <vector>
8813#include <map>
8814
8815#include "km3net-dataformat/online/JDAQRoot.hh"
8816#include "km3net-dataformat/online/JDAQPreamble.hh"
8817#include "km3net-dataformat/online/JDAQTimesliceHeader.hh"
8818#include "km3net-dataformat/online/JDAQSuperFrame.hh"
8819#include "km3net-dataformat/online/JDAQException.hh"
8820#include "km3net-dataformat/online/JDAQPrint.hh"
8821
8822
8823/**
8824 * \author mdejong
8825 */
8826
8827namespace KM3NETDAQ {
8828
8829 class JDAQEvent;
8830 class JDAQSummaryslice;
8831
8832
8833 /**
8834 * Data time slice.
8835 */
8836 class JDAQTimeslice :
8837 public JDAQPreamble,
8838 public JDAQTimesliceHeader,
8839 public std::vector<JDAQSuperFrame>
8840 {
8841 public:
8842
8843 friend size_t getSizeof(const JDAQTimeslice&);
8844 friend JReader& operator>>(JReader&, JDAQTimeslice&);
8845 friend JWriter& operator<<(JWriter&, const JDAQTimeslice&);
8846
8847 /**
8848 * Default constructor.
8849 */
8850 JDAQTimeslice() :
8851 JDAQPreamble(JDAQType<JDAQTimeslice>()),
8852 JDAQTimesliceHeader(),
8853 std::vector<JDAQSuperFrame>()
8854 {}
8855
8856
8857 /**
8858 * Constructor.
8859 *
8860 * \param chronometer DAQ chronometer
8861 */
8862 JDAQTimeslice(const JDAQChronometer& chronometer) :
8863 JDAQPreamble(JDAQType<JDAQTimeslice>()),
8864 JDAQTimesliceHeader(chronometer),
8865 std::vector<JDAQSuperFrame>()
8866 {}
8867
8868
8869 /**
8870 * Constructor.
8871 *
8872 * \param event DAQ event
8873 * \param snapshot use shapshot hits (else use triggered hits)
8874 */
8875 JDAQTimeslice(const JDAQEvent& event,
8876 const bool snapshot = true);
8877
8878
8879 /**
8880 * Constructor.
8881 *
8882 * \param event DAQ event
8883 * \param summary summary
8884 * \param snapshot use shapshot hits (else use triggered hits)
8885 */
8886 JDAQTimeslice(const JDAQEvent& event,
8887 const JDAQSummaryslice& summary,
8888 const bool snapshot = true);
8889
8890
8891 /**
8892 * Virtual destructor.
8893 */
8894 virtual ~JDAQTimeslice()
8895 {
8896 clear();
8897 }
8898
8899
8900 /**
8901 * Clear data.
8902 */
8903 void clear()
8904 {
8905 for (iterator i = this->begin(); i != this->end(); ++i) {
8906 i->clear();
8907 }
8908
8909 std::vector<JDAQSuperFrame>::clear();
8910 }
8911
8912
8913 /**
8914 * Assignment operator.
8915 *
8916 * \param timeslice timeslice
8917 * \return this timeslice
8918 */
8919 JDAQTimeslice& operator=(const JDAQTimeslice& timeslice)
8920 {
8921 clear();
8922
8923 setDAQChronometer(timeslice.getDAQChronometer());
8924
8925 for (const_iterator i = timeslice.begin(); i != timeslice.end(); ++i) {
8926 push_back(*i);
8927 }
8928
8929 return *this;
8930 }
8931
8932
8933 /**
8934 * Add another timeslice.
8935 *
8936 * \param timeslice timeslice
8937 * \return this timeslice
8938 */
8939 JDAQTimeslice& add(const JDAQTimeslice& timeslice)
8940 {
8941 using namespace std;
8942
8943 map<JDAQModuleIdentifier, int> buffer;
8944
8945 for (const_iterator i = this->begin(); i != this->end(); ++i) {
8946 buffer[i->getModuleIdentifier()] = distance(static_cast<const JDAQTimeslice&>(*this).begin(),i);
8947 }
8948
8949 for (JDAQTimeslice::const_iterator i = timeslice.begin(); i != timeslice.end(); ++i) {
8950
8951 map<JDAQModuleIdentifier, int>::const_iterator p = buffer.find(i->getModuleIdentifier());
8952
8953 if (p != buffer.end()) {
8954
8955 JDAQSuperFrame& frame = this->at(p->second);
8956
8957 frame.add(*i);
8958
8959 sort(frame.begin(), frame.end());
8960
8961 } else {
8962
8963 this->push_back(*i);
8964 }
8965 }
8966
8967 return *this;
8968 }
8969
8970
8971 /**
8972 * Print DAQ Timeslice.
8973 *
8974 * \param out output stream
8975 * \param lpr long print
8976 * \return output stream
8977 */
8978 std::ostream& print(std::ostream& out, const bool lpr = false) const
8979 {
8980 using namespace std;
8981
8982 out << this->ClassName() << endl;
8983 out << dynamic_cast<const JDAQPreamble&> (*this) << endl;
8984 out << dynamic_cast<const JDAQChronometer&>(*this) << endl;
8985
8986 for (JDAQTimeslice::const_iterator frame = this->begin(); frame != this->end(); ++frame) {
8987
8988 out << ' ' << setw(10) << frame->getModuleID();
8989 out << ' ' << setw(6) << frame->getLength();
8990 out << ' ' << setw(6) << frame->getDataType();
8991 out << ' ' << setw(6) << frame->getTimesliceStart();
8992 out << ' ' << setw(8) << setfill('0') << hex << frame->getStatus() << dec << setfill(' ');
8993 out << '|' << setw(8) << setfill('0') << hex << frame->getFIFOStatus() << dec << setfill(' ');
8994 out << ' ' << setw(2) << frame->getUDPNumberOfReceivedPackets();
8995 out << '/' << setw(2) << frame->getUDPMaximalSequenceNumber();
8996 out << ' ' << setw(6) << frame->size();
8997
8998 if (!lpr) {
8999
9000 if (!frame->empty()) {
9001
9002 out << ' ' << setw(10) << frame-> begin()->getT();
9003 out << " ... ";
9004 out << ' ' << setw(10) << frame->rbegin()->getT();
9005 }
9006
9007 out << endl;
9008
9009 } else {
9010
9011 out << endl;
9012
9013 int n = 1;
9014
9015 for (JDAQFrame::const_iterator hit = frame->begin(); hit != frame->end(); ++hit, ++n) {
9016 out << setw(2) << (int) hit->getPMT() << ' '
9017 << setw(8) << (int) hit->getT() << ' '
9018 << setw(3) << (int) hit->getToT() << (n%10 == 0 ? '\n' : ' ');
9019 }
9020
9021 out << endl;
9022 }
9023 }
9024
9025 return out;
9026 }
9027
9028
9029 ClassDef(JDAQTimeslice,4);
9030 };
9031
9032
9033 /**
9034 * Equal operator for DAQ time slices.
9035 *
9036 * \param first time slice
9037 * \param second time slice
9038 * \result true if first time slice equal to second; else false
9039 */
9040 inline bool operator==(const JDAQTimeslice& first,
9041 const JDAQTimeslice& second)
9042 {
9043 return (first.getDAQTimesliceHeader() == second.getDAQTimesliceHeader() &&
9044 static_cast<const std::vector<JDAQSuperFrame>&>(first) == static_cast<const std::vector<JDAQSuperFrame>&>(second));
9045 }
9046
9047
9048 /**
9049 * Not-equal operator for DAQ time slices.
9050 *
9051 * \param first time slice
9052 * \param second time slice
9053 * \result true if first time slice not equal to second; else false
9054 */
9055 inline bool operator!=(const JDAQTimeslice& first,
9056 const JDAQTimeslice& second)
9057 {
9058 return !(first == second);
9059 }
9060
9061
9062 /**
9063 * Timeslice data structure for L0 data.
9064 */
9065 struct JDAQTimesliceL0 : public JDAQTimeslice { ClassDef(JDAQTimesliceL0,1); };
9066
9067
9068 /**
9069 * Timeslice data structure for L1 data.
9070 */
9071 struct JDAQTimesliceL1 : public JDAQTimeslice { ClassDef(JDAQTimesliceL1,1); };
9072
9073
9074 /**
9075 * Timeslice data structure for L2 data.
9076 */
9077 struct JDAQTimesliceL2 : public JDAQTimeslice { ClassDef(JDAQTimesliceL2,1); };
9078
9079
9080 /**
9081 * Timeslice data structure for SN data.
9082 */
9083 struct JDAQTimesliceSN : public JDAQTimeslice { ClassDef(JDAQTimesliceSN,1); };
9084
9085
9086 /**
9087 * Print DAQ Timeslice.
9088 *
9089 * \param out output stream
9090 * \param timeslice timeslice
9091 * \return output stream
9092 */
9093 inline std::ostream& operator<<(std::ostream& out, const JDAQTimeslice& timeslice)
9094 {
9095 return timeslice.print(out, getDAQLongprint());
9096 }
9097}
9098
9099#endif
9100#ifndef __JDAQTIMESLICEHEADER__
9101#define __JDAQTIMESLICEHEADER__
9102
9103#include "km3net-dataformat/online/JDAQRoot.hh"
9104#include "km3net-dataformat/online/JDAQHeader.hh"
9105
9106
9107/**
9108 * \author mdejong
9109 */
9110namespace KM3NETDAQ {
9111
9112 /**
9113 * JDAQ timeslice header.
9114 */
9115 class JDAQTimesliceHeader :
9116 public JDAQHeader
9117 {
9118 public:
9119 /**
9120 * Default constructor.
9121 */
9122 JDAQTimesliceHeader() :
9123 JDAQHeader()
9124 {}
9125
9126
9127 /**
9128 * Constructor.
9129 *
9130 * \param chronometer DAQ chronometer
9131 */
9132 JDAQTimesliceHeader(const JDAQChronometer& chronometer) :
9133 JDAQHeader(chronometer)
9134 {}
9135
9136
9137 /**
9138 * Get DAQ time slice header.
9139 *
9140 * \return DAQ time slice header
9141 */
9142 const JDAQTimesliceHeader& getDAQTimesliceHeader() const
9143 {
9144 return static_cast<const JDAQTimesliceHeader&>(*this);
9145 }
9146
9147
9148 ClassDef(JDAQTimesliceHeader,2);
9149 };
9150
9151
9152 /**
9153 * Equal operator for DAQ time slice headers.
9154 *
9155 * \param first time slice header
9156 * \param second time slice header
9157 * \result true if first timeslice header equal to second; else false
9158 */
9159 inline bool operator==(const JDAQTimesliceHeader& first,
9160 const JDAQTimesliceHeader& second)
9161 {
9162 return (first.getDAQHeader() == second.getDAQHeader());
9163 }
9164
9165
9166 /**
9167 * Not-equal operator for DAQ time slice headers.
9168 *
9169 * \param first time slice header
9170 * \param second time slice header
9171 * \result true if first time slice header not equal to second; else false
9172 */
9173 inline bool operator!=(const JDAQTimesliceHeader& first,
9174 const JDAQTimesliceHeader& second)
9175 {
9176 return !(first == second);
9177 }
9178}
9179
9180#endif
9181#ifndef __JDAQTRIGGERCOUNTER__
9182#define __JDAQTRIGGERCOUNTER__
9183
9184#include "km3net-dataformat/online/JDAQRoot.hh"
9185
9186
9187/**
9188 * \author mdejong
9189 */
9190
9191namespace KM3NETDAQ {
9192
9193
9194 /**
9195 * Type definition of trigger counter.
9196 */
9197 typedef unsigned long long int JTriggerCounter_t;
9198
9199
9200 /**
9201 * Auxiliary class to count triggers.
9202 */
9203 class JDAQTriggerCounter {
9204 private:
9205 /**
9206 * Constructor.
9207 *
9208 * \param counter counter value
9209 */
9210 JDAQTriggerCounter(const JTriggerCounter_t counter)
9211 {
9212 this->trigger_counter = counter;
9213 }
9214
9215
9216 public:
9217
9218 friend size_t getSizeof<JDAQTriggerCounter>();
9219 friend JReader& operator>>(JReader&, JDAQTriggerCounter&);
9220 friend JWriter& operator<<(JWriter&, const JDAQTriggerCounter&);
9221
9222 /**
9223 * Default constructor.
9224 *
9225 * This constructor increments the counter of the unique instance
9226 * of this class and stores the result in this object.
9227 */
9228 JDAQTriggerCounter()
9229 {
9230 trigger_counter = getInstance().next();
9231 }
9232
9233
9234 /**
9235 * Virtual destructor.
9236 */
9237 virtual ~JDAQTriggerCounter()
9238 {}
9239
9240
9241 /**
9242 * Get reference to unique instance of this class object.
9243 *
9244 * \return reference to this class object
9245 */
9246 static JDAQTriggerCounter& getInstance()
9247 {
9248 static JDAQTriggerCounter counter(0);
9249
9250 return counter;
9251 }
9252
9253
9254 /**
9255 * Get DAQ trigger counter.
9256 *
9257 * \return DAQ trigger counter
9258 */
9259 const JDAQTriggerCounter& getDAQTriggerCounter() const
9260 {
9261 return static_cast<const JDAQTriggerCounter&>(*this);
9262 }
9263
9264
9265 /**
9266 * Reset counter of unique instance of this class object.
9267 */
9268 static void reset()
9269 {
9270 getInstance().trigger_counter = 0;
9271 }
9272
9273
9274 /**
9275 * Get trigger counter.
9276 *
9277 * \return counter value
9278 */
9279 JTriggerCounter_t getCounter() const
9280 {
9281 return trigger_counter;
9282 }
9283
9284
9285 /**
9286 * Set trigger counter.
9287 *
9288 * \param counter counter value
9289 */
9290 void setCounter(const JTriggerCounter_t counter)
9291 {
9292 this->trigger_counter = counter;
9293 }
9294
9295
9296 /**
9297 * Increment trigger counter.
9298 *
9299 * \return counter value
9300 */
9301 JTriggerCounter_t next()
9302 {
9303 return trigger_counter++;
9304 }
9305
9306
9307 ClassDef(JDAQTriggerCounter,1);
9308
9309
9310 protected:
9311 JTriggerCounter_t trigger_counter;
9312 };
9313
9314
9315 /**
9316 * Equal operator for DAQ trigger counters.
9317 *
9318 * \param first trigger counter
9319 * \param second trigger counter
9320 * \result true if first trigger counter equal to second; else false
9321 */
9322 inline bool operator==(const JDAQTriggerCounter& first,
9323 const JDAQTriggerCounter& second)
9324 {
9325 return (first.getCounter() == second.getCounter());
9326 }
9327
9328
9329 /**
9330 * Not-equal operator for DAQ trigger counters.
9331 *
9332 * \param first trigger counter
9333 * \param second trigger counter
9334 * \result true if first trigger counter not equal to second; else false
9335 */
9336 inline bool operator!=(const JDAQTriggerCounter& first,
9337 const JDAQTriggerCounter& second)
9338 {
9339 return !(first == second);
9340 }
9341}
9342
9343#endif
9344#ifndef __JDAQTRIGGERMASK__
9345#define __JDAQTRIGGERMASK__
9346
9347#include <string>
9348#include <istream>
9349#include <ostream>
9350
9351#include "km3net-dataformat/online/JDAQRoot.hh"
9352
9353
9354/**
9355 * \author mdejong
9356 */
9357
9358namespace KM3NETDAQ {
9359
9360
9361 /**
9362 * Type definition of trigger mask.
9363 */
9364 typedef unsigned long long int JTriggerMask_t;
9365
9366
9367 /**
9368 * Number of trigger bits.
9369 */
9370 static const unsigned int NUMBER_OF_TRIGGER_BITS = sizeof(JTriggerMask_t) * 8;
9371
9372
9373 /**
9374 * Convert trigger bit to trigger mask.
9375 *
9376 * \param bit trigger bit
9377 * \return trigger mask
9378 */
9379 inline JTriggerMask_t getTriggerMask(const unsigned int bit)
9380 {
9381 if (bit < NUMBER_OF_TRIGGER_BITS)
9382 return JTriggerMask_t(1) << bit;
9383 else
9384 return 0;
9385 }
9386
9387
9388 /**
9389 * Auxiliary class for trigger mask.
9390 */
9391 class JDAQTriggerMask {
9392 public:
9393
9394 friend size_t getSizeof<JDAQTriggerMask>();
9395 friend JReader& operator>>(JReader&, JDAQTriggerMask&);
9396 friend JWriter& operator<<(JWriter&, const JDAQTriggerMask&);
9397
9398 /**
9399 * Default constructor.
9400 */
9401 JDAQTriggerMask() :
9402 trigger_mask(0)
9403 {}
9404
9405
9406 /**
9407 * Constructor.
9408 *
9409 * \param mask trigger mask
9410 */
9411 JDAQTriggerMask(const JTriggerMask_t mask) :
9412 trigger_mask(mask)
9413 {}
9414
9415
9416 /**
9417 * Constructor.
9418 *
9419 * \param buffer trigger bit pattern (i.e. sequence of '0' and '1').
9420 */
9421 JDAQTriggerMask(const std::string& buffer) :
9422 trigger_mask(valueOf(buffer).getTriggerMask())
9423 {}
9424
9425
9426 /**
9427 * Virtual destructor.
9428 */
9429 virtual ~JDAQTriggerMask()
9430 {}
9431
9432
9433 /**
9434 * Get DAQ trigger mask.
9435 *
9436 * \return DAQ trigger mask
9437 */
9438 const JDAQTriggerMask& getDAQTriggerMask() const
9439 {
9440 return static_cast<const JDAQTriggerMask&>(*this);
9441 }
9442
9443
9444 /**
9445 * Get trigger mask.
9446 *
9447 * \return trigger mask
9448 */
9449 JTriggerMask_t getTriggerMask() const
9450 {
9451 return trigger_mask;
9452 }
9453
9454
9455 /**
9456 * Set trigger mask.
9457 *
9458 * \param mask trigger mask
9459 */
9460 void setDAQTriggerMask(const JDAQTriggerMask& mask)
9461 {
9462 trigger_mask = mask.trigger_mask;
9463 }
9464
9465
9466 /**
9467 * Set trigger mask.
9468 *
9469 * \param mask trigger mask
9470 */
9471 void setTriggerMask(const JTriggerMask_t mask)
9472 {
9473 trigger_mask = mask;
9474 }
9475
9476
9477 /**
9478 * Add trigger bit pattern.
9479 *
9480 * \param mask trigger mask
9481 * \return trigger mask
9482 */
9483 JDAQTriggerMask& addTriggerMask(const JDAQTriggerMask& mask)
9484 {
9485 trigger_mask |= mask.trigger_mask;
9486
9487 return *this;
9488 }
9489
9490
9491 /**
9492 * Has trigger bit pattern.
9493 *
9494 * \param mask trigger mask
9495 * \return true if one of the bits is set; else false
9496 */
9497 inline bool hasTriggerMask(const JDAQTriggerMask& mask) const
9498 {
9499 return trigger_mask & mask.trigger_mask;
9500 }
9501
9502
9503 /**
9504 * Add trigger bit.
9505 *
9506 * \param bit trigger bit
9507 * \return trigger mask
9508 */
9509 inline JDAQTriggerMask& addTriggerBit(const unsigned int bit)
9510 {
9511 trigger_mask |= KM3NETDAQ::getTriggerMask(bit);
9512
9513 return *this;
9514 }
9515
9516
9517 /**
9518 * Check trigger bit.
9519 *
9520 * \param bit trigger bit
9521 * \return true if bit is set; else false
9522 */
9523 inline bool hasTriggerBit(const unsigned int bit) const
9524 {
9525 return trigger_mask & KM3NETDAQ::getTriggerMask(bit);
9526 }
9527
9528
9529 /**
9530 * Extract trigger mask.
9531 *
9532 * \param buffer trigger bit pattern (i.e. sequence of '0' and '1').
9533 * \return trigger mask
9534 */
9535 static JDAQTriggerMask valueOf(const std::string& buffer)
9536 {
9537 JDAQTriggerMask trigger_mask;
9538
9539 unsigned int bit = 0;
9540
9541 for (std::string::const_reverse_iterator i = buffer.rbegin(); i != buffer.rend() && bit != NUMBER_OF_TRIGGER_BITS; ++i, ++bit) {
9542 if (*i == '1') {
9543 trigger_mask.addTriggerBit(bit);
9544 }
9545 }
9546
9547 return trigger_mask;
9548 }
9549
9550
9551 /**
9552 * Convert trigger mask.
9553 *
9554 * \return trigger bit pattern (i.e. sequence of '0' and '1').
9555 */
9556 std::string toString() const
9557 {
9558 std::string buffer(NUMBER_OF_TRIGGER_BITS, '0');
9559
9560 unsigned int bit = 0;
9561
9562 for (std::string::reverse_iterator i = buffer.rbegin(); i != buffer.rend() && bit != NUMBER_OF_TRIGGER_BITS; ++i, ++bit) {
9563 if (hasTriggerBit(bit)) {
9564 *i = '1';
9565 }
9566 }
9567
9568 return buffer;
9569 }
9570
9571
9572 /**
9573 * Read JDAQTriggerMask from input stream.
9574 *
9575 * \param in input stream
9576 * \param mask JDAQTriggerMask
9577 * \return input stream
9578 */
9579 friend inline std::istream& operator>>(std::istream& in, JDAQTriggerMask& mask)
9580 {
9581 std::string buffer;
9582
9583 if (in >> buffer) {
9584 mask= JDAQTriggerMask::valueOf(buffer);
9585 }
9586
9587 return in;
9588 }
9589
9590
9591 /**
9592 * Write JDAQTriggerMask to output stream.
9593 *
9594 * \param out output stream
9595 * \param mask JDAQTriggerMask
9596 * \return output stream
9597 */
9598 friend inline std::ostream& operator<<(std::ostream& out, const JDAQTriggerMask& mask)
9599 {
9600 out << mask.toString();
9601
9602 return out;
9603 }
9604
9605
9606 ClassDef(JDAQTriggerMask,1);
9607
9608
9609 protected:
9610 JTriggerMask_t trigger_mask;
9611 };
9612
9613
9614 static const JDAQTriggerMask TRIGGER_MASK_ON = JDAQTriggerMask(~JTriggerMask_t(0)); //!< Trigger mask on;
9615 static const JDAQTriggerMask TRIGGER_MASK_OFF = JDAQTriggerMask( JTriggerMask_t(0)); //!< Trigger mask off;
9616
9617
9618 /**
9619 * Equal operator for DAQ trigger masks.
9620 *
9621 * \param first trigger mask
9622 * \param second trigger mask
9623 * \result true if first trigger mask equal to second; else false
9624 */
9625 inline bool operator==(const JDAQTriggerMask& first,
9626 const JDAQTriggerMask& second)
9627 {
9628 return (first.getTriggerMask() == second.getTriggerMask());
9629 }
9630
9631
9632 /**
9633 * Not-equal operator for DAQ trigger masks.
9634 *
9635 * \param first trigger mask
9636 * \param second trigger mask
9637 * \result true if first trigger mask not equal to second; else false
9638 */
9639 inline bool operator!=(const JDAQTriggerMask& first,
9640 const JDAQTriggerMask& second)
9641 {
9642 return !(first == second);
9643 }
9644}
9645
9646#endif
9647#ifndef __JDAQTRIGGEREDHIT__
9648#define __JDAQTRIGGEREDHIT__
9649
9650#include "km3net-dataformat/online/JDAQRoot.hh"
9651#include "km3net-dataformat/online/JDAQModuleIdentifier.hh"
9652#include "km3net-dataformat/online/JDAQHit.hh"
9653#include "km3net-dataformat/online/JDAQKeyHit.hh"
9654#include "km3net-dataformat/online/JDAQTriggerMask.hh"
9655
9656
9657/**
9658 * \author mdejong
9659 */
9660
9661namespace KM3NETDAQ {
9662
9663 /**
9664 * DAQ triggered hit
9665 */
9666 class JDAQTriggeredHit :
9667 public JDAQKeyHit,
9668 public JDAQTriggerMask
9669 {
9670 public:
9671
9672 friend size_t getSizeof<JDAQTriggeredHit>();
9673 friend JReader& operator>>(JReader&, JDAQTriggeredHit&);
9674 friend JWriter& operator<<(JWriter&, const JDAQTriggeredHit&);
9675
9676 /**
9677 * Default constructor.
9678 */
9679 JDAQTriggeredHit() :
9680 JDAQKeyHit (),
9681 JDAQTriggerMask()
9682 {}
9683
9684
9685 /**
9686 * Constructor.
9687 *
9688 * \param ID module identifier
9689 * \param hit PMT hit
9690 * \param mask trigger mask
9691 */
9692 JDAQTriggeredHit(const JDAQModuleIdentifier& ID,
9693 const JDAQHit& hit,
9694 const JDAQTriggerMask& mask) :
9695 JDAQKeyHit(ID,hit),
9696 JDAQTriggerMask(mask)
9697 {}
9698
9699
9700 /**
9701 * Virtual destructor.
9702 */
9703 virtual ~JDAQTriggeredHit()
9704 {}
9705
9706
9707 ClassDef(JDAQTriggeredHit,2);
9708 };
9709
9710
9711 /**
9712 * Equal operator for DAQ triggered hits.
9713 *
9714 * \param first triggered hit
9715 * \param second triggered hit
9716 * \result true if first triggered hit equal to second; else false
9717 */
9718 inline bool operator==(const JDAQTriggeredHit& first,
9719 const JDAQTriggeredHit& second)
9720 {
9721 return (static_cast<const JDAQKeyHit&> (first) == static_cast<const JDAQKeyHit&> (second) &&
9722 static_cast<const JDAQTriggerMask&>(first) == static_cast<const JDAQTriggerMask&>(second));
9723 }
9724
9725
9726 /**
9727 * Not-equal operator for DAQ triggered hits.
9728 *
9729 * \param first triggered hit
9730 * \param second triggered hit
9731 * \result true if first triggered hit not equal to second; else false
9732 */
9733 inline bool operator!=(const JDAQTriggeredHit& first,
9734 const JDAQTriggeredHit& second)
9735 {
9736 return !(first == second);
9737 }
9738}
9739
9740#endif
9741#ifndef __JDAQUTCEXTENDED__
9742#define __JDAQUTCEXTENDED__
9743
9744/**
9745 * \author rbruijn
9746 */
9747
9748#include <cstdint>
9749#include <istream>
9750#include <ostream>
9751#include <iomanip>
9752#include <limits>
9753
9754#include "km3net-dataformat/online/JDAQRoot.hh"
9755
9756
9757namespace KM3NETDAQ {
9758
9759 /**
9760 * Data structure for UTC time.
9761 */
9762 class JDAQUTCExtended
9763 {
9764 public:
9765
9766 friend size_t getSizeof<JDAQUTCExtended>();
9767 friend JReader& operator>>(JReader&, JDAQUTCExtended&);
9768 friend JWriter& operator<<(JWriter&, const JDAQUTCExtended&);
9769
9770
9771 /**
9772 * Default constructor.
9773 */
9774 JDAQUTCExtended() :
9775 UTC_seconds(0),
9776 UTC_16nanosecondcycles(0)
9777 {}
9778
9779
9780 /**
9781 * Constructor.
9782 *
9783 * \param seconds seconds [s]
9784 * \param cycles cycles [16 ns]
9785 */
9786 JDAQUTCExtended(const uint32_t seconds,
9787 const uint32_t cycles):
9788 UTC_seconds(seconds),
9789 UTC_16nanosecondcycles(cycles)
9790 {}
9791
9792
9793 /**
9794 * Constructor.
9795 *
9796 * \param nanoseconds time [ns]
9797 */
9798 JDAQUTCExtended(const double nanoseconds)
9799 {
9800 setTimeNanoSecond(nanoseconds);
9801 }
9802
9803
9804 /**
9805 * Virtual destructor.
9806 */
9807 virtual ~JDAQUTCExtended()
9808 {}
9809
9810
9811 /**
9812 * Get White Rabbit status.
9813 *
9814 * \return true if okay; else false
9815 */
9816 bool getWRStatus() const
9817 {
9818 return (UTC_seconds & ~getMask()) != 0;
9819 }
9820
9821
9822 /**
9823 * Get major time.
9824 *
9825 * \return time [s]
9826 */
9827 uint32_t getUTCseconds() const
9828 {
9829 return (UTC_seconds & getMask());
9830 }
9831
9832
9833 /**
9834 * Get minor time.
9835 *
9836 * \return time [16 ns]
9837 */
9838 uint32_t getUTC16nanosecondcycles() const
9839 {
9840 return UTC_16nanosecondcycles;
9841 }
9842
9843
9844 /**
9845 * Get time (limited to 16 ns cycles).
9846 *
9847 * \return time [ns]
9848 */
9849 double getTimeNanoSecond() const
9850 {
9851 return getUTCseconds() * 1.0e9 + getUTC16nanosecondcycles() * getTick();
9852 }
9853
9854
9855 /**
9856 * Set time.
9857 *
9858 * \param utc_ns time [ns]
9859 */
9860 void setTimeNanoSecond(const double utc_ns)
9861 {
9862 UTC_seconds = (uint32_t) ( utc_ns * 1.0e-9);
9863 UTC_16nanosecondcycles = (uint32_t) ((utc_ns - UTC_seconds*1.0e9) / getTick());
9864 }
9865
9866
9867 /**
9868 * Add time.
9869 *
9870 * \param t_ns time [ns]
9871 */
9872 void addTimeNanoSecond(const double t_ns)
9873 {
9874 const double x_ns = (double) getUTC16nanosecondcycles() * (double) getTick() + t_ns;
9875 const uint32_t t_s = (uint32_t) (x_ns * 1.0e-9);
9876
9877 UTC_seconds += t_s;
9878 UTC_16nanosecondcycles = (uint32_t) ((x_ns - t_s*1.0e9) / getTick());
9879 }
9880
9881
9882 /**
9883 * Get minimum possible value.
9884 *
9885 * \return minimum possible value
9886 */
9887 static JDAQUTCExtended min()
9888 {
9889 return JDAQUTCExtended(0,0);
9890 }
9891
9892
9893 /**
9894 * Get maximum possible value.
9895 *
9896 * \return maximum possible value
9897 */
9898 static JDAQUTCExtended max()
9899 {
9900 return JDAQUTCExtended(std::numeric_limits<uint32_t>::max(),
9901 std::numeric_limits<uint32_t>::max());
9902 }
9903
9904
9905 /**
9906 * Get mask for seconds data.
9907 *
9908 * \return mask
9909 */
9910 static uint32_t getMask()
9911 {
9912 return 0x7FFFFFFF;
9913 }
9914
9915
9916 /**
9917 * Get number of nano-seconds per tick.
9918 *
9919 * \return time [ns]
9920 */
9921 static double getTick()
9922 {
9923 return 16.0;
9924 }
9925
9926
9927 /**
9928 * Get arbitrary offset (e.g. for accuracy of time differences).
9929 *
9930 * \return UTC time
9931 */
9932 static const JDAQUTCExtended& getInstance()
9933 {
9934 static JDAQUTCExtended utc(1600000000, 0);
9935
9936 return utc;
9937 }
9938
9939
9940 /**
9941 * Read UTC time.
9942 *
9943 * \param in intput stream
9944 * \param utc UTC extended time
9945 * \return intput stream
9946 */
9947 friend inline std::istream& operator>>(std::istream& in, JDAQUTCExtended& utc)
9948 {
9949 in >> utc.UTC_seconds;
9950 in.get();
9951 in >> utc.UTC_16nanosecondcycles;
9952
9953 return in;
9954 }
9955
9956
9957 /**
9958 * Write UTC time.
9959 *
9960 * \param out output stream
9961 * \param utc UTC extended time
9962 * \return output stream
9963 */
9964 friend inline std::ostream& operator<<(std::ostream& out, const JDAQUTCExtended& utc)
9965 {
9966 using namespace std;
9967
9968 const char c = out.fill();
9969
9970 out << setw(10) << utc.getUTCseconds();
9971 out << ':';
9972 out << setw(10) << setfill('0') << utc.getUTC16nanosecondcycles() << setfill(c);
9973
9974 return out;
9975 }
9976
9977
9978 ClassDef(JDAQUTCExtended,1);
9979
9980
9981 protected:
9982 uint32_t UTC_seconds;
9983 uint32_t UTC_16nanosecondcycles;
9984 };
9985
9986
9987 /**
9988 * Less than operator for UTC times.
9989 *
9990 * \param first UTC time
9991 * \param second UTC time
9992 * \result true if first UTC time earlier than second UTC time; else false
9993 */
9994 inline bool operator<(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
9995 {
9996 if (first.getUTCseconds() == second.getUTCseconds())
9997 return first.getUTC16nanosecondcycles() < second.getUTC16nanosecondcycles();
9998 else
9999 return first.getUTCseconds() < second.getUTCseconds();
10000 }
10001
10002
10003 /**
10004 * Greater than operator for UTC times.
10005 *
10006 * \param first UTC time
10007 * \param second UTC time
10008 * \result true if first UTC time later than second UTC time; else false
10009 */
10010 inline bool operator>(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
10011 {
10012 return (second < first);
10013 }
10014
10015
10016 /**
10017 * Less than or equal operator for UTC times.
10018 *
10019 * \param first UTC time
10020 * \param second UTC time
10021 * \result true if first UTC time earlier than second UTC time; else false
10022 */
10023 inline bool operator<=(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
10024 {
10025 return !(second < first);
10026 }
10027
10028
10029 /**
10030 * Greater than or equal operator for UTC times.
10031 *
10032 * \param first UTC time
10033 * \param second UTC time
10034 * \result true if first UTC time earlier than second UTC time; else false
10035 */
10036 inline bool operator>=(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
10037 {
10038 return !(first < second);
10039 }
10040
10041
10042 /**
10043 * Equal operator for UTC times.
10044 *
10045 * \param first UTC time
10046 * \param second UTC time
10047 * \result true if first UTC time equal second UTC time; else false
10048 */
10049 inline bool operator==(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
10050 {
10051 return (first.getUTCseconds() == second.getUTCseconds() &&
10052 first.getUTC16nanosecondcycles() == second.getUTC16nanosecondcycles());
10053 }
10054
10055
10056 /**
10057 * Not equal operator for UTC times.
10058 *
10059 * \param first UTC time
10060 * \param second UTC time
10061 * \result true if first UTC time not equal second UTC time; else false
10062 */
10063 inline bool operator!=(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
10064 {
10065 return !(first == second);
10066 }
10067
10068
10069 /**
10070 * Get time difference between two UTC times.
10071 *
10072 * \param first UTC time
10073 * \param second UTC time
10074 * \result time difference [s]
10075 */
10076 inline double getTimeDifference(const JDAQUTCExtended& first, const JDAQUTCExtended& second)
10077 {
10078 const double utc_s = ((double) second.getUTCseconds() - (double) first.getUTCseconds());
10079 const double utc_ns = ((double) second.getUTC16nanosecondcycles() - (double) first.getUTC16nanosecondcycles()) * JDAQUTCExtended::getTick();
10080
10081 return utc_s + utc_ns*1.0e-9;
10082 }
10083}
10084
10085#endif
10086#ifndef AAOBJECTINCLUDED
10087#define AAOBJECTINCLUDED
10088
10089#include "TObject.h"
10090
10091#include <iostream>
10092#include <iomanip>
10093#include <string>
10094#include <algorithm>
10095
10096#include "km3net-dataformat/offline/Exception.hh"
10097
10098
10099/*! \brief AAObject is a base class for I/O-classes that adds the possibility
10100 to add 'user' information which will also be stored in the ROOT file.
10101*/
10102
10103struct AAObject : public TObject
10104{
10105 std::vector<double> usr; ///< user data
10106 std::vector<std::string> usr_names; ///< user keys
10107
10108 /**
10109 * Get index in user data of the item with given key.
10110 *
10111 * \param key key
10112 * \return index (-1 if key does not exists)
10113 */
10114 int idx( const std::string& key ) const
10115 {
10116 auto i = std::find (usr_names.begin(), usr_names.end(), key );
10117 if (i == usr_names.end()) return -1;
10118 return i - usr_names.begin();
10119 }
10120
10121 /**
10122 * Check availability of user data of the item with given key.
10123 *
10124 * \param key key
10125 * \return true if available; else false
10126 */
10127 bool haveusr( const std::string& key ) const
10128 {
10129 return idx( key ) >= 0;
10130 }
10131
10132 /**
10133 * Get index in user data of the item with given key.\n
10134 * This method throws a run-time exception if no user data are available.
10135 *
10136 * \param key key
10137 * \return index (-1 if key does not exists)
10138 */
10139 int idxusr_checked( const std::string& key ) const
10140 {
10141 int r = idx( key );
10142 if (r < 0)
10143 {
10144 THROW(Exception, "No user data for key " << key << " in aanet object of type " << this -> ClassName());
10145 }
10146 return r;
10147 }
10148
10149
10150 /**
10151 * Get user data item with given key.\n
10152 * This method throws a run-time exception if no user data are available.
10153 *
10154 * \param key key
10155 * \return value
10156 */
10157 double getusr(const std::string& key) const
10158 {
10159 const int i = idx( key );
10160
10161 if ( i < 0 )
10162 {
10163 THROW(Exception, "No user data for key " << key << " in aanet object of type " << this -> ClassName());
10164 }
10165
10166 if ( unsigned(i) >= usr.size() )
10167 {
10168 THROW(Exception, "Warning: inconsistent user data " << i << " >= " << usr.size());
10169 }
10170
10171 return usr[i];
10172 }
10173
10174 /**
10175 * Set user data item with given key.\n
10176 *
10177 * \param key key
10178 * \param value value
10179 */
10180 void setusr(const std::string & key, double value )
10181 {
10182 int i = idx( key );
10183 if (i < 0)
10184 {
10185 if ( usr.size() < usr_names.size() )
10186 {
10187 // this should not happen, but let's just add empty data
10188 usr.resize( usr_names.size() );
10189 }
10190 else
10191 {
10192 // this is possible, add empty ("") names
10193 usr_names.resize( usr.size() );
10194 }
10195
10196 usr_names.push_back( key );
10197 usr.push_back( value );
10198 }
10199 else
10200 {
10201 usr[i] = value;
10202 }
10203 }
10204
10205 /**
10206 * Remove (first) user data item with given key.\n
10207 *
10208 * \param key key
10209 * \return true if data have been removed; else false
10210 */
10211 bool delusr( const std::string& key )
10212 {
10213 int i = idx( key );
10214 if ( i < 0 ) return false;
10215
10216 usr.erase ( usr.begin() + i );
10217 usr_names.erase( usr_names.begin() + i );
10218 return true;
10219 }
10220
10221 /**
10222 * Clear user data.
10223 */
10224 void clearusr()
10225 {
10226 usr.resize(0);
10227 usr_names.resize(0);
10228 }
10229
10230 /**
10231 * Print user data (i.e. list of all pairs of keys and values).
10232 *
10233 * \param out output stream
10234 */
10235 void printusr(std::ostream& out = std::cout )
10236 {
10237 unsigned n = std::max( usr.size(), usr_names.size() );
10238
10239 for (unsigned i = 0; i < n ; i++)
10240 {
10241 std::string name = "(unnamed)";
10242 if ( i < usr_names.size() && usr_names[i] != "" ) name = usr_names[i];
10243 out << i << " \t " << name << " : \t ";
10244 if ( i < usr.size() ) out << usr[i] << std::endl;
10245 else out << "(none)" << std::endl;
10246 }
10247 }
10248
10249 /**
10250 * Default constructor.
10251 */
10252 AAObject() : any(NULL) {}
10253 ~AAObject() {}
10254
10255
10256 TObject* any; ///< Pointer to "any" user data.
10257
10258 ClassDef(AAObject, 6)
10259};
10260
10261#endif
10262#ifndef EVT_HH_INCLUDED
10263#define EVT_HH_INCLUDED
10264
10265#include "km3net-dataformat/offline/AAObject.hh"
10266#include "km3net-dataformat/offline/Hit.hh"
10267#include "km3net-dataformat/offline/Trk.hh"
10268#include "km3net-dataformat/offline/Hit.hh"
10269#include "km3net-dataformat/offline/Exception.hh"
10270
10271#include "TTimeStamp.h"
10272
10273#include <uuid/uuid.h>
10274#include <vector>
10275
10276/**
10277 * The Evt class respresent a Monte Carlo (MC) event as well as an offline event.\n
10278 * Some data from the online (DAQ) event are copied.
10279 */
10280
10281struct Evt: public AAObject
10282{
10283 int id; ///< offline event identifier
10284 int det_id; ///< detector identifier from DAQ
10285 int mc_id; ///< identifier of the MC event (as found in ascii or antcc file).
10286
10287 int run_id; ///< DAQ run identifier
10288 int mc_run_id; ///< MC run identifier
10289
10290 int frame_index; ///< from the raw data
10291 ULong64_t trigger_mask; ///< trigger mask from raw data (i.e. the trigger bits)
10292 ULong64_t trigger_counter; ///< trigger counter
10293 unsigned int overlays; ///< number of overlaying triggered events
10294 TTimeStamp t; ///< UTC time of the timeslice, or the event_time for MC. (default: 01 Jan 1970 00:00:00)
10295
10296 uuid_t header_uuid; ///< UUID of header containing the event-weight information
10297
10298 //hits and tracks
10299 std::vector<Hit> hits; ///< list of hits
10300 std::vector<Trk> trks; ///< list of reconstructed tracks (can be several because of prefits,showers, etc).
10301
10302 //Monte carlo
10303 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)
10304 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)
10305 std::vector<double> w3list; ///< MC: atmospheric flux information
10306
10307 TTimeStamp mc_event_time; ///< MC: true generation time (UTC) of the event, (default: 01 Jan 1970 00:00:00)
10308 double mc_t; ///< MC: time where the mc-event was put in the timeslice, since start of run (offset+frameidx*timeslice_duration)
10309 std::vector<Hit> mc_hits; ///< MC: list of MC truth hits
10310 std::vector<Trk> mc_trks; ///< MC: list of MC truth tracks
10311
10312 // --- place to store user info ---
10313 TString comment; ///< user can use this as he/she likes
10314 int index; ///< user can use this as he/she likes
10315 int flags; ///< user can use this as he/she likes
10316
10317
10318 /**
10319 * Default constructor.
10320 */
10321 Evt() :
10322 id(0), det_id(0), mc_id(0), run_id(0), mc_run_id(0), frame_index(0),
10323 trigger_mask(0), trigger_counter(0),
10324 overlays(0), t(0), mc_event_time(0), mc_t(0), index(0), flags(0)
10325 {
10326 uuid_clear(this->header_uuid);
10327 }
10328
10329
10330 /**
10331 * Print event.
10332 *
10333 * \param out output stream
10334 */
10335 void print(std::ostream& out = std::cout) const
10336 {
10337 out << "Evt: id=" << id <<
10338 " run_id=" << run_id <<
10339 " #hits=" << hits.size() <<
10340 " #mc_hits=" << mc_hits.size() <<
10341 " #trks=" << trks.size() <<
10342 " #mc_trks=" << mc_trks.size() << std::endl;
10343 }
10344
10345
10346 /**
10347 * Reset event.
10348 */
10349 void clear()
10350 {
10351 *this = Evt();
10352 }
10353
10354
10355 /**
10356 * Clear the hit vectors and all the references to hits in the tracks
10357 */
10358 void clear_hits()
10359 {
10360 hits.clear();
10361 mc_hits.clear();
10362 for (auto& t : trks ) t.hit_ids.clear();
10363 for (auto& t : mc_trks ) t.hit_ids.clear();
10364 }
10365
10366
10367 /**
10368 * Return a vector with const pointers to the tracks that are 'primary'.\n
10369 * Here, primary means the tracks have no parents.
10370 *
10371 * This method only works if MC parent-child relations are availabe.
10372 *
10373 * \return list of pointers to primary tracks
10374 */
10375 std::vector<const Trk*> primary_trks() const
10376 {
10377 std::vector<const Trk*> r;
10378 for (auto& t : mc_trks )
10379 {
10380 if ( t.is_primary() ) r.push_back(&t);
10381 }
10382 return r;
10383 }
10384
10385
10386 /**
10387 * Return a vector of pointers to tracks that are 'primary'.\n
10388 * Here, primary means the tracks have no parents.
10389 *
10390 * \return list of pointers to primary tracks
10391 */
10392 std::vector<Trk*> primary_trks()
10393 {
10394 std::vector<Trk*> r;
10395 for (auto& t : mc_trks )
10396 {
10397 if ( t.is_primary() ) r.push_back(&t);
10398 }
10399 return r;
10400 }
10401
10402
10403 /**
10404 * Get a const pointer to the (first) neutrino from the MC track list.
10405 *
10406 * \return pointer to neutrino (nullptr if no neutrino is in the list)
10407 */
10408 const Trk* neutrino() const
10409 {
10410 for (auto& t : mc_trks )
10411 {
10412 if ( t.is_neutrino() ) return &t;
10413 }
10414 return nullptr;
10415 }
10416
10417 /**
10418 * Get a pointer to the (first) neutrino from the MC track list.
10419 *
10420 * \return const pointer to neutrino (nullptr if no neutrino is in the list)
10421 */
10422
10423 Trk* neutrino()
10424 {
10425 // see Effective C++, Scott Meyers, ISBN-13: 9780321334879.
10426 return const_cast<Trk *>(static_cast<const Evt &>(*this).neutrino() );
10427 }
10428
10429
10430 /**
10431 * Get a const pointer to primary neutrino from the MC track list.
10432 *
10433 * Only works if MC parent-child relations are availabe.
10434 *
10435 * \return const pointer to primary neutrino (may be nullptr)
10436 */
10437 const Trk* primary_neutrino() const
10438 {
10439 for ( auto& t : mc_trks )
10440 {
10441 if ( t.is_neutrino() and t.is_primary() ) return &t;
10442 }
10443 return nullptr;
10444 }
10445
10446 /**
10447 * Get a pointer to primary neutrino from the MC track list.
10448 *
10449 * Only works if MC parent-child relations are availabe.
10450 *
10451 * \return pointer to primary neutrino
10452 */
10453 Trk* primary_neutrino()
10454 {
10455 return const_cast<Trk *>(static_cast<const Evt &>(*this).primary_neutrino() );
10456 }
10457
10458
10459 /**
10460 * Get a const pointer to the first leading lepton from the MC track list.
10461 * Here, leading means the lepton that has a neutrino as mother.
10462 *
10463 * Only works if MC parent-child relations are availabe.
10464 *
10465 * \return pointer to leadig lepton (may be nullptr in case not found)
10466 */
10467 const Trk* leading_lepton() const
10468 {
10469 const Trk* nu = primary_neutrino();
10470 if (!nu) return nullptr;
10471
10472 for (auto& t : mc_trks )
10473 {
10474 if ( t.is_lepton() &&
10475 t.mother_id == nu->id &&
10476 !t.is_orphan() ) return &t;
10477 }
10478 return nullptr;
10479 }
10480
10481 /**
10482 * Get a pointer to leading lepton from the MC track list.
10483 * Here, leading means the lepton that has a neutrino as mother.
10484 *
10485 * Only works if MC parent-child relations are availabe.
10486 *
10487 * \return pointer to leadig lepton (may be nullptr in case not found)
10488 */
10489 Trk* leading_lepton()
10490 {
10491 return const_cast<Trk *>(static_cast<const Evt &>(*this).leading_lepton() );
10492 }
10493
10494 /**
10495 * Get a const pointer to the (first) parent of the track 'child'.\n
10496 * This method return nullptr if no parent is found.
10497 *
10498 * \param child child particle
10499 * \return pointer to parent
10500 */
10501 const Trk * get_parent_of( const Trk & child ) const
10502 {
10503 for (auto& t : mc_trks )
10504 {
10505 if (child.mother_id == t.id ) return &t;
10506 }
10507 return nullptr;
10508 }
10509
10510
10511 /**
10512 * Get a pointer ot the (first) parent of the track 'child'.\n
10513 * This method return nullptr if no parent is found.
10514 *
10515 * \param child child particle
10516 * \return pointer to parent
10517 */
10518
10519 Trk* get_parent_of( const Trk & child )
10520 {
10521 return const_cast<Trk *>(static_cast<const Evt &>(*this).get_parent_of(child) );
10522 }
10523
10524
10525 /**
10526 * Action method at file open.
10527 *
10528 * \param version version
10529 */
10530 static void actionAtFileOpen(int version)
10531 {
10532 ROOT_IO_VERSION = version;
10533 }
10534
10535 static int ROOT_IO_VERSION; //!< Streamer version as obtained from ROOT file.
10536
10537 ClassDef(Evt, 16)
10538};
10539
10540#endif
10541#ifndef EXCEPTION_HH_INCLUDED
10542#define EXCEPTION_HH_INCLUDED
10543
10544#include <exception>
10545#include <string>
10546#include <ostream>
10547#include <sstream>
10548#include <functional>
10549
10550
10551/**
10552 * General exception
10553 */
10554class Exception : public std::exception {
10555public:
10556 /**
10557 * Constructor.
10558 *
10559 * \param error error message
10560 */
10561 Exception(const std::string& error) :
10562 std::exception(),
10563 buffer(error)
10564 {}
10565
10566
10567 /**
10568 * Destructor.
10569 */
10570 ~Exception() throw()
10571 {}
10572
10573
10574 /**
10575 * Get error message.
10576 *
10577 * \return error message
10578 */
10579 virtual const char* what() const throw()
10580 {
10581 return buffer.c_str();
10582 }
10583
10584
10585 /**
10586 * Print error message of JException.
10587 *
10588 * \param out output stream
10589 * \param exception exception
10590 */
10591 friend inline std::ostream& operator<<(std::ostream& out, const Exception& exception)
10592 {
10593 return out << exception.what();
10594 }
10595
10596private:
10597 const std::string buffer;
10598};
10599
10600
10601/**
10602 * Make exception.
10603 *
10604 * \param JException_t exception
10605 * \param A message
10606 */
10607#ifndef MAKE_EXCEPTION
10608#define MAKE_EXCEPTION(JException_t, A) std::invoke( [&]() { std::ostringstream out; out << __FILE__ << ':' << __LINE__ << std::endl << A; return JException_t(out.str()); } )
10609#endif
10610
10611/**
10612 * Marco for throwing exception with std::ostream compatible message.
10613 *
10614 * \param Exception_t exception
10615 * \param A message
10616 */
10617#ifndef THROW
10618#define THROW(JException_t, A) do { throw MAKE_EXCEPTION(JException_t, A); } while(0)
10619#endif
10620
10621#endif
10622#ifndef HEAD_HH_INCLUDED
10623#define HEAD_HH_INCLUDED
10624
10625#include "km3net-dataformat/offline/Vec.hh"
10626#include "km3net-dataformat/offline/Exception.hh"
10627
10628#include "TObject.h"
10629
10630#include <string>
10631#include <sstream>
10632#include <iostream>
10633#include <map>
10634#include <algorithm>
10635#include <vector>
10636
10637
10638/**
10639 * Trim a string in place
10640 *
10641 * \param s input string
10642 */
10643static inline void trimstring(std::string &s)
10644{
10645 // from the left
10646 s.erase( s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
10647 return !std::isspace(ch);
10648 }));
10649
10650 // from the right
10651 s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
10652 return !std::isspace(ch);
10653 }).base(), s.end());
10654}
10655
10656/**
10657 * Split string at delimiter. Trailing and leading whitespace is removed from each token.
10658 * Empty tokens are not put in the output list.
10659 *
10660 * \param str input string
10661 * \param delim token delimiter
10662 * \return list of tokens
10663 */
10664inline std::vector<std::string> splitstring(const std::string& str, char delim = ' ')
10665{
10666 using namespace std;
10667
10668 vector<string> r;
10669
10670 stringstream ss(str);
10671 string token;
10672 while (getline(ss, token, delim))
10673 {
10674 trimstring(token);
10675 if (token != "") r.push_back(token);
10676 }
10677
10678 return r;
10679}
10680
10681
10682/**
10683 * The Head class reflects the header of Monte-Carlo event files, which consists of keys (also referred to as "tags") and values.
10684 */
10685struct Head : public TObject, std::map<std::string, std::string>
10686{
10687 struct tags {
10688 static constexpr const char* const UUID = "UUID";
10689 };
10690
10691
10692 /**
10693 * Check availability of data with the given key.
10694 *
10695 * \param key key
10696 * \return true if data are available; else false
10697 */
10698 bool have_line (std::string key ) const
10699 {
10700 return count( key ) != 0;
10701 }
10702
10703 /**
10704 * Get data with the given key.\n
10705 * This method throws a run-time exception if no data are available.
10706 *
10707 * \param key key
10708 * \return data
10709 */
10710 const std::string& get_line( std::string key ) const
10711 {
10712 return this->at(key);
10713 }
10714
10715 /**
10716 * Get data with the given key.\n
10717 * This method throws a run-time exception if no data are available.
10718 *
10719 * \param key key
10720 * \return data
10721 */
10722 std::string& get_line( std::string key )
10723 {
10724 return this->at(key);
10725 }
10726
10727
10728 /**
10729 * In case of duplicate keys, they are internally stored in the map
10730 * with a suffix "_n". This function returns all the keys that start
10731 * with 'key' and end in "_n", with n an integer
10732 *
10733 * \param tag tag (without suffix)
10734 */
10735
10736 std::vector< std::string> matching_keys( const std::string& tag ) const
10737 {
10738 std::vector< std::string> r;
10739
10740 auto match = [&] (const std::string & key) {
10741
10742 if (key == tag) return true;
10743
10744 if ( key.find( tag ) != 0 ) return false;
10745
10746 // what is left should be of the form _d(ddd)
10747 std::string left = key.substr( tag.length(), key.length() );
10748 if (left.length() < 2 || left[0] != '_' ) return false ;
10749 for ( unsigned i = 1; i < left.length(); i++ )
10750 {
10751 if (!std::isdigit( left[i] )) return false ;
10752 }
10753 return true;
10754 };
10755
10756 for ( auto& p : *this )
10757 {
10758 if ( match( p.first ) ) r.push_back( p.first );
10759 }
10760
10761 return r;
10762 }
10763
10764
10765
10766
10767 /**
10768 * Get all data compatible with the given key. This means all data
10769 * that is internally stored with "key_n", with n an integer \n
10770 * This method throws a run-time exception if no data are available.
10771 *
10772 * \param tag tag (without suffix)
10773 * \return data
10774 */
10775 std::vector< std::string > get_lines( const std::string& tag ) const
10776 {
10777 std::vector< std::string > r;
10778
10779 for ( auto& key : matching_keys( tag ) ) {
10780 r.push_back( get_line( key ) );
10781 }
10782
10783 return r;
10784 }
10785
10786
10787 /**
10788 * Set data with the given tag. The function will return the actual key that
10789 * is used internally to store the result, which is equal to the tag with an
10790 * optional "_n" added to ensure uniqueness.
10791 *
10792 * \param tag tag
10793 * \param line data
10794 * \param ensure_unique add '_n' (with n an integer) to the tag if it would overwrite an existing key.
10795 */
10796
10797 std::string set_line( std::string tag, std::string line , bool ensure_unique = true )
10798 {
10799 std::string k = tag;
10800
10801 if (ensure_unique)
10802 for (int i = 1; find(k) != end() ; i++)
10803 {
10804 k = tag + "_" + std::to_string(i);
10805 }
10806
10807 std::map<std::string, std::string>::operator[]( k ) = line;
10808 return k;
10809 }
10810
10811 /**
10812 * Get data with the given key at given index.\n
10813 * This method throws a run-time exception if no data are available.
10814 *
10815 * \param key key
10816 * \param idx index
10817 * \return data
10818 */
10819 std::string get_field( std::string key, int idx ) const
10820 {
10821 using namespace std;
10822
10823 vector<string> v = splitstring( get_line(key) );
10824
10825 if ( idx < 0 || idx >= int ( v.size() ) )
10826 {
10827 THROW(Exception, "Cannot find word number " << idx << " in line " << get_line(key) << " for key: " << key);
10828 }
10829 return v[idx];
10830 }
10831
10832 /**
10833 * Get index of data with the given key at given field.\n
10834 *
10835 * Note that this method uses the dictionary define in method Head::_hdr_dict.
10836 *
10837 * \param key key
10838 * \param field field
10839 * \return index (-1 if not present)
10840 */
10841 int get_index_of_field(std::string key, std::string field) const
10842 {
10843 auto& d = _hdr_dict();
10844 if ( d.count(key) == 0 ) return -1;
10845 auto v = d.at(key);
10846 auto i = std::find (v.begin(), v.end(), field );
10847 if (i == v.end()) return -1;
10848 return i - v.begin();
10849 }
10850
10851 /**
10852 * Get data with the given key at given field.\n
10853 * This method throws a run-time exception if no field is available.
10854 *
10855 * Note that this method uses the dictionary define in method Head::_hdr_dict.
10856 *
10857 * \param key key
10858 * \param field field
10859 * \return data
10860 */
10861 std::string get_field( std::string key, std::string field ) const
10862 {
10863 int idx = get_index_of_field(key, field);
10864
10865 if ( idx == -1 )
10866 {
10867 THROW(Exception, "Failed to find" << key << " " << field);
10868 }
10869
10870 return get_field( key, idx );
10871 }
10872
10873
10874 /**
10875 * Set data with the given key at given field.\n
10876 * This method throws a run-time exception if no field available.
10877 *
10878 * Note that this method uses the dictionary define in method Head::_hdr_dict.
10879 *
10880 * \param key key
10881 * \param field field
10882 * \param value vakue
10883 */
10884 void set_field( std::string key, std::string field, std::string value )
10885 {
10886 using namespace std;
10887
10888 if ( field == "" ) get_line( key ) = value;
10889
10890 int idx = get_index_of_field( key, field );
10891
10892 if ( idx < 0 )
10893 {
10894 THROW(Exception, "GFailed to find field in header line: " << key << " " << field);
10895 }
10896
10897 vector<string> vals = splitstring( get_line( key ) );
10898
10899 // if the fields before do not exist, add padding
10900 while ( int( vals.size() ) <= idx ) vals.push_back("0");
10901
10902 vals[idx] = value;
10903 ostringstream ss;
10904
10905 for (unsigned i = 0; i < vals.size() ; i++ )
10906 {
10907 ss << vals[i];
10908 if ( i != vals.size() - 1) ss << " ";
10909 }
10910 set_line( key, ss.str() );
10911
10912 }
10913
10914 /**
10915 * Print header.
10916 *
10917 * \param out output stream
10918 */
10919 void print ( std::ostream& out = std::cout ) const
10920 {
10921 if (count("start_run")) out << "start_run: " << at("start_run") << std::endl;
10922
10923 for ( auto& p : *this )
10924 {
10925 if ( p.first == "start_run" || p.first == "end_event" ) continue;
10926 out << p.first << ": " << p.second << std::endl ;
10927 }
10928 out << "end_event:" << std::endl;
10929 }
10930
10931 /**
10932 * Get internal description of the known lines in header.
10933 *
10934 * \return internal dictionary
10935 */
10936 static const std::map<std::string, std::vector<std::string> >& _hdr_dict()
10937 {
10938 using namespace std;
10939
10940 // map with, for each tag (key), a vector of field-names
10941
10942 static map<string, vector<string> > r;
10943 if ( r.size() > 0 ) return r;
10944
10945 string desc =
10946 "DAQ:livetime\n"
10947 "cut_primary cut_seamuon cut_in cut_nu:Emin Emax cosTmin cosTmax\n"
10948 "generator physics simul:program version date time\n"
10949 "seed:program level iseed\n"
10950 "PM1_type_area:type area TTS\n"
10951 "PDF:i1 i2\n"
10952 "model:interaction muon scattering numberOfEnergyBins\n"
10953 "can:zmin zmax r\n"
10954 "genvol:zmin zmax r volume numberOfEvents\n"
10955 "merge:time gain\n"
10956 "coord_origin:x y z\n"
10957 "translate:x y z\n"
10958 "genhencut:gDir Emin\n"
10959 "k40:rate time\n" // note lower-case k
10960 "K40:livetime\n" // note capital K
10961 "norma:primaryFlux numberOfPrimaries\n"
10962 "livetime:numberOfSeconds errorOfSeconds\n"
10963 "flux:type key file_1 file_2\n"
10964 "spectrum:alpha\n"
10965 "fixedcan:xcenter ycenter zmin zmax radius\n"
10966 "start_run:run_id";
10967
10968 for ( auto line : splitstring(desc, '\n') )
10969 {
10970 auto v = splitstring( line, ':');
10971
10972 vector< string > fields = splitstring( v[1] );
10973 for ( auto key : splitstring( v[0] ) )
10974 {
10975 r[key] = fields;
10976 }
10977 }
10978 return r;
10979 }
10980
10981
10982 /**
10983 * Get the number of generated events needed for computing event rates.
10984 *
10985 * \return number of events
10986 */
10987 double ngen() const
10988 {
10989 return stod ( get_field("genvol", "numberOfEvents") );
10990 }
10991
10992 /**
10993 * Get the the live time provided by the DAQ sytstem (=number of processed timeslices * frametime).
10994 *
10995 * \return live time [s]
10996 */
10997 double daq_livetime() const
10998 {
10999 return stod ( get_field("DAQ", "livetime") );
11000 }
11001
11002
11003 /**
11004 * Get the Monte Carlo live time
11005 *
11006 * \return live time [s]
11007 */
11008 double mc_livetime() const
11009 {
11010 return stod ( get_field("livetime", "numberOfSeconds") );
11011 }
11012
11013 /**
11014 * Get coordinate origin.
11015 *
11016 * \return position
11017 */
11018 Vec coord_origin() const
11019 {
11020 return Vec( stod( get_field("coord_origin", "x") ),
11021 stod( get_field("coord_origin", "y") ),
11022 stod( get_field("coord_origin", "z") ));
11023 }
11024
11025 /**
11026 * Get coordinate translation.
11027 *
11028 * \return translation
11029 */
11030 Vec translate() const
11031 {
11032 return Vec( stod( get_field("translate", "x") ),
11033 stod( get_field("translate", "y") ),
11034 stod( get_field("translate", "z") ));
11035 }
11036
11037 virtual ~Head() {}
11038
11039 /**
11040 * Action method at file open.
11041 *
11042 * \param version version
11043 */
11044 static void actionAtFileOpen(int version)
11045 {
11046 ROOT_IO_VERSION = version;
11047 }
11048
11049 static int ROOT_IO_VERSION; //!< Streamer version as obtained from ROOT file.
11050
11051 ClassDef(Head, 2 );
11052};
11053
11054
11055/**
11056 * Print header.
11057 *
11058 * \param out output stream
11059 * \param h header
11060 * \return output stream
11061 */
11062inline std::ostream& operator<<(std::ostream& out, const Head& h)
11063{
11064 h.print(out);
11065 return out;
11066}
11067
11068
11069#endif
11070#ifndef HIT_HH_INCLUDED
11071#define HIT_HH_INCLUDED
11072
11073#include "TObject.h"
11074#include "TString.h"
11075#include "km3net-dataformat/offline/Vec.hh"
11076
11077struct Hit :
11078 public TObject
11079{
11080 int id;
11081
11082 // straight from the data
11083 int dom_id; ///< module identifier from the data (unique in the detector).
11084 unsigned int channel_id; ///< PMT channel id {0,1, .., 30} local to moduke
11085 unsigned int tdc; ///< hit tdc (=time in ns)
11086 unsigned int tot; ///< tot value as stored in raw data (int for pyroot)
11087 ULong64_t trig; ///< non-zero if the hit is a trigger hit.
11088
11089 int pmt_id; ///< global PMT identifier as found in evt files
11090
11091 // values after calibration
11092 double t; ///< hit time (from tdc+calibration or MC truth)
11093 double a; ///< hit amplitude (in p.e.)
11094 Vec pos; ///< hit position
11095 Vec dir; ///< hit direction; i.e. direction of the PMT
11096
11097 int type; ///< particle type or parametrisation used for hit (mc only)
11098 int origin; ///< track id of the track that created this hit (mc only)
11099
11100 unsigned pattern_flags; ///< some number that you can use to flag the hit
11101
11102 /**
11103 * Default constructor.
11104 */
11105 Hit(): id(0), dom_id(0), channel_id(0), tdc(0), tot(0), trig(0), pmt_id(0),
11106 t(0), a(0), type(0), origin(0), pattern_flags(0) {}
11107 //virtual ~Hit() {}
11108
11109
11110 /**
11111 * Read hit (useful in python).
11112 *
11113 * \param h hit
11114 */
11115 void read(const Hit& h) { *this = h;}
11116
11117 /**
11118 * Write hit (useful in python).
11119 *
11120 * \param h hit
11121 */
11122 void write(Hit& h) const { h = *this;}
11123
11124 /**
11125 * Print hit.
11126 *
11127 * \param out output stream
11128 */
11129 void print( std::ostream& out = std::cout ) const
11130 {
11131 out << "Hit: id=" << id << " dom=" << dom_id << " channel=" << channel_id;
11132 out << " pmt=" << pmt_id << " t=" << t << " tot=" << tot;
11133 out << " pos="; pos.print(out);
11134 out << " dir="; dir.print(out);
11135 }
11136
11137 ClassDefNV(Hit, 106) // reserve <100 for antcc class of the same name
11138};
11139
11140#endif
11141#ifndef MULTIHEAD_HH_INCLUDED
11142#define MULTIHEAD_HH_INCLUDED
11143
11144#include <vector>
11145#include <uuid/uuid.h>
11146
11147#include "km3net-dataformat/offline/Evt.hh"
11148#include "km3net-dataformat/offline/Head.hh"
11149
11150#include "TObject.h"
11151
11152
11153/**
11154 * \author bjung
11155 */
11156
11157struct MultiHead :
11158 public std::vector<Head>,
11159 public TObject
11160{
11161 /**
11162 * Default constructor.
11163 */
11164 MultiHead() :
11165 std::vector<Head>(),
11166 TObject()
11167 {}
11168
11169
11170 /**
11171 * Virtual destructor.
11172 */
11173 virtual ~MultiHead()
11174 {}
11175
11176
11177 /**
11178 * Find header with given UUID.\n
11179 * Note: The parameter useCache can be toggled on for faster lookup.\n
11180 * This should not be used if your `MultiHead` object is modified between look-ups.
11181 *
11182 *
11183 * \param uuid header UUID
11184 * \param useCache use caching for faster look-up
11185 * \return header with given UUID
11186 */
11187 const_iterator find(const uuid_t& uuid,
11188 const bool useCache = false) const
11189 {
11190 using namespace std;
11191
11192 static struct Cache
11193 {
11194 Cache() { uuid_clear(this->uuid); }
11195
11196 const_iterator it;
11197 uuid_t uuid;
11198 } cache;
11199
11200 if (!useCache) {
11201
11202 for (cache.it = this->cbegin(); cache.it != this->cend(); ++cache.it) {
11203
11204 const Head& head = *cache.it;
11205 string uuid_str = head.at(Head::tags::UUID);
11206
11207 uuid_str.erase(remove_if(uuid_str.begin(), uuid_str.end(), ::isspace), uuid_str.end());
11208
11209 uuid_parse(uuid_str.c_str(), cache.uuid);
11210
11211 if (uuid_compare(uuid, cache.uuid) == 0) {
11212 return cache.it;
11213 }
11214 }
11215
11216 return this->end();
11217
11218 } else {
11219
11220 if (uuid_compare(uuid, cache.uuid) == 0) {
11221 return cache.it;
11222 } else {
11223 return find(uuid, false);
11224 }
11225 }
11226 }
11227
11228
11229 /**
11230 * Find the header corresponding to the given event.
11231 * Note: The parameter useCache can be toggled on for faster lookup.\n
11232 * This should not be used if your `MultiHead` object is modified between look-ups.
11233 *
11234 * \param event event
11235 * \param useCache use caching for faster look-up
11236 * \return header corresponding to the given event
11237 */
11238 const_iterator find(const Evt& event,
11239 const bool useCache = false) const
11240 {
11241 return find(event.header_uuid, useCache);
11242 }
11243
11244
11245 /**
11246 * Insert the given header.
11247 *
11248 * \param header header
11249 * \return true if insertion was successful; else false
11250 */
11251 bool insert(const Head& header)
11252 {
11253 using namespace std;
11254
11255 string uuid_str = header.at(Head::tags::UUID);
11256 uuid_str.erase(remove_if(uuid_str.begin(), uuid_str.end(), ::isspace), uuid_str.end());
11257
11258 uuid_t uuid;
11259 uuid_parse(uuid_str.c_str(), uuid);
11260
11261 if (uuid_is_null(uuid) == 0 && find(uuid) == this->cend()) {
11262
11263 this->push_back(header);
11264
11265 return true;
11266 }
11267
11268 return false;
11269 }
11270
11271
11272 /**
11273 * Join given `MultiHead` object with this `MultiHead` object.
11274 *
11275 * \param multiHead `MultiHead` object
11276 * \return number of inserted headers
11277 */
11278 size_t join(const MultiHead& multiHead)
11279 {
11280 using namespace std;
11281
11282 size_t n = 0;
11283
11284 for (const_iterator i = multiHead.cbegin(); i != multiHead.cend(); ++i) {
11285 n += (size_t) this->insert(*i);
11286 }
11287
11288 return n;
11289 }
11290
11291
11292 /**
11293 * Action method at file open.
11294 *
11295 * \param version version
11296 */
11297 static void actionAtFileOpen(int version)
11298 {
11299 ROOT_IO_VERSION = version;
11300 }
11301
11302
11303 static int ROOT_IO_VERSION; //!< Streamer version as obtained from ROOT file.
11304
11305 ClassDef(MultiHead, 1);
11306};
11307
11308#endif
11309#ifndef TRK_HH_INCLUDED
11310#define TRK_HH_INCLUDED
11311
11312#include <vector>
11313#include "TDatabasePDG.h"
11314#include "TPDGCode.h"
11315#include "km3net-dataformat/offline/AAObject.hh"
11316#include "km3net-dataformat/offline/Vec.hh"
11317#include "km3net-dataformat/definitions/trkmembers.hh"
11318
11319/**
11320 * The Trk class represents a Monte Carlo (MC) particle as well as a reconstructed track/shower.
11321 */
11322struct Trk: public AAObject
11323{
11324 int id; ///< track identifier
11325 Vec pos; ///< postion [m] of the track at time t
11326 Vec dir; ///< track direction
11327 double t; ///< track time [ns] (when the particle is at pos )
11328 double E; ///< Energy [GeV] (either MC truth or reconstructed)
11329
11330 double len; ///< length, if applicable [m]
11331 double lik; ///< likelihood or lambda value (for aafit, lambda)
11332 int type; ///< MC: particle type in PDG encoding
11333 int rec_type; ///< identifier of the fitting algorithm/chain/strategy, see km3net-dataformat/definitions/reconstruction.csv
11334 std::vector<int> rec_stages; ///< list of identifiers of successful fitting stages resulting in this track
11335
11336 int status; ///< MC or reconstruction status code, see km3net-dataformat/definitions/trkmembers.csv for values
11337 int mother_id; ///< id of the parent MC particle or of the reconstructed track at the previous stage
11338 int counter; ///< used by CORSIKA7 MC generation to store interaction counters, see <a href="https://web.iap.kit.edu/corsika/usersguide/usersguide.pdf">CORSIKA user guide</a>
11339
11340 std::vector<double> fitinf; ///< place to store additional fit info, see km3net-dataformat/definitions/fitparameters.csv
11341 std::vector<int> hit_ids; ///< list of associated hit-ids (corresponds to Hit::id).
11342 std::vector<double> error_matrix; ///< (NxN) error covariance matrix for fit parameters (stored as linear vector)
11343 std::string comment; ///< use as you like
11344
11345 /**
11346 * Default constructor.
11347 */
11348 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) {}
11349
11350
11351
11352
11353 /**
11354 * Read track (useful in python).
11355 *
11356 * \param t track
11357 */
11358 void read(const Trk& t) { *this = t;}
11359
11360 /**
11361 * Write track (useful in python).
11362 *
11363 * \param t track
11364 */
11365 void write(Trk& t) const { t = *this; }
11366
11367
11368 /**
11369 * Get the name of the MC particle type.
11370 *
11371 * \return name
11372 */
11373 std::string name() const
11374 {
11375 TParticlePDG* p = TDatabasePDG::Instance()->GetParticle( type );
11376 if (!p) return "unnamed state ("+ std::to_string(type)+")";
11377 return p->GetName();
11378 }
11379
11380 /**
11381 * Check if this is a primary particle.
11382 *
11383 * \return true if primary; else false
11384 */
11385 bool is_primary() const
11386 {
11387 return status==TRK_ST_PRIMARYNEUTRINO || status==TRK_ST_PRIMARYCOSMIC;
11388 }
11389
11390 /**
11391 * Test whether given particle is a final state inside the detector.
11392 *
11393 * \return true if particle is final state; else false
11394 */
11395 bool is_finalstate() const
11396 {
11397 return status==TRK_ST_FINALSTATE;
11398 }
11399
11400 /**
11401 * Check if this is a netrino.
11402 *
11403 * Note that its is checked if the PDG type is a nu-e, nu-mu or nu-tau.
11404 *
11405 * \return true if neutrino; else false
11406 */
11407 bool is_neutrino() const
11408 {
11409 return type == kNuE || type == kNuEBar || type == kNuMu || type == kNuMuBar || type == kNuTau || type == kNuTauBar;
11410 }
11411
11412 /**
11413 * Check if this is an electron or positron.
11414 *
11415 * \return true if this is an electron or positron
11416 */
11417 bool is_e() const
11418 {
11419 return type == kElectron || type == kPositron;
11420 }
11421
11422 /**
11423 * Check if this is a muon.
11424 *
11425 * Note that its is checked if the PDG type is a (anti-)muon.
11426 *
11427 * \return true if muon; else false
11428 */
11429 bool is_muon() const
11430 {
11431 return type == kMuonMinus || type == kMuonPlus;
11432 }
11433
11434 /**
11435 * Check if this is a tau.
11436 *
11437 * Note that its is checked if the PDG type is a (anti-)tau.
11438 *
11439 * \return true if tau; else false
11440 */
11441 bool is_tau() const
11442 {
11443 return type == kTauMinus || type == kTauPlus;
11444 }
11445
11446 /**
11447 * Check if this is a charged lepton.
11448 *
11449 * Note that its is checked if the PDG type is a (anti-)electron, (anti-)muon or (anti-)tua.
11450 *
11451 * \return true if charged lepton; else false
11452 */
11453 bool is_lepton() const
11454 {
11455 return is_e() || is_muon() || is_tau();
11456 }
11457
11458 /**
11459 * Check if this is an orphan (i.e. no mother).
11460 *
11461 * \return true if orphan; else false
11462 */
11463 bool is_orphan() const
11464 {
11465 return mother_id == TRK_MOTHER_NONE;
11466 }
11467
11468 /**
11469 * Get list of of pointers to tracks, all of which have their mother identifier set to identifier of this track.
11470 *
11471 * \param mctrks list of input tracks
11472 * \return list of pointers to tracks
11473 */
11474 std::vector< Trk* > get_daughters ( std::vector<Trk>& mctrks )
11475 {
11476 std::vector<Trk*> r;
11477
11478 for( auto& t : mctrks )
11479 {
11480 if ( t.mother_id == id ) r.push_back( &t );
11481 }
11482 return r;
11483 }
11484
11485 /**
11486 * Print track.
11487 *
11488 * \param out output stream
11489 */
11490 void print(std::ostream& out=std::cout) const
11491 {
11492 out << "Trk: id=" << id << " pos="; pos.print(out);
11493 out << " dir="; dir.print(out);
11494 out << " t=" << t << " E=" << E << " pdg-type=" << type;
11495 }
11496
11497 ClassDef(Trk,12)
11498};
11499
11500#endif
11501#ifndef VEC_HH_INCLUDED
11502#define VEC_HH_INCLUDED
11503
11504#include <cmath>
11505#include <iostream>
11506#include <sstream>
11507#include "Rtypes.h"
11508
11509/**
11510 * The Vec class is a straightforward 3-d vector, which also works in pyroot.
11511 */
11512struct Vec
11513{
11514 double x,y,z;
11515
11516 /**
11517 * Constructor.
11518 *
11519 * \param x_ x position
11520 * \param y_ y position
11521 * \param z_ z position
11522 */
11523 Vec(double x_, double y_, double z_) : x(x_), y(y_), z(z_) {}
11524
11525 /**
11526 * Default constructor.
11527 */
11528 Vec():x(0),y(0),z(0) {}
11529
11530 /**
11531 * Get dot product.
11532 *
11533 * \param v vector
11534 * \return dot product
11535 */
11536 double dot(const Vec& v) const { return v.x*x + v.y*y+ v.z*z;}
11537
11538 /**
11539 * Get cross product.
11540 *
11541 * \param r vector
11542 * \return cross product
11543 */
11544 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);}
11545
11546 /**
11547 * Add vector.
11548 *
11549 * \param v vector
11550 * \return this vector
11551 */
11552 Vec& operator+=(const Vec& v) { x+=v.x; y+=v.y; z+=v.z; return *this;}
11553
11554 /**
11555 * Subtract vector.
11556 *
11557 * \param v vector
11558 * \return this vector
11559 */
11560 Vec& operator-=(const Vec& v) { x-=v.x; y-=v.y; z-=v.z; return *this;}
11561
11562 /**
11563 * Multiply vector.
11564 *
11565 * \param d factor
11566 * \return this vector
11567 */
11568 Vec& operator*=(double d) { x*=d; y*=d; z*=d; return *this;}
11569
11570 /**
11571 * Divide vector.
11572 *
11573 * \param d factor
11574 * \return this vector
11575 */
11576 Vec& operator/=(double d) { return operator*=( 1.0 / d ); }
11577
11578 /**
11579 * Negate vector.
11580 *
11581 * \return vector
11582 */
11583 Vec operator-() const { return Vec(-x,-y,-z); }
11584
11585 /**
11586 * Check equality with given vector.
11587 *
11588 * \param v vector
11589 * \return true if (x,y,z) positions of two vectors are equal; else false
11590 */
11591 bool operator==( const Vec& v ) const { return x==v.x && y==v.y && z==v.z ; }
11592
11593 /**
11594 * Check in-equality with given vector.
11595 *
11596 * \param v vector
11597 * \return true if one of (x,y,z) positions of two vectors are not equal; else false
11598 */
11599 bool operator!=( const Vec& v ) const { return x!=v.x || y!=v.y || z!=v.z ; }
11600
11601 /**
11602 * Set vector.
11603 *
11604 * \param xx x position
11605 * \param yy y position
11606 * \param zz z position
11607 * \return this vector
11608 */
11609 Vec& set(double xx, double yy, double zz) { x=xx; y=yy; z=zz; return *this;}
11610
11611 /**
11612 * Set vector according given zenith and azimuth angles.
11613 *
11614 * \param theta zenith angle [rad]
11615 * \param phi azimuth angle [rad]
11616 * \return this vector
11617 */
11618 Vec& set_angles(double theta, double phi)
11619 {
11620 x = sin ( theta ) * cos( phi );
11621 y = sin ( theta ) * sin( phi );
11622 z = cos ( theta );
11623 return *this;
11624 }
11625
11626 /**
11627 * Get azimuth angle.
11628 *
11629 * \return angle [rad]
11630 */
11631 double phi() const { return atan2( y,x ); }
11632
11633 /**
11634 * Get zenith angle.
11635 *
11636 * \return angle [rad]
11637 */
11638 double theta() const { return acos(z); }
11639
11640 /**
11641 * Get length.
11642 *
11643 * \return length
11644 */
11645 double len() const { double l = dot(*this); return (l > 0)? sqrt(l) : 0; }
11646
11647 /**
11648 * Get length of (x,y) component.
11649 *
11650 * \return length
11651 */
11652 double lenxy() const { const double r2 = x*x + y*y; return (r2>0) ? sqrt(r2) :0; }
11653
11654 /**
11655 * Normalise this vector.
11656 *
11657 * \return this vector
11658 */
11659 Vec& normalize() { return operator/=( len() ); }
11660
11661 /**
11662 * Print vector.
11663 *
11664 * \param out output stream
11665 */
11666 void print( std::ostream& out = std::cout ) const
11667 {
11668 out << "Vec:" << x << " " << y << " " << z;
11669 }
11670
11671 /**
11672 * Get string representation of this vector
11673 *
11674 * \return string
11675 */
11676 const char* __repr__() const
11677 {
11678 static std::string buffer;
11679
11680 std::ostringstream s;
11681
11682 print(s);
11683
11684 buffer = s.str();
11685
11686 return buffer.c_str();
11687 }
11688
11689 /**
11690 * Add vector.
11691 *
11692 * \param v vector
11693 * \return vector
11694 */
11695 Vec __add__(const Vec& v) const { Vec r=*this; return r+=v; }
11696
11697 /**
11698 * Subtract vector.
11699 *
11700 * \param v vector
11701 * \return vector
11702 */
11703 Vec __sub__(const Vec& v) const { Vec r=*this; return r-=v; }
11704
11705 /**
11706 * Multiply vector.
11707 *
11708 * \param d factor
11709 * \return vector
11710 */
11711 Vec __mul__(double d ) const { Vec r=*this; return r*=d; }
11712
11713 /**
11714 * Multiply vector.
11715 *
11716 * \param d factor
11717 * \return vector
11718 */
11719 Vec __rmul__(double d ) const { return __mul__(d); }
11720
11721 /**
11722 * Divide vector.
11723 *
11724 * \param d factor
11725 * \return vector
11726 */
11727 Vec __div__(double d ) const { Vec r=*this; return r/=d; }
11728
11729 /**
11730 * Rotate around z-axis with given angle.
11731 *
11732 * \param ang angle [rad]
11733 * \return this vector
11734 */
11735 Vec& rotate_z(double ang)
11736 {
11737 const Vec o = *this;
11738 x = o.x *cos(ang) - o.y * sin(ang);
11739 y = o.x *sin(ang) + o.y * cos(ang);
11740 z = o.z;
11741 return *this;
11742 }
11743
11744 /**
11745 * Rotate around x-axis with given angle.
11746 *
11747 * \param ang angle [rad]
11748 * \return this vector
11749 */
11750 Vec& rotate_x(double ang)
11751 {
11752 const Vec o = *this;
11753 x = o.x;
11754 y = o.y *cos(ang) + o.z * -sin(ang);
11755 z = o.y *sin(ang) + o.z * cos(ang);
11756 return *this;
11757 }
11758
11759 /**
11760 * Rotate around y-axis with given angle.
11761 *
11762 * \param ang angle [rad]
11763 * \return this vector
11764 */
11765 Vec& rotate_y(double ang)
11766 {
11767 const Vec o = *this;
11768 x = o.x *cos(ang) + o.z * sin(ang);
11769 y = o.y;
11770 z = -o.x *sin(ang) + o.z * cos(ang);
11771 return *this;
11772 }
11773
11774 ClassDefNV(Vec,3)
11775};
11776
11777/**
11778 * Write vector to output stream.
11779 *
11780 * \param out output stream
11781 * \param v vector
11782 * \return output stream
11783 */
11784inline std::ostream& operator<<( std::ostream& out , const Vec& v )
11785{
11786 out << v.x << " " << v.y << " " << v.z << " ";
11787 return out;
11788}
11789
11790/**
11791 * Read vector from input stream.
11792 *
11793 * \param in input stream
11794 * \param v vector
11795 * \return input stream
11796 */
11797inline std::istream& operator>>(std::istream& in, Vec& v)
11798{
11799 in >> v.x >> v.y >> v.z ; return in;
11800}
11801
11802/**
11803 * Get cosine of space angle between two vectors.
11804 *
11805 * \param a first vector
11806 * \param b second vector
11807 * \return cosine
11808 */
11809inline double cos_angle_between( const Vec& a, const Vec& b)
11810{
11811 const double n = a.len() * b.len();
11812 return a.dot(b) / n;
11813}
11814
11815/**
11816 * Get space angle between two vectors.
11817 *
11818 * \param a first vector
11819 * \param b second vector
11820 * \return angle [rad]
11821 */
11822inline double angle_between( const Vec& a, const Vec& b )
11823{
11824 double c = cos_angle_between( a, b );
11825 if ( c < -1 ) return M_PI;
11826 if ( c > 1 ) return 0;
11827 return acos( c );
11828}
11829
11830/**
11831 * Add two vectors.
11832 *
11833 * \param a first vector
11834 * \param b second vector
11835 * \return vector
11836 */
11837inline Vec operator+(const Vec& a, const Vec& b) { Vec r(a); return r+=b;}
11838
11839/**
11840 * Subtract two vectors.
11841 *
11842 * \param a first vector
11843 * \param b second vector
11844 * \return vector
11845 */
11846inline Vec operator-(const Vec& a, const Vec& b) { Vec r(a); return r-=b;}
11847
11848/**
11849 * Multiply vector.
11850 *
11851 * \param a factor
11852 * \param v vector
11853 * \return vector
11854 */
11855inline Vec operator*(double a, const Vec& v) { return Vec(a*v.x,a*v.y,a*v.z);}
11856
11857/**
11858 * Multiply vector.
11859 *
11860 * \param v vector
11861 * \param a factor
11862 * \return vector
11863 */
11864inline Vec operator*(const Vec& v, double a) { return Vec(a*v.x,a*v.y,a*v.z);}
11865
11866/**
11867 * Divide vector.
11868 *
11869 * \param v vector
11870 * \param a factor
11871 * \return vector
11872 */
11873inline Vec operator/(const Vec& v, double a) { return Vec(v.x/a,v.y/a,v.z/a);}
11874
11875#endif
11876#ifndef IO_ASCII_INCLUDED
11877#define IO_ASCII_INCLUDED
11878
11879#include <string>
11880#include <istream>
11881#include <ostream>
11882#include <sstream>
11883
11884#include "km3net-dataformat/offline/Evt.hh"
11885#include "km3net-dataformat/offline/Hit.hh"
11886#include "km3net-dataformat/offline/Trk.hh"
11887#include "km3net-dataformat/offline/Head.hh"
11888#include "km3net-dataformat/offline/Exception.hh"
11889#include "km3net-dataformat/definitions/w2list_gseagen.hh"
11890#include "km3net-dataformat/definitions/trkmembers.hh"
11891
11892#include "TDatabasePDG.h"
11893
11894namespace mc_keys
11895{
11896 const char* const auto_t = "auto";
11897 const char* const start_run_t = "start_run:";
11898 const char* const start_event_t = "start_event:";
11899 const char* const hit_t = "hit:";
11900 const char* const hit_raw_t = "hit_raw:";
11901 const char* const track_in_t = "track_in:";
11902 const char* const track_t = "track:";
11903 const char* const track_fit_t = "track_fit:";
11904 const char* const neutrino_t = "neutrino:";
11905 const char* const track_primary_t = "track_primary:";
11906 const char* const track_bundle_t = "track_bundle:";
11907 //const char* const primarylepton_t = "primarylepton:";
11908 const char* const weights_t = "weights:";
11909 const char* const w2list_t = "w2list:";
11910 const char* const w3list_t = "w3list:";
11911 const char* const hourangle_t = "hourangle:";
11912 const char* const eventtime_t = "eventtime:";
11913 const char* const center_on_can_t = "center_on_can:";
11914 const char* const muon_decay_t = "muon_decay:";
11915 const char* const end_event_t = "end_event:";
11916}
11917
11918namespace mc_usr_keys
11919{
11920 // track-level quantities
11921 const char* const energy_lost_in_can = "energy_lost_in_can";
11922
11923
11924 // event-level corsika variables
11925 const char* const muon_decay_x = "muon_decay_x";
11926 const char* const muon_decay_y = "muon_decay_y";
11927 const char* const muon_decay_z = "muon_decay_z";
11928
11929 const char* const center_on_can_x = "center_on_can_x";
11930 const char* const center_on_can_y = "center_on_can_y";
11931 const char* const center_on_can_z = "center_on_can_z";
11932 const char* const hourangle = "hourangle";
11933}
11934
11935
11936namespace io_stringutil
11937{
11938 /**
11939 * Check if string starts with given text.
11940 *
11941 * \param a input string
11942 * \param b text
11943 * \return true if string start with text; else false
11944 */
11945 inline bool startswith( const std::string& a, const std::string& b )
11946 {
11947 if ( a.find( b ) == 0 ) return true;
11948 return false;
11949 }
11950
11951 /**
11952 * Remove leading and trailing white spaces.
11953 *
11954 * \param s input string
11955 * \return trimmed string
11956 */
11957 inline std::string trim(const std::string& s)
11958 {
11959 using namespace std;
11960
11961 if ( s == "" ) return s;
11962
11963 string::size_type i1;
11964 string::size_type i2;
11965
11966 for (i1 = 0; i1 < s.length(); i1++)
11967 {
11968 if ( !isspace (s[i1]) ) break;
11969 }
11970 for (i2 = s.length() - 1 ; i2 > i1 ; i2--)
11971 {
11972 if ( !isspace (s[i2]) ) break;
11973 }
11974 return s.substr( i1, i2 - i1 + 1 );
11975 }
11976
11977}
11978
11979
11980/**
11981 * Convert Geant3 to PDG particle type.
11982 *
11983 * \param geant3_code Geant3 code
11984 * \return PDG code
11985 */
11986inline int pdg_code( int geant3_code )
11987{
11988 if ( geant3_code == -1 ) return -1; // used for k40 hits
11989 if ( geant3_code < 0 ) return pdg_code( -geant3_code ); // used for scattered
11990
11991 return TDatabasePDG::Instance()->ConvertGeant3ToPdg( geant3_code );
11992}
11993
11994/**
11995 * Convert PDG to Geant3 particle type.
11996 *
11997 * \param pdg_code PDG code
11998 * \return Geant3 code
11999 */
12000inline int geant3_code( int pdg_code )
12001{
12002 if (pdg_code == -1 ) return -1;
12003 if (pdg_code == +311 ) return geant3_code( 130 ); // K0 -> K0long
12004 if (pdg_code == -311 ) return geant3_code( 130 ); // K0bar -> K0long
12005
12006 return TDatabasePDG::Instance()->ConvertPdgToGeant3( pdg_code );
12007}
12008
12009
12010/**
12011 * Read a Vec(tor) from a stream.
12012 *
12013 * \param v vector
12014 * \param is input stream
12015 * \return true if correctly read; else false
12016 */
12017inline bool read ( Vec& v, std::istream& is)
12018{
12019 is >> v.x >> v.y >> v.z;
12020 return !is.fail();
12021}
12022
12023/**
12024 * Write a Vec(tor) to a stream.
12025 *
12026 * \param v vector
12027 * \param os output stream
12028 * \return true if correctly written; else false
12029 */
12030inline bool write( const Vec& v, std::ostream& os)
12031{
12032 os << v.x << ' ' << v.y << ' ' << v.z;
12033 return !os.fail();
12034}
12035
12036/**
12037 * Read a hit from a stream.
12038 *
12039 * \param h hit
12040 * \param is input stream
12041 * \param read_mc option to read also type and origin
12042 * \return true if correctly read; else false
12043 */
12044inline bool read ( Hit& h, std::istream& is, bool read_mc = false )
12045{
12046 h.dom_id = 0; // need a proper det file to
12047 h.channel_id = 0; // set these.
12048
12049 is >> h.id >> h.pmt_id >> h.a >> h.t;
12050 if ( !read_mc )
12051 {
12052 return !is.fail();
12053 }
12054 else
12055 {
12056 is >> h.type >> h.origin;
12057 }
12058
12059 // at this point, an additional pure_a and pure_t may be present,
12060 // but we do not read them.
12061
12062 return !is.fail();
12063}
12064
12065
12066/**
12067 * Write a hit to a stream.
12068 *
12069 * \param h hit
12070 * \param os output stream
12071 * \param tag tag
12072 * \return true if correctly written; else false
12073 */
12074inline bool write( const Hit& h, std::ostream& os, const std::string& tag = mc_keys::hit_t)
12075{
12076 int om_id = h.pmt_id; // todo: deal with this better.
12077
12078 os << tag << ' ' << h.id << ' ' << om_id << ' ' << h.a << ' ' << h.t;
12079 if ( tag != mc_keys::hit_raw_t ) {
12080 os << ' ' << h.type << ' ' << h.origin; // not writing pure_a and pure_t
12081 }
12082 os << std::endl;
12083 return !os.fail();
12084}
12085
12086
12087/**
12088 * Read data.
12089 *
12090 * \param is input stream
12091 * \return data
12092 */
12093inline std::vector<double> read_line_to_vector( std::istream& is )
12094{
12095 using namespace std;
12096
12097 vector<double> r;
12098
12099 string ss;
12100 getline(is, ss);
12101 istringstream il(ss);
12102 for ( double x; il >> x ; ) r.push_back( x );
12103
12104 return r;
12105}
12106
12107
12108/**
12109 * Put value in front of data.
12110 *
12111 * \param vec data
12112 * \param value value
12113 */
12114template<typename T>
12115inline void push_front( std::vector<T>& vec, const T& value )
12116{
12117 vec.insert( vec.begin(), value );
12118}
12119
12120
12121/**
12122 * Read event from a stream.
12123 *
12124 * \param evt event
12125 * \param is input stream
12126 * \param skip_hits option to skip reading of hits
12127 * \return true if correctly read; else false
12128 */
12129inline bool read ( Evt& evt, std::istream& is, bool skip_hits = false )
12130{
12131 using namespace std;
12132
12133 string w;
12134
12135 // find next start_event
12136
12137 while ( w != mc_keys::start_event_t && is.good() ) is >> w;
12138
12139 int mc_event_type; // dummy - this is always 1 in all files.
12140 is >> evt.mc_id >> mc_event_type;
12141
12142 Trk trk_nu, trk_primary;
12143 bool have_trk_nu(false), have_trk_primary(false);
12144
12145
12146 evt.mc_trks.clear();
12147 evt.hits.clear();
12148 evt.mc_hits.clear();
12149
12150 string w_old;
12151
12152 while ( is )
12153 {
12154 static Hit h;
12155 static Trk t;
12156
12157 is >> w;
12158
12159 if (skip_hits && ( w == mc_keys::hit_t || w == mc_keys::hit_raw_t)) {
12160 is.ignore( 1000, '\n' );
12161 continue;
12162 }
12163
12164 if ( w == mc_keys::hit_t ) {
12165
12166 read( h, is, true );
12167 evt.mc_hits.push_back( h );
12168
12169 } else if ( w == mc_keys::hit_raw_t ) {
12170
12171 read( h, is, false);
12172 evt.hits.push_back( h );
12173
12174 } else if ( w == mc_keys::track_in_t ||
12175 w == mc_keys::track_t ||
12176 w == mc_keys::neutrino_t ||
12177 w == mc_keys::track_bundle_t ||
12178 w == mc_keys::track_primary_t ) {
12179
12180 t.id = 0;
12181 t.len = 0.0;
12182 t.clearusr();
12183 t.comment = w;
12184
12185 string line;
12186 getline( is, line );
12187 istringstream ii(line);
12188
12189 if ( w != mc_keys::track_bundle_t ) {
12190 ii >> t.id;
12191 } else {
12192 ii >> t.len;
12193 }
12194
12195 ii >> t.pos >> t.dir >> t.E;
12196
12197 if (!ii.fail()) {
12198
12199 if ( w == mc_keys::track_in_t) {
12200
12201 t.status = TRK_ST_FINALSTATE;
12202
12203 ii >> t.t >> t.type;
12204
12205 if (!ii.fail()) {
12206
12207 t.type = pdg_code( t.type );
12208
12209 ii >> t.len;
12210
12211 if ( ii.fail() ) { // missing length is not an error
12212 evt.mc_trks.push_back( t );
12213 continue;
12214 }
12215
12216 double eloss = 0;
12217 ii >> eloss;
12218
12219 if ( ii.fail() ) { // missing eloss is not an error
12220 evt.mc_trks.push_back( t );
12221 continue;
12222 }
12223
12224 t.setusr( mc_usr_keys::energy_lost_in_can, eloss);
12225
12226 evt.mc_trks.push_back( t );
12227 }
12228
12229 } else if ( w == mc_keys::track_t ) {
12230
12231 ii >> t.t;
12232
12233 evt.trks.push_back( t );
12234
12235 } else if ( w == mc_keys::neutrino_t ) {
12236
12237 t.status = TRK_ST_PRIMARYNEUTRINO;
12238
12239 // the last item we will read is W2LIST_GSEAGEN_CC, make enough space;
12240 if (evt.w2list.size() < W2LIST_GSEAGEN_CC+1 ) evt.w2list.resize(W2LIST_GSEAGEN_CC+1);
12241
12242 ii >> t.t >>
12243 evt.w2list[W2LIST_GSEAGEN_BX] >>
12244 evt.w2list[W2LIST_GSEAGEN_BY] >>
12245 evt.w2list[W2LIST_GSEAGEN_ICHAN] >>
12246 t.type >>
12247 evt.w2list[W2LIST_GSEAGEN_CC];
12248
12249 trk_nu = t;
12250 have_trk_nu = true;
12251
12252 } else if ( w == mc_keys::track_primary_t ) {
12253
12254 t.status = TRK_ST_PRIMARYCOSMIC;
12255
12256 ii >> t.t >> trk_primary.type; // nucleus id (in pdg format or not?)
12257
12258 trk_primary = t;
12259 have_trk_primary = true;
12260
12261 } else if ( w == mc_keys::track_bundle_t ) {
12262
12263 t.type = PDG_MUONBUNDLE;
12264 t.status = TRK_ST_MUONBUNDLE;
12265
12266 evt.mc_trks.push_back( t );
12267
12268 } else {
12269
12270 ostringstream out;
12271 out << "Unknown tag " << w << " for trk ";
12272 t.print(out);
12273 throw Exception(static_cast<ostringstream&>(out).str());
12274 }
12275 }
12276
12277 if ( ii.fail() ) {
12278 ostringstream out;
12279 out << "Error reading trk ";
12280 t.print(out);
12281 throw Exception(static_cast<ostringstream&>(out).str());
12282 }
12283
12284 } else if ( w == mc_keys::weights_t) {
12285
12286 evt.w = read_line_to_vector( is );
12287
12288 } else if ( w == mc_keys::w2list_t) {
12289
12290 auto v = read_line_to_vector( is );
12291 evt.w2list.resize( std::max( evt.w2list.size(), v.size()));
12292 std::copy( v.begin(), v.end() , evt.w2list.begin() );
12293
12294 } else if ( w == mc_keys::w3list_t) {
12295
12296 evt.w3list = read_line_to_vector( is );
12297
12298 } else if ( w == mc_keys::hourangle_t ) {
12299
12300 double ha;
12301 is >> ha;
12302 evt.setusr(mc_usr_keys::hourangle, ha );
12303
12304 } else if ( w == mc_keys::center_on_can_t) {
12305
12306 // in corsika files, there is the (undocumented?) center_on_can tag,
12307 // which denoets the projection of the primary on the can. The direction
12308 // of the center_on_can 'track' is by defintion the direction of the
12309 // primary. We record the position in the usr data.
12310
12311 vector<double> v = read_line_to_vector( is );
12312
12313 if ( v.size() > 3 ) {
12314 evt.setusr(mc_usr_keys::center_on_can_x, v[1] );
12315 evt.setusr(mc_usr_keys::center_on_can_y, v[2] );
12316 evt.setusr(mc_usr_keys::center_on_can_z, v[3] );
12317 }
12318
12319 } else if ( w == mc_keys::eventtime_t ) {
12320
12321 unsigned nsec, n16ns_ticks;
12322 is >> nsec >> n16ns_ticks;
12323 evt.mc_event_time.SetSec( nsec );
12324 evt.mc_event_time.SetNanoSec( n16ns_ticks * 16 );
12325
12326 } else if ( w == mc_keys::muon_decay_t) {
12327
12328 // in km3sim files, there are additional tags, including this one
12329 vector<double> v = read_line_to_vector( is );
12330 if ( v.size() > 4 )
12331 {
12332 evt.setusr(mc_usr_keys::muon_decay_x, v[2] );
12333 evt.setusr(mc_usr_keys::muon_decay_y, v[3] );
12334 evt.setusr(mc_usr_keys::muon_decay_z, v[4] );
12335 }
12336
12337 } else if ( w == mc_keys::end_event_t) {
12338
12339 // finalize the mc_tracks -- as best we can.
12340
12341 // If there is both a primary, and a neutrino, then the primary
12342 // will go second (mc_trks[1]) with id=-1 and the neutrino will
12343 // be mc_trks[0] with id=0. Unless they are same particle (identical
12344 // pos,dir,E); in that case the primary is skipped.
12345 // The primarylepton tag is not stored as a seperate Trk.
12346
12347 if ( have_trk_primary && have_trk_nu ) {
12348
12349 bool same = trk_nu.pos == trk_primary.pos &&
12350 trk_nu.dir == trk_primary.dir &&
12351 trk_nu.E == trk_primary.E;
12352
12353 if (!same) {
12354 trk_primary.id = -1;
12355 push_front( evt.mc_trks, trk_primary);
12356 }
12357
12358 trk_nu.id = 0;
12359 push_front( evt.mc_trks, trk_nu);
12360
12361 } else if ( have_trk_primary ) {
12362
12363 trk_primary.id = 0;
12364 push_front( evt.mc_trks, trk_primary);
12365
12366 } else if ( have_trk_nu ) {
12367
12368 trk_nu.id = 0;
12369 push_front( evt.mc_trks, trk_nu);
12370 }
12371
12372 return true;
12373
12374 } else {
12375 is.ignore( 1000, '\n' );
12376 }
12377
12378 w_old = w;
12379 }
12380
12381 if (!is.eof()) {
12382 THROW(Exception, "Error while reading ascii event" << w << ' ' << evt.id);
12383 }
12384
12385 return false;
12386}
12387
12388
12389/**
12390 * Write event to a stream.
12391 *
12392 * \param evt event
12393 * \param os output stream
12394 * \return true if correctly read; else false
12395 */
12396inline bool write( const Evt& evt, std::ostream& os )
12397{
12398 using namespace std;
12399
12400 // set precision to 12 digits.
12401 const int precision = 12;
12402 auto old_flags = os.flags();
12403 auto old_precision = os.precision( precision );
12404 os.unsetf( std::ios_base::scientific | std::ios_base::fixed ); // default behaviour
12405
12406 os << mc_keys::start_event_t << ' ' << evt.mc_id << ' ' << 1 << endl;
12407
12408 for ( auto& trk : evt.mc_trks ) {
12409
12410 const std::string& tag = trk.comment;
12411
12412 os << tag << ' '
12413 << (tag != mc_keys::track_bundle_t ? trk.id : trk.len) << ' '
12414 << trk.pos << ' '
12415 << trk.dir << ' '
12416 << trk.E;
12417
12418 if ( tag == mc_keys::track_in_t ) {
12419
12420 os << ' ' << trk.t << ' ' << geant3_code(trk.type) << ' ' << trk.len;
12421
12422 if ( trk.haveusr( mc_usr_keys::energy_lost_in_can ) ) {
12423 os << ' ' << trk.getusr( mc_usr_keys::energy_lost_in_can );
12424 }
12425
12426 os << endl;
12427
12428 } else if ( tag == mc_keys::track_primary_t ) {
12429
12430 os << ' ' << trk.t << ' ' << trk.type << endl;
12431
12432 } else if ( tag == mc_keys::neutrino_t ) {
12433
12434 double bx(0), by(0);
12435 int ichan(0), cc(0);
12436
12437 if ( evt.w2list.size() > W2LIST_GSEAGEN_CC ) {
12438 bx = evt.w2list[W2LIST_GSEAGEN_BX];
12439 by = evt.w2list[W2LIST_GSEAGEN_BY];
12440 ichan = evt.w2list[W2LIST_GSEAGEN_ICHAN];
12441 cc = evt.w2list[W2LIST_GSEAGEN_CC];
12442 }
12443
12444 os << ' ' << trk.t
12445 << ' ' << bx
12446 << ' ' << by
12447 << ' ' << ichan
12448 << ' ' << trk.type
12449 << ' ' << cc
12450 << endl;
12451
12452 } else {
12453
12454 os << endl;
12455 }
12456 }
12457
12458 for ( auto& trk : evt.trks ) {
12459 os << mc_keys::track_fit_t << ' ' << trk.id << ' ' << trk.pos << ' ' << trk.dir << ' ' << trk.E << ' ' << trk.t << endl;
12460 }
12461
12462 for ( auto& hit : evt.mc_hits ) write ( hit, os, mc_keys::hit_t);
12463 for ( auto& hit : evt.hits ) write ( hit, os, mc_keys::hit_raw_t);
12464
12465 os << mc_keys::weights_t; for (auto& w : evt.w ) os << ' ' << w; os << endl;
12466 os << mc_keys::w2list_t; for (auto& w : evt.w2list ) os << ' ' << w; os << endl;
12467 os << mc_keys::w3list_t; for (auto& w : evt.w3list ) os << ' ' << w; os << endl;
12468
12469 os << mc_keys::eventtime_t << evt.mc_event_time.GetSec() << " "
12470 << evt.mc_event_time.GetNanoSec() / 16 << endl;
12471
12472 os << mc_keys::end_event_t << endl;
12473
12474 // restore os to how we found it.
12475 os.flags( old_flags );
12476 os.precision( old_precision );
12477
12478 return true;
12479}
12480
12481
12482
12483/**
12484 * Read header from a stream.
12485 *
12486 * The stream may be positioned at any point before the tag mc_keys::start_run_t,
12487 * which marks the beginning of the header.
12488 * Information before the header (if any) is disgarded.
12489 *
12490 * \param hdr header
12491 * \param is input stream
12492 * \return true if correctly read; else false
12493 */
12494inline bool read( Head& hdr, std::istream& is )
12495{
12496 using namespace std;
12497
12498 string line;
12499
12500 bool start = false;
12501
12502 while (getline( is, line ))
12503 {
12504 if ( io_stringutil::startswith(line, mc_keys::end_event_t))
12505 {
12506 break;
12507 }
12508
12509 if ( io_stringutil::startswith(line, mc_keys::start_run_t))
12510 {
12511 start = true;
12512 }
12513
12514 if ( io_stringutil::startswith(line, mc_keys::start_event_t))
12515 {
12516 THROW(Exception, "Unexpected tag " << mc_keys::start_event_t << " found while reading header at " << line << " (could mean the evt file has no header)");
12517 }
12518
12519 if (!start) continue;
12520
12521 const string::size_type pos = line.find(':');
12522
12523 if (pos == string::npos)
12524 {
12525 std::cout << "Warning: line with empty tag found when reading header" << endl;
12526 std::cout << " "<< line << endl;
12527 std::cout << " will be skipped" << endl;
12528 continue;
12529 }
12530
12531 // the following with unsure key in the map is unique by adding _1 _2 etc.
12532 hdr.set_line( io_stringutil::trim(line.substr(0,pos)), io_stringutil::trim(line.substr(pos+1)) );
12533
12534 }
12535
12536 if (!start)
12537 {
12538 THROW(Exception, "Reading of MC header terminated before finding a start_run: tag. Please check your file");
12539 }
12540
12541 return start;
12542}
12543
12544
12545/**
12546 * Write header to a stream.
12547 *
12548 * \param hdr header
12549 * \param os output stream
12550 * \return true if correctly written; else false
12551 */
12552inline bool write( const Head& hdr, std::ostream& os )
12553{
12554 hdr.print(os);
12555 return true;
12556}
12557
12558#endif
12559#ifndef IOONLINEINCLUDED
12560#define IOONLINEINCLUDED
12561
12562#include "km3net-dataformat/offline/Evt.hh"
12563#include "km3net-dataformat/offline/Hit.hh"
12564#include "km3net-dataformat/offline/Trk.hh"
12565#include "km3net-dataformat/offline/Exception.hh"
12566
12567#include "km3net-dataformat/online/JDAQEvent.hh"
12568#include "km3net-dataformat/online/JDAQKeyHit.hh"
12569#include "km3net-dataformat/online/JDAQTimeslice.hh"
12570#include "km3net-dataformat/online/JDAQSummaryslice.hh"
12571
12572#include "TStreamerInfo.h"
12573#include "TFile.h"
12574#include "TTree.h"
12575#include "km3net-dataformat/definitions/root.hh"
12576
12577#include <map>
12578#include <vector>
12579
12580
12581using namespace KM3NETDAQ;
12582
12583/**
12584 * Read a hit from a DAQ hit.
12585 *
12586 * \param hit hit
12587 * \param daqhit DAQ hit
12588 */
12589inline void read(Hit& hit, const JDAQHit& daqhit )
12590{
12591 hit.channel_id = daqhit.getPMT();
12592 hit.tot = daqhit.getToT();
12593 hit.tdc = daqhit.getT(); // GetT() just return the bare TDC
12594}
12595
12596/**
12597 * Read a hit from a DAQ key hit.
12598 *
12599 * \param hit hit
12600 * \param daqhit DAQ key hit
12601 */
12602inline void read(Hit& hit, const JDAQKeyHit& daqhit )
12603{
12604 hit.id = hit.pmt_id = 0;
12605
12606 hit.dom_id = daqhit.getModuleID();
12607 hit.channel_id = daqhit.getPMT();
12608 hit.tot = daqhit.getToT();
12609 hit.tdc = daqhit.getT(); // GetT() just return the bare TDC
12610}
12611
12612/**
12613 * Read an event from a DAQ event.
12614 *
12615 * \param evt evt
12616 * \param de DAQ event
12617 */
12618inline void read(Evt& evt, const JDAQEvent& de)
12619{
12620 evt.run_id = de.getRunNumber();
12621 evt.det_id = de.getDetectorID();
12622 evt.frame_index = de.getFrameIndex();
12623 evt.trigger_counter = de.getCounter();
12624 evt.overlays = de.getOverlays();
12625 evt.trigger_mask = de.getTriggerMask();
12626 evt.t.SetSec( de.getTimesliceStart().getUTCseconds() );
12627 evt.t.SetNanoSec( de.getTimesliceStart().getUTC16nanosecondcycles() * 16 );
12628
12629 // The only way to know the hits that are also in the triggeredhits collection
12630 // is by dom and channel id and time.
12631
12632 Hit h;
12633 std::map<int, std::map< int, std::map < unsigned int, Hit*> > > M;
12634
12635 const std::vector<JDAQSnapshotHit>& snapshotHits = de.getHits<JDAQSnapshotHit>();
12636 const std::vector<JDAQTriggeredHit>& triggeredHits = de.getHits<JDAQTriggeredHit>();
12637
12638 // http://stackoverflow.com/questions/10735135/reallocation-in-stdvector-after-stdvector-reserve
12639 evt.hits.clear();
12640 evt.hits.reserve(snapshotHits.size());
12641
12642 for (auto& daqhit : snapshotHits ) // JDAQSnapshotHit
12643 {
12644 read( h, daqhit );
12645 h.trig = 0;
12646 evt.hits.push_back( h );
12647 M[ h.dom_id ][ h.channel_id ][ h.tdc ] = &(*evt.hits.rbegin());
12648 }
12649
12650 for (auto& daqtrighit : triggeredHits)
12651 {
12652 Hit* g = M[daqtrighit.getModuleID()][daqtrighit.getPMT()][daqtrighit.getT()];
12653
12654 if (g)
12655 g->trig = daqtrighit.getTriggerMask ();
12656 else
12657 THROW(Exception, "Failed to flag snaphot hit " << (int) daqtrighit.getModuleID() << "." << (int) daqtrighit.getPMT() << " " << daqtrighit.getT());
12658 }
12659}
12660
12661/**
12662 * Read an event from a DAQ time slice.
12663 *
12664 * \param evt evt
12665 * \param ts DAQ time slice
12666 */
12667
12668inline void read( Evt& evt, const JDAQTimeslice& ts )
12669{
12670 evt.run_id = ts.getRunNumber();
12671 evt.det_id = ts.getDetectorID();
12672 evt.frame_index = ts.getFrameIndex();
12673 evt.t.SetSec( ts.getTimesliceStart().getUTCseconds() );
12674 evt.t.SetNanoSec( ts.getTimesliceStart().getUTC16nanosecondcycles() * 16 );
12675 evt.hits.clear();
12676
12677 // a timeslice is a vector of JDAQSuperFrame's, which is a JDAQFrame, which
12678 // is an stl::vector-like object (supporting stl-like iteration.)
12679
12680 Hit h; h.id = 0; h.pmt_id = 0;
12681
12682 for (auto& sf : ts )
12683 {
12684 for (auto& daqhit : sf )
12685 {
12686 read( h, daqhit);
12687 h.dom_id = sf.getModuleID();
12688 evt.hits.push_back(h);
12689 }
12690 }
12691}
12692
12693
12694/**
12695 * Get summary slice from given file with given frame index. This function will
12696 * (re)build an index each time it encounters a new TFile as input.
12697 *
12698 * \param f pointer to ROOT file
12699 * \param frame_index frame index
12700 * \return pointer to summary slice
12701 */
12702
12703inline JDAQSummaryslice* get_summary_slice( TFile* f , int frame_index )
12704{
12705 static TFile* _f = 0;
12706 static TTree* S = 0;
12707 static TBranch* BS = 0;
12708 JDAQSummaryslice *r = 0 ;
12709
12710 if (!f) THROW(Exception, "get_summary_slice called with TFile pointer that is null");
12711
12712
12713 // in principle, event if the pointer-value is the same, we could have been given a new file
12714
12715 if ( !_f || _f->GetUUID().Compare( f->GetUUID() ) != 0 ) // setup for tree reading and build tree index
12716 {
12717 _f = f;
12718
12719 // first we have to deal with the following....
12720 // The streamer of JDAQSummaryFrame needs to know what to do since
12721 // this information is not written to root file.
12722
12723 const char* name = JDAQSummaryslice::Class()->GetName();
12724
12725 JDAQSummaryFrame::ROOT_IO_VERSION = ((TStreamerInfo*)_f -> GetStreamerInfoList()->FindObject(name))->GetClassVersion();
12726
12727 S = (TTree*) _f->Get( TTREE_ONLINE_SUMMARYSLICE );
12728
12729 if (!S)
12730 {
12731 THROW(Exception, "Failed to get summary slice TTree : " << TTREE_ONLINE_SUMMARYSLICE );
12732 }
12733
12734 BS = S->GetBranch( TBRANCH_ONLINE_SUMMARYSLICE );
12735
12736 if (!BS)
12737 {
12738 THROW(Exception, "Failed to get brach :" << TBRANCH_ONLINE_SUMMARYSLICE );
12739 }
12740
12741 std::cout << "building index to lookup summary slices..." << std::endl;
12742 int n = S->BuildIndex("frame_index");
12743 (void) n;
12744 BS->SetAddress( &r );
12745 }
12746
12747 int nbytes = S->GetEntryWithIndex( frame_index ); // returns -1 if not found
12748 if ( nbytes <= 0 )
12749 {
12750 THROW(Exception, "Failed to find summary slice entry with frame_index " << frame_index);
12751 }
12752 return r;
12753}
12754
12755
12756#endif
12757#ifndef __TOOLS_MULTIPLICITY__
12758#define __TOOLS_MULTIPLICITY__
12759
12760#include <sstream>
12761
12762#include "km3net-dataformat/offline/Evt.hh"
12763#include "km3net-dataformat/offline/Trk.hh"
12764
12765
12766/**
12767 * Retrieve bundle multiplicity of given event.
12768 *
12769 * \param event event
12770 */
12771inline int get_multiplicity(const Evt& event)
12772{
12773 using namespace std;
12774
12775 // Bundle multiplicity is stored in the `len` member variable for `track_bundle`s.
12776
12777 for ( auto& t : event.mc_trks ) {
12778 if ( t.status == TRK_ST_MUONBUNDLE ) { return (int) t.len; }
12779 }
12780
12781 ostringstream out;
12782 out << "get_multiplicity(): The following event does not correspond to a muon bundle:" << endl;
12783 event.print(out);
12784 throw Exception(static_cast<ostringstream&>(out).str());
12785}
12786
12787#endif
12788#ifndef __TOOLS_RECONSTRUCTION__
12789#define __TOOLS_RECONSTRUCTION__
12790
12791#include <limits>
12792#include <algorithm>
12793
12794#include "km3net-dataformat/offline/Hit.hh"
12795#include "km3net-dataformat/offline/Vec.hh"
12796#include "km3net-dataformat/offline/Trk.hh"
12797#include "km3net-dataformat/offline/Evt.hh"
12798#include "km3net-dataformat/offline/Exception.hh"
12799#include "km3net-dataformat/definitions/reconstruction.hh"
12800
12801
12802/**
12803 * \file
12804 *
12805 * Auxiliary methods for selection of reconstructed tracks.
12806 * \author mdejong
12807 */
12808
12809
12810/**
12811 * Range of reconstruction stages.
12812 */
12813struct rec_stages_range {
12814 /**
12815 * Defaut constructor.
12816 */
12817 rec_stages_range() :
12818 lower(0),
12819 upper(std::numeric_limits<int>::max())
12820 {}
12821
12822
12823 /**
12824 * Constructor.
12825 *
12826 * \param lower lower reconstruction stage
12827 * \param upper upper reconstruction stage
12828 */
12829 rec_stages_range(const int lower, const int upper) :
12830 lower(lower),
12831 upper(upper)
12832 {}
12833
12834
12835 /**
12836 * Constructor.
12837 *
12838 * \param stage reconstruction stage
12839 */
12840 rec_stages_range(const int stage) :
12841 lower(stage),
12842 upper(stage)
12843 {}
12844
12845
12846 /**
12847 * Test if given reconstruction stage is within range.
12848 *
12849 * \param stage reconstruction stage
12850 * \return true if within range; else false
12851 */
12852 inline bool operator()(const int stage) const
12853 {
12854 return (stage >= lower && stage <= upper);
12855 }
12856
12857 int lower;
12858 int upper;
12859};
12860
12861
12862/**
12863 * Reconstruction type dependent comparison of track quality.
12864 *
12865 * The specialisation of this class should implement the function object operator
12866 * <pre>
12867 * inline bool operator()(const Trk& first, const Trk& second) const
12868 * </pre>
12869 * and return true if the first track is better then the second track.
12870 */
12871template<int reconstruction_type>
12872struct quality_sorter {
12873 /**
12874 * The default comparison is based on:
12875 * -# number of reconstruction stages, i.e. <tt>Trk::rec_stages.size()</tt> (the larger the better);
12876 * -# likelihood of the final track, i.e. <tt>Trk::lik</tt> (the larger the better).
12877 *
12878 * \param first first track
12879 * \param second second track
12880 * \return true if first track has better quality than second; else false
12881 */
12882 inline bool operator()(const Trk& first, const Trk& second) const
12883 {
12884 if (first.rec_stages.size() == second.rec_stages.size())
12885 return first.lik > second.lik;
12886 else
12887 return first.rec_stages.size() > second.rec_stages.size();
12888 }
12889};
12890
12891
12892/**
12893 * Auxiliary class to test whether given track has specified history.\n
12894 * The history of a track consists of a reconstruction type and a range of application types.
12895 */
12896struct has_history {
12897 /**
12898 * Constructor.
12899 *
12900 * \param type reconstruction type
12901 * \param range range of application types
12902 */
12903 has_history(const int type, const rec_stages_range range) :
12904 type (type),
12905 range(range)
12906 {}
12907
12908 /**
12909 * \param track track
12910 * \return true if given track has specified history; else false
12911 */
12912 inline bool operator()(const Trk& track) const
12913 {
12914 if (track.rec_type == type)
12915 return std::find_if(track.rec_stages.begin(), track.rec_stages.end(), range) != track.rec_stages.end();
12916 else
12917 return false;
12918 }
12919
12920 const int type; //!< reconstruction type
12921 const rec_stages_range range; //!< range of application types
12922};
12923
12924
12925/**
12926 * Test whether given track has muon prefit in history.
12927 *
12928 * \param track track
12929 * \return true if muon prefit in history; else false
12930 */
12931inline bool has_jppmuon_prefit(const Trk& track)
12932{
12933 return ::has_history(JPP_RECONSTRUCTION_TYPE, JMUONPREFIT)(track);
12934}
12935
12936
12937/**
12938 * Test whether given track has muon simplex fit in history.
12939 *
12940 * \param track track
12941 * \return true if muon simplex fit in history; else false
12942 */
12943inline bool has_jppmuon_simplex(const Trk& track)
12944{
12945 return ::has_history(JPP_RECONSTRUCTION_TYPE, JMUONSIMPLEX)(track);
12946}
12947
12948
12949/**
12950 * Test whether given track has muon gandalf fit in history.
12951 *
12952 * \param track track
12953 * \return true if muon gandalf fit in history; else false
12954 */
12955inline bool has_jppmuon_gandalf(const Trk& track)
12956{
12957 return ::has_history(JPP_RECONSTRUCTION_TYPE, JMUONGANDALF)(track);
12958}
12959
12960
12961/**
12962 * Test whether given track has muon energy fit in history.
12963 *
12964 * \param track track
12965 * \return true if muon energy fit in history; else false
12966 */
12967inline bool has_jppmuon_energy(const Trk& track)
12968{
12969 return ::has_history(JPP_RECONSTRUCTION_TYPE, JMUONENERGY)(track);
12970}
12971
12972
12973/**
12974 * Test whether given track has muon start fit in history.
12975 *
12976 * \param track track
12977 * \return true if muon start fit in history; else false
12978 */
12979inline bool has_jppmuon_start(const Trk& track)
12980{
12981 return ::has_history(JPP_RECONSTRUCTION_TYPE, JMUONSTART)(track);
12982}
12983
12984
12985/**
12986 * Test whether given track has default muon fit in history.
12987 *
12988 * \param track track
12989 * \return true if muon fit in history; else false
12990 */
12991inline bool has_jppmuon_fit(const Trk& track)
12992{
12993 return ::has_history(JPP_RECONSTRUCTION_TYPE, rec_stages_range(JMUONBEGIN, JMUONEND))(track);
12994}
12995
12996
12997/**
12998 * Test whether given track has shower prefit in history.
12999 *
13000 * \param track track
13001 * \return true if shower prefit in history; else false
13002 */
13003inline bool has_shower_prefit(const Trk& track)
13004{
13005 return ::has_history(JPP_RECONSTRUCTION_TYPE, JSHOWERPREFIT)(track);
13006}
13007
13008
13009/**
13010 * Test whether given track has shower position fit in history.
13011 *
13012 * \param track track
13013 * \return true if shower position fit in history; else false
13014 */
13015inline bool has_shower_positionfit(const Trk& track)
13016{
13017 return ::has_history(JPP_RECONSTRUCTION_TYPE, JSHOWERPOSITIONFIT)(track);
13018}
13019
13020
13021/**
13022 * Test whether given track has shower complete fit in history.
13023 *
13024 * \param track track
13025 * \return true if shower complete fit in history; else false
13026 */
13027inline bool has_shower_completefit(const Trk& track)
13028{
13029 return ::has_history(JPP_RECONSTRUCTION_TYPE, JSHOWERCOMPLETEFIT)(track);
13030}
13031
13032
13033/**
13034 * Test whether given track has default shower fit in history.
13035 *
13036 * \param track track
13037 * \return true if shower fit in history; else false
13038 */
13039inline bool has_shower_fit(const Trk& track)
13040{
13041 return ::has_history(JPP_RECONSTRUCTION_TYPE, rec_stages_range(JSHOWERBEGIN, JSHOWEREND))(track);
13042}
13043
13044
13045/**
13046 * Test whether given track has default shower fit in history.
13047 *
13048 * \param track track
13049 * \return true if shower fit in history; else false
13050 */
13051inline bool has_aashower_fit(const Trk& track)
13052{
13053 return ::has_history(AANET_RECONSTRUCTION_TYPE, rec_stages_range(AASHOWERBEGIN, AASHOWEREND))(track);
13054}
13055
13056
13057/**
13058 * Test whether given event has a track according selection.\n
13059 * The track selector corresponds to the function operator <tt>bool selector(const Trk&);</tt>.
13060 *
13061 * \param evt event
13062 * \param selector track selector
13063 * \return true if at least one corresponding track; else false
13064 */
13065template<class JTrackSelector_t>
13066inline bool has_reconstructed_track(const Evt& evt, JTrackSelector_t selector)
13067{
13068 return std::find_if(evt.trks.begin(), evt.trks.end(), selector) != evt.trks.end();
13069}
13070
13071
13072/**
13073 * Test whether given event has a track according selection.
13074 *
13075 * \param evt event
13076 * \param range range of application types
13077 * \return true if at least one corresponding track; else false
13078 */
13079template<int reconstruction_type>
13080inline bool has_reconstructed_track(const Evt& evt, const rec_stages_range range = rec_stages_range())
13081{
13082 return ::has_reconstructed_track(evt, ::has_history(reconstruction_type, range));
13083}
13084
13085
13086/**
13087 * Test whether given event has a track with muon reconstruction.
13088 *
13089 * \param evt event
13090 * \return true if at least one reconstructed muon; else false
13091 */
13092inline bool has_reconstructed_jppmuon(const Evt& evt)
13093{
13094 return ::has_reconstructed_track(evt, has_jppmuon_fit);
13095}
13096
13097
13098/**
13099 * Test whether given event has a track with shower reconstruction.
13100 *
13101 * \param evt event
13102 * \return true if at least one reconstructed shower; else false
13103 */
13104inline bool has_reconstructed_jppshower(const Evt& evt)
13105{
13106 return ::has_reconstructed_track(evt, ::has_shower_fit);
13107}
13108
13109
13110/**
13111 * Test whether given event has a track with aashower reconstruction.
13112 *
13113 * \param evt event
13114 * \return true if at least one reconstructed shower; else false
13115 */
13116inline bool has_reconstructed_aashower(const Evt& evt)
13117{
13118 return ::has_reconstructed_track(evt, has_aashower_fit);
13119}
13120
13121
13122/**
13123 * Get best reconstructed track.\n
13124 * The track selector corresponds to the function operator <tt>bool selector(const Trk&);</tt> and
13125 * the track comparator to <tt>bool comparator(const Trk&, const Trk&);</tt>.\n
13126 * This method throws an exception in case no track is present.\n
13127 * The method <tt>has_reconstructed_track</tt> can be used to avoid this exception.
13128 *
13129 * \param evt event
13130 * \param selector track selector
13131 * \param comparator track comparator
13132 * \return track
13133 */
13134template<class JTrackSelector_t, class JQualitySorter_t>
13135inline const Trk& get_best_reconstructed_track(const Evt& evt,
13136 JTrackSelector_t selector,
13137 JQualitySorter_t comparator)
13138{
13139 std::vector<Trk>::const_iterator p = std::find_if(evt.trks.begin(), evt.trks.end(), selector);
13140
13141 for (std::vector<Trk>::const_iterator i = p; i != evt.trks.end(); ++i) {
13142 if (selector(*i) && comparator(*i, *p)) {
13143 p = i;
13144 }
13145 }
13146
13147 if (p != evt.trks.end())
13148 return *p;
13149 else
13150 THROW(Exception, "This event has no reconstructed track with given selector.");
13151}
13152
13153
13154/**
13155 * Get best reconstructed track.
13156 *
13157 * \param evt event
13158 * \param range range of application types
13159 * \return track
13160 */
13161template<int reconstruction_type>
13162inline const Trk& get_best_reconstructed_track(const Evt& evt, const rec_stages_range range = rec_stages_range())
13163{
13164 return get_best_reconstructed_track(evt, ::has_history(reconstruction_type, range), quality_sorter<reconstruction_type>());
13165}
13166
13167
13168/**
13169 * Get best reconstructed muon.
13170 *
13171 * \param evt event
13172 * \return track
13173 */
13174inline const Trk& get_best_reconstructed_jppmuon(const Evt& evt)
13175{
13176 return get_best_reconstructed_track(evt, has_jppmuon_fit, quality_sorter<JPP_RECONSTRUCTION_TYPE>());
13177}
13178
13179
13180/**
13181 * Get best reconstructed shower.
13182 *
13183 * \param evt event
13184 * \return track
13185 */
13186inline const Trk& get_best_reconstructed_jppshower(const Evt& evt)
13187{
13188 return get_best_reconstructed_track(evt, ::has_shower_fit, quality_sorter<JPP_RECONSTRUCTION_TYPE>());
13189}
13190
13191
13192/**
13193 * Get best reconstructed aashower.
13194 *
13195 * \param evt event
13196 * \return track
13197 */
13198inline const Trk& get_best_reconstructed_aashower(const Evt& evt)
13199{
13200 return get_best_reconstructed_track(evt, ::has_aashower_fit, quality_sorter<AANET_RECONSTRUCTION_TYPE>());
13201}
13202
13203#endif
13204#ifndef __TOOLS__TIME_CONVERTER__
13205#define __TOOLS__TIME_CONVERTER__
13206
13207#include "km3net-dataformat/offline/Evt.hh"
13208#include "km3net-dataformat/online/JDAQClock.hh"
13209#include "km3net-dataformat/online/JDAQChronometer.hh"
13210
13211
13212/**
13213 * \file
13214 * Auxiliary include file for time conversion between DAQ/trigger hit and Monte Carlo hit.
13215 *
13216 * \author mdejong
13217 */
13218
13219/**
13220 * Auxiliary class to convert DAQ hit time to/from Monte Carlo hit time.
13221 */
13222class time_converter
13223{
13224public:
13225 /**
13226 * Default constructor.
13227 */
13228 time_converter() :
13229 __t0(0.0),
13230 __t1(0.0)
13231 {}
13232
13233
13234 /**
13235 * Constructor.
13236 * Note that this constructor should only be used after incorporation of KM3NETDAQ::JDAQEvent.
13237 *
13238 * \param event event
13239 */
13240 time_converter(const Evt& event) :
13241 __t0(event.mc_t),
13242 __t1(getTimeOfRTS(event.frame_index))
13243 {}
13244
13245
13246 /**
13247 * Constructor.
13248 *
13249 * \param event Monte Carlo event
13250 * \param chronometer DAQ chronometer
13251 */
13252 time_converter(const Evt& event,
13253 const JDAQChronometer& chronometer) :
13254 __t0(event.mc_t),
13255 __t1(getTimeOfRTS(chronometer))
13256 {}
13257
13258
13259 /**
13260 * Get DAQ/trigger time minus Monte Carlo time.
13261 *
13262 * \return time difference [ns]
13263 */
13264 double getTime() const
13265 {
13266 return __t1 - __t0;
13267 }
13268
13269
13270 /**
13271 * Get Monte Carlo time minus DAQ/trigger time.
13272 *
13273 * \return time difference [ns]
13274 */
13275 double putTime() const
13276 {
13277 return __t0 - __t1;
13278 }
13279
13280
13281 /**
13282 * Get Monte Carlo hit time.
13283 *
13284 * \param t0 DAQ/trigger hit time [ns]
13285 * \return Monte Carlo hit time [ns]
13286 */
13287 double getTime(const double t0) const
13288 {
13289 return t0 + __t1 - __t0;
13290 }
13291
13292
13293 /**
13294 * Get DAQ hit time.
13295 *
13296 * \param t0 Monte Carlo hit time [ns]
13297 * \return DAQ/trigger hit time [ns]
13298 */
13299 double putTime(const double t0) const
13300 {
13301 return t0 - __t1 + __t0;
13302 }
13303
13304protected:
13305 double __t0; // Monte Carlo event time [ns]
13306 double __t1; // DAQ RTS [ns]
13307};
13308
13309#endif
13310
13311#undef _BACKWARD_BACKWARD_WARNING_H
13312)DICTPAYLOAD";
13313 static const char* classesHeaders[] = {
13314"AAObject", payloadCode, "@",
13315"Evt", payloadCode, "@",
13316"Head", payloadCode, "@",
13317"Hit", payloadCode, "@",
13318"KM3NETDAQ::JDAQAbstractPreamble", payloadCode, "@",
13319"KM3NETDAQ::JDAQChronometer", payloadCode, "@",
13320"KM3NETDAQ::JDAQEvent", payloadCode, "@",
13321"KM3NETDAQ::JDAQEventHeader", payloadCode, "@",
13322"KM3NETDAQ::JDAQFrame", payloadCode, "@",
13323"KM3NETDAQ::JDAQFrameStatus", payloadCode, "@",
13324"KM3NETDAQ::JDAQHeader", payloadCode, "@",
13325"KM3NETDAQ::JDAQHit", payloadCode, "@",
13326"KM3NETDAQ::JDAQKeyHit", payloadCode, "@",
13327"KM3NETDAQ::JDAQModuleIdentifier", payloadCode, "@",
13328"KM3NETDAQ::JDAQPMTIdentifier", payloadCode, "@",
13329"KM3NETDAQ::JDAQPreamble", payloadCode, "@",
13330"KM3NETDAQ::JDAQRate", payloadCode, "@",
13331"KM3NETDAQ::JDAQSummaryFrame", payloadCode, "@",
13332"KM3NETDAQ::JDAQSummaryslice", payloadCode, "@",
13333"KM3NETDAQ::JDAQSummarysliceHeader", payloadCode, "@",
13334"KM3NETDAQ::JDAQSuperFrame", payloadCode, "@",
13335"KM3NETDAQ::JDAQSuperFrameHeader", payloadCode, "@",
13336"KM3NETDAQ::JDAQTimeslice", payloadCode, "@",
13337"KM3NETDAQ::JDAQTimesliceHeader", payloadCode, "@",
13338"KM3NETDAQ::JDAQTimesliceL0", payloadCode, "@",
13339"KM3NETDAQ::JDAQTimesliceL1", payloadCode, "@",
13340"KM3NETDAQ::JDAQTimesliceL2", payloadCode, "@",
13341"KM3NETDAQ::JDAQTimesliceSN", payloadCode, "@",
13342"KM3NETDAQ::JDAQTriggerCounter", payloadCode, "@",
13343"KM3NETDAQ::JDAQTriggerMask", payloadCode, "@",
13344"KM3NETDAQ::JDAQTriggeredHit", payloadCode, "@",
13345"KM3NETDAQ::JDAQUTCExtended", payloadCode, "@",
13346"MultiHead", payloadCode, "@",
13347"Trk", payloadCode, "@",
13348"Vec", payloadCode, "@",
13349nullptr
13350};
13351 static bool isInitialized = false;
13352 if (!isInitialized) {
13353 TROOT::RegisterModule("G__KM3NeTROOT",
13354 headers, includePaths, payloadCode, fwdDeclCode,
13355 TriggerDictionaryInitialization_G__KM3NeTROOT_Impl, {}, classesHeaders, /*hasCxxModule*/false);
13356 isInitialized = true;
13357 }
13358 }
13359 static struct DictInit {
13360 DictInit() {
13361 TriggerDictionaryInitialization_G__KM3NeTROOT_Impl();
13362 }
13363 } __TheDictionaryInitializer;
13364}
13365void TriggerDictionaryInitialization_G__KM3NeTROOT() {
13366 TriggerDictionaryInitialization_G__KM3NeTROOT_Impl();
13367}
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:4227
ROOT::new_vectorlEKM3NETDAQcLcLJDAQSuperFramegR
static void * new_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p=nullptr)
Definition G__KM3NeTROOT.cc:4032
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:4357
ROOT::new_vectorlETrkgR
static void * new_vectorlETrkgR(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3902
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:3912
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:4090
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:3905
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:4344
ROOT::vectorlEHitgR_TClassManip
static void vectorlEHitgR_TClassManip(TClass *)
Definition G__KM3NeTROOT.cc:4220
ROOT::delete_vectorlEKM3NETDAQcLcLJDAQSuperFramegR
static void delete_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p)
Definition G__KM3NeTROOT.cc:4039
ROOT::destruct_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR
static void destruct_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p)
Definition G__KM3NeTROOT.cc:4110
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:4230
ROOT::maplEstringcOstringgR_TClassManip
static void maplEstringcOstringgR_TClassManip(TClass *)
Definition G__KM3NeTROOT.cc:4350
ROOT::deleteArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR
static void deleteArray_vectorlEKM3NETDAQcLcLJDAQSuperFramegR(void *p)
Definition G__KM3NeTROOT.cc:4042
ROOT::delete_vectorlEVecgR
static void delete_vectorlEVecgR(void *p)
Definition G__KM3NeTROOT.cc:3844
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:3970
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:4214
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:3960
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:4364
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:4305
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:4360
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:3954
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:4165
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::vectorlEVecgR_Dictionary
static TClass * vectorlEVecgR_Dictionary()
Definition G__KM3NeTROOT.cc:3824
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:4025
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:4299
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:4234
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:4370
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:4162
ROOT::new_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR
static void * new_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3967
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:4292
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:3915
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:4367
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:3889
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:3895
ROOT::vectorlEVecgR_TClassManip
static void vectorlEVecgR_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:4240
ROOT::destruct_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR
static void destruct_vectorlEKM3NETDAQcLcLJDAQTriggeredHitgR(void *p)
Definition G__KM3NeTROOT.cc:3980
ROOT::deleteArray_vectorlEHeadgR
static void deleteArray_vectorlEHeadgR(void *p)
Definition G__KM3NeTROOT.cc:4302
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:4155
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_vectorlEVecgR
static void * newArray_vectorlEVecgR(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:3840
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::destruct_vectorlEVecgR
static void destruct_vectorlEVecgR(void *p)
Definition G__KM3NeTROOT.cc:3850
ROOT::deleteArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR
static void deleteArray_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p)
Definition G__KM3NeTROOT.cc:4107
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:4100
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:4097
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:3909
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:4045
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:4279
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:4035
ROOT::vectorlEKM3NETDAQcLcLJDAQSuperFramegR_Dictionary
static TClass * vectorlEKM3NETDAQcLcLJDAQSuperFramegR_Dictionary()
Definition G__KM3NeTROOT.cc:4019
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:4175
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:4285
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:3977
ROOT::new_vectorlEVecgR
static void * new_vectorlEVecgR(void *p=nullptr)
Definition G__KM3NeTROOT.cc:3837
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:3974
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:4237
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::deleteArray_vectorlEVecgR
static void deleteArray_vectorlEVecgR(void *p)
Definition G__KM3NeTROOT.cc:3847
ROOT::vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_Dictionary
static TClass * vectorlEKM3NETDAQcLcLJDAQSummaryFramegR_Dictionary()
Definition G__KM3NeTROOT.cc:4084
ROOT::delete_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR
static void delete_vectorlEKM3NETDAQcLcLJDAQSummaryFramegR(void *p)
Definition G__KM3NeTROOT.cc:4104
ROOT::deleteArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR
static void deleteArray_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p)
Definition G__KM3NeTROOT.cc:4172
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:4149
ROOT::newArray_vectorlEHeadgR
static void * newArray_vectorlEHeadgR(Long_t size, void *p)
Definition G__KM3NeTROOT.cc:4295
ROOT::delete_vectorlEKM3NETDAQcLcLJDAQKeyHitgR
static void delete_vectorlEKM3NETDAQcLcLJDAQKeyHitgR(void *p)
Definition G__KM3NeTROOT.cc:4169
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