BOSS 7.1.3
BESIII Offline Software System
Loading...
Searching...
No Matches
src/RootEventData_rootcint.cxx
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 dOdOdIRootEventDatadIRootEventData_rootcint
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 "RConfig.h"
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// The generated code does not explicitly qualifies STL entities
38namespace std {} using namespace std;
39
40// Header files passed as explicit arguments
41#include "../RootEventData/TJobInfo.h"
42#include "../RootEventData/TDigiEvent.h"
43#include "../RootEventData/TRecTrackEvent.h"
44#include "../RootEventData/TMdcDigi.h"
45#include "../RootEventData/TEmcDigi.h"
46#include "../RootEventData/TTofDigi.h"
47#include "../RootEventData/TMucDigi.h"
48#include "../RootEventData/TLumiDigi.h"
49#include "../RootEventData/TDstEvent.h"
50#include "../RootEventData/TEmcTrack.h"
51#include "../RootEventData/TMdcTrack.h"
52#include "../RootEventData/TRecMdcHit.h"
53#include "../RootEventData/TRecMdcTrack.h"
54#include "../RootEventData/TRecMucTrack.h"
55#include "../RootEventData/TTofTrack.h"
56#include "../RootEventData/TMucTrack.h"
57#include "../RootEventData/TExtTrack.h"
58#include "../RootEventData/TRecExtTrack.h"
59#include "../RootEventData/TMdcKalTrack.h"
60#include "../RootEventData/TRecMdcKalTrack.h"
61#include "../RootEventData/TRecMdcKalHelixSeg.h"
62#include "../RootEventData/TMdcDedx.h"
63#include "../RootEventData/TRecMdcDedx.h"
64#include "../RootEventData/TRecMdcDedxHit.h"
65#include "../RootEventData/TMcEvent.h"
66#include "../RootEventData/TEmcMc.h"
67#include "../RootEventData/TMdcMc.h"
68#include "../RootEventData/TTofMc.h"
69#include "../RootEventData/TMucMc.h"
70#include "../RootEventData/TMcParticle.h"
71#include "../RootEventData/TRecEmcHit.h"
72#include "../RootEventData/TRecEmcCluster.h"
73#include "../RootEventData/TRecEmcShower.h"
74#include "../RootEventData/TRecMucTrack.h"
75#include "../RootEventData/TRecEvTime.h"
76#include "../RootEventData/TRecZddChannel.h"
77#include "../RootEventData/TEvtHeader.h"
78#include "../RootEventData/TEvtNavigator.h"
79#include "../RootEventData/TTrigEvent.h"
80#include "../RootEventData/TTrigData.h"
81#include "../RootEventData/THltEvent.h"
82#include "../RootEventData/THltRaw.h"
83#include "../RootEventData/THltInf.h"
84#include "../RootEventData/TDstHltInf.h"
85#include "../RootEventData/TDisTrack.h"
86#include "../RootEventData/TEvtRecObject.h"
87#include "../RootEventData/TEvtRecEvent.h"
88#include "../RootEventData/TEvtRecTrack.h"
89#include "../RootEventData/TMcHitEvent.h"
90#include "../RootEventData/TMcHitTof.h"
91#include "../RootEventData/TMcHitMdc.h"
92#include "../RootEventData/TMcDigiEmc.h"
93#include "../RootEventData/TEvtRecPrimaryVertex.h"
94#include "../RootEventData/TEvtRecVeeVertex.h"
95#include "../RootEventData/TEvtRecDTag.h"
96#include "../RootEventData/TEvtRecPi0.h"
97#include "../RootEventData/TBossFullEvent.h"
98
99// Header files passed via #pragma extra_include
100
101namespace ROOT {
102 static void *new_TJobInfo(void *p = 0);
103 static void *newArray_TJobInfo(Long_t size, void *p);
104 static void delete_TJobInfo(void *p);
105 static void deleteArray_TJobInfo(void *p);
106 static void destruct_TJobInfo(void *p);
107
108 // Function generating the singleton type initializer
109 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TJobInfo*)
110 {
111 ::TJobInfo *ptr = 0;
112 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TJobInfo >(0);
113 static ::ROOT::TGenericClassInfo
114 instance("TJobInfo", ::TJobInfo::Class_Version(), "TJobInfo.h", 9,
115 typeid(::TJobInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr),
116 &::TJobInfo::Dictionary, isa_proxy, 4,
117 sizeof(::TJobInfo) );
118 instance.SetNew(&new_TJobInfo);
119 instance.SetNewArray(&newArray_TJobInfo);
120 instance.SetDelete(&delete_TJobInfo);
121 instance.SetDeleteArray(&deleteArray_TJobInfo);
122 instance.SetDestructor(&destruct_TJobInfo);
123 return &instance;
124 }
125 TGenericClassInfo *GenerateInitInstance(const ::TJobInfo*)
126 {
127 return GenerateInitInstanceLocal((::TJobInfo*)0);
128 }
129 // Static variable to force the class initialization
130 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TJobInfo*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
131} // end of namespace ROOT
132
133namespace ROOT {
134 static void *new_TRawData(void *p = 0);
135 static void *newArray_TRawData(Long_t size, void *p);
136 static void delete_TRawData(void *p);
137 static void deleteArray_TRawData(void *p);
138 static void destruct_TRawData(void *p);
139
140 // Function generating the singleton type initializer
141 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRawData*)
142 {
143 ::TRawData *ptr = 0;
144 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRawData >(0);
145 static ::ROOT::TGenericClassInfo
146 instance("TRawData", ::TRawData::Class_Version(), "TRawData.h", 7,
147 typeid(::TRawData), ::ROOT::Internal::DefineBehavior(ptr, ptr),
148 &::TRawData::Dictionary, isa_proxy, 4,
149 sizeof(::TRawData) );
150 instance.SetNew(&new_TRawData);
151 instance.SetNewArray(&newArray_TRawData);
152 instance.SetDelete(&delete_TRawData);
153 instance.SetDeleteArray(&deleteArray_TRawData);
154 instance.SetDestructor(&destruct_TRawData);
155 return &instance;
156 }
157 TGenericClassInfo *GenerateInitInstance(const ::TRawData*)
158 {
159 return GenerateInitInstanceLocal((::TRawData*)0);
160 }
161 // Static variable to force the class initialization
162 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TRawData*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
163} // end of namespace ROOT
164
165namespace ROOT {
166 static void *new_TMdcDigi(void *p = 0);
167 static void *newArray_TMdcDigi(Long_t size, void *p);
168 static void delete_TMdcDigi(void *p);
169 static void deleteArray_TMdcDigi(void *p);
170 static void destruct_TMdcDigi(void *p);
171
172 // Function generating the singleton type initializer
173 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMdcDigi*)
174 {
175 ::TMdcDigi *ptr = 0;
176 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMdcDigi >(0);
177 static ::ROOT::TGenericClassInfo
178 instance("TMdcDigi", ::TMdcDigi::Class_Version(), "TMdcDigi.h", 7,
179 typeid(::TMdcDigi), ::ROOT::Internal::DefineBehavior(ptr, ptr),
180 &::TMdcDigi::Dictionary, isa_proxy, 4,
181 sizeof(::TMdcDigi) );
182 instance.SetNew(&new_TMdcDigi);
183 instance.SetNewArray(&newArray_TMdcDigi);
184 instance.SetDelete(&delete_TMdcDigi);
185 instance.SetDeleteArray(&deleteArray_TMdcDigi);
186 instance.SetDestructor(&destruct_TMdcDigi);
187 return &instance;
188 }
189 TGenericClassInfo *GenerateInitInstance(const ::TMdcDigi*)
190 {
191 return GenerateInitInstanceLocal((::TMdcDigi*)0);
192 }
193 // Static variable to force the class initialization
194 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TMdcDigi*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
195} // end of namespace ROOT
196
197namespace ROOT {
198 static void *new_TEmcDigi(void *p = 0);
199 static void *newArray_TEmcDigi(Long_t size, void *p);
200 static void delete_TEmcDigi(void *p);
201 static void deleteArray_TEmcDigi(void *p);
202 static void destruct_TEmcDigi(void *p);
203
204 // Function generating the singleton type initializer
205 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEmcDigi*)
206 {
207 ::TEmcDigi *ptr = 0;
208 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEmcDigi >(0);
209 static ::ROOT::TGenericClassInfo
210 instance("TEmcDigi", ::TEmcDigi::Class_Version(), "TEmcDigi.h", 6,
211 typeid(::TEmcDigi), ::ROOT::Internal::DefineBehavior(ptr, ptr),
212 &::TEmcDigi::Dictionary, isa_proxy, 4,
213 sizeof(::TEmcDigi) );
214 instance.SetNew(&new_TEmcDigi);
215 instance.SetNewArray(&newArray_TEmcDigi);
216 instance.SetDelete(&delete_TEmcDigi);
217 instance.SetDeleteArray(&deleteArray_TEmcDigi);
218 instance.SetDestructor(&destruct_TEmcDigi);
219 return &instance;
220 }
221 TGenericClassInfo *GenerateInitInstance(const ::TEmcDigi*)
222 {
223 return GenerateInitInstanceLocal((::TEmcDigi*)0);
224 }
225 // Static variable to force the class initialization
226 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TEmcDigi*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
227} // end of namespace ROOT
228
229namespace ROOT {
230 static void *new_TTofDigi(void *p = 0);
231 static void *newArray_TTofDigi(Long_t size, void *p);
232 static void delete_TTofDigi(void *p);
233 static void deleteArray_TTofDigi(void *p);
234 static void destruct_TTofDigi(void *p);
235
236 // Function generating the singleton type initializer
237 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTofDigi*)
238 {
239 ::TTofDigi *ptr = 0;
240 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTofDigi >(0);
241 static ::ROOT::TGenericClassInfo
242 instance("TTofDigi", ::TTofDigi::Class_Version(), "TTofDigi.h", 7,
243 typeid(::TTofDigi), ::ROOT::Internal::DefineBehavior(ptr, ptr),
244 &::TTofDigi::Dictionary, isa_proxy, 4,
245 sizeof(::TTofDigi) );
246 instance.SetNew(&new_TTofDigi);
247 instance.SetNewArray(&newArray_TTofDigi);
248 instance.SetDelete(&delete_TTofDigi);
249 instance.SetDeleteArray(&deleteArray_TTofDigi);
250 instance.SetDestructor(&destruct_TTofDigi);
251 return &instance;
252 }
253 TGenericClassInfo *GenerateInitInstance(const ::TTofDigi*)
254 {
255 return GenerateInitInstanceLocal((::TTofDigi*)0);
256 }
257 // Static variable to force the class initialization
258 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TTofDigi*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
259} // end of namespace ROOT
260
261namespace ROOT {
262 static void *new_TMucDigi(void *p = 0);
263 static void *newArray_TMucDigi(Long_t size, void *p);
264 static void delete_TMucDigi(void *p);
265 static void deleteArray_TMucDigi(void *p);
266 static void destruct_TMucDigi(void *p);
267
268 // Function generating the singleton type initializer
269 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMucDigi*)
270 {
271 ::TMucDigi *ptr = 0;
272 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMucDigi >(0);
273 static ::ROOT::TGenericClassInfo
274 instance("TMucDigi", ::TMucDigi::Class_Version(), "TMucDigi.h", 7,
275 typeid(::TMucDigi), ::ROOT::Internal::DefineBehavior(ptr, ptr),
276 &::TMucDigi::Dictionary, isa_proxy, 4,
277 sizeof(::TMucDigi) );
278 instance.SetNew(&new_TMucDigi);
279 instance.SetNewArray(&newArray_TMucDigi);
280 instance.SetDelete(&delete_TMucDigi);
281 instance.SetDeleteArray(&deleteArray_TMucDigi);
282 instance.SetDestructor(&destruct_TMucDigi);
283 return &instance;
284 }
285 TGenericClassInfo *GenerateInitInstance(const ::TMucDigi*)
286 {
287 return GenerateInitInstanceLocal((::TMucDigi*)0);
288 }
289 // Static variable to force the class initialization
290 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TMucDigi*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
291} // end of namespace ROOT
292
293namespace ROOT {
294 static void *new_TLumiDigi(void *p = 0);
295 static void *newArray_TLumiDigi(Long_t size, void *p);
296 static void delete_TLumiDigi(void *p);
297 static void deleteArray_TLumiDigi(void *p);
298 static void destruct_TLumiDigi(void *p);
299
300 // Function generating the singleton type initializer
301 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TLumiDigi*)
302 {
303 ::TLumiDigi *ptr = 0;
304 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TLumiDigi >(0);
305 static ::ROOT::TGenericClassInfo
306 instance("TLumiDigi", ::TLumiDigi::Class_Version(), "TLumiDigi.h", 6,
307 typeid(::TLumiDigi), ::ROOT::Internal::DefineBehavior(ptr, ptr),
308 &::TLumiDigi::Dictionary, isa_proxy, 4,
309 sizeof(::TLumiDigi) );
310 instance.SetNew(&new_TLumiDigi);
311 instance.SetNewArray(&newArray_TLumiDigi);
312 instance.SetDelete(&delete_TLumiDigi);
313 instance.SetDeleteArray(&deleteArray_TLumiDigi);
314 instance.SetDestructor(&destruct_TLumiDigi);
315 return &instance;
316 }
317 TGenericClassInfo *GenerateInitInstance(const ::TLumiDigi*)
318 {
319 return GenerateInitInstanceLocal((::TLumiDigi*)0);
320 }
321 // Static variable to force the class initialization
322 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TLumiDigi*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
323} // end of namespace ROOT
324
325namespace ROOT {
326 static void *new_TDigiEvent(void *p = 0);
327 static void *newArray_TDigiEvent(Long_t size, void *p);
328 static void delete_TDigiEvent(void *p);
329 static void deleteArray_TDigiEvent(void *p);
330 static void destruct_TDigiEvent(void *p);
331
332 // Function generating the singleton type initializer
333 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDigiEvent*)
334 {
335 ::TDigiEvent *ptr = 0;
336 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDigiEvent >(0);
337 static ::ROOT::TGenericClassInfo
338 instance("TDigiEvent", ::TDigiEvent::Class_Version(), "TDigiEvent.h", 14,
339 typeid(::TDigiEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
340 &::TDigiEvent::Dictionary, isa_proxy, 4,
341 sizeof(::TDigiEvent) );
342 instance.SetNew(&new_TDigiEvent);
343 instance.SetNewArray(&newArray_TDigiEvent);
344 instance.SetDelete(&delete_TDigiEvent);
345 instance.SetDeleteArray(&deleteArray_TDigiEvent);
346 instance.SetDestructor(&destruct_TDigiEvent);
347 return &instance;
348 }
349 TGenericClassInfo *GenerateInitInstance(const ::TDigiEvent*)
350 {
351 return GenerateInitInstanceLocal((::TDigiEvent*)0);
352 }
353 // Static variable to force the class initialization
354 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TDigiEvent*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
355} // end of namespace ROOT
356
357namespace ROOT {
358 static void *new_TRecMdcTrack(void *p = 0);
359 static void *newArray_TRecMdcTrack(Long_t size, void *p);
360 static void delete_TRecMdcTrack(void *p);
361 static void deleteArray_TRecMdcTrack(void *p);
362 static void destruct_TRecMdcTrack(void *p);
363
364 // Function generating the singleton type initializer
365 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMdcTrack*)
366 {
367 ::TRecMdcTrack *ptr = 0;
368 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcTrack >(0);
369 static ::ROOT::TGenericClassInfo
370 instance("TRecMdcTrack", ::TRecMdcTrack::Class_Version(), "TRecMdcTrack.h", 9,
371 typeid(::TRecMdcTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
372 &::TRecMdcTrack::Dictionary, isa_proxy, 4,
373 sizeof(::TRecMdcTrack) );
374 instance.SetNew(&new_TRecMdcTrack);
375 instance.SetNewArray(&newArray_TRecMdcTrack);
376 instance.SetDelete(&delete_TRecMdcTrack);
377 instance.SetDeleteArray(&deleteArray_TRecMdcTrack);
378 instance.SetDestructor(&destruct_TRecMdcTrack);
379 return &instance;
380 }
381 TGenericClassInfo *GenerateInitInstance(const ::TRecMdcTrack*)
382 {
383 return GenerateInitInstanceLocal((::TRecMdcTrack*)0);
384 }
385 // Static variable to force the class initialization
386 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TRecMdcTrack*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
387} // end of namespace ROOT
388
389namespace ROOT {
390 static void *new_TRecMdcKalTrack(void *p = 0);
391 static void *newArray_TRecMdcKalTrack(Long_t size, void *p);
392 static void delete_TRecMdcKalTrack(void *p);
393 static void deleteArray_TRecMdcKalTrack(void *p);
394 static void destruct_TRecMdcKalTrack(void *p);
395
396 // Function generating the singleton type initializer
397 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMdcKalTrack*)
398 {
399 ::TRecMdcKalTrack *ptr = 0;
400 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcKalTrack >(0);
401 static ::ROOT::TGenericClassInfo
402 instance("TRecMdcKalTrack", ::TRecMdcKalTrack::Class_Version(), "TRecMdcKalTrack.h", 7,
403 typeid(::TRecMdcKalTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
404 &::TRecMdcKalTrack::Dictionary, isa_proxy, 4,
405 sizeof(::TRecMdcKalTrack) );
406 instance.SetNew(&new_TRecMdcKalTrack);
407 instance.SetNewArray(&newArray_TRecMdcKalTrack);
408 instance.SetDelete(&delete_TRecMdcKalTrack);
409 instance.SetDeleteArray(&deleteArray_TRecMdcKalTrack);
410 instance.SetDestructor(&destruct_TRecMdcKalTrack);
411 return &instance;
412 }
413 TGenericClassInfo *GenerateInitInstance(const ::TRecMdcKalTrack*)
414 {
415 return GenerateInitInstanceLocal((::TRecMdcKalTrack*)0);
416 }
417 // Static variable to force the class initialization
418 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TRecMdcKalTrack*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
419} // end of namespace ROOT
420
421namespace ROOT {
422 static void *new_TRecMdcHit(void *p = 0);
423 static void *newArray_TRecMdcHit(Long_t size, void *p);
424 static void delete_TRecMdcHit(void *p);
425 static void deleteArray_TRecMdcHit(void *p);
426 static void destruct_TRecMdcHit(void *p);
427
428 // Function generating the singleton type initializer
429 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMdcHit*)
430 {
431 ::TRecMdcHit *ptr = 0;
432 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcHit >(0);
433 static ::ROOT::TGenericClassInfo
434 instance("TRecMdcHit", ::TRecMdcHit::Class_Version(), "TRecMdcHit.h", 9,
435 typeid(::TRecMdcHit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
436 &::TRecMdcHit::Dictionary, isa_proxy, 4,
437 sizeof(::TRecMdcHit) );
438 instance.SetNew(&new_TRecMdcHit);
439 instance.SetNewArray(&newArray_TRecMdcHit);
440 instance.SetDelete(&delete_TRecMdcHit);
441 instance.SetDeleteArray(&deleteArray_TRecMdcHit);
442 instance.SetDestructor(&destruct_TRecMdcHit);
443 return &instance;
444 }
445 TGenericClassInfo *GenerateInitInstance(const ::TRecMdcHit*)
446 {
447 return GenerateInitInstanceLocal((::TRecMdcHit*)0);
448 }
449 // Static variable to force the class initialization
450 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TRecMdcHit*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
451} // end of namespace ROOT
452
453namespace ROOT {
454 static void *new_TTofTrack(void *p = 0);
455 static void *newArray_TTofTrack(Long_t size, void *p);
456 static void delete_TTofTrack(void *p);
457 static void deleteArray_TTofTrack(void *p);
458 static void destruct_TTofTrack(void *p);
459
460 // Function generating the singleton type initializer
461 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTofTrack*)
462 {
463 ::TTofTrack *ptr = 0;
464 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTofTrack >(0);
465 static ::ROOT::TGenericClassInfo
466 instance("TTofTrack", ::TTofTrack::Class_Version(), "TTofTrack.h", 10,
467 typeid(::TTofTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
468 &::TTofTrack::Dictionary, isa_proxy, 4,
469 sizeof(::TTofTrack) );
470 instance.SetNew(&new_TTofTrack);
471 instance.SetNewArray(&newArray_TTofTrack);
472 instance.SetDelete(&delete_TTofTrack);
473 instance.SetDeleteArray(&deleteArray_TTofTrack);
474 instance.SetDestructor(&destruct_TTofTrack);
475 return &instance;
476 }
477 TGenericClassInfo *GenerateInitInstance(const ::TTofTrack*)
478 {
479 return GenerateInitInstanceLocal((::TTofTrack*)0);
480 }
481 // Static variable to force the class initialization
482 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TTofTrack*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
483} // end of namespace ROOT
484
485namespace ROOT {
486 static void *new_TRecTofTrack(void *p = 0);
487 static void *newArray_TRecTofTrack(Long_t size, void *p);
488 static void delete_TRecTofTrack(void *p);
489 static void deleteArray_TRecTofTrack(void *p);
490 static void destruct_TRecTofTrack(void *p);
491
492 // Function generating the singleton type initializer
493 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecTofTrack*)
494 {
495 ::TRecTofTrack *ptr = 0;
496 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecTofTrack >(0);
497 static ::ROOT::TGenericClassInfo
498 instance("TRecTofTrack", ::TRecTofTrack::Class_Version(), "TRecTofTrack.h", 9,
499 typeid(::TRecTofTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
500 &::TRecTofTrack::Dictionary, isa_proxy, 4,
501 sizeof(::TRecTofTrack) );
502 instance.SetNew(&new_TRecTofTrack);
503 instance.SetNewArray(&newArray_TRecTofTrack);
504 instance.SetDelete(&delete_TRecTofTrack);
505 instance.SetDeleteArray(&deleteArray_TRecTofTrack);
506 instance.SetDestructor(&destruct_TRecTofTrack);
507 return &instance;
508 }
509 TGenericClassInfo *GenerateInitInstance(const ::TRecTofTrack*)
510 {
511 return GenerateInitInstanceLocal((::TRecTofTrack*)0);
512 }
513 // Static variable to force the class initialization
514 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TRecTofTrack*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
515} // end of namespace ROOT
516
517namespace ROOT {
518 static void *new_TRecEmcHit(void *p = 0);
519 static void *newArray_TRecEmcHit(Long_t size, void *p);
520 static void delete_TRecEmcHit(void *p);
521 static void deleteArray_TRecEmcHit(void *p);
522 static void destruct_TRecEmcHit(void *p);
523
524 // Function generating the singleton type initializer
525 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecEmcHit*)
526 {
527 ::TRecEmcHit *ptr = 0;
528 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecEmcHit >(0);
529 static ::ROOT::TGenericClassInfo
530 instance("TRecEmcHit", ::TRecEmcHit::Class_Version(), "TRecEmcHit.h", 9,
531 typeid(::TRecEmcHit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
532 &::TRecEmcHit::Dictionary, isa_proxy, 4,
533 sizeof(::TRecEmcHit) );
534 instance.SetNew(&new_TRecEmcHit);
535 instance.SetNewArray(&newArray_TRecEmcHit);
536 instance.SetDelete(&delete_TRecEmcHit);
537 instance.SetDeleteArray(&deleteArray_TRecEmcHit);
538 instance.SetDestructor(&destruct_TRecEmcHit);
539 return &instance;
540 }
541 TGenericClassInfo *GenerateInitInstance(const ::TRecEmcHit*)
542 {
543 return GenerateInitInstanceLocal((::TRecEmcHit*)0);
544 }
545 // Static variable to force the class initialization
546 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TRecEmcHit*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
547} // end of namespace ROOT
548
549namespace ROOT {
550 static void *new_TRecEmcCluster(void *p = 0);
551 static void *newArray_TRecEmcCluster(Long_t size, void *p);
552 static void delete_TRecEmcCluster(void *p);
553 static void deleteArray_TRecEmcCluster(void *p);
554 static void destruct_TRecEmcCluster(void *p);
555
556 // Function generating the singleton type initializer
557 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecEmcCluster*)
558 {
559 ::TRecEmcCluster *ptr = 0;
560 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecEmcCluster >(0);
561 static ::ROOT::TGenericClassInfo
562 instance("TRecEmcCluster", ::TRecEmcCluster::Class_Version(), "TRecEmcCluster.h", 9,
563 typeid(::TRecEmcCluster), ::ROOT::Internal::DefineBehavior(ptr, ptr),
564 &::TRecEmcCluster::Dictionary, isa_proxy, 4,
565 sizeof(::TRecEmcCluster) );
566 instance.SetNew(&new_TRecEmcCluster);
567 instance.SetNewArray(&newArray_TRecEmcCluster);
568 instance.SetDelete(&delete_TRecEmcCluster);
569 instance.SetDeleteArray(&deleteArray_TRecEmcCluster);
570 instance.SetDestructor(&destruct_TRecEmcCluster);
571 return &instance;
572 }
573 TGenericClassInfo *GenerateInitInstance(const ::TRecEmcCluster*)
574 {
575 return GenerateInitInstanceLocal((::TRecEmcCluster*)0);
576 }
577 // Static variable to force the class initialization
578 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TRecEmcCluster*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
579} // end of namespace ROOT
580
581namespace ROOT {
582 static void *new_TRecEmcShower(void *p = 0);
583 static void *newArray_TRecEmcShower(Long_t size, void *p);
584 static void delete_TRecEmcShower(void *p);
585 static void deleteArray_TRecEmcShower(void *p);
586 static void destruct_TRecEmcShower(void *p);
587
588 // Function generating the singleton type initializer
589 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecEmcShower*)
590 {
591 ::TRecEmcShower *ptr = 0;
592 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecEmcShower >(0);
593 static ::ROOT::TGenericClassInfo
594 instance("TRecEmcShower", ::TRecEmcShower::Class_Version(), "TRecEmcShower.h", 11,
595 typeid(::TRecEmcShower), ::ROOT::Internal::DefineBehavior(ptr, ptr),
596 &::TRecEmcShower::Dictionary, isa_proxy, 4,
597 sizeof(::TRecEmcShower) );
598 instance.SetNew(&new_TRecEmcShower);
599 instance.SetNewArray(&newArray_TRecEmcShower);
600 instance.SetDelete(&delete_TRecEmcShower);
601 instance.SetDeleteArray(&deleteArray_TRecEmcShower);
602 instance.SetDestructor(&destruct_TRecEmcShower);
603 return &instance;
604 }
605 TGenericClassInfo *GenerateInitInstance(const ::TRecEmcShower*)
606 {
607 return GenerateInitInstanceLocal((::TRecEmcShower*)0);
608 }
609 // Static variable to force the class initialization
610 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TRecEmcShower*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
611} // end of namespace ROOT
612
613namespace ROOT {
614 static void *new_TRecMucTrack(void *p = 0);
615 static void *newArray_TRecMucTrack(Long_t size, void *p);
616 static void delete_TRecMucTrack(void *p);
617 static void deleteArray_TRecMucTrack(void *p);
618 static void destruct_TRecMucTrack(void *p);
619
620 // Function generating the singleton type initializer
621 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMucTrack*)
622 {
623 ::TRecMucTrack *ptr = 0;
624 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMucTrack >(0);
625 static ::ROOT::TGenericClassInfo
626 instance("TRecMucTrack", ::TRecMucTrack::Class_Version(), "TRecMucTrack.h", 9,
627 typeid(::TRecMucTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
628 &::TRecMucTrack::Dictionary, isa_proxy, 4,
629 sizeof(::TRecMucTrack) );
630 instance.SetNew(&new_TRecMucTrack);
631 instance.SetNewArray(&newArray_TRecMucTrack);
632 instance.SetDelete(&delete_TRecMucTrack);
633 instance.SetDeleteArray(&deleteArray_TRecMucTrack);
634 instance.SetDestructor(&destruct_TRecMucTrack);
635 return &instance;
636 }
637 TGenericClassInfo *GenerateInitInstance(const ::TRecMucTrack*)
638 {
639 return GenerateInitInstanceLocal((::TRecMucTrack*)0);
640 }
641 // Static variable to force the class initialization
642 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TRecMucTrack*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
643} // end of namespace ROOT
644
645namespace ROOT {
646 static void *new_TRecMdcDedx(void *p = 0);
647 static void *newArray_TRecMdcDedx(Long_t size, void *p);
648 static void delete_TRecMdcDedx(void *p);
649 static void deleteArray_TRecMdcDedx(void *p);
650 static void destruct_TRecMdcDedx(void *p);
651
652 // Function generating the singleton type initializer
653 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMdcDedx*)
654 {
655 ::TRecMdcDedx *ptr = 0;
656 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcDedx >(0);
657 static ::ROOT::TGenericClassInfo
658 instance("TRecMdcDedx", ::TRecMdcDedx::Class_Version(), "TRecMdcDedx.h", 6,
659 typeid(::TRecMdcDedx), ::ROOT::Internal::DefineBehavior(ptr, ptr),
660 &::TRecMdcDedx::Dictionary, isa_proxy, 4,
661 sizeof(::TRecMdcDedx) );
662 instance.SetNew(&new_TRecMdcDedx);
663 instance.SetNewArray(&newArray_TRecMdcDedx);
664 instance.SetDelete(&delete_TRecMdcDedx);
665 instance.SetDeleteArray(&deleteArray_TRecMdcDedx);
666 instance.SetDestructor(&destruct_TRecMdcDedx);
667 return &instance;
668 }
669 TGenericClassInfo *GenerateInitInstance(const ::TRecMdcDedx*)
670 {
671 return GenerateInitInstanceLocal((::TRecMdcDedx*)0);
672 }
673 // Static variable to force the class initialization
674 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TRecMdcDedx*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
675} // end of namespace ROOT
676
677namespace ROOT {
678 static void *new_TRecMdcDedxHit(void *p = 0);
679 static void *newArray_TRecMdcDedxHit(Long_t size, void *p);
680 static void delete_TRecMdcDedxHit(void *p);
681 static void deleteArray_TRecMdcDedxHit(void *p);
682 static void destruct_TRecMdcDedxHit(void *p);
683
684 // Function generating the singleton type initializer
685 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMdcDedxHit*)
686 {
687 ::TRecMdcDedxHit *ptr = 0;
688 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcDedxHit >(0);
689 static ::ROOT::TGenericClassInfo
690 instance("TRecMdcDedxHit", ::TRecMdcDedxHit::Class_Version(), "TRecMdcDedxHit.h", 7,
691 typeid(::TRecMdcDedxHit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
692 &::TRecMdcDedxHit::Dictionary, isa_proxy, 4,
693 sizeof(::TRecMdcDedxHit) );
694 instance.SetNew(&new_TRecMdcDedxHit);
695 instance.SetNewArray(&newArray_TRecMdcDedxHit);
696 instance.SetDelete(&delete_TRecMdcDedxHit);
697 instance.SetDeleteArray(&deleteArray_TRecMdcDedxHit);
698 instance.SetDestructor(&destruct_TRecMdcDedxHit);
699 return &instance;
700 }
701 TGenericClassInfo *GenerateInitInstance(const ::TRecMdcDedxHit*)
702 {
703 return GenerateInitInstanceLocal((::TRecMdcDedxHit*)0);
704 }
705 // Static variable to force the class initialization
706 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TRecMdcDedxHit*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
707} // end of namespace ROOT
708
709namespace ROOT {
710 static void *new_TRecExtTrack(void *p = 0);
711 static void *newArray_TRecExtTrack(Long_t size, void *p);
712 static void delete_TRecExtTrack(void *p);
713 static void deleteArray_TRecExtTrack(void *p);
714 static void destruct_TRecExtTrack(void *p);
715
716 // Function generating the singleton type initializer
717 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecExtTrack*)
718 {
719 ::TRecExtTrack *ptr = 0;
720 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecExtTrack >(0);
721 static ::ROOT::TGenericClassInfo
722 instance("TRecExtTrack", ::TRecExtTrack::Class_Version(), "TRecExtTrack.h", 8,
723 typeid(::TRecExtTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
724 &::TRecExtTrack::Dictionary, isa_proxy, 4,
725 sizeof(::TRecExtTrack) );
726 instance.SetNew(&new_TRecExtTrack);
727 instance.SetNewArray(&newArray_TRecExtTrack);
728 instance.SetDelete(&delete_TRecExtTrack);
729 instance.SetDeleteArray(&deleteArray_TRecExtTrack);
730 instance.SetDestructor(&destruct_TRecExtTrack);
731 return &instance;
732 }
733 TGenericClassInfo *GenerateInitInstance(const ::TRecExtTrack*)
734 {
735 return GenerateInitInstanceLocal((::TRecExtTrack*)0);
736 }
737 // Static variable to force the class initialization
738 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TRecExtTrack*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
739} // end of namespace ROOT
740
741namespace ROOT {
742 static void *new_TRecEvTime(void *p = 0);
743 static void *newArray_TRecEvTime(Long_t size, void *p);
744 static void delete_TRecEvTime(void *p);
745 static void deleteArray_TRecEvTime(void *p);
746 static void destruct_TRecEvTime(void *p);
747
748 // Function generating the singleton type initializer
749 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecEvTime*)
750 {
751 ::TRecEvTime *ptr = 0;
752 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecEvTime >(0);
753 static ::ROOT::TGenericClassInfo
754 instance("TRecEvTime", ::TRecEvTime::Class_Version(), "TRecEvTime.h", 10,
755 typeid(::TRecEvTime), ::ROOT::Internal::DefineBehavior(ptr, ptr),
756 &::TRecEvTime::Dictionary, isa_proxy, 4,
757 sizeof(::TRecEvTime) );
758 instance.SetNew(&new_TRecEvTime);
759 instance.SetNewArray(&newArray_TRecEvTime);
760 instance.SetDelete(&delete_TRecEvTime);
761 instance.SetDeleteArray(&deleteArray_TRecEvTime);
762 instance.SetDestructor(&destruct_TRecEvTime);
763 return &instance;
764 }
765 TGenericClassInfo *GenerateInitInstance(const ::TRecEvTime*)
766 {
767 return GenerateInitInstanceLocal((::TRecEvTime*)0);
768 }
769 // Static variable to force the class initialization
770 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TRecEvTime*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
771} // end of namespace ROOT
772
773namespace ROOT {
774 static void *new_TRecMdcKalHelixSeg(void *p = 0);
775 static void *newArray_TRecMdcKalHelixSeg(Long_t size, void *p);
776 static void delete_TRecMdcKalHelixSeg(void *p);
777 static void deleteArray_TRecMdcKalHelixSeg(void *p);
778 static void destruct_TRecMdcKalHelixSeg(void *p);
779
780 // Function generating the singleton type initializer
781 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMdcKalHelixSeg*)
782 {
783 ::TRecMdcKalHelixSeg *ptr = 0;
784 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcKalHelixSeg >(0);
785 static ::ROOT::TGenericClassInfo
786 instance("TRecMdcKalHelixSeg", ::TRecMdcKalHelixSeg::Class_Version(), "TRecMdcKalHelixSeg.h", 9,
787 typeid(::TRecMdcKalHelixSeg), ::ROOT::Internal::DefineBehavior(ptr, ptr),
788 &::TRecMdcKalHelixSeg::Dictionary, isa_proxy, 4,
789 sizeof(::TRecMdcKalHelixSeg) );
790 instance.SetNew(&new_TRecMdcKalHelixSeg);
791 instance.SetNewArray(&newArray_TRecMdcKalHelixSeg);
792 instance.SetDelete(&delete_TRecMdcKalHelixSeg);
793 instance.SetDeleteArray(&deleteArray_TRecMdcKalHelixSeg);
794 instance.SetDestructor(&destruct_TRecMdcKalHelixSeg);
795 return &instance;
796 }
797 TGenericClassInfo *GenerateInitInstance(const ::TRecMdcKalHelixSeg*)
798 {
799 return GenerateInitInstanceLocal((::TRecMdcKalHelixSeg*)0);
800 }
801 // Static variable to force the class initialization
802 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TRecMdcKalHelixSeg*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
803} // end of namespace ROOT
804
805namespace ROOT {
806 static void *new_TRecZddChannel(void *p = 0);
807 static void *newArray_TRecZddChannel(Long_t size, void *p);
808 static void delete_TRecZddChannel(void *p);
809 static void deleteArray_TRecZddChannel(void *p);
810 static void destruct_TRecZddChannel(void *p);
811
812 // Function generating the singleton type initializer
813 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecZddChannel*)
814 {
815 ::TRecZddChannel *ptr = 0;
816 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecZddChannel >(0);
817 static ::ROOT::TGenericClassInfo
818 instance("TRecZddChannel", ::TRecZddChannel::Class_Version(), "TRecZddChannel.h", 8,
819 typeid(::TRecZddChannel), ::ROOT::Internal::DefineBehavior(ptr, ptr),
820 &::TRecZddChannel::Dictionary, isa_proxy, 4,
821 sizeof(::TRecZddChannel) );
822 instance.SetNew(&new_TRecZddChannel);
823 instance.SetNewArray(&newArray_TRecZddChannel);
824 instance.SetDelete(&delete_TRecZddChannel);
825 instance.SetDeleteArray(&deleteArray_TRecZddChannel);
826 instance.SetDestructor(&destruct_TRecZddChannel);
827 return &instance;
828 }
829 TGenericClassInfo *GenerateInitInstance(const ::TRecZddChannel*)
830 {
831 return GenerateInitInstanceLocal((::TRecZddChannel*)0);
832 }
833 // Static variable to force the class initialization
834 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TRecZddChannel*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
835} // end of namespace ROOT
836
837namespace ROOT {
838 static void *new_TRecTrackEvent(void *p = 0);
839 static void *newArray_TRecTrackEvent(Long_t size, void *p);
840 static void delete_TRecTrackEvent(void *p);
841 static void deleteArray_TRecTrackEvent(void *p);
842 static void destruct_TRecTrackEvent(void *p);
843
844 // Function generating the singleton type initializer
845 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecTrackEvent*)
846 {
847 ::TRecTrackEvent *ptr = 0;
848 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecTrackEvent >(0);
849 static ::ROOT::TGenericClassInfo
850 instance("TRecTrackEvent", ::TRecTrackEvent::Class_Version(), "TRecTrackEvent.h", 24,
851 typeid(::TRecTrackEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
852 &::TRecTrackEvent::Dictionary, isa_proxy, 4,
853 sizeof(::TRecTrackEvent) );
854 instance.SetNew(&new_TRecTrackEvent);
855 instance.SetNewArray(&newArray_TRecTrackEvent);
856 instance.SetDelete(&delete_TRecTrackEvent);
857 instance.SetDeleteArray(&deleteArray_TRecTrackEvent);
858 instance.SetDestructor(&destruct_TRecTrackEvent);
859 return &instance;
860 }
861 TGenericClassInfo *GenerateInitInstance(const ::TRecTrackEvent*)
862 {
863 return GenerateInitInstanceLocal((::TRecTrackEvent*)0);
864 }
865 // Static variable to force the class initialization
866 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TRecTrackEvent*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
867} // end of namespace ROOT
868
869namespace ROOT {
870 static void *new_TMdcTrack(void *p = 0);
871 static void *newArray_TMdcTrack(Long_t size, void *p);
872 static void delete_TMdcTrack(void *p);
873 static void deleteArray_TMdcTrack(void *p);
874 static void destruct_TMdcTrack(void *p);
875
876 // Function generating the singleton type initializer
877 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMdcTrack*)
878 {
879 ::TMdcTrack *ptr = 0;
880 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMdcTrack >(0);
881 static ::ROOT::TGenericClassInfo
882 instance("TMdcTrack", ::TMdcTrack::Class_Version(), "TMdcTrack.h", 6,
883 typeid(::TMdcTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
884 &::TMdcTrack::Dictionary, isa_proxy, 4,
885 sizeof(::TMdcTrack) );
886 instance.SetNew(&new_TMdcTrack);
887 instance.SetNewArray(&newArray_TMdcTrack);
888 instance.SetDelete(&delete_TMdcTrack);
889 instance.SetDeleteArray(&deleteArray_TMdcTrack);
890 instance.SetDestructor(&destruct_TMdcTrack);
891 return &instance;
892 }
893 TGenericClassInfo *GenerateInitInstance(const ::TMdcTrack*)
894 {
895 return GenerateInitInstanceLocal((::TMdcTrack*)0);
896 }
897 // Static variable to force the class initialization
898 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TMdcTrack*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
899} // end of namespace ROOT
900
901namespace ROOT {
902 static void *new_TEmcTrack(void *p = 0);
903 static void *newArray_TEmcTrack(Long_t size, void *p);
904 static void delete_TEmcTrack(void *p);
905 static void deleteArray_TEmcTrack(void *p);
906 static void destruct_TEmcTrack(void *p);
907
908 // Function generating the singleton type initializer
909 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEmcTrack*)
910 {
911 ::TEmcTrack *ptr = 0;
912 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEmcTrack >(0);
913 static ::ROOT::TGenericClassInfo
914 instance("TEmcTrack", ::TEmcTrack::Class_Version(), "TEmcTrack.h", 7,
915 typeid(::TEmcTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
916 &::TEmcTrack::Dictionary, isa_proxy, 4,
917 sizeof(::TEmcTrack) );
918 instance.SetNew(&new_TEmcTrack);
919 instance.SetNewArray(&newArray_TEmcTrack);
920 instance.SetDelete(&delete_TEmcTrack);
921 instance.SetDeleteArray(&deleteArray_TEmcTrack);
922 instance.SetDestructor(&destruct_TEmcTrack);
923 return &instance;
924 }
925 TGenericClassInfo *GenerateInitInstance(const ::TEmcTrack*)
926 {
927 return GenerateInitInstanceLocal((::TEmcTrack*)0);
928 }
929 // Static variable to force the class initialization
930 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TEmcTrack*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
931} // end of namespace ROOT
932
933namespace ROOT {
934 static void *new_TMucTrack(void *p = 0);
935 static void *newArray_TMucTrack(Long_t size, void *p);
936 static void delete_TMucTrack(void *p);
937 static void deleteArray_TMucTrack(void *p);
938 static void destruct_TMucTrack(void *p);
939
940 // Function generating the singleton type initializer
941 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMucTrack*)
942 {
943 ::TMucTrack *ptr = 0;
944 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMucTrack >(0);
945 static ::ROOT::TGenericClassInfo
946 instance("TMucTrack", ::TMucTrack::Class_Version(), "TMucTrack.h", 9,
947 typeid(::TMucTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
948 &::TMucTrack::Dictionary, isa_proxy, 4,
949 sizeof(::TMucTrack) );
950 instance.SetNew(&new_TMucTrack);
951 instance.SetNewArray(&newArray_TMucTrack);
952 instance.SetDelete(&delete_TMucTrack);
953 instance.SetDeleteArray(&deleteArray_TMucTrack);
954 instance.SetDestructor(&destruct_TMucTrack);
955 return &instance;
956 }
957 TGenericClassInfo *GenerateInitInstance(const ::TMucTrack*)
958 {
959 return GenerateInitInstanceLocal((::TMucTrack*)0);
960 }
961 // Static variable to force the class initialization
962 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TMucTrack*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
963} // end of namespace ROOT
964
965namespace ROOT {
966 static void *new_TMdcDedx(void *p = 0);
967 static void *newArray_TMdcDedx(Long_t size, void *p);
968 static void delete_TMdcDedx(void *p);
969 static void deleteArray_TMdcDedx(void *p);
970 static void destruct_TMdcDedx(void *p);
971
972 // Function generating the singleton type initializer
973 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMdcDedx*)
974 {
975 ::TMdcDedx *ptr = 0;
976 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMdcDedx >(0);
977 static ::ROOT::TGenericClassInfo
978 instance("TMdcDedx", ::TMdcDedx::Class_Version(), "TMdcDedx.h", 6,
979 typeid(::TMdcDedx), ::ROOT::Internal::DefineBehavior(ptr, ptr),
980 &::TMdcDedx::Dictionary, isa_proxy, 4,
981 sizeof(::TMdcDedx) );
982 instance.SetNew(&new_TMdcDedx);
983 instance.SetNewArray(&newArray_TMdcDedx);
984 instance.SetDelete(&delete_TMdcDedx);
985 instance.SetDeleteArray(&deleteArray_TMdcDedx);
986 instance.SetDestructor(&destruct_TMdcDedx);
987 return &instance;
988 }
989 TGenericClassInfo *GenerateInitInstance(const ::TMdcDedx*)
990 {
991 return GenerateInitInstanceLocal((::TMdcDedx*)0);
992 }
993 // Static variable to force the class initialization
994 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TMdcDedx*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
995} // end of namespace ROOT
996
997namespace ROOT {
998 static void *new_TExtTrack(void *p = 0);
999 static void *newArray_TExtTrack(Long_t size, void *p);
1000 static void delete_TExtTrack(void *p);
1001 static void deleteArray_TExtTrack(void *p);
1002 static void destruct_TExtTrack(void *p);
1003
1004 // Function generating the singleton type initializer
1005 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TExtTrack*)
1006 {
1007 ::TExtTrack *ptr = 0;
1008 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TExtTrack >(0);
1009 static ::ROOT::TGenericClassInfo
1010 instance("TExtTrack", ::TExtTrack::Class_Version(), "TExtTrack.h", 9,
1011 typeid(::TExtTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1012 &::TExtTrack::Dictionary, isa_proxy, 4,
1013 sizeof(::TExtTrack) );
1014 instance.SetNew(&new_TExtTrack);
1015 instance.SetNewArray(&newArray_TExtTrack);
1016 instance.SetDelete(&delete_TExtTrack);
1017 instance.SetDeleteArray(&deleteArray_TExtTrack);
1018 instance.SetDestructor(&destruct_TExtTrack);
1019 return &instance;
1020 }
1021 TGenericClassInfo *GenerateInitInstance(const ::TExtTrack*)
1022 {
1023 return GenerateInitInstanceLocal((::TExtTrack*)0);
1024 }
1025 // Static variable to force the class initialization
1026 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TExtTrack*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1027} // end of namespace ROOT
1028
1029namespace ROOT {
1030 static void *new_TMdcKalTrack(void *p = 0);
1031 static void *newArray_TMdcKalTrack(Long_t size, void *p);
1032 static void delete_TMdcKalTrack(void *p);
1033 static void deleteArray_TMdcKalTrack(void *p);
1034 static void destruct_TMdcKalTrack(void *p);
1035
1036 // Function generating the singleton type initializer
1037 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMdcKalTrack*)
1038 {
1039 ::TMdcKalTrack *ptr = 0;
1040 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMdcKalTrack >(0);
1041 static ::ROOT::TGenericClassInfo
1042 instance("TMdcKalTrack", ::TMdcKalTrack::Class_Version(), "TMdcKalTrack.h", 8,
1043 typeid(::TMdcKalTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1044 &::TMdcKalTrack::Dictionary, isa_proxy, 4,
1045 sizeof(::TMdcKalTrack) );
1046 instance.SetNew(&new_TMdcKalTrack);
1047 instance.SetNewArray(&newArray_TMdcKalTrack);
1048 instance.SetDelete(&delete_TMdcKalTrack);
1049 instance.SetDeleteArray(&deleteArray_TMdcKalTrack);
1050 instance.SetDestructor(&destruct_TMdcKalTrack);
1051 return &instance;
1052 }
1053 TGenericClassInfo *GenerateInitInstance(const ::TMdcKalTrack*)
1054 {
1055 return GenerateInitInstanceLocal((::TMdcKalTrack*)0);
1056 }
1057 // Static variable to force the class initialization
1058 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TMdcKalTrack*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1059} // end of namespace ROOT
1060
1061namespace ROOT {
1062 static void *new_TDstEvent(void *p = 0);
1063 static void *newArray_TDstEvent(Long_t size, void *p);
1064 static void delete_TDstEvent(void *p);
1065 static void deleteArray_TDstEvent(void *p);
1066 static void destruct_TDstEvent(void *p);
1067
1068 // Function generating the singleton type initializer
1069 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDstEvent*)
1070 {
1071 ::TDstEvent *ptr = 0;
1072 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDstEvent >(0);
1073 static ::ROOT::TGenericClassInfo
1074 instance("TDstEvent", ::TDstEvent::Class_Version(), "TDstEvent.h", 16,
1075 typeid(::TDstEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1076 &::TDstEvent::Dictionary, isa_proxy, 4,
1077 sizeof(::TDstEvent) );
1078 instance.SetNew(&new_TDstEvent);
1079 instance.SetNewArray(&newArray_TDstEvent);
1080 instance.SetDelete(&delete_TDstEvent);
1081 instance.SetDeleteArray(&deleteArray_TDstEvent);
1082 instance.SetDestructor(&destruct_TDstEvent);
1083 return &instance;
1084 }
1085 TGenericClassInfo *GenerateInitInstance(const ::TDstEvent*)
1086 {
1087 return GenerateInitInstanceLocal((::TDstEvent*)0);
1088 }
1089 // Static variable to force the class initialization
1090 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TDstEvent*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1091} // end of namespace ROOT
1092
1093namespace ROOT {
1094 static void *new_TMdcMc(void *p = 0);
1095 static void *newArray_TMdcMc(Long_t size, void *p);
1096 static void delete_TMdcMc(void *p);
1097 static void deleteArray_TMdcMc(void *p);
1098 static void destruct_TMdcMc(void *p);
1099
1100 // Function generating the singleton type initializer
1101 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMdcMc*)
1102 {
1103 ::TMdcMc *ptr = 0;
1104 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMdcMc >(0);
1105 static ::ROOT::TGenericClassInfo
1106 instance("TMdcMc", ::TMdcMc::Class_Version(), "TMdcMc.h", 9,
1107 typeid(::TMdcMc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1108 &::TMdcMc::Dictionary, isa_proxy, 4,
1109 sizeof(::TMdcMc) );
1110 instance.SetNew(&new_TMdcMc);
1111 instance.SetNewArray(&newArray_TMdcMc);
1112 instance.SetDelete(&delete_TMdcMc);
1113 instance.SetDeleteArray(&deleteArray_TMdcMc);
1114 instance.SetDestructor(&destruct_TMdcMc);
1115 return &instance;
1116 }
1117 TGenericClassInfo *GenerateInitInstance(const ::TMdcMc*)
1118 {
1119 return GenerateInitInstanceLocal((::TMdcMc*)0);
1120 }
1121 // Static variable to force the class initialization
1122 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TMdcMc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1123} // end of namespace ROOT
1124
1125namespace ROOT {
1126 static void *new_TEmcMc(void *p = 0);
1127 static void *newArray_TEmcMc(Long_t size, void *p);
1128 static void delete_TEmcMc(void *p);
1129 static void deleteArray_TEmcMc(void *p);
1130 static void destruct_TEmcMc(void *p);
1131
1132 // Function generating the singleton type initializer
1133 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEmcMc*)
1134 {
1135 ::TEmcMc *ptr = 0;
1136 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEmcMc >(0);
1137 static ::ROOT::TGenericClassInfo
1138 instance("TEmcMc", ::TEmcMc::Class_Version(), "TEmcMc.h", 10,
1139 typeid(::TEmcMc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1140 &::TEmcMc::Dictionary, isa_proxy, 4,
1141 sizeof(::TEmcMc) );
1142 instance.SetNew(&new_TEmcMc);
1143 instance.SetNewArray(&newArray_TEmcMc);
1144 instance.SetDelete(&delete_TEmcMc);
1145 instance.SetDeleteArray(&deleteArray_TEmcMc);
1146 instance.SetDestructor(&destruct_TEmcMc);
1147 return &instance;
1148 }
1149 TGenericClassInfo *GenerateInitInstance(const ::TEmcMc*)
1150 {
1151 return GenerateInitInstanceLocal((::TEmcMc*)0);
1152 }
1153 // Static variable to force the class initialization
1154 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TEmcMc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1155} // end of namespace ROOT
1156
1157namespace ROOT {
1158 static void *new_TTofMc(void *p = 0);
1159 static void *newArray_TTofMc(Long_t size, void *p);
1160 static void delete_TTofMc(void *p);
1161 static void deleteArray_TTofMc(void *p);
1162 static void destruct_TTofMc(void *p);
1163
1164 // Function generating the singleton type initializer
1165 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTofMc*)
1166 {
1167 ::TTofMc *ptr = 0;
1168 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTofMc >(0);
1169 static ::ROOT::TGenericClassInfo
1170 instance("TTofMc", ::TTofMc::Class_Version(), "TTofMc.h", 8,
1171 typeid(::TTofMc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1172 &::TTofMc::Dictionary, isa_proxy, 4,
1173 sizeof(::TTofMc) );
1174 instance.SetNew(&new_TTofMc);
1175 instance.SetNewArray(&newArray_TTofMc);
1176 instance.SetDelete(&delete_TTofMc);
1177 instance.SetDeleteArray(&deleteArray_TTofMc);
1178 instance.SetDestructor(&destruct_TTofMc);
1179 return &instance;
1180 }
1181 TGenericClassInfo *GenerateInitInstance(const ::TTofMc*)
1182 {
1183 return GenerateInitInstanceLocal((::TTofMc*)0);
1184 }
1185 // Static variable to force the class initialization
1186 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TTofMc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1187} // end of namespace ROOT
1188
1189namespace ROOT {
1190 static void *new_TMucMc(void *p = 0);
1191 static void *newArray_TMucMc(Long_t size, void *p);
1192 static void delete_TMucMc(void *p);
1193 static void deleteArray_TMucMc(void *p);
1194 static void destruct_TMucMc(void *p);
1195
1196 // Function generating the singleton type initializer
1197 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMucMc*)
1198 {
1199 ::TMucMc *ptr = 0;
1200 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMucMc >(0);
1201 static ::ROOT::TGenericClassInfo
1202 instance("TMucMc", ::TMucMc::Class_Version(), "TMucMc.h", 8,
1203 typeid(::TMucMc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1204 &::TMucMc::Dictionary, isa_proxy, 4,
1205 sizeof(::TMucMc) );
1206 instance.SetNew(&new_TMucMc);
1207 instance.SetNewArray(&newArray_TMucMc);
1208 instance.SetDelete(&delete_TMucMc);
1209 instance.SetDeleteArray(&deleteArray_TMucMc);
1210 instance.SetDestructor(&destruct_TMucMc);
1211 return &instance;
1212 }
1213 TGenericClassInfo *GenerateInitInstance(const ::TMucMc*)
1214 {
1215 return GenerateInitInstanceLocal((::TMucMc*)0);
1216 }
1217 // Static variable to force the class initialization
1218 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TMucMc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1219} // end of namespace ROOT
1220
1221namespace ROOT {
1222 static void *new_TMcParticle(void *p = 0);
1223 static void *newArray_TMcParticle(Long_t size, void *p);
1224 static void delete_TMcParticle(void *p);
1225 static void deleteArray_TMcParticle(void *p);
1226 static void destruct_TMcParticle(void *p);
1227
1228 // Function generating the singleton type initializer
1229 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMcParticle*)
1230 {
1231 ::TMcParticle *ptr = 0;
1232 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcParticle >(0);
1233 static ::ROOT::TGenericClassInfo
1234 instance("TMcParticle", ::TMcParticle::Class_Version(), "TMcParticle.h", 9,
1235 typeid(::TMcParticle), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1236 &::TMcParticle::Dictionary, isa_proxy, 4,
1237 sizeof(::TMcParticle) );
1238 instance.SetNew(&new_TMcParticle);
1239 instance.SetNewArray(&newArray_TMcParticle);
1240 instance.SetDelete(&delete_TMcParticle);
1241 instance.SetDeleteArray(&deleteArray_TMcParticle);
1242 instance.SetDestructor(&destruct_TMcParticle);
1243 return &instance;
1244 }
1245 TGenericClassInfo *GenerateInitInstance(const ::TMcParticle*)
1246 {
1247 return GenerateInitInstanceLocal((::TMcParticle*)0);
1248 }
1249 // Static variable to force the class initialization
1250 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TMcParticle*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1251} // end of namespace ROOT
1252
1253namespace ROOT {
1254 static void *new_TMcEvent(void *p = 0);
1255 static void *newArray_TMcEvent(Long_t size, void *p);
1256 static void delete_TMcEvent(void *p);
1257 static void deleteArray_TMcEvent(void *p);
1258 static void destruct_TMcEvent(void *p);
1259
1260 // Function generating the singleton type initializer
1261 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMcEvent*)
1262 {
1263 ::TMcEvent *ptr = 0;
1264 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcEvent >(0);
1265 static ::ROOT::TGenericClassInfo
1266 instance("TMcEvent", ::TMcEvent::Class_Version(), "TMcEvent.h", 16,
1267 typeid(::TMcEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1268 &::TMcEvent::Dictionary, isa_proxy, 4,
1269 sizeof(::TMcEvent) );
1270 instance.SetNew(&new_TMcEvent);
1271 instance.SetNewArray(&newArray_TMcEvent);
1272 instance.SetDelete(&delete_TMcEvent);
1273 instance.SetDeleteArray(&deleteArray_TMcEvent);
1274 instance.SetDestructor(&destruct_TMcEvent);
1275 return &instance;
1276 }
1277 TGenericClassInfo *GenerateInitInstance(const ::TMcEvent*)
1278 {
1279 return GenerateInitInstanceLocal((::TMcEvent*)0);
1280 }
1281 // Static variable to force the class initialization
1282 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TMcEvent*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1283} // end of namespace ROOT
1284
1285namespace ROOT {
1286 static void *new_TEvtHeader(void *p = 0);
1287 static void *newArray_TEvtHeader(Long_t size, void *p);
1288 static void delete_TEvtHeader(void *p);
1289 static void deleteArray_TEvtHeader(void *p);
1290 static void destruct_TEvtHeader(void *p);
1291
1292 // Function generating the singleton type initializer
1293 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtHeader*)
1294 {
1295 ::TEvtHeader *ptr = 0;
1296 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtHeader >(0);
1297 static ::ROOT::TGenericClassInfo
1298 instance("TEvtHeader", ::TEvtHeader::Class_Version(), "TEvtHeader.h", 8,
1299 typeid(::TEvtHeader), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1300 &::TEvtHeader::Dictionary, isa_proxy, 4,
1301 sizeof(::TEvtHeader) );
1302 instance.SetNew(&new_TEvtHeader);
1303 instance.SetNewArray(&newArray_TEvtHeader);
1304 instance.SetDelete(&delete_TEvtHeader);
1305 instance.SetDeleteArray(&deleteArray_TEvtHeader);
1306 instance.SetDestructor(&destruct_TEvtHeader);
1307 return &instance;
1308 }
1309 TGenericClassInfo *GenerateInitInstance(const ::TEvtHeader*)
1310 {
1311 return GenerateInitInstanceLocal((::TEvtHeader*)0);
1312 }
1313 // Static variable to force the class initialization
1314 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TEvtHeader*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1315} // end of namespace ROOT
1316
1317namespace ROOT {
1318 static void *new_TEvtNavigator(void *p = 0);
1319 static void *newArray_TEvtNavigator(Long_t size, void *p);
1320 static void delete_TEvtNavigator(void *p);
1321 static void deleteArray_TEvtNavigator(void *p);
1322 static void destruct_TEvtNavigator(void *p);
1323
1324 // Function generating the singleton type initializer
1325 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtNavigator*)
1326 {
1327 ::TEvtNavigator *ptr = 0;
1328 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtNavigator >(0);
1329 static ::ROOT::TGenericClassInfo
1330 instance("TEvtNavigator", ::TEvtNavigator::Class_Version(), "TEvtNavigator.h", 11,
1331 typeid(::TEvtNavigator), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1332 &::TEvtNavigator::Dictionary, isa_proxy, 4,
1333 sizeof(::TEvtNavigator) );
1334 instance.SetNew(&new_TEvtNavigator);
1335 instance.SetNewArray(&newArray_TEvtNavigator);
1336 instance.SetDelete(&delete_TEvtNavigator);
1337 instance.SetDeleteArray(&deleteArray_TEvtNavigator);
1338 instance.SetDestructor(&destruct_TEvtNavigator);
1339 return &instance;
1340 }
1341 TGenericClassInfo *GenerateInitInstance(const ::TEvtNavigator*)
1342 {
1343 return GenerateInitInstanceLocal((::TEvtNavigator*)0);
1344 }
1345 // Static variable to force the class initialization
1346 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TEvtNavigator*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1347} // end of namespace ROOT
1348
1349namespace ROOT {
1350 static void *new_TTrigData(void *p = 0);
1351 static void *newArray_TTrigData(Long_t size, void *p);
1352 static void delete_TTrigData(void *p);
1353 static void deleteArray_TTrigData(void *p);
1354 static void destruct_TTrigData(void *p);
1355
1356 // Function generating the singleton type initializer
1357 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTrigData*)
1358 {
1359 ::TTrigData *ptr = 0;
1360 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTrigData >(0);
1361 static ::ROOT::TGenericClassInfo
1362 instance("TTrigData", ::TTrigData::Class_Version(), "TTrigData.h", 8,
1363 typeid(::TTrigData), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1364 &::TTrigData::Dictionary, isa_proxy, 4,
1365 sizeof(::TTrigData) );
1366 instance.SetNew(&new_TTrigData);
1367 instance.SetNewArray(&newArray_TTrigData);
1368 instance.SetDelete(&delete_TTrigData);
1369 instance.SetDeleteArray(&deleteArray_TTrigData);
1370 instance.SetDestructor(&destruct_TTrigData);
1371 return &instance;
1372 }
1373 TGenericClassInfo *GenerateInitInstance(const ::TTrigData*)
1374 {
1375 return GenerateInitInstanceLocal((::TTrigData*)0);
1376 }
1377 // Static variable to force the class initialization
1378 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TTrigData*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1379} // end of namespace ROOT
1380
1381namespace ROOT {
1382 static void *new_TTrigEvent(void *p = 0);
1383 static void *newArray_TTrigEvent(Long_t size, void *p);
1384 static void delete_TTrigEvent(void *p);
1385 static void deleteArray_TTrigEvent(void *p);
1386 static void destruct_TTrigEvent(void *p);
1387
1388 // Function generating the singleton type initializer
1389 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTrigEvent*)
1390 {
1391 ::TTrigEvent *ptr = 0;
1392 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTrigEvent >(0);
1393 static ::ROOT::TGenericClassInfo
1394 instance("TTrigEvent", ::TTrigEvent::Class_Version(), "TTrigEvent.h", 10,
1395 typeid(::TTrigEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1396 &::TTrigEvent::Dictionary, isa_proxy, 4,
1397 sizeof(::TTrigEvent) );
1398 instance.SetNew(&new_TTrigEvent);
1399 instance.SetNewArray(&newArray_TTrigEvent);
1400 instance.SetDelete(&delete_TTrigEvent);
1401 instance.SetDeleteArray(&deleteArray_TTrigEvent);
1402 instance.SetDestructor(&destruct_TTrigEvent);
1403 return &instance;
1404 }
1405 TGenericClassInfo *GenerateInitInstance(const ::TTrigEvent*)
1406 {
1407 return GenerateInitInstanceLocal((::TTrigEvent*)0);
1408 }
1409 // Static variable to force the class initialization
1410 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TTrigEvent*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1411} // end of namespace ROOT
1412
1413namespace ROOT {
1414 static void *new_THltRaw(void *p = 0);
1415 static void *newArray_THltRaw(Long_t size, void *p);
1416 static void delete_THltRaw(void *p);
1417 static void deleteArray_THltRaw(void *p);
1418 static void destruct_THltRaw(void *p);
1419
1420 // Function generating the singleton type initializer
1421 static TGenericClassInfo *GenerateInitInstanceLocal(const ::THltRaw*)
1422 {
1423 ::THltRaw *ptr = 0;
1424 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THltRaw >(0);
1425 static ::ROOT::TGenericClassInfo
1426 instance("THltRaw", ::THltRaw::Class_Version(), "THltRaw.h", 7,
1427 typeid(::THltRaw), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1428 &::THltRaw::Dictionary, isa_proxy, 4,
1429 sizeof(::THltRaw) );
1430 instance.SetNew(&new_THltRaw);
1431 instance.SetNewArray(&newArray_THltRaw);
1432 instance.SetDelete(&delete_THltRaw);
1433 instance.SetDeleteArray(&deleteArray_THltRaw);
1434 instance.SetDestructor(&destruct_THltRaw);
1435 return &instance;
1436 }
1437 TGenericClassInfo *GenerateInitInstance(const ::THltRaw*)
1438 {
1439 return GenerateInitInstanceLocal((::THltRaw*)0);
1440 }
1441 // Static variable to force the class initialization
1442 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::THltRaw*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1443} // end of namespace ROOT
1444
1445namespace ROOT {
1446 static void *new_THltInf(void *p = 0);
1447 static void *newArray_THltInf(Long_t size, void *p);
1448 static void delete_THltInf(void *p);
1449 static void deleteArray_THltInf(void *p);
1450 static void destruct_THltInf(void *p);
1451
1452 // Function generating the singleton type initializer
1453 static TGenericClassInfo *GenerateInitInstanceLocal(const ::THltInf*)
1454 {
1455 ::THltInf *ptr = 0;
1456 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THltInf >(0);
1457 static ::ROOT::TGenericClassInfo
1458 instance("THltInf", ::THltInf::Class_Version(), "THltInf.h", 9,
1459 typeid(::THltInf), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1460 &::THltInf::Dictionary, isa_proxy, 4,
1461 sizeof(::THltInf) );
1462 instance.SetNew(&new_THltInf);
1463 instance.SetNewArray(&newArray_THltInf);
1464 instance.SetDelete(&delete_THltInf);
1465 instance.SetDeleteArray(&deleteArray_THltInf);
1466 instance.SetDestructor(&destruct_THltInf);
1467 return &instance;
1468 }
1469 TGenericClassInfo *GenerateInitInstance(const ::THltInf*)
1470 {
1471 return GenerateInitInstanceLocal((::THltInf*)0);
1472 }
1473 // Static variable to force the class initialization
1474 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::THltInf*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1475} // end of namespace ROOT
1476
1477namespace ROOT {
1478 static void *new_TDstHltInf(void *p = 0);
1479 static void *newArray_TDstHltInf(Long_t size, void *p);
1480 static void delete_TDstHltInf(void *p);
1481 static void deleteArray_TDstHltInf(void *p);
1482 static void destruct_TDstHltInf(void *p);
1483
1484 // Function generating the singleton type initializer
1485 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDstHltInf*)
1486 {
1487 ::TDstHltInf *ptr = 0;
1488 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDstHltInf >(0);
1489 static ::ROOT::TGenericClassInfo
1490 instance("TDstHltInf", ::TDstHltInf::Class_Version(), "TDstHltInf.h", 9,
1491 typeid(::TDstHltInf), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1492 &::TDstHltInf::Dictionary, isa_proxy, 4,
1493 sizeof(::TDstHltInf) );
1494 instance.SetNew(&new_TDstHltInf);
1495 instance.SetNewArray(&newArray_TDstHltInf);
1496 instance.SetDelete(&delete_TDstHltInf);
1497 instance.SetDeleteArray(&deleteArray_TDstHltInf);
1498 instance.SetDestructor(&destruct_TDstHltInf);
1499 return &instance;
1500 }
1501 TGenericClassInfo *GenerateInitInstance(const ::TDstHltInf*)
1502 {
1503 return GenerateInitInstanceLocal((::TDstHltInf*)0);
1504 }
1505 // Static variable to force the class initialization
1506 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TDstHltInf*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1507} // end of namespace ROOT
1508
1509namespace ROOT {
1510 static void *new_THltEvent(void *p = 0);
1511 static void *newArray_THltEvent(Long_t size, void *p);
1512 static void delete_THltEvent(void *p);
1513 static void deleteArray_THltEvent(void *p);
1514 static void destruct_THltEvent(void *p);
1515
1516 // Function generating the singleton type initializer
1517 static TGenericClassInfo *GenerateInitInstanceLocal(const ::THltEvent*)
1518 {
1519 ::THltEvent *ptr = 0;
1520 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THltEvent >(0);
1521 static ::ROOT::TGenericClassInfo
1522 instance("THltEvent", ::THltEvent::Class_Version(), "THltEvent.h", 12,
1523 typeid(::THltEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1524 &::THltEvent::Dictionary, isa_proxy, 4,
1525 sizeof(::THltEvent) );
1526 instance.SetNew(&new_THltEvent);
1527 instance.SetNewArray(&newArray_THltEvent);
1528 instance.SetDelete(&delete_THltEvent);
1529 instance.SetDeleteArray(&deleteArray_THltEvent);
1530 instance.SetDestructor(&destruct_THltEvent);
1531 return &instance;
1532 }
1533 TGenericClassInfo *GenerateInitInstance(const ::THltEvent*)
1534 {
1535 return GenerateInitInstanceLocal((::THltEvent*)0);
1536 }
1537 // Static variable to force the class initialization
1538 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::THltEvent*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1539} // end of namespace ROOT
1540
1541namespace ROOT {
1542 static void *new_TDisTrack(void *p = 0);
1543 static void *newArray_TDisTrack(Long_t size, void *p);
1544 static void delete_TDisTrack(void *p);
1545 static void deleteArray_TDisTrack(void *p);
1546 static void destruct_TDisTrack(void *p);
1547 static void streamer_TDisTrack(TBuffer &buf, void *obj);
1548
1549 // Function generating the singleton type initializer
1550 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDisTrack*)
1551 {
1552 ::TDisTrack *ptr = 0;
1553 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDisTrack >(0);
1554 static ::ROOT::TGenericClassInfo
1555 instance("TDisTrack", ::TDisTrack::Class_Version(), "TDisTrack.h", 12,
1556 typeid(::TDisTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1557 &::TDisTrack::Dictionary, isa_proxy, 16,
1558 sizeof(::TDisTrack) );
1559 instance.SetNew(&new_TDisTrack);
1560 instance.SetNewArray(&newArray_TDisTrack);
1561 instance.SetDelete(&delete_TDisTrack);
1562 instance.SetDeleteArray(&deleteArray_TDisTrack);
1563 instance.SetDestructor(&destruct_TDisTrack);
1564 instance.SetStreamerFunc(&streamer_TDisTrack);
1565 return &instance;
1566 }
1567 TGenericClassInfo *GenerateInitInstance(const ::TDisTrack*)
1568 {
1569 return GenerateInitInstanceLocal((::TDisTrack*)0);
1570 }
1571 // Static variable to force the class initialization
1572 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TDisTrack*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1573} // end of namespace ROOT
1574
1575namespace ROOT {
1576 static void *new_TEvtRecEvent(void *p = 0);
1577 static void *newArray_TEvtRecEvent(Long_t size, void *p);
1578 static void delete_TEvtRecEvent(void *p);
1579 static void deleteArray_TEvtRecEvent(void *p);
1580 static void destruct_TEvtRecEvent(void *p);
1581
1582 // Function generating the singleton type initializer
1583 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecEvent*)
1584 {
1585 ::TEvtRecEvent *ptr = 0;
1586 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecEvent >(0);
1587 static ::ROOT::TGenericClassInfo
1588 instance("TEvtRecEvent", ::TEvtRecEvent::Class_Version(), "TEvtRecEvent.h", 7,
1589 typeid(::TEvtRecEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1590 &::TEvtRecEvent::Dictionary, isa_proxy, 4,
1591 sizeof(::TEvtRecEvent) );
1592 instance.SetNew(&new_TEvtRecEvent);
1593 instance.SetNewArray(&newArray_TEvtRecEvent);
1594 instance.SetDelete(&delete_TEvtRecEvent);
1595 instance.SetDeleteArray(&deleteArray_TEvtRecEvent);
1596 instance.SetDestructor(&destruct_TEvtRecEvent);
1597 return &instance;
1598 }
1599 TGenericClassInfo *GenerateInitInstance(const ::TEvtRecEvent*)
1600 {
1601 return GenerateInitInstanceLocal((::TEvtRecEvent*)0);
1602 }
1603 // Static variable to force the class initialization
1604 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TEvtRecEvent*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1605} // end of namespace ROOT
1606
1607namespace ROOT {
1608 static void *new_TEvtRecTrack(void *p = 0);
1609 static void *newArray_TEvtRecTrack(Long_t size, void *p);
1610 static void delete_TEvtRecTrack(void *p);
1611 static void deleteArray_TEvtRecTrack(void *p);
1612 static void destruct_TEvtRecTrack(void *p);
1613
1614 // Function generating the singleton type initializer
1615 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecTrack*)
1616 {
1617 ::TEvtRecTrack *ptr = 0;
1618 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecTrack >(0);
1619 static ::ROOT::TGenericClassInfo
1620 instance("TEvtRecTrack", ::TEvtRecTrack::Class_Version(), "TEvtRecTrack.h", 7,
1621 typeid(::TEvtRecTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1622 &::TEvtRecTrack::Dictionary, isa_proxy, 4,
1623 sizeof(::TEvtRecTrack) );
1624 instance.SetNew(&new_TEvtRecTrack);
1625 instance.SetNewArray(&newArray_TEvtRecTrack);
1626 instance.SetDelete(&delete_TEvtRecTrack);
1627 instance.SetDeleteArray(&deleteArray_TEvtRecTrack);
1628 instance.SetDestructor(&destruct_TEvtRecTrack);
1629 return &instance;
1630 }
1631 TGenericClassInfo *GenerateInitInstance(const ::TEvtRecTrack*)
1632 {
1633 return GenerateInitInstanceLocal((::TEvtRecTrack*)0);
1634 }
1635 // Static variable to force the class initialization
1636 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TEvtRecTrack*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1637} // end of namespace ROOT
1638
1639namespace ROOT {
1640 static void *new_TEvtRecPrimaryVertex(void *p = 0);
1641 static void *newArray_TEvtRecPrimaryVertex(Long_t size, void *p);
1642 static void delete_TEvtRecPrimaryVertex(void *p);
1643 static void deleteArray_TEvtRecPrimaryVertex(void *p);
1644 static void destruct_TEvtRecPrimaryVertex(void *p);
1645
1646 // Function generating the singleton type initializer
1647 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecPrimaryVertex*)
1648 {
1649 ::TEvtRecPrimaryVertex *ptr = 0;
1650 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecPrimaryVertex >(0);
1651 static ::ROOT::TGenericClassInfo
1652 instance("TEvtRecPrimaryVertex", ::TEvtRecPrimaryVertex::Class_Version(), "TEvtRecPrimaryVertex.h", 7,
1653 typeid(::TEvtRecPrimaryVertex), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1654 &::TEvtRecPrimaryVertex::Dictionary, isa_proxy, 4,
1655 sizeof(::TEvtRecPrimaryVertex) );
1656 instance.SetNew(&new_TEvtRecPrimaryVertex);
1657 instance.SetNewArray(&newArray_TEvtRecPrimaryVertex);
1658 instance.SetDelete(&delete_TEvtRecPrimaryVertex);
1659 instance.SetDeleteArray(&deleteArray_TEvtRecPrimaryVertex);
1660 instance.SetDestructor(&destruct_TEvtRecPrimaryVertex);
1661 return &instance;
1662 }
1663 TGenericClassInfo *GenerateInitInstance(const ::TEvtRecPrimaryVertex*)
1664 {
1665 return GenerateInitInstanceLocal((::TEvtRecPrimaryVertex*)0);
1666 }
1667 // Static variable to force the class initialization
1668 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TEvtRecPrimaryVertex*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1669} // end of namespace ROOT
1670
1671namespace ROOT {
1672 static void *new_TEvtRecVeeVertex(void *p = 0);
1673 static void *newArray_TEvtRecVeeVertex(Long_t size, void *p);
1674 static void delete_TEvtRecVeeVertex(void *p);
1675 static void deleteArray_TEvtRecVeeVertex(void *p);
1676 static void destruct_TEvtRecVeeVertex(void *p);
1677
1678 // Function generating the singleton type initializer
1679 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecVeeVertex*)
1680 {
1681 ::TEvtRecVeeVertex *ptr = 0;
1682 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecVeeVertex >(0);
1683 static ::ROOT::TGenericClassInfo
1684 instance("TEvtRecVeeVertex", ::TEvtRecVeeVertex::Class_Version(), "TEvtRecVeeVertex.h", 6,
1685 typeid(::TEvtRecVeeVertex), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1686 &::TEvtRecVeeVertex::Dictionary, isa_proxy, 4,
1687 sizeof(::TEvtRecVeeVertex) );
1688 instance.SetNew(&new_TEvtRecVeeVertex);
1689 instance.SetNewArray(&newArray_TEvtRecVeeVertex);
1690 instance.SetDelete(&delete_TEvtRecVeeVertex);
1691 instance.SetDeleteArray(&deleteArray_TEvtRecVeeVertex);
1692 instance.SetDestructor(&destruct_TEvtRecVeeVertex);
1693 return &instance;
1694 }
1695 TGenericClassInfo *GenerateInitInstance(const ::TEvtRecVeeVertex*)
1696 {
1697 return GenerateInitInstanceLocal((::TEvtRecVeeVertex*)0);
1698 }
1699 // Static variable to force the class initialization
1700 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TEvtRecVeeVertex*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1701} // end of namespace ROOT
1702
1703namespace ROOT {
1704 static void *new_TEvtRecPi0(void *p = 0);
1705 static void *newArray_TEvtRecPi0(Long_t size, void *p);
1706 static void delete_TEvtRecPi0(void *p);
1707 static void deleteArray_TEvtRecPi0(void *p);
1708 static void destruct_TEvtRecPi0(void *p);
1709
1710 // Function generating the singleton type initializer
1711 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecPi0*)
1712 {
1713 ::TEvtRecPi0 *ptr = 0;
1714 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecPi0 >(0);
1715 static ::ROOT::TGenericClassInfo
1716 instance("TEvtRecPi0", ::TEvtRecPi0::Class_Version(), "TEvtRecPi0.h", 8,
1717 typeid(::TEvtRecPi0), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1718 &::TEvtRecPi0::Dictionary, isa_proxy, 4,
1719 sizeof(::TEvtRecPi0) );
1720 instance.SetNew(&new_TEvtRecPi0);
1721 instance.SetNewArray(&newArray_TEvtRecPi0);
1722 instance.SetDelete(&delete_TEvtRecPi0);
1723 instance.SetDeleteArray(&deleteArray_TEvtRecPi0);
1724 instance.SetDestructor(&destruct_TEvtRecPi0);
1725 return &instance;
1726 }
1727 TGenericClassInfo *GenerateInitInstance(const ::TEvtRecPi0*)
1728 {
1729 return GenerateInitInstanceLocal((::TEvtRecPi0*)0);
1730 }
1731 // Static variable to force the class initialization
1732 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TEvtRecPi0*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1733} // end of namespace ROOT
1734
1735namespace ROOT {
1736 static void *new_TEvtRecEtaToGG(void *p = 0);
1737 static void *newArray_TEvtRecEtaToGG(Long_t size, void *p);
1738 static void delete_TEvtRecEtaToGG(void *p);
1739 static void deleteArray_TEvtRecEtaToGG(void *p);
1740 static void destruct_TEvtRecEtaToGG(void *p);
1741
1742 // Function generating the singleton type initializer
1743 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecEtaToGG*)
1744 {
1745 ::TEvtRecEtaToGG *ptr = 0;
1746 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecEtaToGG >(0);
1747 static ::ROOT::TGenericClassInfo
1748 instance("TEvtRecEtaToGG", ::TEvtRecEtaToGG::Class_Version(), "TEvtRecEtaToGG.h", 8,
1749 typeid(::TEvtRecEtaToGG), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1750 &::TEvtRecEtaToGG::Dictionary, isa_proxy, 4,
1751 sizeof(::TEvtRecEtaToGG) );
1752 instance.SetNew(&new_TEvtRecEtaToGG);
1753 instance.SetNewArray(&newArray_TEvtRecEtaToGG);
1754 instance.SetDelete(&delete_TEvtRecEtaToGG);
1755 instance.SetDeleteArray(&deleteArray_TEvtRecEtaToGG);
1756 instance.SetDestructor(&destruct_TEvtRecEtaToGG);
1757 return &instance;
1758 }
1759 TGenericClassInfo *GenerateInitInstance(const ::TEvtRecEtaToGG*)
1760 {
1761 return GenerateInitInstanceLocal((::TEvtRecEtaToGG*)0);
1762 }
1763 // Static variable to force the class initialization
1764 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TEvtRecEtaToGG*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1765} // end of namespace ROOT
1766
1767namespace ROOT {
1768 static void *new_TEvtRecDTag(void *p = 0);
1769 static void *newArray_TEvtRecDTag(Long_t size, void *p);
1770 static void delete_TEvtRecDTag(void *p);
1771 static void deleteArray_TEvtRecDTag(void *p);
1772 static void destruct_TEvtRecDTag(void *p);
1773
1774 // Function generating the singleton type initializer
1775 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecDTag*)
1776 {
1777 ::TEvtRecDTag *ptr = 0;
1778 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecDTag >(0);
1779 static ::ROOT::TGenericClassInfo
1780 instance("TEvtRecDTag", ::TEvtRecDTag::Class_Version(), "TEvtRecDTag.h", 8,
1781 typeid(::TEvtRecDTag), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1782 &::TEvtRecDTag::Dictionary, isa_proxy, 4,
1783 sizeof(::TEvtRecDTag) );
1784 instance.SetNew(&new_TEvtRecDTag);
1785 instance.SetNewArray(&newArray_TEvtRecDTag);
1786 instance.SetDelete(&delete_TEvtRecDTag);
1787 instance.SetDeleteArray(&deleteArray_TEvtRecDTag);
1788 instance.SetDestructor(&destruct_TEvtRecDTag);
1789 return &instance;
1790 }
1791 TGenericClassInfo *GenerateInitInstance(const ::TEvtRecDTag*)
1792 {
1793 return GenerateInitInstanceLocal((::TEvtRecDTag*)0);
1794 }
1795 // Static variable to force the class initialization
1796 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TEvtRecDTag*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1797} // end of namespace ROOT
1798
1799namespace ROOT {
1800 static void *new_TEvtRecObject(void *p = 0);
1801 static void *newArray_TEvtRecObject(Long_t size, void *p);
1802 static void delete_TEvtRecObject(void *p);
1803 static void deleteArray_TEvtRecObject(void *p);
1804 static void destruct_TEvtRecObject(void *p);
1805
1806 // Function generating the singleton type initializer
1807 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecObject*)
1808 {
1809 ::TEvtRecObject *ptr = 0;
1810 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecObject >(0);
1811 static ::ROOT::TGenericClassInfo
1812 instance("TEvtRecObject", ::TEvtRecObject::Class_Version(), "TEvtRecObject.h", 15,
1813 typeid(::TEvtRecObject), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1814 &::TEvtRecObject::Dictionary, isa_proxy, 4,
1815 sizeof(::TEvtRecObject) );
1816 instance.SetNew(&new_TEvtRecObject);
1817 instance.SetNewArray(&newArray_TEvtRecObject);
1818 instance.SetDelete(&delete_TEvtRecObject);
1819 instance.SetDeleteArray(&deleteArray_TEvtRecObject);
1820 instance.SetDestructor(&destruct_TEvtRecObject);
1821 return &instance;
1822 }
1823 TGenericClassInfo *GenerateInitInstance(const ::TEvtRecObject*)
1824 {
1825 return GenerateInitInstanceLocal((::TEvtRecObject*)0);
1826 }
1827 // Static variable to force the class initialization
1828 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TEvtRecObject*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1829} // end of namespace ROOT
1830
1831namespace ROOT {
1832 static void *new_TMcHitTof(void *p = 0);
1833 static void *newArray_TMcHitTof(Long_t size, void *p);
1834 static void delete_TMcHitTof(void *p);
1835 static void deleteArray_TMcHitTof(void *p);
1836 static void destruct_TMcHitTof(void *p);
1837
1838 // Function generating the singleton type initializer
1839 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMcHitTof*)
1840 {
1841 ::TMcHitTof *ptr = 0;
1842 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcHitTof >(0);
1843 static ::ROOT::TGenericClassInfo
1844 instance("TMcHitTof", ::TMcHitTof::Class_Version(), "TMcHitTof.h", 8,
1845 typeid(::TMcHitTof), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1846 &::TMcHitTof::Dictionary, isa_proxy, 4,
1847 sizeof(::TMcHitTof) );
1848 instance.SetNew(&new_TMcHitTof);
1849 instance.SetNewArray(&newArray_TMcHitTof);
1850 instance.SetDelete(&delete_TMcHitTof);
1851 instance.SetDeleteArray(&deleteArray_TMcHitTof);
1852 instance.SetDestructor(&destruct_TMcHitTof);
1853 return &instance;
1854 }
1855 TGenericClassInfo *GenerateInitInstance(const ::TMcHitTof*)
1856 {
1857 return GenerateInitInstanceLocal((::TMcHitTof*)0);
1858 }
1859 // Static variable to force the class initialization
1860 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TMcHitTof*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1861} // end of namespace ROOT
1862
1863namespace ROOT {
1864 static void *new_TMcHitMdc(void *p = 0);
1865 static void *newArray_TMcHitMdc(Long_t size, void *p);
1866 static void delete_TMcHitMdc(void *p);
1867 static void deleteArray_TMcHitMdc(void *p);
1868 static void destruct_TMcHitMdc(void *p);
1869
1870 // Function generating the singleton type initializer
1871 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMcHitMdc*)
1872 {
1873 ::TMcHitMdc *ptr = 0;
1874 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcHitMdc >(0);
1875 static ::ROOT::TGenericClassInfo
1876 instance("TMcHitMdc", ::TMcHitMdc::Class_Version(), "TMcHitMdc.h", 8,
1877 typeid(::TMcHitMdc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1878 &::TMcHitMdc::Dictionary, isa_proxy, 4,
1879 sizeof(::TMcHitMdc) );
1880 instance.SetNew(&new_TMcHitMdc);
1881 instance.SetNewArray(&newArray_TMcHitMdc);
1882 instance.SetDelete(&delete_TMcHitMdc);
1883 instance.SetDeleteArray(&deleteArray_TMcHitMdc);
1884 instance.SetDestructor(&destruct_TMcHitMdc);
1885 return &instance;
1886 }
1887 TGenericClassInfo *GenerateInitInstance(const ::TMcHitMdc*)
1888 {
1889 return GenerateInitInstanceLocal((::TMcHitMdc*)0);
1890 }
1891 // Static variable to force the class initialization
1892 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TMcHitMdc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1893} // end of namespace ROOT
1894
1895namespace ROOT {
1896 static void *new_TMcDigiEmc(void *p = 0);
1897 static void *newArray_TMcDigiEmc(Long_t size, void *p);
1898 static void delete_TMcDigiEmc(void *p);
1899 static void deleteArray_TMcDigiEmc(void *p);
1900 static void destruct_TMcDigiEmc(void *p);
1901
1902 // Function generating the singleton type initializer
1903 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMcDigiEmc*)
1904 {
1905 ::TMcDigiEmc *ptr = 0;
1906 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcDigiEmc >(0);
1907 static ::ROOT::TGenericClassInfo
1908 instance("TMcDigiEmc", ::TMcDigiEmc::Class_Version(), "TMcDigiEmc.h", 8,
1909 typeid(::TMcDigiEmc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1910 &::TMcDigiEmc::Dictionary, isa_proxy, 4,
1911 sizeof(::TMcDigiEmc) );
1912 instance.SetNew(&new_TMcDigiEmc);
1913 instance.SetNewArray(&newArray_TMcDigiEmc);
1914 instance.SetDelete(&delete_TMcDigiEmc);
1915 instance.SetDeleteArray(&deleteArray_TMcDigiEmc);
1916 instance.SetDestructor(&destruct_TMcDigiEmc);
1917 return &instance;
1918 }
1919 TGenericClassInfo *GenerateInitInstance(const ::TMcDigiEmc*)
1920 {
1921 return GenerateInitInstanceLocal((::TMcDigiEmc*)0);
1922 }
1923 // Static variable to force the class initialization
1924 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TMcDigiEmc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1925} // end of namespace ROOT
1926
1927namespace ROOT {
1928 static void *new_TMcHitEvent(void *p = 0);
1929 static void *newArray_TMcHitEvent(Long_t size, void *p);
1930 static void delete_TMcHitEvent(void *p);
1931 static void deleteArray_TMcHitEvent(void *p);
1932 static void destruct_TMcHitEvent(void *p);
1933
1934 // Function generating the singleton type initializer
1935 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMcHitEvent*)
1936 {
1937 ::TMcHitEvent *ptr = 0;
1938 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcHitEvent >(0);
1939 static ::ROOT::TGenericClassInfo
1940 instance("TMcHitEvent", ::TMcHitEvent::Class_Version(), "TMcHitEvent.h", 12,
1941 typeid(::TMcHitEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1942 &::TMcHitEvent::Dictionary, isa_proxy, 4,
1943 sizeof(::TMcHitEvent) );
1944 instance.SetNew(&new_TMcHitEvent);
1945 instance.SetNewArray(&newArray_TMcHitEvent);
1946 instance.SetDelete(&delete_TMcHitEvent);
1947 instance.SetDeleteArray(&deleteArray_TMcHitEvent);
1948 instance.SetDestructor(&destruct_TMcHitEvent);
1949 return &instance;
1950 }
1951 TGenericClassInfo *GenerateInitInstance(const ::TMcHitEvent*)
1952 {
1953 return GenerateInitInstanceLocal((::TMcHitEvent*)0);
1954 }
1955 // Static variable to force the class initialization
1956 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TMcHitEvent*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1957} // end of namespace ROOT
1958
1959namespace ROOT {
1960 static void *new_TBossFullEvent(void *p = 0);
1961 static void *newArray_TBossFullEvent(Long_t size, void *p);
1962 static void delete_TBossFullEvent(void *p);
1963 static void deleteArray_TBossFullEvent(void *p);
1964 static void destruct_TBossFullEvent(void *p);
1965 static void streamer_TBossFullEvent(TBuffer &buf, void *obj);
1966
1967 // Function generating the singleton type initializer
1968 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TBossFullEvent*)
1969 {
1970 ::TBossFullEvent *ptr = 0;
1971 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TBossFullEvent >(0);
1972 static ::ROOT::TGenericClassInfo
1973 instance("TBossFullEvent", ::TBossFullEvent::Class_Version(), "TBossFullEvent.h", 14,
1974 typeid(::TBossFullEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1975 &::TBossFullEvent::Dictionary, isa_proxy, 17,
1976 sizeof(::TBossFullEvent) );
1977 instance.SetNew(&new_TBossFullEvent);
1978 instance.SetNewArray(&newArray_TBossFullEvent);
1979 instance.SetDelete(&delete_TBossFullEvent);
1980 instance.SetDeleteArray(&deleteArray_TBossFullEvent);
1981 instance.SetDestructor(&destruct_TBossFullEvent);
1982 instance.SetStreamerFunc(&streamer_TBossFullEvent);
1983 return &instance;
1984 }
1985 TGenericClassInfo *GenerateInitInstance(const ::TBossFullEvent*)
1986 {
1987 return GenerateInitInstanceLocal((::TBossFullEvent*)0);
1988 }
1989 // Static variable to force the class initialization
1990 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TBossFullEvent*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1991} // end of namespace ROOT
1992
1993//______________________________________________________________________________
1994atomic_TClass_ptr TJobInfo::fgIsA(0); // static to hold class pointer
1995
1996//______________________________________________________________________________
1997const char *TJobInfo::Class_Name()
1998{
1999 return "TJobInfo";
2000}
2001
2002//______________________________________________________________________________
2003const char *TJobInfo::ImplFileName()
2004{
2005 return ::ROOT::GenerateInitInstanceLocal((const ::TJobInfo*)0x0)->GetImplFileName();
2006}
2007
2008//______________________________________________________________________________
2009int TJobInfo::ImplFileLine()
2010{
2011 return ::ROOT::GenerateInitInstanceLocal((const ::TJobInfo*)0x0)->GetImplFileLine();
2012}
2013
2014//______________________________________________________________________________
2015TClass *TJobInfo::Dictionary()
2016{
2017 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TJobInfo*)0x0)->GetClass();
2018 return fgIsA;
2019}
2020
2021//______________________________________________________________________________
2022TClass *TJobInfo::Class()
2023{
2024 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TJobInfo*)0x0)->GetClass(); }
2025 return fgIsA;
2026}
2027
2028//______________________________________________________________________________
2029atomic_TClass_ptr TRawData::fgIsA(0); // static to hold class pointer
2030
2031//______________________________________________________________________________
2032const char *TRawData::Class_Name()
2033{
2034 return "TRawData";
2035}
2036
2037//______________________________________________________________________________
2038const char *TRawData::ImplFileName()
2039{
2040 return ::ROOT::GenerateInitInstanceLocal((const ::TRawData*)0x0)->GetImplFileName();
2041}
2042
2043//______________________________________________________________________________
2044int TRawData::ImplFileLine()
2045{
2046 return ::ROOT::GenerateInitInstanceLocal((const ::TRawData*)0x0)->GetImplFileLine();
2047}
2048
2049//______________________________________________________________________________
2050TClass *TRawData::Dictionary()
2051{
2052 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRawData*)0x0)->GetClass();
2053 return fgIsA;
2054}
2055
2056//______________________________________________________________________________
2057TClass *TRawData::Class()
2058{
2059 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRawData*)0x0)->GetClass(); }
2060 return fgIsA;
2061}
2062
2063//______________________________________________________________________________
2064atomic_TClass_ptr TMdcDigi::fgIsA(0); // static to hold class pointer
2065
2066//______________________________________________________________________________
2067const char *TMdcDigi::Class_Name()
2068{
2069 return "TMdcDigi";
2070}
2071
2072//______________________________________________________________________________
2073const char *TMdcDigi::ImplFileName()
2074{
2075 return ::ROOT::GenerateInitInstanceLocal((const ::TMdcDigi*)0x0)->GetImplFileName();
2076}
2077
2078//______________________________________________________________________________
2079int TMdcDigi::ImplFileLine()
2080{
2081 return ::ROOT::GenerateInitInstanceLocal((const ::TMdcDigi*)0x0)->GetImplFileLine();
2082}
2083
2084//______________________________________________________________________________
2085TClass *TMdcDigi::Dictionary()
2086{
2087 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcDigi*)0x0)->GetClass();
2088 return fgIsA;
2089}
2090
2091//______________________________________________________________________________
2092TClass *TMdcDigi::Class()
2093{
2094 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcDigi*)0x0)->GetClass(); }
2095 return fgIsA;
2096}
2097
2098//______________________________________________________________________________
2099atomic_TClass_ptr TEmcDigi::fgIsA(0); // static to hold class pointer
2100
2101//______________________________________________________________________________
2102const char *TEmcDigi::Class_Name()
2103{
2104 return "TEmcDigi";
2105}
2106
2107//______________________________________________________________________________
2108const char *TEmcDigi::ImplFileName()
2109{
2110 return ::ROOT::GenerateInitInstanceLocal((const ::TEmcDigi*)0x0)->GetImplFileName();
2111}
2112
2113//______________________________________________________________________________
2114int TEmcDigi::ImplFileLine()
2115{
2116 return ::ROOT::GenerateInitInstanceLocal((const ::TEmcDigi*)0x0)->GetImplFileLine();
2117}
2118
2119//______________________________________________________________________________
2120TClass *TEmcDigi::Dictionary()
2121{
2122 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEmcDigi*)0x0)->GetClass();
2123 return fgIsA;
2124}
2125
2126//______________________________________________________________________________
2127TClass *TEmcDigi::Class()
2128{
2129 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEmcDigi*)0x0)->GetClass(); }
2130 return fgIsA;
2131}
2132
2133//______________________________________________________________________________
2134atomic_TClass_ptr TTofDigi::fgIsA(0); // static to hold class pointer
2135
2136//______________________________________________________________________________
2137const char *TTofDigi::Class_Name()
2138{
2139 return "TTofDigi";
2140}
2141
2142//______________________________________________________________________________
2143const char *TTofDigi::ImplFileName()
2144{
2145 return ::ROOT::GenerateInitInstanceLocal((const ::TTofDigi*)0x0)->GetImplFileName();
2146}
2147
2148//______________________________________________________________________________
2149int TTofDigi::ImplFileLine()
2150{
2151 return ::ROOT::GenerateInitInstanceLocal((const ::TTofDigi*)0x0)->GetImplFileLine();
2152}
2153
2154//______________________________________________________________________________
2155TClass *TTofDigi::Dictionary()
2156{
2157 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTofDigi*)0x0)->GetClass();
2158 return fgIsA;
2159}
2160
2161//______________________________________________________________________________
2162TClass *TTofDigi::Class()
2163{
2164 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTofDigi*)0x0)->GetClass(); }
2165 return fgIsA;
2166}
2167
2168//______________________________________________________________________________
2169atomic_TClass_ptr TMucDigi::fgIsA(0); // static to hold class pointer
2170
2171//______________________________________________________________________________
2172const char *TMucDigi::Class_Name()
2173{
2174 return "TMucDigi";
2175}
2176
2177//______________________________________________________________________________
2178const char *TMucDigi::ImplFileName()
2179{
2180 return ::ROOT::GenerateInitInstanceLocal((const ::TMucDigi*)0x0)->GetImplFileName();
2181}
2182
2183//______________________________________________________________________________
2184int TMucDigi::ImplFileLine()
2185{
2186 return ::ROOT::GenerateInitInstanceLocal((const ::TMucDigi*)0x0)->GetImplFileLine();
2187}
2188
2189//______________________________________________________________________________
2190TClass *TMucDigi::Dictionary()
2191{
2192 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMucDigi*)0x0)->GetClass();
2193 return fgIsA;
2194}
2195
2196//______________________________________________________________________________
2197TClass *TMucDigi::Class()
2198{
2199 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMucDigi*)0x0)->GetClass(); }
2200 return fgIsA;
2201}
2202
2203//______________________________________________________________________________
2204atomic_TClass_ptr TLumiDigi::fgIsA(0); // static to hold class pointer
2205
2206//______________________________________________________________________________
2207const char *TLumiDigi::Class_Name()
2208{
2209 return "TLumiDigi";
2210}
2211
2212//______________________________________________________________________________
2213const char *TLumiDigi::ImplFileName()
2214{
2215 return ::ROOT::GenerateInitInstanceLocal((const ::TLumiDigi*)0x0)->GetImplFileName();
2216}
2217
2218//______________________________________________________________________________
2219int TLumiDigi::ImplFileLine()
2220{
2221 return ::ROOT::GenerateInitInstanceLocal((const ::TLumiDigi*)0x0)->GetImplFileLine();
2222}
2223
2224//______________________________________________________________________________
2225TClass *TLumiDigi::Dictionary()
2226{
2227 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TLumiDigi*)0x0)->GetClass();
2228 return fgIsA;
2229}
2230
2231//______________________________________________________________________________
2232TClass *TLumiDigi::Class()
2233{
2234 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TLumiDigi*)0x0)->GetClass(); }
2235 return fgIsA;
2236}
2237
2238//______________________________________________________________________________
2239atomic_TClass_ptr TDigiEvent::fgIsA(0); // static to hold class pointer
2240
2241//______________________________________________________________________________
2242const char *TDigiEvent::Class_Name()
2243{
2244 return "TDigiEvent";
2245}
2246
2247//______________________________________________________________________________
2248const char *TDigiEvent::ImplFileName()
2249{
2250 return ::ROOT::GenerateInitInstanceLocal((const ::TDigiEvent*)0x0)->GetImplFileName();
2251}
2252
2253//______________________________________________________________________________
2254int TDigiEvent::ImplFileLine()
2255{
2256 return ::ROOT::GenerateInitInstanceLocal((const ::TDigiEvent*)0x0)->GetImplFileLine();
2257}
2258
2259//______________________________________________________________________________
2260TClass *TDigiEvent::Dictionary()
2261{
2262 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDigiEvent*)0x0)->GetClass();
2263 return fgIsA;
2264}
2265
2266//______________________________________________________________________________
2267TClass *TDigiEvent::Class()
2268{
2269 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDigiEvent*)0x0)->GetClass(); }
2270 return fgIsA;
2271}
2272
2273//______________________________________________________________________________
2274atomic_TClass_ptr TRecMdcTrack::fgIsA(0); // static to hold class pointer
2275
2276//______________________________________________________________________________
2277const char *TRecMdcTrack::Class_Name()
2278{
2279 return "TRecMdcTrack";
2280}
2281
2282//______________________________________________________________________________
2283const char *TRecMdcTrack::ImplFileName()
2284{
2285 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcTrack*)0x0)->GetImplFileName();
2286}
2287
2288//______________________________________________________________________________
2289int TRecMdcTrack::ImplFileLine()
2290{
2291 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcTrack*)0x0)->GetImplFileLine();
2292}
2293
2294//______________________________________________________________________________
2295TClass *TRecMdcTrack::Dictionary()
2296{
2297 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcTrack*)0x0)->GetClass();
2298 return fgIsA;
2299}
2300
2301//______________________________________________________________________________
2302TClass *TRecMdcTrack::Class()
2303{
2304 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcTrack*)0x0)->GetClass(); }
2305 return fgIsA;
2306}
2307
2308//______________________________________________________________________________
2309atomic_TClass_ptr TRecMdcKalTrack::fgIsA(0); // static to hold class pointer
2310
2311//______________________________________________________________________________
2312const char *TRecMdcKalTrack::Class_Name()
2313{
2314 return "TRecMdcKalTrack";
2315}
2316
2317//______________________________________________________________________________
2318const char *TRecMdcKalTrack::ImplFileName()
2319{
2320 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalTrack*)0x0)->GetImplFileName();
2321}
2322
2323//______________________________________________________________________________
2324int TRecMdcKalTrack::ImplFileLine()
2325{
2326 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalTrack*)0x0)->GetImplFileLine();
2327}
2328
2329//______________________________________________________________________________
2330TClass *TRecMdcKalTrack::Dictionary()
2331{
2332 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalTrack*)0x0)->GetClass();
2333 return fgIsA;
2334}
2335
2336//______________________________________________________________________________
2337TClass *TRecMdcKalTrack::Class()
2338{
2339 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalTrack*)0x0)->GetClass(); }
2340 return fgIsA;
2341}
2342
2343//______________________________________________________________________________
2344atomic_TClass_ptr TRecMdcHit::fgIsA(0); // static to hold class pointer
2345
2346//______________________________________________________________________________
2347const char *TRecMdcHit::Class_Name()
2348{
2349 return "TRecMdcHit";
2350}
2351
2352//______________________________________________________________________________
2353const char *TRecMdcHit::ImplFileName()
2354{
2355 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcHit*)0x0)->GetImplFileName();
2356}
2357
2358//______________________________________________________________________________
2359int TRecMdcHit::ImplFileLine()
2360{
2361 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcHit*)0x0)->GetImplFileLine();
2362}
2363
2364//______________________________________________________________________________
2365TClass *TRecMdcHit::Dictionary()
2366{
2367 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcHit*)0x0)->GetClass();
2368 return fgIsA;
2369}
2370
2371//______________________________________________________________________________
2372TClass *TRecMdcHit::Class()
2373{
2374 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcHit*)0x0)->GetClass(); }
2375 return fgIsA;
2376}
2377
2378//______________________________________________________________________________
2379atomic_TClass_ptr TTofTrack::fgIsA(0); // static to hold class pointer
2380
2381//______________________________________________________________________________
2382const char *TTofTrack::Class_Name()
2383{
2384 return "TTofTrack";
2385}
2386
2387//______________________________________________________________________________
2388const char *TTofTrack::ImplFileName()
2389{
2390 return ::ROOT::GenerateInitInstanceLocal((const ::TTofTrack*)0x0)->GetImplFileName();
2391}
2392
2393//______________________________________________________________________________
2394int TTofTrack::ImplFileLine()
2395{
2396 return ::ROOT::GenerateInitInstanceLocal((const ::TTofTrack*)0x0)->GetImplFileLine();
2397}
2398
2399//______________________________________________________________________________
2400TClass *TTofTrack::Dictionary()
2401{
2402 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTofTrack*)0x0)->GetClass();
2403 return fgIsA;
2404}
2405
2406//______________________________________________________________________________
2407TClass *TTofTrack::Class()
2408{
2409 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTofTrack*)0x0)->GetClass(); }
2410 return fgIsA;
2411}
2412
2413//______________________________________________________________________________
2414atomic_TClass_ptr TRecTofTrack::fgIsA(0); // static to hold class pointer
2415
2416//______________________________________________________________________________
2417const char *TRecTofTrack::Class_Name()
2418{
2419 return "TRecTofTrack";
2420}
2421
2422//______________________________________________________________________________
2423const char *TRecTofTrack::ImplFileName()
2424{
2425 return ::ROOT::GenerateInitInstanceLocal((const ::TRecTofTrack*)0x0)->GetImplFileName();
2426}
2427
2428//______________________________________________________________________________
2429int TRecTofTrack::ImplFileLine()
2430{
2431 return ::ROOT::GenerateInitInstanceLocal((const ::TRecTofTrack*)0x0)->GetImplFileLine();
2432}
2433
2434//______________________________________________________________________________
2435TClass *TRecTofTrack::Dictionary()
2436{
2437 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecTofTrack*)0x0)->GetClass();
2438 return fgIsA;
2439}
2440
2441//______________________________________________________________________________
2442TClass *TRecTofTrack::Class()
2443{
2444 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecTofTrack*)0x0)->GetClass(); }
2445 return fgIsA;
2446}
2447
2448//______________________________________________________________________________
2449atomic_TClass_ptr TRecEmcHit::fgIsA(0); // static to hold class pointer
2450
2451//______________________________________________________________________________
2452const char *TRecEmcHit::Class_Name()
2453{
2454 return "TRecEmcHit";
2455}
2456
2457//______________________________________________________________________________
2458const char *TRecEmcHit::ImplFileName()
2459{
2460 return ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcHit*)0x0)->GetImplFileName();
2461}
2462
2463//______________________________________________________________________________
2464int TRecEmcHit::ImplFileLine()
2465{
2466 return ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcHit*)0x0)->GetImplFileLine();
2467}
2468
2469//______________________________________________________________________________
2470TClass *TRecEmcHit::Dictionary()
2471{
2472 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcHit*)0x0)->GetClass();
2473 return fgIsA;
2474}
2475
2476//______________________________________________________________________________
2477TClass *TRecEmcHit::Class()
2478{
2479 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcHit*)0x0)->GetClass(); }
2480 return fgIsA;
2481}
2482
2483//______________________________________________________________________________
2484atomic_TClass_ptr TRecEmcCluster::fgIsA(0); // static to hold class pointer
2485
2486//______________________________________________________________________________
2487const char *TRecEmcCluster::Class_Name()
2488{
2489 return "TRecEmcCluster";
2490}
2491
2492//______________________________________________________________________________
2493const char *TRecEmcCluster::ImplFileName()
2494{
2495 return ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcCluster*)0x0)->GetImplFileName();
2496}
2497
2498//______________________________________________________________________________
2499int TRecEmcCluster::ImplFileLine()
2500{
2501 return ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcCluster*)0x0)->GetImplFileLine();
2502}
2503
2504//______________________________________________________________________________
2505TClass *TRecEmcCluster::Dictionary()
2506{
2507 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcCluster*)0x0)->GetClass();
2508 return fgIsA;
2509}
2510
2511//______________________________________________________________________________
2512TClass *TRecEmcCluster::Class()
2513{
2514 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcCluster*)0x0)->GetClass(); }
2515 return fgIsA;
2516}
2517
2518//______________________________________________________________________________
2519atomic_TClass_ptr TRecEmcShower::fgIsA(0); // static to hold class pointer
2520
2521//______________________________________________________________________________
2522const char *TRecEmcShower::Class_Name()
2523{
2524 return "TRecEmcShower";
2525}
2526
2527//______________________________________________________________________________
2528const char *TRecEmcShower::ImplFileName()
2529{
2530 return ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcShower*)0x0)->GetImplFileName();
2531}
2532
2533//______________________________________________________________________________
2534int TRecEmcShower::ImplFileLine()
2535{
2536 return ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcShower*)0x0)->GetImplFileLine();
2537}
2538
2539//______________________________________________________________________________
2540TClass *TRecEmcShower::Dictionary()
2541{
2542 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcShower*)0x0)->GetClass();
2543 return fgIsA;
2544}
2545
2546//______________________________________________________________________________
2547TClass *TRecEmcShower::Class()
2548{
2549 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcShower*)0x0)->GetClass(); }
2550 return fgIsA;
2551}
2552
2553//______________________________________________________________________________
2554atomic_TClass_ptr TRecMucTrack::fgIsA(0); // static to hold class pointer
2555
2556//______________________________________________________________________________
2557const char *TRecMucTrack::Class_Name()
2558{
2559 return "TRecMucTrack";
2560}
2561
2562//______________________________________________________________________________
2563const char *TRecMucTrack::ImplFileName()
2564{
2565 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMucTrack*)0x0)->GetImplFileName();
2566}
2567
2568//______________________________________________________________________________
2569int TRecMucTrack::ImplFileLine()
2570{
2571 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMucTrack*)0x0)->GetImplFileLine();
2572}
2573
2574//______________________________________________________________________________
2575TClass *TRecMucTrack::Dictionary()
2576{
2577 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMucTrack*)0x0)->GetClass();
2578 return fgIsA;
2579}
2580
2581//______________________________________________________________________________
2582TClass *TRecMucTrack::Class()
2583{
2584 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMucTrack*)0x0)->GetClass(); }
2585 return fgIsA;
2586}
2587
2588//______________________________________________________________________________
2589atomic_TClass_ptr TRecMdcDedx::fgIsA(0); // static to hold class pointer
2590
2591//______________________________________________________________________________
2592const char *TRecMdcDedx::Class_Name()
2593{
2594 return "TRecMdcDedx";
2595}
2596
2597//______________________________________________________________________________
2598const char *TRecMdcDedx::ImplFileName()
2599{
2600 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedx*)0x0)->GetImplFileName();
2601}
2602
2603//______________________________________________________________________________
2604int TRecMdcDedx::ImplFileLine()
2605{
2606 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedx*)0x0)->GetImplFileLine();
2607}
2608
2609//______________________________________________________________________________
2610TClass *TRecMdcDedx::Dictionary()
2611{
2612 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedx*)0x0)->GetClass();
2613 return fgIsA;
2614}
2615
2616//______________________________________________________________________________
2617TClass *TRecMdcDedx::Class()
2618{
2619 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedx*)0x0)->GetClass(); }
2620 return fgIsA;
2621}
2622
2623//______________________________________________________________________________
2624atomic_TClass_ptr TRecMdcDedxHit::fgIsA(0); // static to hold class pointer
2625
2626//______________________________________________________________________________
2627const char *TRecMdcDedxHit::Class_Name()
2628{
2629 return "TRecMdcDedxHit";
2630}
2631
2632//______________________________________________________________________________
2633const char *TRecMdcDedxHit::ImplFileName()
2634{
2635 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedxHit*)0x0)->GetImplFileName();
2636}
2637
2638//______________________________________________________________________________
2639int TRecMdcDedxHit::ImplFileLine()
2640{
2641 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedxHit*)0x0)->GetImplFileLine();
2642}
2643
2644//______________________________________________________________________________
2645TClass *TRecMdcDedxHit::Dictionary()
2646{
2647 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedxHit*)0x0)->GetClass();
2648 return fgIsA;
2649}
2650
2651//______________________________________________________________________________
2652TClass *TRecMdcDedxHit::Class()
2653{
2654 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedxHit*)0x0)->GetClass(); }
2655 return fgIsA;
2656}
2657
2658//______________________________________________________________________________
2659atomic_TClass_ptr TRecExtTrack::fgIsA(0); // static to hold class pointer
2660
2661//______________________________________________________________________________
2662const char *TRecExtTrack::Class_Name()
2663{
2664 return "TRecExtTrack";
2665}
2666
2667//______________________________________________________________________________
2668const char *TRecExtTrack::ImplFileName()
2669{
2670 return ::ROOT::GenerateInitInstanceLocal((const ::TRecExtTrack*)0x0)->GetImplFileName();
2671}
2672
2673//______________________________________________________________________________
2674int TRecExtTrack::ImplFileLine()
2675{
2676 return ::ROOT::GenerateInitInstanceLocal((const ::TRecExtTrack*)0x0)->GetImplFileLine();
2677}
2678
2679//______________________________________________________________________________
2680TClass *TRecExtTrack::Dictionary()
2681{
2682 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecExtTrack*)0x0)->GetClass();
2683 return fgIsA;
2684}
2685
2686//______________________________________________________________________________
2687TClass *TRecExtTrack::Class()
2688{
2689 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecExtTrack*)0x0)->GetClass(); }
2690 return fgIsA;
2691}
2692
2693//______________________________________________________________________________
2694atomic_TClass_ptr TRecEvTime::fgIsA(0); // static to hold class pointer
2695
2696//______________________________________________________________________________
2697const char *TRecEvTime::Class_Name()
2698{
2699 return "TRecEvTime";
2700}
2701
2702//______________________________________________________________________________
2703const char *TRecEvTime::ImplFileName()
2704{
2705 return ::ROOT::GenerateInitInstanceLocal((const ::TRecEvTime*)0x0)->GetImplFileName();
2706}
2707
2708//______________________________________________________________________________
2709int TRecEvTime::ImplFileLine()
2710{
2711 return ::ROOT::GenerateInitInstanceLocal((const ::TRecEvTime*)0x0)->GetImplFileLine();
2712}
2713
2714//______________________________________________________________________________
2715TClass *TRecEvTime::Dictionary()
2716{
2717 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEvTime*)0x0)->GetClass();
2718 return fgIsA;
2719}
2720
2721//______________________________________________________________________________
2722TClass *TRecEvTime::Class()
2723{
2724 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEvTime*)0x0)->GetClass(); }
2725 return fgIsA;
2726}
2727
2728//______________________________________________________________________________
2729atomic_TClass_ptr TRecMdcKalHelixSeg::fgIsA(0); // static to hold class pointer
2730
2731//______________________________________________________________________________
2732const char *TRecMdcKalHelixSeg::Class_Name()
2733{
2734 return "TRecMdcKalHelixSeg";
2735}
2736
2737//______________________________________________________________________________
2738const char *TRecMdcKalHelixSeg::ImplFileName()
2739{
2740 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalHelixSeg*)0x0)->GetImplFileName();
2741}
2742
2743//______________________________________________________________________________
2744int TRecMdcKalHelixSeg::ImplFileLine()
2745{
2746 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalHelixSeg*)0x0)->GetImplFileLine();
2747}
2748
2749//______________________________________________________________________________
2750TClass *TRecMdcKalHelixSeg::Dictionary()
2751{
2752 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalHelixSeg*)0x0)->GetClass();
2753 return fgIsA;
2754}
2755
2756//______________________________________________________________________________
2757TClass *TRecMdcKalHelixSeg::Class()
2758{
2759 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalHelixSeg*)0x0)->GetClass(); }
2760 return fgIsA;
2761}
2762
2763//______________________________________________________________________________
2764atomic_TClass_ptr TRecZddChannel::fgIsA(0); // static to hold class pointer
2765
2766//______________________________________________________________________________
2767const char *TRecZddChannel::Class_Name()
2768{
2769 return "TRecZddChannel";
2770}
2771
2772//______________________________________________________________________________
2773const char *TRecZddChannel::ImplFileName()
2774{
2775 return ::ROOT::GenerateInitInstanceLocal((const ::TRecZddChannel*)0x0)->GetImplFileName();
2776}
2777
2778//______________________________________________________________________________
2779int TRecZddChannel::ImplFileLine()
2780{
2781 return ::ROOT::GenerateInitInstanceLocal((const ::TRecZddChannel*)0x0)->GetImplFileLine();
2782}
2783
2784//______________________________________________________________________________
2785TClass *TRecZddChannel::Dictionary()
2786{
2787 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecZddChannel*)0x0)->GetClass();
2788 return fgIsA;
2789}
2790
2791//______________________________________________________________________________
2792TClass *TRecZddChannel::Class()
2793{
2794 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecZddChannel*)0x0)->GetClass(); }
2795 return fgIsA;
2796}
2797
2798//______________________________________________________________________________
2799atomic_TClass_ptr TRecTrackEvent::fgIsA(0); // static to hold class pointer
2800
2801//______________________________________________________________________________
2802const char *TRecTrackEvent::Class_Name()
2803{
2804 return "TRecTrackEvent";
2805}
2806
2807//______________________________________________________________________________
2808const char *TRecTrackEvent::ImplFileName()
2809{
2810 return ::ROOT::GenerateInitInstanceLocal((const ::TRecTrackEvent*)0x0)->GetImplFileName();
2811}
2812
2813//______________________________________________________________________________
2814int TRecTrackEvent::ImplFileLine()
2815{
2816 return ::ROOT::GenerateInitInstanceLocal((const ::TRecTrackEvent*)0x0)->GetImplFileLine();
2817}
2818
2819//______________________________________________________________________________
2820TClass *TRecTrackEvent::Dictionary()
2821{
2822 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecTrackEvent*)0x0)->GetClass();
2823 return fgIsA;
2824}
2825
2826//______________________________________________________________________________
2827TClass *TRecTrackEvent::Class()
2828{
2829 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecTrackEvent*)0x0)->GetClass(); }
2830 return fgIsA;
2831}
2832
2833//______________________________________________________________________________
2834atomic_TClass_ptr TMdcTrack::fgIsA(0); // static to hold class pointer
2835
2836//______________________________________________________________________________
2837const char *TMdcTrack::Class_Name()
2838{
2839 return "TMdcTrack";
2840}
2841
2842//______________________________________________________________________________
2843const char *TMdcTrack::ImplFileName()
2844{
2845 return ::ROOT::GenerateInitInstanceLocal((const ::TMdcTrack*)0x0)->GetImplFileName();
2846}
2847
2848//______________________________________________________________________________
2849int TMdcTrack::ImplFileLine()
2850{
2851 return ::ROOT::GenerateInitInstanceLocal((const ::TMdcTrack*)0x0)->GetImplFileLine();
2852}
2853
2854//______________________________________________________________________________
2855TClass *TMdcTrack::Dictionary()
2856{
2857 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcTrack*)0x0)->GetClass();
2858 return fgIsA;
2859}
2860
2861//______________________________________________________________________________
2862TClass *TMdcTrack::Class()
2863{
2864 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcTrack*)0x0)->GetClass(); }
2865 return fgIsA;
2866}
2867
2868//______________________________________________________________________________
2869atomic_TClass_ptr TEmcTrack::fgIsA(0); // static to hold class pointer
2870
2871//______________________________________________________________________________
2872const char *TEmcTrack::Class_Name()
2873{
2874 return "TEmcTrack";
2875}
2876
2877//______________________________________________________________________________
2878const char *TEmcTrack::ImplFileName()
2879{
2880 return ::ROOT::GenerateInitInstanceLocal((const ::TEmcTrack*)0x0)->GetImplFileName();
2881}
2882
2883//______________________________________________________________________________
2884int TEmcTrack::ImplFileLine()
2885{
2886 return ::ROOT::GenerateInitInstanceLocal((const ::TEmcTrack*)0x0)->GetImplFileLine();
2887}
2888
2889//______________________________________________________________________________
2890TClass *TEmcTrack::Dictionary()
2891{
2892 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEmcTrack*)0x0)->GetClass();
2893 return fgIsA;
2894}
2895
2896//______________________________________________________________________________
2897TClass *TEmcTrack::Class()
2898{
2899 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEmcTrack*)0x0)->GetClass(); }
2900 return fgIsA;
2901}
2902
2903//______________________________________________________________________________
2904atomic_TClass_ptr TMucTrack::fgIsA(0); // static to hold class pointer
2905
2906//______________________________________________________________________________
2907const char *TMucTrack::Class_Name()
2908{
2909 return "TMucTrack";
2910}
2911
2912//______________________________________________________________________________
2913const char *TMucTrack::ImplFileName()
2914{
2915 return ::ROOT::GenerateInitInstanceLocal((const ::TMucTrack*)0x0)->GetImplFileName();
2916}
2917
2918//______________________________________________________________________________
2919int TMucTrack::ImplFileLine()
2920{
2921 return ::ROOT::GenerateInitInstanceLocal((const ::TMucTrack*)0x0)->GetImplFileLine();
2922}
2923
2924//______________________________________________________________________________
2925TClass *TMucTrack::Dictionary()
2926{
2927 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMucTrack*)0x0)->GetClass();
2928 return fgIsA;
2929}
2930
2931//______________________________________________________________________________
2932TClass *TMucTrack::Class()
2933{
2934 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMucTrack*)0x0)->GetClass(); }
2935 return fgIsA;
2936}
2937
2938//______________________________________________________________________________
2939atomic_TClass_ptr TMdcDedx::fgIsA(0); // static to hold class pointer
2940
2941//______________________________________________________________________________
2942const char *TMdcDedx::Class_Name()
2943{
2944 return "TMdcDedx";
2945}
2946
2947//______________________________________________________________________________
2948const char *TMdcDedx::ImplFileName()
2949{
2950 return ::ROOT::GenerateInitInstanceLocal((const ::TMdcDedx*)0x0)->GetImplFileName();
2951}
2952
2953//______________________________________________________________________________
2954int TMdcDedx::ImplFileLine()
2955{
2956 return ::ROOT::GenerateInitInstanceLocal((const ::TMdcDedx*)0x0)->GetImplFileLine();
2957}
2958
2959//______________________________________________________________________________
2960TClass *TMdcDedx::Dictionary()
2961{
2962 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcDedx*)0x0)->GetClass();
2963 return fgIsA;
2964}
2965
2966//______________________________________________________________________________
2967TClass *TMdcDedx::Class()
2968{
2969 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcDedx*)0x0)->GetClass(); }
2970 return fgIsA;
2971}
2972
2973//______________________________________________________________________________
2974atomic_TClass_ptr TExtTrack::fgIsA(0); // static to hold class pointer
2975
2976//______________________________________________________________________________
2977const char *TExtTrack::Class_Name()
2978{
2979 return "TExtTrack";
2980}
2981
2982//______________________________________________________________________________
2983const char *TExtTrack::ImplFileName()
2984{
2985 return ::ROOT::GenerateInitInstanceLocal((const ::TExtTrack*)0x0)->GetImplFileName();
2986}
2987
2988//______________________________________________________________________________
2989int TExtTrack::ImplFileLine()
2990{
2991 return ::ROOT::GenerateInitInstanceLocal((const ::TExtTrack*)0x0)->GetImplFileLine();
2992}
2993
2994//______________________________________________________________________________
2995TClass *TExtTrack::Dictionary()
2996{
2997 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TExtTrack*)0x0)->GetClass();
2998 return fgIsA;
2999}
3000
3001//______________________________________________________________________________
3002TClass *TExtTrack::Class()
3003{
3004 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TExtTrack*)0x0)->GetClass(); }
3005 return fgIsA;
3006}
3007
3008//______________________________________________________________________________
3009atomic_TClass_ptr TMdcKalTrack::fgIsA(0); // static to hold class pointer
3010
3011//______________________________________________________________________________
3012const char *TMdcKalTrack::Class_Name()
3013{
3014 return "TMdcKalTrack";
3015}
3016
3017//______________________________________________________________________________
3018const char *TMdcKalTrack::ImplFileName()
3019{
3020 return ::ROOT::GenerateInitInstanceLocal((const ::TMdcKalTrack*)0x0)->GetImplFileName();
3021}
3022
3023//______________________________________________________________________________
3024int TMdcKalTrack::ImplFileLine()
3025{
3026 return ::ROOT::GenerateInitInstanceLocal((const ::TMdcKalTrack*)0x0)->GetImplFileLine();
3027}
3028
3029//______________________________________________________________________________
3030TClass *TMdcKalTrack::Dictionary()
3031{
3032 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcKalTrack*)0x0)->GetClass();
3033 return fgIsA;
3034}
3035
3036//______________________________________________________________________________
3037TClass *TMdcKalTrack::Class()
3038{
3039 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcKalTrack*)0x0)->GetClass(); }
3040 return fgIsA;
3041}
3042
3043//______________________________________________________________________________
3044atomic_TClass_ptr TDstEvent::fgIsA(0); // static to hold class pointer
3045
3046//______________________________________________________________________________
3047const char *TDstEvent::Class_Name()
3048{
3049 return "TDstEvent";
3050}
3051
3052//______________________________________________________________________________
3053const char *TDstEvent::ImplFileName()
3054{
3055 return ::ROOT::GenerateInitInstanceLocal((const ::TDstEvent*)0x0)->GetImplFileName();
3056}
3057
3058//______________________________________________________________________________
3059int TDstEvent::ImplFileLine()
3060{
3061 return ::ROOT::GenerateInitInstanceLocal((const ::TDstEvent*)0x0)->GetImplFileLine();
3062}
3063
3064//______________________________________________________________________________
3065TClass *TDstEvent::Dictionary()
3066{
3067 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDstEvent*)0x0)->GetClass();
3068 return fgIsA;
3069}
3070
3071//______________________________________________________________________________
3072TClass *TDstEvent::Class()
3073{
3074 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDstEvent*)0x0)->GetClass(); }
3075 return fgIsA;
3076}
3077
3078//______________________________________________________________________________
3079atomic_TClass_ptr TMdcMc::fgIsA(0); // static to hold class pointer
3080
3081//______________________________________________________________________________
3082const char *TMdcMc::Class_Name()
3083{
3084 return "TMdcMc";
3085}
3086
3087//______________________________________________________________________________
3088const char *TMdcMc::ImplFileName()
3089{
3090 return ::ROOT::GenerateInitInstanceLocal((const ::TMdcMc*)0x0)->GetImplFileName();
3091}
3092
3093//______________________________________________________________________________
3094int TMdcMc::ImplFileLine()
3095{
3096 return ::ROOT::GenerateInitInstanceLocal((const ::TMdcMc*)0x0)->GetImplFileLine();
3097}
3098
3099//______________________________________________________________________________
3100TClass *TMdcMc::Dictionary()
3101{
3102 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcMc*)0x0)->GetClass();
3103 return fgIsA;
3104}
3105
3106//______________________________________________________________________________
3107TClass *TMdcMc::Class()
3108{
3109 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcMc*)0x0)->GetClass(); }
3110 return fgIsA;
3111}
3112
3113//______________________________________________________________________________
3114atomic_TClass_ptr TEmcMc::fgIsA(0); // static to hold class pointer
3115
3116//______________________________________________________________________________
3117const char *TEmcMc::Class_Name()
3118{
3119 return "TEmcMc";
3120}
3121
3122//______________________________________________________________________________
3123const char *TEmcMc::ImplFileName()
3124{
3125 return ::ROOT::GenerateInitInstanceLocal((const ::TEmcMc*)0x0)->GetImplFileName();
3126}
3127
3128//______________________________________________________________________________
3129int TEmcMc::ImplFileLine()
3130{
3131 return ::ROOT::GenerateInitInstanceLocal((const ::TEmcMc*)0x0)->GetImplFileLine();
3132}
3133
3134//______________________________________________________________________________
3135TClass *TEmcMc::Dictionary()
3136{
3137 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEmcMc*)0x0)->GetClass();
3138 return fgIsA;
3139}
3140
3141//______________________________________________________________________________
3142TClass *TEmcMc::Class()
3143{
3144 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEmcMc*)0x0)->GetClass(); }
3145 return fgIsA;
3146}
3147
3148//______________________________________________________________________________
3149atomic_TClass_ptr TTofMc::fgIsA(0); // static to hold class pointer
3150
3151//______________________________________________________________________________
3152const char *TTofMc::Class_Name()
3153{
3154 return "TTofMc";
3155}
3156
3157//______________________________________________________________________________
3158const char *TTofMc::ImplFileName()
3159{
3160 return ::ROOT::GenerateInitInstanceLocal((const ::TTofMc*)0x0)->GetImplFileName();
3161}
3162
3163//______________________________________________________________________________
3164int TTofMc::ImplFileLine()
3165{
3166 return ::ROOT::GenerateInitInstanceLocal((const ::TTofMc*)0x0)->GetImplFileLine();
3167}
3168
3169//______________________________________________________________________________
3170TClass *TTofMc::Dictionary()
3171{
3172 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTofMc*)0x0)->GetClass();
3173 return fgIsA;
3174}
3175
3176//______________________________________________________________________________
3177TClass *TTofMc::Class()
3178{
3179 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTofMc*)0x0)->GetClass(); }
3180 return fgIsA;
3181}
3182
3183//______________________________________________________________________________
3184atomic_TClass_ptr TMucMc::fgIsA(0); // static to hold class pointer
3185
3186//______________________________________________________________________________
3187const char *TMucMc::Class_Name()
3188{
3189 return "TMucMc";
3190}
3191
3192//______________________________________________________________________________
3193const char *TMucMc::ImplFileName()
3194{
3195 return ::ROOT::GenerateInitInstanceLocal((const ::TMucMc*)0x0)->GetImplFileName();
3196}
3197
3198//______________________________________________________________________________
3199int TMucMc::ImplFileLine()
3200{
3201 return ::ROOT::GenerateInitInstanceLocal((const ::TMucMc*)0x0)->GetImplFileLine();
3202}
3203
3204//______________________________________________________________________________
3205TClass *TMucMc::Dictionary()
3206{
3207 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMucMc*)0x0)->GetClass();
3208 return fgIsA;
3209}
3210
3211//______________________________________________________________________________
3212TClass *TMucMc::Class()
3213{
3214 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMucMc*)0x0)->GetClass(); }
3215 return fgIsA;
3216}
3217
3218//______________________________________________________________________________
3219atomic_TClass_ptr TMcParticle::fgIsA(0); // static to hold class pointer
3220
3221//______________________________________________________________________________
3222const char *TMcParticle::Class_Name()
3223{
3224 return "TMcParticle";
3225}
3226
3227//______________________________________________________________________________
3228const char *TMcParticle::ImplFileName()
3229{
3230 return ::ROOT::GenerateInitInstanceLocal((const ::TMcParticle*)0x0)->GetImplFileName();
3231}
3232
3233//______________________________________________________________________________
3234int TMcParticle::ImplFileLine()
3235{
3236 return ::ROOT::GenerateInitInstanceLocal((const ::TMcParticle*)0x0)->GetImplFileLine();
3237}
3238
3239//______________________________________________________________________________
3240TClass *TMcParticle::Dictionary()
3241{
3242 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcParticle*)0x0)->GetClass();
3243 return fgIsA;
3244}
3245
3246//______________________________________________________________________________
3247TClass *TMcParticle::Class()
3248{
3249 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcParticle*)0x0)->GetClass(); }
3250 return fgIsA;
3251}
3252
3253//______________________________________________________________________________
3254atomic_TClass_ptr TMcEvent::fgIsA(0); // static to hold class pointer
3255
3256//______________________________________________________________________________
3257const char *TMcEvent::Class_Name()
3258{
3259 return "TMcEvent";
3260}
3261
3262//______________________________________________________________________________
3263const char *TMcEvent::ImplFileName()
3264{
3265 return ::ROOT::GenerateInitInstanceLocal((const ::TMcEvent*)0x0)->GetImplFileName();
3266}
3267
3268//______________________________________________________________________________
3269int TMcEvent::ImplFileLine()
3270{
3271 return ::ROOT::GenerateInitInstanceLocal((const ::TMcEvent*)0x0)->GetImplFileLine();
3272}
3273
3274//______________________________________________________________________________
3275TClass *TMcEvent::Dictionary()
3276{
3277 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcEvent*)0x0)->GetClass();
3278 return fgIsA;
3279}
3280
3281//______________________________________________________________________________
3282TClass *TMcEvent::Class()
3283{
3284 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcEvent*)0x0)->GetClass(); }
3285 return fgIsA;
3286}
3287
3288//______________________________________________________________________________
3289atomic_TClass_ptr TEvtHeader::fgIsA(0); // static to hold class pointer
3290
3291//______________________________________________________________________________
3292const char *TEvtHeader::Class_Name()
3293{
3294 return "TEvtHeader";
3295}
3296
3297//______________________________________________________________________________
3298const char *TEvtHeader::ImplFileName()
3299{
3300 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtHeader*)0x0)->GetImplFileName();
3301}
3302
3303//______________________________________________________________________________
3304int TEvtHeader::ImplFileLine()
3305{
3306 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtHeader*)0x0)->GetImplFileLine();
3307}
3308
3309//______________________________________________________________________________
3310TClass *TEvtHeader::Dictionary()
3311{
3312 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtHeader*)0x0)->GetClass();
3313 return fgIsA;
3314}
3315
3316//______________________________________________________________________________
3317TClass *TEvtHeader::Class()
3318{
3319 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtHeader*)0x0)->GetClass(); }
3320 return fgIsA;
3321}
3322
3323//______________________________________________________________________________
3324atomic_TClass_ptr TEvtNavigator::fgIsA(0); // static to hold class pointer
3325
3326//______________________________________________________________________________
3327const char *TEvtNavigator::Class_Name()
3328{
3329 return "TEvtNavigator";
3330}
3331
3332//______________________________________________________________________________
3333const char *TEvtNavigator::ImplFileName()
3334{
3335 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtNavigator*)0x0)->GetImplFileName();
3336}
3337
3338//______________________________________________________________________________
3339int TEvtNavigator::ImplFileLine()
3340{
3341 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtNavigator*)0x0)->GetImplFileLine();
3342}
3343
3344//______________________________________________________________________________
3345TClass *TEvtNavigator::Dictionary()
3346{
3347 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtNavigator*)0x0)->GetClass();
3348 return fgIsA;
3349}
3350
3351//______________________________________________________________________________
3352TClass *TEvtNavigator::Class()
3353{
3354 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtNavigator*)0x0)->GetClass(); }
3355 return fgIsA;
3356}
3357
3358//______________________________________________________________________________
3359atomic_TClass_ptr TTrigData::fgIsA(0); // static to hold class pointer
3360
3361//______________________________________________________________________________
3362const char *TTrigData::Class_Name()
3363{
3364 return "TTrigData";
3365}
3366
3367//______________________________________________________________________________
3368const char *TTrigData::ImplFileName()
3369{
3370 return ::ROOT::GenerateInitInstanceLocal((const ::TTrigData*)0x0)->GetImplFileName();
3371}
3372
3373//______________________________________________________________________________
3374int TTrigData::ImplFileLine()
3375{
3376 return ::ROOT::GenerateInitInstanceLocal((const ::TTrigData*)0x0)->GetImplFileLine();
3377}
3378
3379//______________________________________________________________________________
3380TClass *TTrigData::Dictionary()
3381{
3382 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTrigData*)0x0)->GetClass();
3383 return fgIsA;
3384}
3385
3386//______________________________________________________________________________
3387TClass *TTrigData::Class()
3388{
3389 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTrigData*)0x0)->GetClass(); }
3390 return fgIsA;
3391}
3392
3393//______________________________________________________________________________
3394atomic_TClass_ptr TTrigEvent::fgIsA(0); // static to hold class pointer
3395
3396//______________________________________________________________________________
3397const char *TTrigEvent::Class_Name()
3398{
3399 return "TTrigEvent";
3400}
3401
3402//______________________________________________________________________________
3403const char *TTrigEvent::ImplFileName()
3404{
3405 return ::ROOT::GenerateInitInstanceLocal((const ::TTrigEvent*)0x0)->GetImplFileName();
3406}
3407
3408//______________________________________________________________________________
3409int TTrigEvent::ImplFileLine()
3410{
3411 return ::ROOT::GenerateInitInstanceLocal((const ::TTrigEvent*)0x0)->GetImplFileLine();
3412}
3413
3414//______________________________________________________________________________
3415TClass *TTrigEvent::Dictionary()
3416{
3417 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTrigEvent*)0x0)->GetClass();
3418 return fgIsA;
3419}
3420
3421//______________________________________________________________________________
3422TClass *TTrigEvent::Class()
3423{
3424 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTrigEvent*)0x0)->GetClass(); }
3425 return fgIsA;
3426}
3427
3428//______________________________________________________________________________
3429atomic_TClass_ptr THltRaw::fgIsA(0); // static to hold class pointer
3430
3431//______________________________________________________________________________
3432const char *THltRaw::Class_Name()
3433{
3434 return "THltRaw";
3435}
3436
3437//______________________________________________________________________________
3438const char *THltRaw::ImplFileName()
3439{
3440 return ::ROOT::GenerateInitInstanceLocal((const ::THltRaw*)0x0)->GetImplFileName();
3441}
3442
3443//______________________________________________________________________________
3444int THltRaw::ImplFileLine()
3445{
3446 return ::ROOT::GenerateInitInstanceLocal((const ::THltRaw*)0x0)->GetImplFileLine();
3447}
3448
3449//______________________________________________________________________________
3450TClass *THltRaw::Dictionary()
3451{
3452 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THltRaw*)0x0)->GetClass();
3453 return fgIsA;
3454}
3455
3456//______________________________________________________________________________
3457TClass *THltRaw::Class()
3458{
3459 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THltRaw*)0x0)->GetClass(); }
3460 return fgIsA;
3461}
3462
3463//______________________________________________________________________________
3464atomic_TClass_ptr THltInf::fgIsA(0); // static to hold class pointer
3465
3466//______________________________________________________________________________
3467const char *THltInf::Class_Name()
3468{
3469 return "THltInf";
3470}
3471
3472//______________________________________________________________________________
3473const char *THltInf::ImplFileName()
3474{
3475 return ::ROOT::GenerateInitInstanceLocal((const ::THltInf*)0x0)->GetImplFileName();
3476}
3477
3478//______________________________________________________________________________
3479int THltInf::ImplFileLine()
3480{
3481 return ::ROOT::GenerateInitInstanceLocal((const ::THltInf*)0x0)->GetImplFileLine();
3482}
3483
3484//______________________________________________________________________________
3485TClass *THltInf::Dictionary()
3486{
3487 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THltInf*)0x0)->GetClass();
3488 return fgIsA;
3489}
3490
3491//______________________________________________________________________________
3492TClass *THltInf::Class()
3493{
3494 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THltInf*)0x0)->GetClass(); }
3495 return fgIsA;
3496}
3497
3498//______________________________________________________________________________
3499atomic_TClass_ptr TDstHltInf::fgIsA(0); // static to hold class pointer
3500
3501//______________________________________________________________________________
3502const char *TDstHltInf::Class_Name()
3503{
3504 return "TDstHltInf";
3505}
3506
3507//______________________________________________________________________________
3508const char *TDstHltInf::ImplFileName()
3509{
3510 return ::ROOT::GenerateInitInstanceLocal((const ::TDstHltInf*)0x0)->GetImplFileName();
3511}
3512
3513//______________________________________________________________________________
3514int TDstHltInf::ImplFileLine()
3515{
3516 return ::ROOT::GenerateInitInstanceLocal((const ::TDstHltInf*)0x0)->GetImplFileLine();
3517}
3518
3519//______________________________________________________________________________
3520TClass *TDstHltInf::Dictionary()
3521{
3522 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDstHltInf*)0x0)->GetClass();
3523 return fgIsA;
3524}
3525
3526//______________________________________________________________________________
3527TClass *TDstHltInf::Class()
3528{
3529 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDstHltInf*)0x0)->GetClass(); }
3530 return fgIsA;
3531}
3532
3533//______________________________________________________________________________
3534atomic_TClass_ptr THltEvent::fgIsA(0); // static to hold class pointer
3535
3536//______________________________________________________________________________
3537const char *THltEvent::Class_Name()
3538{
3539 return "THltEvent";
3540}
3541
3542//______________________________________________________________________________
3543const char *THltEvent::ImplFileName()
3544{
3545 return ::ROOT::GenerateInitInstanceLocal((const ::THltEvent*)0x0)->GetImplFileName();
3546}
3547
3548//______________________________________________________________________________
3549int THltEvent::ImplFileLine()
3550{
3551 return ::ROOT::GenerateInitInstanceLocal((const ::THltEvent*)0x0)->GetImplFileLine();
3552}
3553
3554//______________________________________________________________________________
3555TClass *THltEvent::Dictionary()
3556{
3557 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THltEvent*)0x0)->GetClass();
3558 return fgIsA;
3559}
3560
3561//______________________________________________________________________________
3562TClass *THltEvent::Class()
3563{
3564 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THltEvent*)0x0)->GetClass(); }
3565 return fgIsA;
3566}
3567
3568//______________________________________________________________________________
3569atomic_TClass_ptr TDisTrack::fgIsA(0); // static to hold class pointer
3570
3571//______________________________________________________________________________
3572const char *TDisTrack::Class_Name()
3573{
3574 return "TDisTrack";
3575}
3576
3577//______________________________________________________________________________
3578const char *TDisTrack::ImplFileName()
3579{
3580 return ::ROOT::GenerateInitInstanceLocal((const ::TDisTrack*)0x0)->GetImplFileName();
3581}
3582
3583//______________________________________________________________________________
3584int TDisTrack::ImplFileLine()
3585{
3586 return ::ROOT::GenerateInitInstanceLocal((const ::TDisTrack*)0x0)->GetImplFileLine();
3587}
3588
3589//______________________________________________________________________________
3590TClass *TDisTrack::Dictionary()
3591{
3592 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDisTrack*)0x0)->GetClass();
3593 return fgIsA;
3594}
3595
3596//______________________________________________________________________________
3597TClass *TDisTrack::Class()
3598{
3599 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDisTrack*)0x0)->GetClass(); }
3600 return fgIsA;
3601}
3602
3603//______________________________________________________________________________
3604atomic_TClass_ptr TEvtRecEvent::fgIsA(0); // static to hold class pointer
3605
3606//______________________________________________________________________________
3607const char *TEvtRecEvent::Class_Name()
3608{
3609 return "TEvtRecEvent";
3610}
3611
3612//______________________________________________________________________________
3613const char *TEvtRecEvent::ImplFileName()
3614{
3615 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEvent*)0x0)->GetImplFileName();
3616}
3617
3618//______________________________________________________________________________
3619int TEvtRecEvent::ImplFileLine()
3620{
3621 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEvent*)0x0)->GetImplFileLine();
3622}
3623
3624//______________________________________________________________________________
3625TClass *TEvtRecEvent::Dictionary()
3626{
3627 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEvent*)0x0)->GetClass();
3628 return fgIsA;
3629}
3630
3631//______________________________________________________________________________
3632TClass *TEvtRecEvent::Class()
3633{
3634 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEvent*)0x0)->GetClass(); }
3635 return fgIsA;
3636}
3637
3638//______________________________________________________________________________
3639atomic_TClass_ptr TEvtRecTrack::fgIsA(0); // static to hold class pointer
3640
3641//______________________________________________________________________________
3642const char *TEvtRecTrack::Class_Name()
3643{
3644 return "TEvtRecTrack";
3645}
3646
3647//______________________________________________________________________________
3648const char *TEvtRecTrack::ImplFileName()
3649{
3650 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecTrack*)0x0)->GetImplFileName();
3651}
3652
3653//______________________________________________________________________________
3654int TEvtRecTrack::ImplFileLine()
3655{
3656 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecTrack*)0x0)->GetImplFileLine();
3657}
3658
3659//______________________________________________________________________________
3660TClass *TEvtRecTrack::Dictionary()
3661{
3662 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecTrack*)0x0)->GetClass();
3663 return fgIsA;
3664}
3665
3666//______________________________________________________________________________
3667TClass *TEvtRecTrack::Class()
3668{
3669 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecTrack*)0x0)->GetClass(); }
3670 return fgIsA;
3671}
3672
3673//______________________________________________________________________________
3674atomic_TClass_ptr TEvtRecPrimaryVertex::fgIsA(0); // static to hold class pointer
3675
3676//______________________________________________________________________________
3677const char *TEvtRecPrimaryVertex::Class_Name()
3678{
3679 return "TEvtRecPrimaryVertex";
3680}
3681
3682//______________________________________________________________________________
3683const char *TEvtRecPrimaryVertex::ImplFileName()
3684{
3685 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPrimaryVertex*)0x0)->GetImplFileName();
3686}
3687
3688//______________________________________________________________________________
3689int TEvtRecPrimaryVertex::ImplFileLine()
3690{
3691 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPrimaryVertex*)0x0)->GetImplFileLine();
3692}
3693
3694//______________________________________________________________________________
3695TClass *TEvtRecPrimaryVertex::Dictionary()
3696{
3697 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPrimaryVertex*)0x0)->GetClass();
3698 return fgIsA;
3699}
3700
3701//______________________________________________________________________________
3702TClass *TEvtRecPrimaryVertex::Class()
3703{
3704 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPrimaryVertex*)0x0)->GetClass(); }
3705 return fgIsA;
3706}
3707
3708//______________________________________________________________________________
3709atomic_TClass_ptr TEvtRecVeeVertex::fgIsA(0); // static to hold class pointer
3710
3711//______________________________________________________________________________
3712const char *TEvtRecVeeVertex::Class_Name()
3713{
3714 return "TEvtRecVeeVertex";
3715}
3716
3717//______________________________________________________________________________
3718const char *TEvtRecVeeVertex::ImplFileName()
3719{
3720 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecVeeVertex*)0x0)->GetImplFileName();
3721}
3722
3723//______________________________________________________________________________
3724int TEvtRecVeeVertex::ImplFileLine()
3725{
3726 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecVeeVertex*)0x0)->GetImplFileLine();
3727}
3728
3729//______________________________________________________________________________
3730TClass *TEvtRecVeeVertex::Dictionary()
3731{
3732 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecVeeVertex*)0x0)->GetClass();
3733 return fgIsA;
3734}
3735
3736//______________________________________________________________________________
3737TClass *TEvtRecVeeVertex::Class()
3738{
3739 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecVeeVertex*)0x0)->GetClass(); }
3740 return fgIsA;
3741}
3742
3743//______________________________________________________________________________
3744atomic_TClass_ptr TEvtRecPi0::fgIsA(0); // static to hold class pointer
3745
3746//______________________________________________________________________________
3747const char *TEvtRecPi0::Class_Name()
3748{
3749 return "TEvtRecPi0";
3750}
3751
3752//______________________________________________________________________________
3753const char *TEvtRecPi0::ImplFileName()
3754{
3755 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPi0*)0x0)->GetImplFileName();
3756}
3757
3758//______________________________________________________________________________
3759int TEvtRecPi0::ImplFileLine()
3760{
3761 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPi0*)0x0)->GetImplFileLine();
3762}
3763
3764//______________________________________________________________________________
3765TClass *TEvtRecPi0::Dictionary()
3766{
3767 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPi0*)0x0)->GetClass();
3768 return fgIsA;
3769}
3770
3771//______________________________________________________________________________
3772TClass *TEvtRecPi0::Class()
3773{
3774 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPi0*)0x0)->GetClass(); }
3775 return fgIsA;
3776}
3777
3778//______________________________________________________________________________
3779atomic_TClass_ptr TEvtRecEtaToGG::fgIsA(0); // static to hold class pointer
3780
3781//______________________________________________________________________________
3782const char *TEvtRecEtaToGG::Class_Name()
3783{
3784 return "TEvtRecEtaToGG";
3785}
3786
3787//______________________________________________________________________________
3788const char *TEvtRecEtaToGG::ImplFileName()
3789{
3790 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEtaToGG*)0x0)->GetImplFileName();
3791}
3792
3793//______________________________________________________________________________
3794int TEvtRecEtaToGG::ImplFileLine()
3795{
3796 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEtaToGG*)0x0)->GetImplFileLine();
3797}
3798
3799//______________________________________________________________________________
3800TClass *TEvtRecEtaToGG::Dictionary()
3801{
3802 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEtaToGG*)0x0)->GetClass();
3803 return fgIsA;
3804}
3805
3806//______________________________________________________________________________
3807TClass *TEvtRecEtaToGG::Class()
3808{
3809 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEtaToGG*)0x0)->GetClass(); }
3810 return fgIsA;
3811}
3812
3813//______________________________________________________________________________
3814atomic_TClass_ptr TEvtRecDTag::fgIsA(0); // static to hold class pointer
3815
3816//______________________________________________________________________________
3817const char *TEvtRecDTag::Class_Name()
3818{
3819 return "TEvtRecDTag";
3820}
3821
3822//______________________________________________________________________________
3823const char *TEvtRecDTag::ImplFileName()
3824{
3825 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecDTag*)0x0)->GetImplFileName();
3826}
3827
3828//______________________________________________________________________________
3829int TEvtRecDTag::ImplFileLine()
3830{
3831 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecDTag*)0x0)->GetImplFileLine();
3832}
3833
3834//______________________________________________________________________________
3835TClass *TEvtRecDTag::Dictionary()
3836{
3837 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecDTag*)0x0)->GetClass();
3838 return fgIsA;
3839}
3840
3841//______________________________________________________________________________
3842TClass *TEvtRecDTag::Class()
3843{
3844 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecDTag*)0x0)->GetClass(); }
3845 return fgIsA;
3846}
3847
3848//______________________________________________________________________________
3849atomic_TClass_ptr TEvtRecObject::fgIsA(0); // static to hold class pointer
3850
3851//______________________________________________________________________________
3852const char *TEvtRecObject::Class_Name()
3853{
3854 return "TEvtRecObject";
3855}
3856
3857//______________________________________________________________________________
3858const char *TEvtRecObject::ImplFileName()
3859{
3860 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecObject*)0x0)->GetImplFileName();
3861}
3862
3863//______________________________________________________________________________
3864int TEvtRecObject::ImplFileLine()
3865{
3866 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecObject*)0x0)->GetImplFileLine();
3867}
3868
3869//______________________________________________________________________________
3870TClass *TEvtRecObject::Dictionary()
3871{
3872 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecObject*)0x0)->GetClass();
3873 return fgIsA;
3874}
3875
3876//______________________________________________________________________________
3877TClass *TEvtRecObject::Class()
3878{
3879 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecObject*)0x0)->GetClass(); }
3880 return fgIsA;
3881}
3882
3883//______________________________________________________________________________
3884atomic_TClass_ptr TMcHitTof::fgIsA(0); // static to hold class pointer
3885
3886//______________________________________________________________________________
3887const char *TMcHitTof::Class_Name()
3888{
3889 return "TMcHitTof";
3890}
3891
3892//______________________________________________________________________________
3893const char *TMcHitTof::ImplFileName()
3894{
3895 return ::ROOT::GenerateInitInstanceLocal((const ::TMcHitTof*)0x0)->GetImplFileName();
3896}
3897
3898//______________________________________________________________________________
3899int TMcHitTof::ImplFileLine()
3900{
3901 return ::ROOT::GenerateInitInstanceLocal((const ::TMcHitTof*)0x0)->GetImplFileLine();
3902}
3903
3904//______________________________________________________________________________
3905TClass *TMcHitTof::Dictionary()
3906{
3907 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcHitTof*)0x0)->GetClass();
3908 return fgIsA;
3909}
3910
3911//______________________________________________________________________________
3912TClass *TMcHitTof::Class()
3913{
3914 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcHitTof*)0x0)->GetClass(); }
3915 return fgIsA;
3916}
3917
3918//______________________________________________________________________________
3919atomic_TClass_ptr TMcHitMdc::fgIsA(0); // static to hold class pointer
3920
3921//______________________________________________________________________________
3922const char *TMcHitMdc::Class_Name()
3923{
3924 return "TMcHitMdc";
3925}
3926
3927//______________________________________________________________________________
3928const char *TMcHitMdc::ImplFileName()
3929{
3930 return ::ROOT::GenerateInitInstanceLocal((const ::TMcHitMdc*)0x0)->GetImplFileName();
3931}
3932
3933//______________________________________________________________________________
3934int TMcHitMdc::ImplFileLine()
3935{
3936 return ::ROOT::GenerateInitInstanceLocal((const ::TMcHitMdc*)0x0)->GetImplFileLine();
3937}
3938
3939//______________________________________________________________________________
3940TClass *TMcHitMdc::Dictionary()
3941{
3942 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcHitMdc*)0x0)->GetClass();
3943 return fgIsA;
3944}
3945
3946//______________________________________________________________________________
3947TClass *TMcHitMdc::Class()
3948{
3949 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcHitMdc*)0x0)->GetClass(); }
3950 return fgIsA;
3951}
3952
3953//______________________________________________________________________________
3954atomic_TClass_ptr TMcDigiEmc::fgIsA(0); // static to hold class pointer
3955
3956//______________________________________________________________________________
3957const char *TMcDigiEmc::Class_Name()
3958{
3959 return "TMcDigiEmc";
3960}
3961
3962//______________________________________________________________________________
3963const char *TMcDigiEmc::ImplFileName()
3964{
3965 return ::ROOT::GenerateInitInstanceLocal((const ::TMcDigiEmc*)0x0)->GetImplFileName();
3966}
3967
3968//______________________________________________________________________________
3969int TMcDigiEmc::ImplFileLine()
3970{
3971 return ::ROOT::GenerateInitInstanceLocal((const ::TMcDigiEmc*)0x0)->GetImplFileLine();
3972}
3973
3974//______________________________________________________________________________
3975TClass *TMcDigiEmc::Dictionary()
3976{
3977 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcDigiEmc*)0x0)->GetClass();
3978 return fgIsA;
3979}
3980
3981//______________________________________________________________________________
3982TClass *TMcDigiEmc::Class()
3983{
3984 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcDigiEmc*)0x0)->GetClass(); }
3985 return fgIsA;
3986}
3987
3988//______________________________________________________________________________
3989atomic_TClass_ptr TMcHitEvent::fgIsA(0); // static to hold class pointer
3990
3991//______________________________________________________________________________
3992const char *TMcHitEvent::Class_Name()
3993{
3994 return "TMcHitEvent";
3995}
3996
3997//______________________________________________________________________________
3998const char *TMcHitEvent::ImplFileName()
3999{
4000 return ::ROOT::GenerateInitInstanceLocal((const ::TMcHitEvent*)0x0)->GetImplFileName();
4001}
4002
4003//______________________________________________________________________________
4004int TMcHitEvent::ImplFileLine()
4005{
4006 return ::ROOT::GenerateInitInstanceLocal((const ::TMcHitEvent*)0x0)->GetImplFileLine();
4007}
4008
4009//______________________________________________________________________________
4010TClass *TMcHitEvent::Dictionary()
4011{
4012 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcHitEvent*)0x0)->GetClass();
4013 return fgIsA;
4014}
4015
4016//______________________________________________________________________________
4017TClass *TMcHitEvent::Class()
4018{
4019 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcHitEvent*)0x0)->GetClass(); }
4020 return fgIsA;
4021}
4022
4023//______________________________________________________________________________
4024atomic_TClass_ptr TBossFullEvent::fgIsA(0); // static to hold class pointer
4025
4026//______________________________________________________________________________
4027const char *TBossFullEvent::Class_Name()
4028{
4029 return "TBossFullEvent";
4030}
4031
4032//______________________________________________________________________________
4033const char *TBossFullEvent::ImplFileName()
4034{
4035 return ::ROOT::GenerateInitInstanceLocal((const ::TBossFullEvent*)0x0)->GetImplFileName();
4036}
4037
4038//______________________________________________________________________________
4039int TBossFullEvent::ImplFileLine()
4040{
4041 return ::ROOT::GenerateInitInstanceLocal((const ::TBossFullEvent*)0x0)->GetImplFileLine();
4042}
4043
4044//______________________________________________________________________________
4045TClass *TBossFullEvent::Dictionary()
4046{
4047 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TBossFullEvent*)0x0)->GetClass();
4048 return fgIsA;
4049}
4050
4051//______________________________________________________________________________
4052TClass *TBossFullEvent::Class()
4053{
4054 if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TBossFullEvent*)0x0)->GetClass(); }
4055 return fgIsA;
4056}
4057
4058//______________________________________________________________________________
4059void TJobInfo::Streamer(TBuffer &R__b)
4060{
4061 // Stream an object of class TJobInfo.
4062
4063 if (R__b.IsReading()) {
4064 R__b.ReadClassBuffer(TJobInfo::Class(),this);
4065 } else {
4066 R__b.WriteClassBuffer(TJobInfo::Class(),this);
4067 }
4068}
4069
4070namespace ROOT {
4071 // Wrappers around operator new
4072 static void *new_TJobInfo(void *p) {
4073 return p ? new(p) ::TJobInfo : new ::TJobInfo;
4074 }
4075 static void *newArray_TJobInfo(Long_t nElements, void *p) {
4076 return p ? new(p) ::TJobInfo[nElements] : new ::TJobInfo[nElements];
4077 }
4078 // Wrapper around operator delete
4079 static void delete_TJobInfo(void *p) {
4080 delete ((::TJobInfo*)p);
4081 }
4082 static void deleteArray_TJobInfo(void *p) {
4083 delete [] ((::TJobInfo*)p);
4084 }
4085 static void destruct_TJobInfo(void *p) {
4086 typedef ::TJobInfo current_t;
4087 ((current_t*)p)->~current_t();
4088 }
4089} // end of namespace ROOT for class ::TJobInfo
4090
4091//______________________________________________________________________________
4092void TRawData::Streamer(TBuffer &R__b)
4093{
4094 // Stream an object of class TRawData.
4095
4096 if (R__b.IsReading()) {
4097 R__b.ReadClassBuffer(TRawData::Class(),this);
4098 } else {
4099 R__b.WriteClassBuffer(TRawData::Class(),this);
4100 }
4101}
4102
4103namespace ROOT {
4104 // Wrappers around operator new
4105 static void *new_TRawData(void *p) {
4106 return p ? new(p) ::TRawData : new ::TRawData;
4107 }
4108 static void *newArray_TRawData(Long_t nElements, void *p) {
4109 return p ? new(p) ::TRawData[nElements] : new ::TRawData[nElements];
4110 }
4111 // Wrapper around operator delete
4112 static void delete_TRawData(void *p) {
4113 delete ((::TRawData*)p);
4114 }
4115 static void deleteArray_TRawData(void *p) {
4116 delete [] ((::TRawData*)p);
4117 }
4118 static void destruct_TRawData(void *p) {
4119 typedef ::TRawData current_t;
4120 ((current_t*)p)->~current_t();
4121 }
4122} // end of namespace ROOT for class ::TRawData
4123
4124//______________________________________________________________________________
4125void TMdcDigi::Streamer(TBuffer &R__b)
4126{
4127 // Stream an object of class TMdcDigi.
4128
4129 if (R__b.IsReading()) {
4130 R__b.ReadClassBuffer(TMdcDigi::Class(),this);
4131 } else {
4132 R__b.WriteClassBuffer(TMdcDigi::Class(),this);
4133 }
4134}
4135
4136namespace ROOT {
4137 // Wrappers around operator new
4138 static void *new_TMdcDigi(void *p) {
4139 return p ? new(p) ::TMdcDigi : new ::TMdcDigi;
4140 }
4141 static void *newArray_TMdcDigi(Long_t nElements, void *p) {
4142 return p ? new(p) ::TMdcDigi[nElements] : new ::TMdcDigi[nElements];
4143 }
4144 // Wrapper around operator delete
4145 static void delete_TMdcDigi(void *p) {
4146 delete ((::TMdcDigi*)p);
4147 }
4148 static void deleteArray_TMdcDigi(void *p) {
4149 delete [] ((::TMdcDigi*)p);
4150 }
4151 static void destruct_TMdcDigi(void *p) {
4152 typedef ::TMdcDigi current_t;
4153 ((current_t*)p)->~current_t();
4154 }
4155} // end of namespace ROOT for class ::TMdcDigi
4156
4157//______________________________________________________________________________
4158void TEmcDigi::Streamer(TBuffer &R__b)
4159{
4160 // Stream an object of class TEmcDigi.
4161
4162 if (R__b.IsReading()) {
4163 R__b.ReadClassBuffer(TEmcDigi::Class(),this);
4164 } else {
4165 R__b.WriteClassBuffer(TEmcDigi::Class(),this);
4166 }
4167}
4168
4169namespace ROOT {
4170 // Wrappers around operator new
4171 static void *new_TEmcDigi(void *p) {
4172 return p ? new(p) ::TEmcDigi : new ::TEmcDigi;
4173 }
4174 static void *newArray_TEmcDigi(Long_t nElements, void *p) {
4175 return p ? new(p) ::TEmcDigi[nElements] : new ::TEmcDigi[nElements];
4176 }
4177 // Wrapper around operator delete
4178 static void delete_TEmcDigi(void *p) {
4179 delete ((::TEmcDigi*)p);
4180 }
4181 static void deleteArray_TEmcDigi(void *p) {
4182 delete [] ((::TEmcDigi*)p);
4183 }
4184 static void destruct_TEmcDigi(void *p) {
4185 typedef ::TEmcDigi current_t;
4186 ((current_t*)p)->~current_t();
4187 }
4188} // end of namespace ROOT for class ::TEmcDigi
4189
4190//______________________________________________________________________________
4191void TTofDigi::Streamer(TBuffer &R__b)
4192{
4193 // Stream an object of class TTofDigi.
4194
4195 if (R__b.IsReading()) {
4196 R__b.ReadClassBuffer(TTofDigi::Class(),this);
4197 } else {
4198 R__b.WriteClassBuffer(TTofDigi::Class(),this);
4199 }
4200}
4201
4202namespace ROOT {
4203 // Wrappers around operator new
4204 static void *new_TTofDigi(void *p) {
4205 return p ? new(p) ::TTofDigi : new ::TTofDigi;
4206 }
4207 static void *newArray_TTofDigi(Long_t nElements, void *p) {
4208 return p ? new(p) ::TTofDigi[nElements] : new ::TTofDigi[nElements];
4209 }
4210 // Wrapper around operator delete
4211 static void delete_TTofDigi(void *p) {
4212 delete ((::TTofDigi*)p);
4213 }
4214 static void deleteArray_TTofDigi(void *p) {
4215 delete [] ((::TTofDigi*)p);
4216 }
4217 static void destruct_TTofDigi(void *p) {
4218 typedef ::TTofDigi current_t;
4219 ((current_t*)p)->~current_t();
4220 }
4221} // end of namespace ROOT for class ::TTofDigi
4222
4223//______________________________________________________________________________
4224void TMucDigi::Streamer(TBuffer &R__b)
4225{
4226 // Stream an object of class TMucDigi.
4227
4228 if (R__b.IsReading()) {
4229 R__b.ReadClassBuffer(TMucDigi::Class(),this);
4230 } else {
4231 R__b.WriteClassBuffer(TMucDigi::Class(),this);
4232 }
4233}
4234
4235namespace ROOT {
4236 // Wrappers around operator new
4237 static void *new_TMucDigi(void *p) {
4238 return p ? new(p) ::TMucDigi : new ::TMucDigi;
4239 }
4240 static void *newArray_TMucDigi(Long_t nElements, void *p) {
4241 return p ? new(p) ::TMucDigi[nElements] : new ::TMucDigi[nElements];
4242 }
4243 // Wrapper around operator delete
4244 static void delete_TMucDigi(void *p) {
4245 delete ((::TMucDigi*)p);
4246 }
4247 static void deleteArray_TMucDigi(void *p) {
4248 delete [] ((::TMucDigi*)p);
4249 }
4250 static void destruct_TMucDigi(void *p) {
4251 typedef ::TMucDigi current_t;
4252 ((current_t*)p)->~current_t();
4253 }
4254} // end of namespace ROOT for class ::TMucDigi
4255
4256//______________________________________________________________________________
4257void TLumiDigi::Streamer(TBuffer &R__b)
4258{
4259 // Stream an object of class TLumiDigi.
4260
4261 if (R__b.IsReading()) {
4262 R__b.ReadClassBuffer(TLumiDigi::Class(),this);
4263 } else {
4264 R__b.WriteClassBuffer(TLumiDigi::Class(),this);
4265 }
4266}
4267
4268namespace ROOT {
4269 // Wrappers around operator new
4270 static void *new_TLumiDigi(void *p) {
4271 return p ? new(p) ::TLumiDigi : new ::TLumiDigi;
4272 }
4273 static void *newArray_TLumiDigi(Long_t nElements, void *p) {
4274 return p ? new(p) ::TLumiDigi[nElements] : new ::TLumiDigi[nElements];
4275 }
4276 // Wrapper around operator delete
4277 static void delete_TLumiDigi(void *p) {
4278 delete ((::TLumiDigi*)p);
4279 }
4280 static void deleteArray_TLumiDigi(void *p) {
4281 delete [] ((::TLumiDigi*)p);
4282 }
4283 static void destruct_TLumiDigi(void *p) {
4284 typedef ::TLumiDigi current_t;
4285 ((current_t*)p)->~current_t();
4286 }
4287} // end of namespace ROOT for class ::TLumiDigi
4288
4289//______________________________________________________________________________
4290void TDigiEvent::Streamer(TBuffer &R__b)
4291{
4292 // Stream an object of class TDigiEvent.
4293
4294 if (R__b.IsReading()) {
4295 R__b.ReadClassBuffer(TDigiEvent::Class(),this);
4296 } else {
4297 R__b.WriteClassBuffer(TDigiEvent::Class(),this);
4298 }
4299}
4300
4301namespace ROOT {
4302 // Wrappers around operator new
4303 static void *new_TDigiEvent(void *p) {
4304 return p ? new(p) ::TDigiEvent : new ::TDigiEvent;
4305 }
4306 static void *newArray_TDigiEvent(Long_t nElements, void *p) {
4307 return p ? new(p) ::TDigiEvent[nElements] : new ::TDigiEvent[nElements];
4308 }
4309 // Wrapper around operator delete
4310 static void delete_TDigiEvent(void *p) {
4311 delete ((::TDigiEvent*)p);
4312 }
4313 static void deleteArray_TDigiEvent(void *p) {
4314 delete [] ((::TDigiEvent*)p);
4315 }
4316 static void destruct_TDigiEvent(void *p) {
4317 typedef ::TDigiEvent current_t;
4318 ((current_t*)p)->~current_t();
4319 }
4320} // end of namespace ROOT for class ::TDigiEvent
4321
4322//______________________________________________________________________________
4323void TRecMdcTrack::Streamer(TBuffer &R__b)
4324{
4325 // Stream an object of class TRecMdcTrack.
4326
4327 if (R__b.IsReading()) {
4328 R__b.ReadClassBuffer(TRecMdcTrack::Class(),this);
4329 } else {
4330 R__b.WriteClassBuffer(TRecMdcTrack::Class(),this);
4331 }
4332}
4333
4334namespace ROOT {
4335 // Wrappers around operator new
4336 static void *new_TRecMdcTrack(void *p) {
4337 return p ? new(p) ::TRecMdcTrack : new ::TRecMdcTrack;
4338 }
4339 static void *newArray_TRecMdcTrack(Long_t nElements, void *p) {
4340 return p ? new(p) ::TRecMdcTrack[nElements] : new ::TRecMdcTrack[nElements];
4341 }
4342 // Wrapper around operator delete
4343 static void delete_TRecMdcTrack(void *p) {
4344 delete ((::TRecMdcTrack*)p);
4345 }
4346 static void deleteArray_TRecMdcTrack(void *p) {
4347 delete [] ((::TRecMdcTrack*)p);
4348 }
4349 static void destruct_TRecMdcTrack(void *p) {
4350 typedef ::TRecMdcTrack current_t;
4351 ((current_t*)p)->~current_t();
4352 }
4353} // end of namespace ROOT for class ::TRecMdcTrack
4354
4355//______________________________________________________________________________
4356void TRecMdcKalTrack::Streamer(TBuffer &R__b)
4357{
4358 // Stream an object of class TRecMdcKalTrack.
4359
4360 if (R__b.IsReading()) {
4361 R__b.ReadClassBuffer(TRecMdcKalTrack::Class(),this);
4362 } else {
4363 R__b.WriteClassBuffer(TRecMdcKalTrack::Class(),this);
4364 }
4365}
4366
4367namespace ROOT {
4368 // Wrappers around operator new
4369 static void *new_TRecMdcKalTrack(void *p) {
4370 return p ? new(p) ::TRecMdcKalTrack : new ::TRecMdcKalTrack;
4371 }
4372 static void *newArray_TRecMdcKalTrack(Long_t nElements, void *p) {
4373 return p ? new(p) ::TRecMdcKalTrack[nElements] : new ::TRecMdcKalTrack[nElements];
4374 }
4375 // Wrapper around operator delete
4376 static void delete_TRecMdcKalTrack(void *p) {
4377 delete ((::TRecMdcKalTrack*)p);
4378 }
4379 static void deleteArray_TRecMdcKalTrack(void *p) {
4380 delete [] ((::TRecMdcKalTrack*)p);
4381 }
4382 static void destruct_TRecMdcKalTrack(void *p) {
4383 typedef ::TRecMdcKalTrack current_t;
4384 ((current_t*)p)->~current_t();
4385 }
4386} // end of namespace ROOT for class ::TRecMdcKalTrack
4387
4388//______________________________________________________________________________
4389void TRecMdcHit::Streamer(TBuffer &R__b)
4390{
4391 // Stream an object of class TRecMdcHit.
4392
4393 if (R__b.IsReading()) {
4394 R__b.ReadClassBuffer(TRecMdcHit::Class(),this);
4395 } else {
4396 R__b.WriteClassBuffer(TRecMdcHit::Class(),this);
4397 }
4398}
4399
4400namespace ROOT {
4401 // Wrappers around operator new
4402 static void *new_TRecMdcHit(void *p) {
4403 return p ? new(p) ::TRecMdcHit : new ::TRecMdcHit;
4404 }
4405 static void *newArray_TRecMdcHit(Long_t nElements, void *p) {
4406 return p ? new(p) ::TRecMdcHit[nElements] : new ::TRecMdcHit[nElements];
4407 }
4408 // Wrapper around operator delete
4409 static void delete_TRecMdcHit(void *p) {
4410 delete ((::TRecMdcHit*)p);
4411 }
4412 static void deleteArray_TRecMdcHit(void *p) {
4413 delete [] ((::TRecMdcHit*)p);
4414 }
4415 static void destruct_TRecMdcHit(void *p) {
4416 typedef ::TRecMdcHit current_t;
4417 ((current_t*)p)->~current_t();
4418 }
4419} // end of namespace ROOT for class ::TRecMdcHit
4420
4421//______________________________________________________________________________
4422void TTofTrack::Streamer(TBuffer &R__b)
4423{
4424 // Stream an object of class TTofTrack.
4425
4426 if (R__b.IsReading()) {
4427 R__b.ReadClassBuffer(TTofTrack::Class(),this);
4428 } else {
4429 R__b.WriteClassBuffer(TTofTrack::Class(),this);
4430 }
4431}
4432
4433namespace ROOT {
4434 // Wrappers around operator new
4435 static void *new_TTofTrack(void *p) {
4436 return p ? new(p) ::TTofTrack : new ::TTofTrack;
4437 }
4438 static void *newArray_TTofTrack(Long_t nElements, void *p) {
4439 return p ? new(p) ::TTofTrack[nElements] : new ::TTofTrack[nElements];
4440 }
4441 // Wrapper around operator delete
4442 static void delete_TTofTrack(void *p) {
4443 delete ((::TTofTrack*)p);
4444 }
4445 static void deleteArray_TTofTrack(void *p) {
4446 delete [] ((::TTofTrack*)p);
4447 }
4448 static void destruct_TTofTrack(void *p) {
4449 typedef ::TTofTrack current_t;
4450 ((current_t*)p)->~current_t();
4451 }
4452} // end of namespace ROOT for class ::TTofTrack
4453
4454//______________________________________________________________________________
4455void TRecTofTrack::Streamer(TBuffer &R__b)
4456{
4457 // Stream an object of class TRecTofTrack.
4458
4459 if (R__b.IsReading()) {
4460 R__b.ReadClassBuffer(TRecTofTrack::Class(),this);
4461 } else {
4462 R__b.WriteClassBuffer(TRecTofTrack::Class(),this);
4463 }
4464}
4465
4466namespace ROOT {
4467 // Wrappers around operator new
4468 static void *new_TRecTofTrack(void *p) {
4469 return p ? new(p) ::TRecTofTrack : new ::TRecTofTrack;
4470 }
4471 static void *newArray_TRecTofTrack(Long_t nElements, void *p) {
4472 return p ? new(p) ::TRecTofTrack[nElements] : new ::TRecTofTrack[nElements];
4473 }
4474 // Wrapper around operator delete
4475 static void delete_TRecTofTrack(void *p) {
4476 delete ((::TRecTofTrack*)p);
4477 }
4478 static void deleteArray_TRecTofTrack(void *p) {
4479 delete [] ((::TRecTofTrack*)p);
4480 }
4481 static void destruct_TRecTofTrack(void *p) {
4482 typedef ::TRecTofTrack current_t;
4483 ((current_t*)p)->~current_t();
4484 }
4485} // end of namespace ROOT for class ::TRecTofTrack
4486
4487//______________________________________________________________________________
4488void TRecEmcHit::Streamer(TBuffer &R__b)
4489{
4490 // Stream an object of class TRecEmcHit.
4491
4492 if (R__b.IsReading()) {
4493 R__b.ReadClassBuffer(TRecEmcHit::Class(),this);
4494 } else {
4495 R__b.WriteClassBuffer(TRecEmcHit::Class(),this);
4496 }
4497}
4498
4499namespace ROOT {
4500 // Wrappers around operator new
4501 static void *new_TRecEmcHit(void *p) {
4502 return p ? new(p) ::TRecEmcHit : new ::TRecEmcHit;
4503 }
4504 static void *newArray_TRecEmcHit(Long_t nElements, void *p) {
4505 return p ? new(p) ::TRecEmcHit[nElements] : new ::TRecEmcHit[nElements];
4506 }
4507 // Wrapper around operator delete
4508 static void delete_TRecEmcHit(void *p) {
4509 delete ((::TRecEmcHit*)p);
4510 }
4511 static void deleteArray_TRecEmcHit(void *p) {
4512 delete [] ((::TRecEmcHit*)p);
4513 }
4514 static void destruct_TRecEmcHit(void *p) {
4515 typedef ::TRecEmcHit current_t;
4516 ((current_t*)p)->~current_t();
4517 }
4518} // end of namespace ROOT for class ::TRecEmcHit
4519
4520//______________________________________________________________________________
4521void TRecEmcCluster::Streamer(TBuffer &R__b)
4522{
4523 // Stream an object of class TRecEmcCluster.
4524
4525 if (R__b.IsReading()) {
4526 R__b.ReadClassBuffer(TRecEmcCluster::Class(),this);
4527 } else {
4528 R__b.WriteClassBuffer(TRecEmcCluster::Class(),this);
4529 }
4530}
4531
4532namespace ROOT {
4533 // Wrappers around operator new
4534 static void *new_TRecEmcCluster(void *p) {
4535 return p ? new(p) ::TRecEmcCluster : new ::TRecEmcCluster;
4536 }
4537 static void *newArray_TRecEmcCluster(Long_t nElements, void *p) {
4538 return p ? new(p) ::TRecEmcCluster[nElements] : new ::TRecEmcCluster[nElements];
4539 }
4540 // Wrapper around operator delete
4541 static void delete_TRecEmcCluster(void *p) {
4542 delete ((::TRecEmcCluster*)p);
4543 }
4544 static void deleteArray_TRecEmcCluster(void *p) {
4545 delete [] ((::TRecEmcCluster*)p);
4546 }
4547 static void destruct_TRecEmcCluster(void *p) {
4548 typedef ::TRecEmcCluster current_t;
4549 ((current_t*)p)->~current_t();
4550 }
4551} // end of namespace ROOT for class ::TRecEmcCluster
4552
4553//______________________________________________________________________________
4554void TRecEmcShower::Streamer(TBuffer &R__b)
4555{
4556 // Stream an object of class TRecEmcShower.
4557
4558 if (R__b.IsReading()) {
4559 R__b.ReadClassBuffer(TRecEmcShower::Class(),this);
4560 } else {
4561 R__b.WriteClassBuffer(TRecEmcShower::Class(),this);
4562 }
4563}
4564
4565namespace ROOT {
4566 // Wrappers around operator new
4567 static void *new_TRecEmcShower(void *p) {
4568 return p ? new(p) ::TRecEmcShower : new ::TRecEmcShower;
4569 }
4570 static void *newArray_TRecEmcShower(Long_t nElements, void *p) {
4571 return p ? new(p) ::TRecEmcShower[nElements] : new ::TRecEmcShower[nElements];
4572 }
4573 // Wrapper around operator delete
4574 static void delete_TRecEmcShower(void *p) {
4575 delete ((::TRecEmcShower*)p);
4576 }
4577 static void deleteArray_TRecEmcShower(void *p) {
4578 delete [] ((::TRecEmcShower*)p);
4579 }
4580 static void destruct_TRecEmcShower(void *p) {
4581 typedef ::TRecEmcShower current_t;
4582 ((current_t*)p)->~current_t();
4583 }
4584} // end of namespace ROOT for class ::TRecEmcShower
4585
4586//______________________________________________________________________________
4587void TRecMucTrack::Streamer(TBuffer &R__b)
4588{
4589 // Stream an object of class TRecMucTrack.
4590
4591 if (R__b.IsReading()) {
4592 R__b.ReadClassBuffer(TRecMucTrack::Class(),this);
4593 } else {
4594 R__b.WriteClassBuffer(TRecMucTrack::Class(),this);
4595 }
4596}
4597
4598namespace ROOT {
4599 // Wrappers around operator new
4600 static void *new_TRecMucTrack(void *p) {
4601 return p ? new(p) ::TRecMucTrack : new ::TRecMucTrack;
4602 }
4603 static void *newArray_TRecMucTrack(Long_t nElements, void *p) {
4604 return p ? new(p) ::TRecMucTrack[nElements] : new ::TRecMucTrack[nElements];
4605 }
4606 // Wrapper around operator delete
4607 static void delete_TRecMucTrack(void *p) {
4608 delete ((::TRecMucTrack*)p);
4609 }
4610 static void deleteArray_TRecMucTrack(void *p) {
4611 delete [] ((::TRecMucTrack*)p);
4612 }
4613 static void destruct_TRecMucTrack(void *p) {
4614 typedef ::TRecMucTrack current_t;
4615 ((current_t*)p)->~current_t();
4616 }
4617} // end of namespace ROOT for class ::TRecMucTrack
4618
4619//______________________________________________________________________________
4620void TRecMdcDedx::Streamer(TBuffer &R__b)
4621{
4622 // Stream an object of class TRecMdcDedx.
4623
4624 if (R__b.IsReading()) {
4625 R__b.ReadClassBuffer(TRecMdcDedx::Class(),this);
4626 } else {
4627 R__b.WriteClassBuffer(TRecMdcDedx::Class(),this);
4628 }
4629}
4630
4631namespace ROOT {
4632 // Wrappers around operator new
4633 static void *new_TRecMdcDedx(void *p) {
4634 return p ? new(p) ::TRecMdcDedx : new ::TRecMdcDedx;
4635 }
4636 static void *newArray_TRecMdcDedx(Long_t nElements, void *p) {
4637 return p ? new(p) ::TRecMdcDedx[nElements] : new ::TRecMdcDedx[nElements];
4638 }
4639 // Wrapper around operator delete
4640 static void delete_TRecMdcDedx(void *p) {
4641 delete ((::TRecMdcDedx*)p);
4642 }
4643 static void deleteArray_TRecMdcDedx(void *p) {
4644 delete [] ((::TRecMdcDedx*)p);
4645 }
4646 static void destruct_TRecMdcDedx(void *p) {
4647 typedef ::TRecMdcDedx current_t;
4648 ((current_t*)p)->~current_t();
4649 }
4650} // end of namespace ROOT for class ::TRecMdcDedx
4651
4652//______________________________________________________________________________
4653void TRecMdcDedxHit::Streamer(TBuffer &R__b)
4654{
4655 // Stream an object of class TRecMdcDedxHit.
4656
4657 if (R__b.IsReading()) {
4658 R__b.ReadClassBuffer(TRecMdcDedxHit::Class(),this);
4659 } else {
4660 R__b.WriteClassBuffer(TRecMdcDedxHit::Class(),this);
4661 }
4662}
4663
4664namespace ROOT {
4665 // Wrappers around operator new
4666 static void *new_TRecMdcDedxHit(void *p) {
4667 return p ? new(p) ::TRecMdcDedxHit : new ::TRecMdcDedxHit;
4668 }
4669 static void *newArray_TRecMdcDedxHit(Long_t nElements, void *p) {
4670 return p ? new(p) ::TRecMdcDedxHit[nElements] : new ::TRecMdcDedxHit[nElements];
4671 }
4672 // Wrapper around operator delete
4673 static void delete_TRecMdcDedxHit(void *p) {
4674 delete ((::TRecMdcDedxHit*)p);
4675 }
4676 static void deleteArray_TRecMdcDedxHit(void *p) {
4677 delete [] ((::TRecMdcDedxHit*)p);
4678 }
4679 static void destruct_TRecMdcDedxHit(void *p) {
4680 typedef ::TRecMdcDedxHit current_t;
4681 ((current_t*)p)->~current_t();
4682 }
4683} // end of namespace ROOT for class ::TRecMdcDedxHit
4684
4685//______________________________________________________________________________
4686void TRecExtTrack::Streamer(TBuffer &R__b)
4687{
4688 // Stream an object of class TRecExtTrack.
4689
4690 if (R__b.IsReading()) {
4691 R__b.ReadClassBuffer(TRecExtTrack::Class(),this);
4692 } else {
4693 R__b.WriteClassBuffer(TRecExtTrack::Class(),this);
4694 }
4695}
4696
4697namespace ROOT {
4698 // Wrappers around operator new
4699 static void *new_TRecExtTrack(void *p) {
4700 return p ? new(p) ::TRecExtTrack : new ::TRecExtTrack;
4701 }
4702 static void *newArray_TRecExtTrack(Long_t nElements, void *p) {
4703 return p ? new(p) ::TRecExtTrack[nElements] : new ::TRecExtTrack[nElements];
4704 }
4705 // Wrapper around operator delete
4706 static void delete_TRecExtTrack(void *p) {
4707 delete ((::TRecExtTrack*)p);
4708 }
4709 static void deleteArray_TRecExtTrack(void *p) {
4710 delete [] ((::TRecExtTrack*)p);
4711 }
4712 static void destruct_TRecExtTrack(void *p) {
4713 typedef ::TRecExtTrack current_t;
4714 ((current_t*)p)->~current_t();
4715 }
4716} // end of namespace ROOT for class ::TRecExtTrack
4717
4718//______________________________________________________________________________
4719void TRecEvTime::Streamer(TBuffer &R__b)
4720{
4721 // Stream an object of class TRecEvTime.
4722
4723 if (R__b.IsReading()) {
4724 R__b.ReadClassBuffer(TRecEvTime::Class(),this);
4725 } else {
4726 R__b.WriteClassBuffer(TRecEvTime::Class(),this);
4727 }
4728}
4729
4730namespace ROOT {
4731 // Wrappers around operator new
4732 static void *new_TRecEvTime(void *p) {
4733 return p ? new(p) ::TRecEvTime : new ::TRecEvTime;
4734 }
4735 static void *newArray_TRecEvTime(Long_t nElements, void *p) {
4736 return p ? new(p) ::TRecEvTime[nElements] : new ::TRecEvTime[nElements];
4737 }
4738 // Wrapper around operator delete
4739 static void delete_TRecEvTime(void *p) {
4740 delete ((::TRecEvTime*)p);
4741 }
4742 static void deleteArray_TRecEvTime(void *p) {
4743 delete [] ((::TRecEvTime*)p);
4744 }
4745 static void destruct_TRecEvTime(void *p) {
4746 typedef ::TRecEvTime current_t;
4747 ((current_t*)p)->~current_t();
4748 }
4749} // end of namespace ROOT for class ::TRecEvTime
4750
4751//______________________________________________________________________________
4752void TRecMdcKalHelixSeg::Streamer(TBuffer &R__b)
4753{
4754 // Stream an object of class TRecMdcKalHelixSeg.
4755
4756 if (R__b.IsReading()) {
4757 R__b.ReadClassBuffer(TRecMdcKalHelixSeg::Class(),this);
4758 } else {
4759 R__b.WriteClassBuffer(TRecMdcKalHelixSeg::Class(),this);
4760 }
4761}
4762
4763namespace ROOT {
4764 // Wrappers around operator new
4765 static void *new_TRecMdcKalHelixSeg(void *p) {
4766 return p ? new(p) ::TRecMdcKalHelixSeg : new ::TRecMdcKalHelixSeg;
4767 }
4768 static void *newArray_TRecMdcKalHelixSeg(Long_t nElements, void *p) {
4769 return p ? new(p) ::TRecMdcKalHelixSeg[nElements] : new ::TRecMdcKalHelixSeg[nElements];
4770 }
4771 // Wrapper around operator delete
4772 static void delete_TRecMdcKalHelixSeg(void *p) {
4773 delete ((::TRecMdcKalHelixSeg*)p);
4774 }
4775 static void deleteArray_TRecMdcKalHelixSeg(void *p) {
4776 delete [] ((::TRecMdcKalHelixSeg*)p);
4777 }
4778 static void destruct_TRecMdcKalHelixSeg(void *p) {
4779 typedef ::TRecMdcKalHelixSeg current_t;
4780 ((current_t*)p)->~current_t();
4781 }
4782} // end of namespace ROOT for class ::TRecMdcKalHelixSeg
4783
4784//______________________________________________________________________________
4785void TRecZddChannel::Streamer(TBuffer &R__b)
4786{
4787 // Stream an object of class TRecZddChannel.
4788
4789 if (R__b.IsReading()) {
4790 R__b.ReadClassBuffer(TRecZddChannel::Class(),this);
4791 } else {
4792 R__b.WriteClassBuffer(TRecZddChannel::Class(),this);
4793 }
4794}
4795
4796namespace ROOT {
4797 // Wrappers around operator new
4798 static void *new_TRecZddChannel(void *p) {
4799 return p ? new(p) ::TRecZddChannel : new ::TRecZddChannel;
4800 }
4801 static void *newArray_TRecZddChannel(Long_t nElements, void *p) {
4802 return p ? new(p) ::TRecZddChannel[nElements] : new ::TRecZddChannel[nElements];
4803 }
4804 // Wrapper around operator delete
4805 static void delete_TRecZddChannel(void *p) {
4806 delete ((::TRecZddChannel*)p);
4807 }
4808 static void deleteArray_TRecZddChannel(void *p) {
4809 delete [] ((::TRecZddChannel*)p);
4810 }
4811 static void destruct_TRecZddChannel(void *p) {
4812 typedef ::TRecZddChannel current_t;
4813 ((current_t*)p)->~current_t();
4814 }
4815} // end of namespace ROOT for class ::TRecZddChannel
4816
4817//______________________________________________________________________________
4818void TRecTrackEvent::Streamer(TBuffer &R__b)
4819{
4820 // Stream an object of class TRecTrackEvent.
4821
4822 if (R__b.IsReading()) {
4823 R__b.ReadClassBuffer(TRecTrackEvent::Class(),this);
4824 } else {
4825 R__b.WriteClassBuffer(TRecTrackEvent::Class(),this);
4826 }
4827}
4828
4829namespace ROOT {
4830 // Wrappers around operator new
4831 static void *new_TRecTrackEvent(void *p) {
4832 return p ? new(p) ::TRecTrackEvent : new ::TRecTrackEvent;
4833 }
4834 static void *newArray_TRecTrackEvent(Long_t nElements, void *p) {
4835 return p ? new(p) ::TRecTrackEvent[nElements] : new ::TRecTrackEvent[nElements];
4836 }
4837 // Wrapper around operator delete
4838 static void delete_TRecTrackEvent(void *p) {
4839 delete ((::TRecTrackEvent*)p);
4840 }
4841 static void deleteArray_TRecTrackEvent(void *p) {
4842 delete [] ((::TRecTrackEvent*)p);
4843 }
4844 static void destruct_TRecTrackEvent(void *p) {
4845 typedef ::TRecTrackEvent current_t;
4846 ((current_t*)p)->~current_t();
4847 }
4848} // end of namespace ROOT for class ::TRecTrackEvent
4849
4850//______________________________________________________________________________
4851void TMdcTrack::Streamer(TBuffer &R__b)
4852{
4853 // Stream an object of class TMdcTrack.
4854
4855 if (R__b.IsReading()) {
4856 R__b.ReadClassBuffer(TMdcTrack::Class(),this);
4857 } else {
4858 R__b.WriteClassBuffer(TMdcTrack::Class(),this);
4859 }
4860}
4861
4862namespace ROOT {
4863 // Wrappers around operator new
4864 static void *new_TMdcTrack(void *p) {
4865 return p ? new(p) ::TMdcTrack : new ::TMdcTrack;
4866 }
4867 static void *newArray_TMdcTrack(Long_t nElements, void *p) {
4868 return p ? new(p) ::TMdcTrack[nElements] : new ::TMdcTrack[nElements];
4869 }
4870 // Wrapper around operator delete
4871 static void delete_TMdcTrack(void *p) {
4872 delete ((::TMdcTrack*)p);
4873 }
4874 static void deleteArray_TMdcTrack(void *p) {
4875 delete [] ((::TMdcTrack*)p);
4876 }
4877 static void destruct_TMdcTrack(void *p) {
4878 typedef ::TMdcTrack current_t;
4879 ((current_t*)p)->~current_t();
4880 }
4881} // end of namespace ROOT for class ::TMdcTrack
4882
4883//______________________________________________________________________________
4884void TEmcTrack::Streamer(TBuffer &R__b)
4885{
4886 // Stream an object of class TEmcTrack.
4887
4888 if (R__b.IsReading()) {
4889 R__b.ReadClassBuffer(TEmcTrack::Class(),this);
4890 } else {
4891 R__b.WriteClassBuffer(TEmcTrack::Class(),this);
4892 }
4893}
4894
4895namespace ROOT {
4896 // Wrappers around operator new
4897 static void *new_TEmcTrack(void *p) {
4898 return p ? new(p) ::TEmcTrack : new ::TEmcTrack;
4899 }
4900 static void *newArray_TEmcTrack(Long_t nElements, void *p) {
4901 return p ? new(p) ::TEmcTrack[nElements] : new ::TEmcTrack[nElements];
4902 }
4903 // Wrapper around operator delete
4904 static void delete_TEmcTrack(void *p) {
4905 delete ((::TEmcTrack*)p);
4906 }
4907 static void deleteArray_TEmcTrack(void *p) {
4908 delete [] ((::TEmcTrack*)p);
4909 }
4910 static void destruct_TEmcTrack(void *p) {
4911 typedef ::TEmcTrack current_t;
4912 ((current_t*)p)->~current_t();
4913 }
4914} // end of namespace ROOT for class ::TEmcTrack
4915
4916//______________________________________________________________________________
4917void TMucTrack::Streamer(TBuffer &R__b)
4918{
4919 // Stream an object of class TMucTrack.
4920
4921 if (R__b.IsReading()) {
4922 R__b.ReadClassBuffer(TMucTrack::Class(),this);
4923 } else {
4924 R__b.WriteClassBuffer(TMucTrack::Class(),this);
4925 }
4926}
4927
4928namespace ROOT {
4929 // Wrappers around operator new
4930 static void *new_TMucTrack(void *p) {
4931 return p ? new(p) ::TMucTrack : new ::TMucTrack;
4932 }
4933 static void *newArray_TMucTrack(Long_t nElements, void *p) {
4934 return p ? new(p) ::TMucTrack[nElements] : new ::TMucTrack[nElements];
4935 }
4936 // Wrapper around operator delete
4937 static void delete_TMucTrack(void *p) {
4938 delete ((::TMucTrack*)p);
4939 }
4940 static void deleteArray_TMucTrack(void *p) {
4941 delete [] ((::TMucTrack*)p);
4942 }
4943 static void destruct_TMucTrack(void *p) {
4944 typedef ::TMucTrack current_t;
4945 ((current_t*)p)->~current_t();
4946 }
4947} // end of namespace ROOT for class ::TMucTrack
4948
4949//______________________________________________________________________________
4950void TMdcDedx::Streamer(TBuffer &R__b)
4951{
4952 // Stream an object of class TMdcDedx.
4953
4954 if (R__b.IsReading()) {
4955 R__b.ReadClassBuffer(TMdcDedx::Class(),this);
4956 } else {
4957 R__b.WriteClassBuffer(TMdcDedx::Class(),this);
4958 }
4959}
4960
4961namespace ROOT {
4962 // Wrappers around operator new
4963 static void *new_TMdcDedx(void *p) {
4964 return p ? new(p) ::TMdcDedx : new ::TMdcDedx;
4965 }
4966 static void *newArray_TMdcDedx(Long_t nElements, void *p) {
4967 return p ? new(p) ::TMdcDedx[nElements] : new ::TMdcDedx[nElements];
4968 }
4969 // Wrapper around operator delete
4970 static void delete_TMdcDedx(void *p) {
4971 delete ((::TMdcDedx*)p);
4972 }
4973 static void deleteArray_TMdcDedx(void *p) {
4974 delete [] ((::TMdcDedx*)p);
4975 }
4976 static void destruct_TMdcDedx(void *p) {
4977 typedef ::TMdcDedx current_t;
4978 ((current_t*)p)->~current_t();
4979 }
4980} // end of namespace ROOT for class ::TMdcDedx
4981
4982//______________________________________________________________________________
4983void TExtTrack::Streamer(TBuffer &R__b)
4984{
4985 // Stream an object of class TExtTrack.
4986
4987 if (R__b.IsReading()) {
4988 R__b.ReadClassBuffer(TExtTrack::Class(),this);
4989 } else {
4990 R__b.WriteClassBuffer(TExtTrack::Class(),this);
4991 }
4992}
4993
4994namespace ROOT {
4995 // Wrappers around operator new
4996 static void *new_TExtTrack(void *p) {
4997 return p ? new(p) ::TExtTrack : new ::TExtTrack;
4998 }
4999 static void *newArray_TExtTrack(Long_t nElements, void *p) {
5000 return p ? new(p) ::TExtTrack[nElements] : new ::TExtTrack[nElements];
5001 }
5002 // Wrapper around operator delete
5003 static void delete_TExtTrack(void *p) {
5004 delete ((::TExtTrack*)p);
5005 }
5006 static void deleteArray_TExtTrack(void *p) {
5007 delete [] ((::TExtTrack*)p);
5008 }
5009 static void destruct_TExtTrack(void *p) {
5010 typedef ::TExtTrack current_t;
5011 ((current_t*)p)->~current_t();
5012 }
5013} // end of namespace ROOT for class ::TExtTrack
5014
5015//______________________________________________________________________________
5016void TMdcKalTrack::Streamer(TBuffer &R__b)
5017{
5018 // Stream an object of class TMdcKalTrack.
5019
5020 if (R__b.IsReading()) {
5021 R__b.ReadClassBuffer(TMdcKalTrack::Class(),this);
5022 } else {
5023 R__b.WriteClassBuffer(TMdcKalTrack::Class(),this);
5024 }
5025}
5026
5027namespace ROOT {
5028 // Wrappers around operator new
5029 static void *new_TMdcKalTrack(void *p) {
5030 return p ? new(p) ::TMdcKalTrack : new ::TMdcKalTrack;
5031 }
5032 static void *newArray_TMdcKalTrack(Long_t nElements, void *p) {
5033 return p ? new(p) ::TMdcKalTrack[nElements] : new ::TMdcKalTrack[nElements];
5034 }
5035 // Wrapper around operator delete
5036 static void delete_TMdcKalTrack(void *p) {
5037 delete ((::TMdcKalTrack*)p);
5038 }
5039 static void deleteArray_TMdcKalTrack(void *p) {
5040 delete [] ((::TMdcKalTrack*)p);
5041 }
5042 static void destruct_TMdcKalTrack(void *p) {
5043 typedef ::TMdcKalTrack current_t;
5044 ((current_t*)p)->~current_t();
5045 }
5046} // end of namespace ROOT for class ::TMdcKalTrack
5047
5048//______________________________________________________________________________
5049void TDstEvent::Streamer(TBuffer &R__b)
5050{
5051 // Stream an object of class TDstEvent.
5052
5053 if (R__b.IsReading()) {
5054 R__b.ReadClassBuffer(TDstEvent::Class(),this);
5055 } else {
5056 R__b.WriteClassBuffer(TDstEvent::Class(),this);
5057 }
5058}
5059
5060namespace ROOT {
5061 // Wrappers around operator new
5062 static void *new_TDstEvent(void *p) {
5063 return p ? new(p) ::TDstEvent : new ::TDstEvent;
5064 }
5065 static void *newArray_TDstEvent(Long_t nElements, void *p) {
5066 return p ? new(p) ::TDstEvent[nElements] : new ::TDstEvent[nElements];
5067 }
5068 // Wrapper around operator delete
5069 static void delete_TDstEvent(void *p) {
5070 delete ((::TDstEvent*)p);
5071 }
5072 static void deleteArray_TDstEvent(void *p) {
5073 delete [] ((::TDstEvent*)p);
5074 }
5075 static void destruct_TDstEvent(void *p) {
5076 typedef ::TDstEvent current_t;
5077 ((current_t*)p)->~current_t();
5078 }
5079} // end of namespace ROOT for class ::TDstEvent
5080
5081//______________________________________________________________________________
5082void TMdcMc::Streamer(TBuffer &R__b)
5083{
5084 // Stream an object of class TMdcMc.
5085
5086 if (R__b.IsReading()) {
5087 R__b.ReadClassBuffer(TMdcMc::Class(),this);
5088 } else {
5089 R__b.WriteClassBuffer(TMdcMc::Class(),this);
5090 }
5091}
5092
5093namespace ROOT {
5094 // Wrappers around operator new
5095 static void *new_TMdcMc(void *p) {
5096 return p ? new(p) ::TMdcMc : new ::TMdcMc;
5097 }
5098 static void *newArray_TMdcMc(Long_t nElements, void *p) {
5099 return p ? new(p) ::TMdcMc[nElements] : new ::TMdcMc[nElements];
5100 }
5101 // Wrapper around operator delete
5102 static void delete_TMdcMc(void *p) {
5103 delete ((::TMdcMc*)p);
5104 }
5105 static void deleteArray_TMdcMc(void *p) {
5106 delete [] ((::TMdcMc*)p);
5107 }
5108 static void destruct_TMdcMc(void *p) {
5109 typedef ::TMdcMc current_t;
5110 ((current_t*)p)->~current_t();
5111 }
5112} // end of namespace ROOT for class ::TMdcMc
5113
5114//______________________________________________________________________________
5115void TEmcMc::Streamer(TBuffer &R__b)
5116{
5117 // Stream an object of class TEmcMc.
5118
5119 if (R__b.IsReading()) {
5120 R__b.ReadClassBuffer(TEmcMc::Class(),this);
5121 } else {
5122 R__b.WriteClassBuffer(TEmcMc::Class(),this);
5123 }
5124}
5125
5126namespace ROOT {
5127 // Wrappers around operator new
5128 static void *new_TEmcMc(void *p) {
5129 return p ? new(p) ::TEmcMc : new ::TEmcMc;
5130 }
5131 static void *newArray_TEmcMc(Long_t nElements, void *p) {
5132 return p ? new(p) ::TEmcMc[nElements] : new ::TEmcMc[nElements];
5133 }
5134 // Wrapper around operator delete
5135 static void delete_TEmcMc(void *p) {
5136 delete ((::TEmcMc*)p);
5137 }
5138 static void deleteArray_TEmcMc(void *p) {
5139 delete [] ((::TEmcMc*)p);
5140 }
5141 static void destruct_TEmcMc(void *p) {
5142 typedef ::TEmcMc current_t;
5143 ((current_t*)p)->~current_t();
5144 }
5145} // end of namespace ROOT for class ::TEmcMc
5146
5147//______________________________________________________________________________
5148void TTofMc::Streamer(TBuffer &R__b)
5149{
5150 // Stream an object of class TTofMc.
5151
5152 if (R__b.IsReading()) {
5153 R__b.ReadClassBuffer(TTofMc::Class(),this);
5154 } else {
5155 R__b.WriteClassBuffer(TTofMc::Class(),this);
5156 }
5157}
5158
5159namespace ROOT {
5160 // Wrappers around operator new
5161 static void *new_TTofMc(void *p) {
5162 return p ? new(p) ::TTofMc : new ::TTofMc;
5163 }
5164 static void *newArray_TTofMc(Long_t nElements, void *p) {
5165 return p ? new(p) ::TTofMc[nElements] : new ::TTofMc[nElements];
5166 }
5167 // Wrapper around operator delete
5168 static void delete_TTofMc(void *p) {
5169 delete ((::TTofMc*)p);
5170 }
5171 static void deleteArray_TTofMc(void *p) {
5172 delete [] ((::TTofMc*)p);
5173 }
5174 static void destruct_TTofMc(void *p) {
5175 typedef ::TTofMc current_t;
5176 ((current_t*)p)->~current_t();
5177 }
5178} // end of namespace ROOT for class ::TTofMc
5179
5180//______________________________________________________________________________
5181void TMucMc::Streamer(TBuffer &R__b)
5182{
5183 // Stream an object of class TMucMc.
5184
5185 if (R__b.IsReading()) {
5186 R__b.ReadClassBuffer(TMucMc::Class(),this);
5187 } else {
5188 R__b.WriteClassBuffer(TMucMc::Class(),this);
5189 }
5190}
5191
5192namespace ROOT {
5193 // Wrappers around operator new
5194 static void *new_TMucMc(void *p) {
5195 return p ? new(p) ::TMucMc : new ::TMucMc;
5196 }
5197 static void *newArray_TMucMc(Long_t nElements, void *p) {
5198 return p ? new(p) ::TMucMc[nElements] : new ::TMucMc[nElements];
5199 }
5200 // Wrapper around operator delete
5201 static void delete_TMucMc(void *p) {
5202 delete ((::TMucMc*)p);
5203 }
5204 static void deleteArray_TMucMc(void *p) {
5205 delete [] ((::TMucMc*)p);
5206 }
5207 static void destruct_TMucMc(void *p) {
5208 typedef ::TMucMc current_t;
5209 ((current_t*)p)->~current_t();
5210 }
5211} // end of namespace ROOT for class ::TMucMc
5212
5213//______________________________________________________________________________
5214void TMcParticle::Streamer(TBuffer &R__b)
5215{
5216 // Stream an object of class TMcParticle.
5217
5218 if (R__b.IsReading()) {
5219 R__b.ReadClassBuffer(TMcParticle::Class(),this);
5220 } else {
5221 R__b.WriteClassBuffer(TMcParticle::Class(),this);
5222 }
5223}
5224
5225namespace ROOT {
5226 // Wrappers around operator new
5227 static void *new_TMcParticle(void *p) {
5228 return p ? new(p) ::TMcParticle : new ::TMcParticle;
5229 }
5230 static void *newArray_TMcParticle(Long_t nElements, void *p) {
5231 return p ? new(p) ::TMcParticle[nElements] : new ::TMcParticle[nElements];
5232 }
5233 // Wrapper around operator delete
5234 static void delete_TMcParticle(void *p) {
5235 delete ((::TMcParticle*)p);
5236 }
5237 static void deleteArray_TMcParticle(void *p) {
5238 delete [] ((::TMcParticle*)p);
5239 }
5240 static void destruct_TMcParticle(void *p) {
5241 typedef ::TMcParticle current_t;
5242 ((current_t*)p)->~current_t();
5243 }
5244} // end of namespace ROOT for class ::TMcParticle
5245
5246//______________________________________________________________________________
5247void TMcEvent::Streamer(TBuffer &R__b)
5248{
5249 // Stream an object of class TMcEvent.
5250
5251 if (R__b.IsReading()) {
5252 R__b.ReadClassBuffer(TMcEvent::Class(),this);
5253 } else {
5254 R__b.WriteClassBuffer(TMcEvent::Class(),this);
5255 }
5256}
5257
5258namespace ROOT {
5259 // Wrappers around operator new
5260 static void *new_TMcEvent(void *p) {
5261 return p ? new(p) ::TMcEvent : new ::TMcEvent;
5262 }
5263 static void *newArray_TMcEvent(Long_t nElements, void *p) {
5264 return p ? new(p) ::TMcEvent[nElements] : new ::TMcEvent[nElements];
5265 }
5266 // Wrapper around operator delete
5267 static void delete_TMcEvent(void *p) {
5268 delete ((::TMcEvent*)p);
5269 }
5270 static void deleteArray_TMcEvent(void *p) {
5271 delete [] ((::TMcEvent*)p);
5272 }
5273 static void destruct_TMcEvent(void *p) {
5274 typedef ::TMcEvent current_t;
5275 ((current_t*)p)->~current_t();
5276 }
5277} // end of namespace ROOT for class ::TMcEvent
5278
5279//______________________________________________________________________________
5280void TEvtHeader::Streamer(TBuffer &R__b)
5281{
5282 // Stream an object of class TEvtHeader.
5283
5284 if (R__b.IsReading()) {
5285 R__b.ReadClassBuffer(TEvtHeader::Class(),this);
5286 } else {
5287 R__b.WriteClassBuffer(TEvtHeader::Class(),this);
5288 }
5289}
5290
5291namespace ROOT {
5292 // Wrappers around operator new
5293 static void *new_TEvtHeader(void *p) {
5294 return p ? new(p) ::TEvtHeader : new ::TEvtHeader;
5295 }
5296 static void *newArray_TEvtHeader(Long_t nElements, void *p) {
5297 return p ? new(p) ::TEvtHeader[nElements] : new ::TEvtHeader[nElements];
5298 }
5299 // Wrapper around operator delete
5300 static void delete_TEvtHeader(void *p) {
5301 delete ((::TEvtHeader*)p);
5302 }
5303 static void deleteArray_TEvtHeader(void *p) {
5304 delete [] ((::TEvtHeader*)p);
5305 }
5306 static void destruct_TEvtHeader(void *p) {
5307 typedef ::TEvtHeader current_t;
5308 ((current_t*)p)->~current_t();
5309 }
5310} // end of namespace ROOT for class ::TEvtHeader
5311
5312//______________________________________________________________________________
5313void TEvtNavigator::Streamer(TBuffer &R__b)
5314{
5315 // Stream an object of class TEvtNavigator.
5316
5317 if (R__b.IsReading()) {
5318 R__b.ReadClassBuffer(TEvtNavigator::Class(),this);
5319 } else {
5320 R__b.WriteClassBuffer(TEvtNavigator::Class(),this);
5321 }
5322}
5323
5324namespace ROOT {
5325 // Wrappers around operator new
5326 static void *new_TEvtNavigator(void *p) {
5327 return p ? new(p) ::TEvtNavigator : new ::TEvtNavigator;
5328 }
5329 static void *newArray_TEvtNavigator(Long_t nElements, void *p) {
5330 return p ? new(p) ::TEvtNavigator[nElements] : new ::TEvtNavigator[nElements];
5331 }
5332 // Wrapper around operator delete
5333 static void delete_TEvtNavigator(void *p) {
5334 delete ((::TEvtNavigator*)p);
5335 }
5336 static void deleteArray_TEvtNavigator(void *p) {
5337 delete [] ((::TEvtNavigator*)p);
5338 }
5339 static void destruct_TEvtNavigator(void *p) {
5340 typedef ::TEvtNavigator current_t;
5341 ((current_t*)p)->~current_t();
5342 }
5343} // end of namespace ROOT for class ::TEvtNavigator
5344
5345//______________________________________________________________________________
5346void TTrigData::Streamer(TBuffer &R__b)
5347{
5348 // Stream an object of class TTrigData.
5349
5350 if (R__b.IsReading()) {
5351 R__b.ReadClassBuffer(TTrigData::Class(),this);
5352 } else {
5353 R__b.WriteClassBuffer(TTrigData::Class(),this);
5354 }
5355}
5356
5357namespace ROOT {
5358 // Wrappers around operator new
5359 static void *new_TTrigData(void *p) {
5360 return p ? new(p) ::TTrigData : new ::TTrigData;
5361 }
5362 static void *newArray_TTrigData(Long_t nElements, void *p) {
5363 return p ? new(p) ::TTrigData[nElements] : new ::TTrigData[nElements];
5364 }
5365 // Wrapper around operator delete
5366 static void delete_TTrigData(void *p) {
5367 delete ((::TTrigData*)p);
5368 }
5369 static void deleteArray_TTrigData(void *p) {
5370 delete [] ((::TTrigData*)p);
5371 }
5372 static void destruct_TTrigData(void *p) {
5373 typedef ::TTrigData current_t;
5374 ((current_t*)p)->~current_t();
5375 }
5376} // end of namespace ROOT for class ::TTrigData
5377
5378//______________________________________________________________________________
5379void TTrigEvent::Streamer(TBuffer &R__b)
5380{
5381 // Stream an object of class TTrigEvent.
5382
5383 if (R__b.IsReading()) {
5384 R__b.ReadClassBuffer(TTrigEvent::Class(),this);
5385 } else {
5386 R__b.WriteClassBuffer(TTrigEvent::Class(),this);
5387 }
5388}
5389
5390namespace ROOT {
5391 // Wrappers around operator new
5392 static void *new_TTrigEvent(void *p) {
5393 return p ? new(p) ::TTrigEvent : new ::TTrigEvent;
5394 }
5395 static void *newArray_TTrigEvent(Long_t nElements, void *p) {
5396 return p ? new(p) ::TTrigEvent[nElements] : new ::TTrigEvent[nElements];
5397 }
5398 // Wrapper around operator delete
5399 static void delete_TTrigEvent(void *p) {
5400 delete ((::TTrigEvent*)p);
5401 }
5402 static void deleteArray_TTrigEvent(void *p) {
5403 delete [] ((::TTrigEvent*)p);
5404 }
5405 static void destruct_TTrigEvent(void *p) {
5406 typedef ::TTrigEvent current_t;
5407 ((current_t*)p)->~current_t();
5408 }
5409} // end of namespace ROOT for class ::TTrigEvent
5410
5411//______________________________________________________________________________
5412void THltRaw::Streamer(TBuffer &R__b)
5413{
5414 // Stream an object of class THltRaw.
5415
5416 if (R__b.IsReading()) {
5417 R__b.ReadClassBuffer(THltRaw::Class(),this);
5418 } else {
5419 R__b.WriteClassBuffer(THltRaw::Class(),this);
5420 }
5421}
5422
5423namespace ROOT {
5424 // Wrappers around operator new
5425 static void *new_THltRaw(void *p) {
5426 return p ? new(p) ::THltRaw : new ::THltRaw;
5427 }
5428 static void *newArray_THltRaw(Long_t nElements, void *p) {
5429 return p ? new(p) ::THltRaw[nElements] : new ::THltRaw[nElements];
5430 }
5431 // Wrapper around operator delete
5432 static void delete_THltRaw(void *p) {
5433 delete ((::THltRaw*)p);
5434 }
5435 static void deleteArray_THltRaw(void *p) {
5436 delete [] ((::THltRaw*)p);
5437 }
5438 static void destruct_THltRaw(void *p) {
5439 typedef ::THltRaw current_t;
5440 ((current_t*)p)->~current_t();
5441 }
5442} // end of namespace ROOT for class ::THltRaw
5443
5444//______________________________________________________________________________
5445void THltInf::Streamer(TBuffer &R__b)
5446{
5447 // Stream an object of class THltInf.
5448
5449 if (R__b.IsReading()) {
5450 R__b.ReadClassBuffer(THltInf::Class(),this);
5451 } else {
5452 R__b.WriteClassBuffer(THltInf::Class(),this);
5453 }
5454}
5455
5456namespace ROOT {
5457 // Wrappers around operator new
5458 static void *new_THltInf(void *p) {
5459 return p ? new(p) ::THltInf : new ::THltInf;
5460 }
5461 static void *newArray_THltInf(Long_t nElements, void *p) {
5462 return p ? new(p) ::THltInf[nElements] : new ::THltInf[nElements];
5463 }
5464 // Wrapper around operator delete
5465 static void delete_THltInf(void *p) {
5466 delete ((::THltInf*)p);
5467 }
5468 static void deleteArray_THltInf(void *p) {
5469 delete [] ((::THltInf*)p);
5470 }
5471 static void destruct_THltInf(void *p) {
5472 typedef ::THltInf current_t;
5473 ((current_t*)p)->~current_t();
5474 }
5475} // end of namespace ROOT for class ::THltInf
5476
5477//______________________________________________________________________________
5478void TDstHltInf::Streamer(TBuffer &R__b)
5479{
5480 // Stream an object of class TDstHltInf.
5481
5482 if (R__b.IsReading()) {
5483 R__b.ReadClassBuffer(TDstHltInf::Class(),this);
5484 } else {
5485 R__b.WriteClassBuffer(TDstHltInf::Class(),this);
5486 }
5487}
5488
5489namespace ROOT {
5490 // Wrappers around operator new
5491 static void *new_TDstHltInf(void *p) {
5492 return p ? new(p) ::TDstHltInf : new ::TDstHltInf;
5493 }
5494 static void *newArray_TDstHltInf(Long_t nElements, void *p) {
5495 return p ? new(p) ::TDstHltInf[nElements] : new ::TDstHltInf[nElements];
5496 }
5497 // Wrapper around operator delete
5498 static void delete_TDstHltInf(void *p) {
5499 delete ((::TDstHltInf*)p);
5500 }
5501 static void deleteArray_TDstHltInf(void *p) {
5502 delete [] ((::TDstHltInf*)p);
5503 }
5504 static void destruct_TDstHltInf(void *p) {
5505 typedef ::TDstHltInf current_t;
5506 ((current_t*)p)->~current_t();
5507 }
5508} // end of namespace ROOT for class ::TDstHltInf
5509
5510//______________________________________________________________________________
5511void THltEvent::Streamer(TBuffer &R__b)
5512{
5513 // Stream an object of class THltEvent.
5514
5515 if (R__b.IsReading()) {
5516 R__b.ReadClassBuffer(THltEvent::Class(),this);
5517 } else {
5518 R__b.WriteClassBuffer(THltEvent::Class(),this);
5519 }
5520}
5521
5522namespace ROOT {
5523 // Wrappers around operator new
5524 static void *new_THltEvent(void *p) {
5525 return p ? new(p) ::THltEvent : new ::THltEvent;
5526 }
5527 static void *newArray_THltEvent(Long_t nElements, void *p) {
5528 return p ? new(p) ::THltEvent[nElements] : new ::THltEvent[nElements];
5529 }
5530 // Wrapper around operator delete
5531 static void delete_THltEvent(void *p) {
5532 delete ((::THltEvent*)p);
5533 }
5534 static void deleteArray_THltEvent(void *p) {
5535 delete [] ((::THltEvent*)p);
5536 }
5537 static void destruct_THltEvent(void *p) {
5538 typedef ::THltEvent current_t;
5539 ((current_t*)p)->~current_t();
5540 }
5541} // end of namespace ROOT for class ::THltEvent
5542
5543//______________________________________________________________________________
5544void TDisTrack::Streamer(TBuffer &R__b)
5545{
5546 // Stream an object of class TDisTrack.
5547
5548 UInt_t R__s, R__c;
5549 if (R__b.IsReading()) {
5550 Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
5551 TObject::Streamer(R__b);
5552 R__b >> m_recMdcTrackCol;
5553 R__b >> m_recTofTrackCol;
5554 R__b >> m_recMdcHitCol;
5555 R__b >> m_recMucTrackCol;
5556 R__b >> m_recEmcShowerCol;
5557 R__b.CheckByteCount(R__s, R__c, TDisTrack::IsA());
5558 } else {
5559 R__c = R__b.WriteVersion(TDisTrack::IsA(), kTRUE);
5560 TObject::Streamer(R__b);
5561 R__b << m_recMdcTrackCol;
5562 R__b << m_recTofTrackCol;
5563 R__b << m_recMdcHitCol;
5564 R__b << m_recMucTrackCol;
5565 R__b << m_recEmcShowerCol;
5566 R__b.SetByteCount(R__c, kTRUE);
5567 }
5568}
5569
5570namespace ROOT {
5571 // Wrappers around operator new
5572 static void *new_TDisTrack(void *p) {
5573 return p ? new(p) ::TDisTrack : new ::TDisTrack;
5574 }
5575 static void *newArray_TDisTrack(Long_t nElements, void *p) {
5576 return p ? new(p) ::TDisTrack[nElements] : new ::TDisTrack[nElements];
5577 }
5578 // Wrapper around operator delete
5579 static void delete_TDisTrack(void *p) {
5580 delete ((::TDisTrack*)p);
5581 }
5582 static void deleteArray_TDisTrack(void *p) {
5583 delete [] ((::TDisTrack*)p);
5584 }
5585 static void destruct_TDisTrack(void *p) {
5586 typedef ::TDisTrack current_t;
5587 ((current_t*)p)->~current_t();
5588 }
5589 // Wrapper around a custom streamer member function.
5590 static void streamer_TDisTrack(TBuffer &buf, void *obj) {
5591 ((::TDisTrack*)obj)->::TDisTrack::Streamer(buf);
5592 }
5593} // end of namespace ROOT for class ::TDisTrack
5594
5595//______________________________________________________________________________
5596void TEvtRecEvent::Streamer(TBuffer &R__b)
5597{
5598 // Stream an object of class TEvtRecEvent.
5599
5600 if (R__b.IsReading()) {
5601 R__b.ReadClassBuffer(TEvtRecEvent::Class(),this);
5602 } else {
5603 R__b.WriteClassBuffer(TEvtRecEvent::Class(),this);
5604 }
5605}
5606
5607namespace ROOT {
5608 // Wrappers around operator new
5609 static void *new_TEvtRecEvent(void *p) {
5610 return p ? new(p) ::TEvtRecEvent : new ::TEvtRecEvent;
5611 }
5612 static void *newArray_TEvtRecEvent(Long_t nElements, void *p) {
5613 return p ? new(p) ::TEvtRecEvent[nElements] : new ::TEvtRecEvent[nElements];
5614 }
5615 // Wrapper around operator delete
5616 static void delete_TEvtRecEvent(void *p) {
5617 delete ((::TEvtRecEvent*)p);
5618 }
5619 static void deleteArray_TEvtRecEvent(void *p) {
5620 delete [] ((::TEvtRecEvent*)p);
5621 }
5622 static void destruct_TEvtRecEvent(void *p) {
5623 typedef ::TEvtRecEvent current_t;
5624 ((current_t*)p)->~current_t();
5625 }
5626} // end of namespace ROOT for class ::TEvtRecEvent
5627
5628//______________________________________________________________________________
5629void TEvtRecTrack::Streamer(TBuffer &R__b)
5630{
5631 // Stream an object of class TEvtRecTrack.
5632
5633 if (R__b.IsReading()) {
5634 R__b.ReadClassBuffer(TEvtRecTrack::Class(),this);
5635 } else {
5636 R__b.WriteClassBuffer(TEvtRecTrack::Class(),this);
5637 }
5638}
5639
5640namespace ROOT {
5641 // Wrappers around operator new
5642 static void *new_TEvtRecTrack(void *p) {
5643 return p ? new(p) ::TEvtRecTrack : new ::TEvtRecTrack;
5644 }
5645 static void *newArray_TEvtRecTrack(Long_t nElements, void *p) {
5646 return p ? new(p) ::TEvtRecTrack[nElements] : new ::TEvtRecTrack[nElements];
5647 }
5648 // Wrapper around operator delete
5649 static void delete_TEvtRecTrack(void *p) {
5650 delete ((::TEvtRecTrack*)p);
5651 }
5652 static void deleteArray_TEvtRecTrack(void *p) {
5653 delete [] ((::TEvtRecTrack*)p);
5654 }
5655 static void destruct_TEvtRecTrack(void *p) {
5656 typedef ::TEvtRecTrack current_t;
5657 ((current_t*)p)->~current_t();
5658 }
5659} // end of namespace ROOT for class ::TEvtRecTrack
5660
5661//______________________________________________________________________________
5662void TEvtRecPrimaryVertex::Streamer(TBuffer &R__b)
5663{
5664 // Stream an object of class TEvtRecPrimaryVertex.
5665
5666 if (R__b.IsReading()) {
5667 R__b.ReadClassBuffer(TEvtRecPrimaryVertex::Class(),this);
5668 } else {
5669 R__b.WriteClassBuffer(TEvtRecPrimaryVertex::Class(),this);
5670 }
5671}
5672
5673namespace ROOT {
5674 // Wrappers around operator new
5675 static void *new_TEvtRecPrimaryVertex(void *p) {
5676 return p ? new(p) ::TEvtRecPrimaryVertex : new ::TEvtRecPrimaryVertex;
5677 }
5678 static void *newArray_TEvtRecPrimaryVertex(Long_t nElements, void *p) {
5679 return p ? new(p) ::TEvtRecPrimaryVertex[nElements] : new ::TEvtRecPrimaryVertex[nElements];
5680 }
5681 // Wrapper around operator delete
5682 static void delete_TEvtRecPrimaryVertex(void *p) {
5683 delete ((::TEvtRecPrimaryVertex*)p);
5684 }
5685 static void deleteArray_TEvtRecPrimaryVertex(void *p) {
5686 delete [] ((::TEvtRecPrimaryVertex*)p);
5687 }
5688 static void destruct_TEvtRecPrimaryVertex(void *p) {
5689 typedef ::TEvtRecPrimaryVertex current_t;
5690 ((current_t*)p)->~current_t();
5691 }
5692} // end of namespace ROOT for class ::TEvtRecPrimaryVertex
5693
5694//______________________________________________________________________________
5695void TEvtRecVeeVertex::Streamer(TBuffer &R__b)
5696{
5697 // Stream an object of class TEvtRecVeeVertex.
5698
5699 if (R__b.IsReading()) {
5700 R__b.ReadClassBuffer(TEvtRecVeeVertex::Class(),this);
5701 } else {
5702 R__b.WriteClassBuffer(TEvtRecVeeVertex::Class(),this);
5703 }
5704}
5705
5706namespace ROOT {
5707 // Wrappers around operator new
5708 static void *new_TEvtRecVeeVertex(void *p) {
5709 return p ? new(p) ::TEvtRecVeeVertex : new ::TEvtRecVeeVertex;
5710 }
5711 static void *newArray_TEvtRecVeeVertex(Long_t nElements, void *p) {
5712 return p ? new(p) ::TEvtRecVeeVertex[nElements] : new ::TEvtRecVeeVertex[nElements];
5713 }
5714 // Wrapper around operator delete
5715 static void delete_TEvtRecVeeVertex(void *p) {
5716 delete ((::TEvtRecVeeVertex*)p);
5717 }
5718 static void deleteArray_TEvtRecVeeVertex(void *p) {
5719 delete [] ((::TEvtRecVeeVertex*)p);
5720 }
5721 static void destruct_TEvtRecVeeVertex(void *p) {
5722 typedef ::TEvtRecVeeVertex current_t;
5723 ((current_t*)p)->~current_t();
5724 }
5725} // end of namespace ROOT for class ::TEvtRecVeeVertex
5726
5727//______________________________________________________________________________
5728void TEvtRecPi0::Streamer(TBuffer &R__b)
5729{
5730 // Stream an object of class TEvtRecPi0.
5731
5732 if (R__b.IsReading()) {
5733 R__b.ReadClassBuffer(TEvtRecPi0::Class(),this);
5734 } else {
5735 R__b.WriteClassBuffer(TEvtRecPi0::Class(),this);
5736 }
5737}
5738
5739namespace ROOT {
5740 // Wrappers around operator new
5741 static void *new_TEvtRecPi0(void *p) {
5742 return p ? new(p) ::TEvtRecPi0 : new ::TEvtRecPi0;
5743 }
5744 static void *newArray_TEvtRecPi0(Long_t nElements, void *p) {
5745 return p ? new(p) ::TEvtRecPi0[nElements] : new ::TEvtRecPi0[nElements];
5746 }
5747 // Wrapper around operator delete
5748 static void delete_TEvtRecPi0(void *p) {
5749 delete ((::TEvtRecPi0*)p);
5750 }
5751 static void deleteArray_TEvtRecPi0(void *p) {
5752 delete [] ((::TEvtRecPi0*)p);
5753 }
5754 static void destruct_TEvtRecPi0(void *p) {
5755 typedef ::TEvtRecPi0 current_t;
5756 ((current_t*)p)->~current_t();
5757 }
5758} // end of namespace ROOT for class ::TEvtRecPi0
5759
5760//______________________________________________________________________________
5761void TEvtRecEtaToGG::Streamer(TBuffer &R__b)
5762{
5763 // Stream an object of class TEvtRecEtaToGG.
5764
5765 if (R__b.IsReading()) {
5766 R__b.ReadClassBuffer(TEvtRecEtaToGG::Class(),this);
5767 } else {
5768 R__b.WriteClassBuffer(TEvtRecEtaToGG::Class(),this);
5769 }
5770}
5771
5772namespace ROOT {
5773 // Wrappers around operator new
5774 static void *new_TEvtRecEtaToGG(void *p) {
5775 return p ? new(p) ::TEvtRecEtaToGG : new ::TEvtRecEtaToGG;
5776 }
5777 static void *newArray_TEvtRecEtaToGG(Long_t nElements, void *p) {
5778 return p ? new(p) ::TEvtRecEtaToGG[nElements] : new ::TEvtRecEtaToGG[nElements];
5779 }
5780 // Wrapper around operator delete
5781 static void delete_TEvtRecEtaToGG(void *p) {
5782 delete ((::TEvtRecEtaToGG*)p);
5783 }
5784 static void deleteArray_TEvtRecEtaToGG(void *p) {
5785 delete [] ((::TEvtRecEtaToGG*)p);
5786 }
5787 static void destruct_TEvtRecEtaToGG(void *p) {
5788 typedef ::TEvtRecEtaToGG current_t;
5789 ((current_t*)p)->~current_t();
5790 }
5791} // end of namespace ROOT for class ::TEvtRecEtaToGG
5792
5793//______________________________________________________________________________
5794void TEvtRecDTag::Streamer(TBuffer &R__b)
5795{
5796 // Stream an object of class TEvtRecDTag.
5797
5798 if (R__b.IsReading()) {
5799 R__b.ReadClassBuffer(TEvtRecDTag::Class(),this);
5800 } else {
5801 R__b.WriteClassBuffer(TEvtRecDTag::Class(),this);
5802 }
5803}
5804
5805namespace ROOT {
5806 // Wrappers around operator new
5807 static void *new_TEvtRecDTag(void *p) {
5808 return p ? new(p) ::TEvtRecDTag : new ::TEvtRecDTag;
5809 }
5810 static void *newArray_TEvtRecDTag(Long_t nElements, void *p) {
5811 return p ? new(p) ::TEvtRecDTag[nElements] : new ::TEvtRecDTag[nElements];
5812 }
5813 // Wrapper around operator delete
5814 static void delete_TEvtRecDTag(void *p) {
5815 delete ((::TEvtRecDTag*)p);
5816 }
5817 static void deleteArray_TEvtRecDTag(void *p) {
5818 delete [] ((::TEvtRecDTag*)p);
5819 }
5820 static void destruct_TEvtRecDTag(void *p) {
5821 typedef ::TEvtRecDTag current_t;
5822 ((current_t*)p)->~current_t();
5823 }
5824} // end of namespace ROOT for class ::TEvtRecDTag
5825
5826//______________________________________________________________________________
5827void TEvtRecObject::Streamer(TBuffer &R__b)
5828{
5829 // Stream an object of class TEvtRecObject.
5830
5831 if (R__b.IsReading()) {
5832 R__b.ReadClassBuffer(TEvtRecObject::Class(),this);
5833 } else {
5834 R__b.WriteClassBuffer(TEvtRecObject::Class(),this);
5835 }
5836}
5837
5838namespace ROOT {
5839 // Wrappers around operator new
5840 static void *new_TEvtRecObject(void *p) {
5841 return p ? new(p) ::TEvtRecObject : new ::TEvtRecObject;
5842 }
5843 static void *newArray_TEvtRecObject(Long_t nElements, void *p) {
5844 return p ? new(p) ::TEvtRecObject[nElements] : new ::TEvtRecObject[nElements];
5845 }
5846 // Wrapper around operator delete
5847 static void delete_TEvtRecObject(void *p) {
5848 delete ((::TEvtRecObject*)p);
5849 }
5850 static void deleteArray_TEvtRecObject(void *p) {
5851 delete [] ((::TEvtRecObject*)p);
5852 }
5853 static void destruct_TEvtRecObject(void *p) {
5854 typedef ::TEvtRecObject current_t;
5855 ((current_t*)p)->~current_t();
5856 }
5857} // end of namespace ROOT for class ::TEvtRecObject
5858
5859//______________________________________________________________________________
5860void TMcHitTof::Streamer(TBuffer &R__b)
5861{
5862 // Stream an object of class TMcHitTof.
5863
5864 if (R__b.IsReading()) {
5865 R__b.ReadClassBuffer(TMcHitTof::Class(),this);
5866 } else {
5867 R__b.WriteClassBuffer(TMcHitTof::Class(),this);
5868 }
5869}
5870
5871namespace ROOT {
5872 // Wrappers around operator new
5873 static void *new_TMcHitTof(void *p) {
5874 return p ? new(p) ::TMcHitTof : new ::TMcHitTof;
5875 }
5876 static void *newArray_TMcHitTof(Long_t nElements, void *p) {
5877 return p ? new(p) ::TMcHitTof[nElements] : new ::TMcHitTof[nElements];
5878 }
5879 // Wrapper around operator delete
5880 static void delete_TMcHitTof(void *p) {
5881 delete ((::TMcHitTof*)p);
5882 }
5883 static void deleteArray_TMcHitTof(void *p) {
5884 delete [] ((::TMcHitTof*)p);
5885 }
5886 static void destruct_TMcHitTof(void *p) {
5887 typedef ::TMcHitTof current_t;
5888 ((current_t*)p)->~current_t();
5889 }
5890} // end of namespace ROOT for class ::TMcHitTof
5891
5892//______________________________________________________________________________
5893void TMcHitMdc::Streamer(TBuffer &R__b)
5894{
5895 // Stream an object of class TMcHitMdc.
5896
5897 if (R__b.IsReading()) {
5898 R__b.ReadClassBuffer(TMcHitMdc::Class(),this);
5899 } else {
5900 R__b.WriteClassBuffer(TMcHitMdc::Class(),this);
5901 }
5902}
5903
5904namespace ROOT {
5905 // Wrappers around operator new
5906 static void *new_TMcHitMdc(void *p) {
5907 return p ? new(p) ::TMcHitMdc : new ::TMcHitMdc;
5908 }
5909 static void *newArray_TMcHitMdc(Long_t nElements, void *p) {
5910 return p ? new(p) ::TMcHitMdc[nElements] : new ::TMcHitMdc[nElements];
5911 }
5912 // Wrapper around operator delete
5913 static void delete_TMcHitMdc(void *p) {
5914 delete ((::TMcHitMdc*)p);
5915 }
5916 static void deleteArray_TMcHitMdc(void *p) {
5917 delete [] ((::TMcHitMdc*)p);
5918 }
5919 static void destruct_TMcHitMdc(void *p) {
5920 typedef ::TMcHitMdc current_t;
5921 ((current_t*)p)->~current_t();
5922 }
5923} // end of namespace ROOT for class ::TMcHitMdc
5924
5925//______________________________________________________________________________
5926void TMcDigiEmc::Streamer(TBuffer &R__b)
5927{
5928 // Stream an object of class TMcDigiEmc.
5929
5930 if (R__b.IsReading()) {
5931 R__b.ReadClassBuffer(TMcDigiEmc::Class(),this);
5932 } else {
5933 R__b.WriteClassBuffer(TMcDigiEmc::Class(),this);
5934 }
5935}
5936
5937namespace ROOT {
5938 // Wrappers around operator new
5939 static void *new_TMcDigiEmc(void *p) {
5940 return p ? new(p) ::TMcDigiEmc : new ::TMcDigiEmc;
5941 }
5942 static void *newArray_TMcDigiEmc(Long_t nElements, void *p) {
5943 return p ? new(p) ::TMcDigiEmc[nElements] : new ::TMcDigiEmc[nElements];
5944 }
5945 // Wrapper around operator delete
5946 static void delete_TMcDigiEmc(void *p) {
5947 delete ((::TMcDigiEmc*)p);
5948 }
5949 static void deleteArray_TMcDigiEmc(void *p) {
5950 delete [] ((::TMcDigiEmc*)p);
5951 }
5952 static void destruct_TMcDigiEmc(void *p) {
5953 typedef ::TMcDigiEmc current_t;
5954 ((current_t*)p)->~current_t();
5955 }
5956} // end of namespace ROOT for class ::TMcDigiEmc
5957
5958//______________________________________________________________________________
5959void TMcHitEvent::Streamer(TBuffer &R__b)
5960{
5961 // Stream an object of class TMcHitEvent.
5962
5963 if (R__b.IsReading()) {
5964 R__b.ReadClassBuffer(TMcHitEvent::Class(),this);
5965 } else {
5966 R__b.WriteClassBuffer(TMcHitEvent::Class(),this);
5967 }
5968}
5969
5970namespace ROOT {
5971 // Wrappers around operator new
5972 static void *new_TMcHitEvent(void *p) {
5973 return p ? new(p) ::TMcHitEvent : new ::TMcHitEvent;
5974 }
5975 static void *newArray_TMcHitEvent(Long_t nElements, void *p) {
5976 return p ? new(p) ::TMcHitEvent[nElements] : new ::TMcHitEvent[nElements];
5977 }
5978 // Wrapper around operator delete
5979 static void delete_TMcHitEvent(void *p) {
5980 delete ((::TMcHitEvent*)p);
5981 }
5982 static void deleteArray_TMcHitEvent(void *p) {
5983 delete [] ((::TMcHitEvent*)p);
5984 }
5985 static void destruct_TMcHitEvent(void *p) {
5986 typedef ::TMcHitEvent current_t;
5987 ((current_t*)p)->~current_t();
5988 }
5989} // end of namespace ROOT for class ::TMcHitEvent
5990
5991namespace ROOT {
5992 // Wrappers around operator new
5993 static void *new_TBossFullEvent(void *p) {
5994 return p ? new(p) ::TBossFullEvent : new ::TBossFullEvent;
5995 }
5996 static void *newArray_TBossFullEvent(Long_t nElements, void *p) {
5997 return p ? new(p) ::TBossFullEvent[nElements] : new ::TBossFullEvent[nElements];
5998 }
5999 // Wrapper around operator delete
6000 static void delete_TBossFullEvent(void *p) {
6001 delete ((::TBossFullEvent*)p);
6002 }
6003 static void deleteArray_TBossFullEvent(void *p) {
6004 delete [] ((::TBossFullEvent*)p);
6005 }
6006 static void destruct_TBossFullEvent(void *p) {
6007 typedef ::TBossFullEvent current_t;
6008 ((current_t*)p)->~current_t();
6009 }
6010 // Wrapper around a custom streamer member function.
6011 static void streamer_TBossFullEvent(TBuffer &buf, void *obj) {
6012 ((::TBossFullEvent*)obj)->::TBossFullEvent::Streamer(buf);
6013 }
6014} // end of namespace ROOT for class ::TBossFullEvent
6015
6016namespace ROOT {
6017 static TClass *vectorlEvectorlEdoublegRsPgR_Dictionary();
6018 static void vectorlEvectorlEdoublegRsPgR_TClassManip(TClass*);
6019 static void *new_vectorlEvectorlEdoublegRsPgR(void *p = 0);
6020 static void *newArray_vectorlEvectorlEdoublegRsPgR(Long_t size, void *p);
6021 static void delete_vectorlEvectorlEdoublegRsPgR(void *p);
6022 static void deleteArray_vectorlEvectorlEdoublegRsPgR(void *p);
6023 static void destruct_vectorlEvectorlEdoublegRsPgR(void *p);
6024
6025 // Function generating the singleton type initializer
6026 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<vector<double> >*)
6027 {
6028 vector<vector<double> > *ptr = 0;
6029 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<vector<double> >));
6030 static ::ROOT::TGenericClassInfo
6031 instance("vector<vector<double> >", -2, "vector", 214,
6032 typeid(vector<vector<double> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6033 &vectorlEvectorlEdoublegRsPgR_Dictionary, isa_proxy, 0,
6034 sizeof(vector<vector<double> >) );
6035 instance.SetNew(&new_vectorlEvectorlEdoublegRsPgR);
6036 instance.SetNewArray(&newArray_vectorlEvectorlEdoublegRsPgR);
6037 instance.SetDelete(&delete_vectorlEvectorlEdoublegRsPgR);
6038 instance.SetDeleteArray(&deleteArray_vectorlEvectorlEdoublegRsPgR);
6039 instance.SetDestructor(&destruct_vectorlEvectorlEdoublegRsPgR);
6040 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<vector<double> > >()));
6041 return &instance;
6042 }
6043 // Static variable to force the class initialization
6044 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<vector<double> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6045
6046 // Dictionary for non-ClassDef classes
6047 static TClass *vectorlEvectorlEdoublegRsPgR_Dictionary() {
6048 TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<vector<double> >*)0x0)->GetClass();
6049 vectorlEvectorlEdoublegRsPgR_TClassManip(theClass);
6050 return theClass;
6051 }
6052
6053 static void vectorlEvectorlEdoublegRsPgR_TClassManip(TClass* ){
6054 }
6055
6056} // end of namespace ROOT
6057
6058namespace ROOT {
6059 // Wrappers around operator new
6060 static void *new_vectorlEvectorlEdoublegRsPgR(void *p) {
6061 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<vector<double> > : new vector<vector<double> >;
6062 }
6063 static void *newArray_vectorlEvectorlEdoublegRsPgR(Long_t nElements, void *p) {
6064 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<vector<double> >[nElements] : new vector<vector<double> >[nElements];
6065 }
6066 // Wrapper around operator delete
6067 static void delete_vectorlEvectorlEdoublegRsPgR(void *p) {
6068 delete ((vector<vector<double> >*)p);
6069 }
6070 static void deleteArray_vectorlEvectorlEdoublegRsPgR(void *p) {
6071 delete [] ((vector<vector<double> >*)p);
6072 }
6073 static void destruct_vectorlEvectorlEdoublegRsPgR(void *p) {
6074 typedef vector<vector<double> > current_t;
6075 ((current_t*)p)->~current_t();
6076 }
6077} // end of namespace ROOT for class vector<vector<double> >
6078
6079namespace ROOT {
6080 static TClass *vectorlEstringgR_Dictionary();
6081 static void vectorlEstringgR_TClassManip(TClass*);
6082 static void *new_vectorlEstringgR(void *p = 0);
6083 static void *newArray_vectorlEstringgR(Long_t size, void *p);
6084 static void delete_vectorlEstringgR(void *p);
6085 static void deleteArray_vectorlEstringgR(void *p);
6086 static void destruct_vectorlEstringgR(void *p);
6087
6088 // Function generating the singleton type initializer
6089 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<string>*)
6090 {
6091 vector<string> *ptr = 0;
6092 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<string>));
6093 static ::ROOT::TGenericClassInfo
6094 instance("vector<string>", -2, "vector", 214,
6095 typeid(vector<string>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6096 &vectorlEstringgR_Dictionary, isa_proxy, 0,
6097 sizeof(vector<string>) );
6098 instance.SetNew(&new_vectorlEstringgR);
6099 instance.SetNewArray(&newArray_vectorlEstringgR);
6100 instance.SetDelete(&delete_vectorlEstringgR);
6101 instance.SetDeleteArray(&deleteArray_vectorlEstringgR);
6102 instance.SetDestructor(&destruct_vectorlEstringgR);
6103 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<string> >()));
6104 return &instance;
6105 }
6106 // Static variable to force the class initialization
6107 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<string>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6108
6109 // Dictionary for non-ClassDef classes
6110 static TClass *vectorlEstringgR_Dictionary() {
6111 TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<string>*)0x0)->GetClass();
6112 vectorlEstringgR_TClassManip(theClass);
6113 return theClass;
6114 }
6115
6116 static void vectorlEstringgR_TClassManip(TClass* ){
6117 }
6118
6119} // end of namespace ROOT
6120
6121namespace ROOT {
6122 // Wrappers around operator new
6123 static void *new_vectorlEstringgR(void *p) {
6124 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<string> : new vector<string>;
6125 }
6126 static void *newArray_vectorlEstringgR(Long_t nElements, void *p) {
6127 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<string>[nElements] : new vector<string>[nElements];
6128 }
6129 // Wrapper around operator delete
6130 static void delete_vectorlEstringgR(void *p) {
6131 delete ((vector<string>*)p);
6132 }
6133 static void deleteArray_vectorlEstringgR(void *p) {
6134 delete [] ((vector<string>*)p);
6135 }
6136 static void destruct_vectorlEstringgR(void *p) {
6137 typedef vector<string> current_t;
6138 ((current_t*)p)->~current_t();
6139 }
6140} // end of namespace ROOT for class vector<string>
6141
6142namespace ROOT {
6143 static TClass *vectorlEpairlEintcOfloatgRsPgR_Dictionary();
6144 static void vectorlEpairlEintcOfloatgRsPgR_TClassManip(TClass*);
6145 static void *new_vectorlEpairlEintcOfloatgRsPgR(void *p = 0);
6146 static void *newArray_vectorlEpairlEintcOfloatgRsPgR(Long_t size, void *p);
6147 static void delete_vectorlEpairlEintcOfloatgRsPgR(void *p);
6148 static void deleteArray_vectorlEpairlEintcOfloatgRsPgR(void *p);
6149 static void destruct_vectorlEpairlEintcOfloatgRsPgR(void *p);
6150
6151 // Function generating the singleton type initializer
6152 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<pair<int,float> >*)
6153 {
6154 vector<pair<int,float> > *ptr = 0;
6155 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<pair<int,float> >));
6156 static ::ROOT::TGenericClassInfo
6157 instance("vector<pair<int,float> >", -2, "vector", 214,
6158 typeid(vector<pair<int,float> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6159 &vectorlEpairlEintcOfloatgRsPgR_Dictionary, isa_proxy, 0,
6160 sizeof(vector<pair<int,float> >) );
6161 instance.SetNew(&new_vectorlEpairlEintcOfloatgRsPgR);
6162 instance.SetNewArray(&newArray_vectorlEpairlEintcOfloatgRsPgR);
6163 instance.SetDelete(&delete_vectorlEpairlEintcOfloatgRsPgR);
6164 instance.SetDeleteArray(&deleteArray_vectorlEpairlEintcOfloatgRsPgR);
6165 instance.SetDestructor(&destruct_vectorlEpairlEintcOfloatgRsPgR);
6166 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<pair<int,float> > >()));
6167 return &instance;
6168 }
6169 // Static variable to force the class initialization
6170 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<pair<int,float> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6171
6172 // Dictionary for non-ClassDef classes
6173 static TClass *vectorlEpairlEintcOfloatgRsPgR_Dictionary() {
6174 TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<pair<int,float> >*)0x0)->GetClass();
6175 vectorlEpairlEintcOfloatgRsPgR_TClassManip(theClass);
6176 return theClass;
6177 }
6178
6179 static void vectorlEpairlEintcOfloatgRsPgR_TClassManip(TClass* ){
6180 }
6181
6182} // end of namespace ROOT
6183
6184namespace ROOT {
6185 // Wrappers around operator new
6186 static void *new_vectorlEpairlEintcOfloatgRsPgR(void *p) {
6187 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<pair<int,float> > : new vector<pair<int,float> >;
6188 }
6189 static void *newArray_vectorlEpairlEintcOfloatgRsPgR(Long_t nElements, void *p) {
6190 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<pair<int,float> >[nElements] : new vector<pair<int,float> >[nElements];
6191 }
6192 // Wrapper around operator delete
6193 static void delete_vectorlEpairlEintcOfloatgRsPgR(void *p) {
6194 delete ((vector<pair<int,float> >*)p);
6195 }
6196 static void deleteArray_vectorlEpairlEintcOfloatgRsPgR(void *p) {
6197 delete [] ((vector<pair<int,float> >*)p);
6198 }
6199 static void destruct_vectorlEpairlEintcOfloatgRsPgR(void *p) {
6200 typedef vector<pair<int,float> > current_t;
6201 ((current_t*)p)->~current_t();
6202 }
6203} // end of namespace ROOT for class vector<pair<int,float> >
6204
6205namespace ROOT {
6206 static TClass *vectorlEintgR_Dictionary();
6207 static void vectorlEintgR_TClassManip(TClass*);
6208 static void *new_vectorlEintgR(void *p = 0);
6209 static void *newArray_vectorlEintgR(Long_t size, void *p);
6210 static void delete_vectorlEintgR(void *p);
6211 static void deleteArray_vectorlEintgR(void *p);
6212 static void destruct_vectorlEintgR(void *p);
6213
6214 // Function generating the singleton type initializer
6215 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<int>*)
6216 {
6217 vector<int> *ptr = 0;
6218 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<int>));
6219 static ::ROOT::TGenericClassInfo
6220 instance("vector<int>", -2, "vector", 214,
6221 typeid(vector<int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6222 &vectorlEintgR_Dictionary, isa_proxy, 0,
6223 sizeof(vector<int>) );
6224 instance.SetNew(&new_vectorlEintgR);
6225 instance.SetNewArray(&newArray_vectorlEintgR);
6226 instance.SetDelete(&delete_vectorlEintgR);
6227 instance.SetDeleteArray(&deleteArray_vectorlEintgR);
6228 instance.SetDestructor(&destruct_vectorlEintgR);
6229 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<int> >()));
6230 return &instance;
6231 }
6232 // Static variable to force the class initialization
6233 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6234
6235 // Dictionary for non-ClassDef classes
6236 static TClass *vectorlEintgR_Dictionary() {
6237 TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<int>*)0x0)->GetClass();
6238 vectorlEintgR_TClassManip(theClass);
6239 return theClass;
6240 }
6241
6242 static void vectorlEintgR_TClassManip(TClass* ){
6243 }
6244
6245} // end of namespace ROOT
6246
6247namespace ROOT {
6248 // Wrappers around operator new
6249 static void *new_vectorlEintgR(void *p) {
6250 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<int> : new vector<int>;
6251 }
6252 static void *newArray_vectorlEintgR(Long_t nElements, void *p) {
6253 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<int>[nElements] : new vector<int>[nElements];
6254 }
6255 // Wrapper around operator delete
6256 static void delete_vectorlEintgR(void *p) {
6257 delete ((vector<int>*)p);
6258 }
6259 static void deleteArray_vectorlEintgR(void *p) {
6260 delete [] ((vector<int>*)p);
6261 }
6262 static void destruct_vectorlEintgR(void *p) {
6263 typedef vector<int> current_t;
6264 ((current_t*)p)->~current_t();
6265 }
6266} // end of namespace ROOT for class vector<int>
6267
6268namespace ROOT {
6269 static TClass *vectorlEfloatgR_Dictionary();
6270 static void vectorlEfloatgR_TClassManip(TClass*);
6271 static void *new_vectorlEfloatgR(void *p = 0);
6272 static void *newArray_vectorlEfloatgR(Long_t size, void *p);
6273 static void delete_vectorlEfloatgR(void *p);
6274 static void deleteArray_vectorlEfloatgR(void *p);
6275 static void destruct_vectorlEfloatgR(void *p);
6276
6277 // Function generating the singleton type initializer
6278 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<float>*)
6279 {
6280 vector<float> *ptr = 0;
6281 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<float>));
6282 static ::ROOT::TGenericClassInfo
6283 instance("vector<float>", -2, "vector", 214,
6284 typeid(vector<float>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6285 &vectorlEfloatgR_Dictionary, isa_proxy, 0,
6286 sizeof(vector<float>) );
6287 instance.SetNew(&new_vectorlEfloatgR);
6288 instance.SetNewArray(&newArray_vectorlEfloatgR);
6289 instance.SetDelete(&delete_vectorlEfloatgR);
6290 instance.SetDeleteArray(&deleteArray_vectorlEfloatgR);
6291 instance.SetDestructor(&destruct_vectorlEfloatgR);
6292 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<float> >()));
6293 return &instance;
6294 }
6295 // Static variable to force the class initialization
6296 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<float>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6297
6298 // Dictionary for non-ClassDef classes
6299 static TClass *vectorlEfloatgR_Dictionary() {
6300 TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<float>*)0x0)->GetClass();
6301 vectorlEfloatgR_TClassManip(theClass);
6302 return theClass;
6303 }
6304
6305 static void vectorlEfloatgR_TClassManip(TClass* ){
6306 }
6307
6308} // end of namespace ROOT
6309
6310namespace ROOT {
6311 // Wrappers around operator new
6312 static void *new_vectorlEfloatgR(void *p) {
6313 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<float> : new vector<float>;
6314 }
6315 static void *newArray_vectorlEfloatgR(Long_t nElements, void *p) {
6316 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<float>[nElements] : new vector<float>[nElements];
6317 }
6318 // Wrapper around operator delete
6319 static void delete_vectorlEfloatgR(void *p) {
6320 delete ((vector<float>*)p);
6321 }
6322 static void deleteArray_vectorlEfloatgR(void *p) {
6323 delete [] ((vector<float>*)p);
6324 }
6325 static void destruct_vectorlEfloatgR(void *p) {
6326 typedef vector<float> current_t;
6327 ((current_t*)p)->~current_t();
6328 }
6329} // end of namespace ROOT for class vector<float>
6330
6331namespace ROOT {
6332 static TClass *vectorlEdoublegR_Dictionary();
6333 static void vectorlEdoublegR_TClassManip(TClass*);
6334 static void *new_vectorlEdoublegR(void *p = 0);
6335 static void *newArray_vectorlEdoublegR(Long_t size, void *p);
6336 static void delete_vectorlEdoublegR(void *p);
6337 static void deleteArray_vectorlEdoublegR(void *p);
6338 static void destruct_vectorlEdoublegR(void *p);
6339
6340 // Function generating the singleton type initializer
6341 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<double>*)
6342 {
6343 vector<double> *ptr = 0;
6344 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<double>));
6345 static ::ROOT::TGenericClassInfo
6346 instance("vector<double>", -2, "vector", 214,
6347 typeid(vector<double>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6348 &vectorlEdoublegR_Dictionary, isa_proxy, 0,
6349 sizeof(vector<double>) );
6350 instance.SetNew(&new_vectorlEdoublegR);
6351 instance.SetNewArray(&newArray_vectorlEdoublegR);
6352 instance.SetDelete(&delete_vectorlEdoublegR);
6353 instance.SetDeleteArray(&deleteArray_vectorlEdoublegR);
6354 instance.SetDestructor(&destruct_vectorlEdoublegR);
6355 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<double> >()));
6356 return &instance;
6357 }
6358 // Static variable to force the class initialization
6359 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<double>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6360
6361 // Dictionary for non-ClassDef classes
6362 static TClass *vectorlEdoublegR_Dictionary() {
6363 TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<double>*)0x0)->GetClass();
6364 vectorlEdoublegR_TClassManip(theClass);
6365 return theClass;
6366 }
6367
6368 static void vectorlEdoublegR_TClassManip(TClass* ){
6369 }
6370
6371} // end of namespace ROOT
6372
6373namespace ROOT {
6374 // Wrappers around operator new
6375 static void *new_vectorlEdoublegR(void *p) {
6376 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<double> : new vector<double>;
6377 }
6378 static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) {
6379 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<double>[nElements] : new vector<double>[nElements];
6380 }
6381 // Wrapper around operator delete
6382 static void delete_vectorlEdoublegR(void *p) {
6383 delete ((vector<double>*)p);
6384 }
6385 static void deleteArray_vectorlEdoublegR(void *p) {
6386 delete [] ((vector<double>*)p);
6387 }
6388 static void destruct_vectorlEdoublegR(void *p) {
6389 typedef vector<double> current_t;
6390 ((current_t*)p)->~current_t();
6391 }
6392} // end of namespace ROOT for class vector<double>
6393
6394namespace ROOT {
6395 static TClass *vectorlETStringgR_Dictionary();
6396 static void vectorlETStringgR_TClassManip(TClass*);
6397 static void *new_vectorlETStringgR(void *p = 0);
6398 static void *newArray_vectorlETStringgR(Long_t size, void *p);
6399 static void delete_vectorlETStringgR(void *p);
6400 static void deleteArray_vectorlETStringgR(void *p);
6401 static void destruct_vectorlETStringgR(void *p);
6402
6403 // Function generating the singleton type initializer
6404 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<TString>*)
6405 {
6406 vector<TString> *ptr = 0;
6407 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<TString>));
6408 static ::ROOT::TGenericClassInfo
6409 instance("vector<TString>", -2, "vector", 214,
6410 typeid(vector<TString>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6411 &vectorlETStringgR_Dictionary, isa_proxy, 0,
6412 sizeof(vector<TString>) );
6413 instance.SetNew(&new_vectorlETStringgR);
6414 instance.SetNewArray(&newArray_vectorlETStringgR);
6415 instance.SetDelete(&delete_vectorlETStringgR);
6416 instance.SetDeleteArray(&deleteArray_vectorlETStringgR);
6417 instance.SetDestructor(&destruct_vectorlETStringgR);
6418 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<TString> >()));
6419 return &instance;
6420 }
6421 // Static variable to force the class initialization
6422 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<TString>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6423
6424 // Dictionary for non-ClassDef classes
6425 static TClass *vectorlETStringgR_Dictionary() {
6426 TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<TString>*)0x0)->GetClass();
6427 vectorlETStringgR_TClassManip(theClass);
6428 return theClass;
6429 }
6430
6431 static void vectorlETStringgR_TClassManip(TClass* ){
6432 }
6433
6434} // end of namespace ROOT
6435
6436namespace ROOT {
6437 // Wrappers around operator new
6438 static void *new_vectorlETStringgR(void *p) {
6439 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<TString> : new vector<TString>;
6440 }
6441 static void *newArray_vectorlETStringgR(Long_t nElements, void *p) {
6442 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<TString>[nElements] : new vector<TString>[nElements];
6443 }
6444 // Wrapper around operator delete
6445 static void delete_vectorlETStringgR(void *p) {
6446 delete ((vector<TString>*)p);
6447 }
6448 static void deleteArray_vectorlETStringgR(void *p) {
6449 delete [] ((vector<TString>*)p);
6450 }
6451 static void destruct_vectorlETStringgR(void *p) {
6452 typedef vector<TString> current_t;
6453 ((current_t*)p)->~current_t();
6454 }
6455} // end of namespace ROOT for class vector<TString>
6456
6457namespace ROOT {
6458 static TClass *multimaplEintcOintgR_Dictionary();
6459 static void multimaplEintcOintgR_TClassManip(TClass*);
6460 static void *new_multimaplEintcOintgR(void *p = 0);
6461 static void *newArray_multimaplEintcOintgR(Long_t size, void *p);
6462 static void delete_multimaplEintcOintgR(void *p);
6463 static void deleteArray_multimaplEintcOintgR(void *p);
6464 static void destruct_multimaplEintcOintgR(void *p);
6465
6466 // Function generating the singleton type initializer
6467 static TGenericClassInfo *GenerateInitInstanceLocal(const multimap<int,int>*)
6468 {
6469 multimap<int,int> *ptr = 0;
6470 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(multimap<int,int>));
6471 static ::ROOT::TGenericClassInfo
6472 instance("multimap<int,int>", -2, "map", 95,
6473 typeid(multimap<int,int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6474 &multimaplEintcOintgR_Dictionary, isa_proxy, 0,
6475 sizeof(multimap<int,int>) );
6476 instance.SetNew(&new_multimaplEintcOintgR);
6477 instance.SetNewArray(&newArray_multimaplEintcOintgR);
6478 instance.SetDelete(&delete_multimaplEintcOintgR);
6479 instance.SetDeleteArray(&deleteArray_multimaplEintcOintgR);
6480 instance.SetDestructor(&destruct_multimaplEintcOintgR);
6481 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< multimap<int,int> >()));
6482 return &instance;
6483 }
6484 // Static variable to force the class initialization
6485 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const multimap<int,int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6486
6487 // Dictionary for non-ClassDef classes
6488 static TClass *multimaplEintcOintgR_Dictionary() {
6489 TClass* theClass =::ROOT::GenerateInitInstanceLocal((const multimap<int,int>*)0x0)->GetClass();
6490 multimaplEintcOintgR_TClassManip(theClass);
6491 return theClass;
6492 }
6493
6494 static void multimaplEintcOintgR_TClassManip(TClass* ){
6495 }
6496
6497} // end of namespace ROOT
6498
6499namespace ROOT {
6500 // Wrappers around operator new
6501 static void *new_multimaplEintcOintgR(void *p) {
6502 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) multimap<int,int> : new multimap<int,int>;
6503 }
6504 static void *newArray_multimaplEintcOintgR(Long_t nElements, void *p) {
6505 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) multimap<int,int>[nElements] : new multimap<int,int>[nElements];
6506 }
6507 // Wrapper around operator delete
6508 static void delete_multimaplEintcOintgR(void *p) {
6509 delete ((multimap<int,int>*)p);
6510 }
6511 static void deleteArray_multimaplEintcOintgR(void *p) {
6512 delete [] ((multimap<int,int>*)p);
6513 }
6514 static void destruct_multimaplEintcOintgR(void *p) {
6515 typedef multimap<int,int> current_t;
6516 ((current_t*)p)->~current_t();
6517 }
6518} // end of namespace ROOT for class multimap<int,int>
6519
6520namespace ROOT {
6521 static TClass *maplEintcOdoublegR_Dictionary();
6522 static void maplEintcOdoublegR_TClassManip(TClass*);
6523 static void *new_maplEintcOdoublegR(void *p = 0);
6524 static void *newArray_maplEintcOdoublegR(Long_t size, void *p);
6525 static void delete_maplEintcOdoublegR(void *p);
6526 static void deleteArray_maplEintcOdoublegR(void *p);
6527 static void destruct_maplEintcOdoublegR(void *p);
6528
6529 // Function generating the singleton type initializer
6530 static TGenericClassInfo *GenerateInitInstanceLocal(const map<int,double>*)
6531 {
6532 map<int,double> *ptr = 0;
6533 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<int,double>));
6534 static ::ROOT::TGenericClassInfo
6535 instance("map<int,double>", -2, "map", 96,
6536 typeid(map<int,double>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
6537 &maplEintcOdoublegR_Dictionary, isa_proxy, 0,
6538 sizeof(map<int,double>) );
6539 instance.SetNew(&new_maplEintcOdoublegR);
6540 instance.SetNewArray(&newArray_maplEintcOdoublegR);
6541 instance.SetDelete(&delete_maplEintcOdoublegR);
6542 instance.SetDeleteArray(&deleteArray_maplEintcOdoublegR);
6543 instance.SetDestructor(&destruct_maplEintcOdoublegR);
6544 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<int,double> >()));
6545 return &instance;
6546 }
6547 // Static variable to force the class initialization
6548 static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const map<int,double>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
6549
6550 // Dictionary for non-ClassDef classes
6551 static TClass *maplEintcOdoublegR_Dictionary() {
6552 TClass* theClass =::ROOT::GenerateInitInstanceLocal((const map<int,double>*)0x0)->GetClass();
6553 maplEintcOdoublegR_TClassManip(theClass);
6554 return theClass;
6555 }
6556
6557 static void maplEintcOdoublegR_TClassManip(TClass* ){
6558 }
6559
6560} // end of namespace ROOT
6561
6562namespace ROOT {
6563 // Wrappers around operator new
6564 static void *new_maplEintcOdoublegR(void *p) {
6565 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map<int,double> : new map<int,double>;
6566 }
6567 static void *newArray_maplEintcOdoublegR(Long_t nElements, void *p) {
6568 return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map<int,double>[nElements] : new map<int,double>[nElements];
6569 }
6570 // Wrapper around operator delete
6571 static void delete_maplEintcOdoublegR(void *p) {
6572 delete ((map<int,double>*)p);
6573 }
6574 static void deleteArray_maplEintcOdoublegR(void *p) {
6575 delete [] ((map<int,double>*)p);
6576 }
6577 static void destruct_maplEintcOdoublegR(void *p) {
6578 typedef map<int,double> current_t;
6579 ((current_t*)p)->~current_t();
6580 }
6581} // end of namespace ROOT for class map<int,double>
6582
6583namespace {
6584 void TriggerDictionaryInitialization_RootEventData_rootcint_Impl() {
6585 static const char* headers[] = {
6586"../RootEventData/TJobInfo.h",
6587"../RootEventData/TDigiEvent.h",
6588"../RootEventData/TRecTrackEvent.h",
6589"../RootEventData/TMdcDigi.h",
6590"../RootEventData/TEmcDigi.h",
6591"../RootEventData/TTofDigi.h",
6592"../RootEventData/TMucDigi.h",
6593"../RootEventData/TLumiDigi.h",
6594"../RootEventData/TDstEvent.h",
6595"../RootEventData/TEmcTrack.h",
6596"../RootEventData/TMdcTrack.h",
6597"../RootEventData/TRecMdcHit.h",
6598"../RootEventData/TRecMdcTrack.h",
6599"../RootEventData/TRecMucTrack.h",
6600"../RootEventData/TTofTrack.h",
6601"../RootEventData/TMucTrack.h",
6602"../RootEventData/TExtTrack.h",
6603"../RootEventData/TRecExtTrack.h",
6604"../RootEventData/TMdcKalTrack.h",
6605"../RootEventData/TRecMdcKalTrack.h",
6606"../RootEventData/TRecMdcKalHelixSeg.h",
6607"../RootEventData/TMdcDedx.h",
6608"../RootEventData/TRecMdcDedx.h",
6609"../RootEventData/TRecMdcDedxHit.h",
6610"../RootEventData/TMcEvent.h",
6611"../RootEventData/TEmcMc.h",
6612"../RootEventData/TMdcMc.h",
6613"../RootEventData/TTofMc.h",
6614"../RootEventData/TMucMc.h",
6615"../RootEventData/TMcParticle.h",
6616"../RootEventData/TRecEmcHit.h",
6617"../RootEventData/TRecEmcCluster.h",
6618"../RootEventData/TRecEmcShower.h",
6619"../RootEventData/TRecMucTrack.h",
6620"../RootEventData/TRecEvTime.h",
6621"../RootEventData/TRecZddChannel.h",
6622"../RootEventData/TEvtHeader.h",
6623"../RootEventData/TEvtNavigator.h",
6624"../RootEventData/TTrigEvent.h",
6625"../RootEventData/TTrigData.h",
6626"../RootEventData/THltEvent.h",
6627"../RootEventData/THltRaw.h",
6628"../RootEventData/THltInf.h",
6629"../RootEventData/TDstHltInf.h",
6630"../RootEventData/TDisTrack.h",
6631"../RootEventData/TEvtRecObject.h",
6632"../RootEventData/TEvtRecEvent.h",
6633"../RootEventData/TEvtRecTrack.h",
6634"../RootEventData/TMcHitEvent.h",
6635"../RootEventData/TMcHitTof.h",
6636"../RootEventData/TMcHitMdc.h",
6637"../RootEventData/TMcDigiEmc.h",
6638"../RootEventData/TEvtRecPrimaryVertex.h",
6639"../RootEventData/TEvtRecVeeVertex.h",
6640"../RootEventData/TEvtRecDTag.h",
6641"../RootEventData/TEvtRecPi0.h",
6642"../RootEventData/TBossFullEvent.h",
66430
6644 };
6645 static const char* includePaths[] = {
6646"/cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/lcg/LCG_84/ROOT/6.20.02/x86_64-centos7-gcc49-opt-python2.7/include/",
6647"/cvmfs/bes3.ihep.ac.cn/bes3sw/Boss/7.1.3/Event/RootEventData/RootEventData-00-04-01/RootEventData/",
66480
6649 };
6650 static const char* fwdDeclCode = R"DICTFWDDCLS(
6651#line 1 "RootEventData_rootcint dictionary forward declarations' payload"
6652#pragma clang diagnostic ignored "-Wkeyword-compat"
6653#pragma clang diagnostic ignored "-Wignored-attributes"
6654#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
6655extern int __Cling_Autoloading_Map;
6656class __attribute__((annotate("$clingAutoload$../RootEventData/TJobInfo.h"))) TJobInfo;
6657class __attribute__((annotate("$clingAutoload$TRawData.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TDigiEvent.h"))) TRawData;
6658class __attribute__((annotate("$clingAutoload$TMdcDigi.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TDigiEvent.h"))) TMdcDigi;
6659class __attribute__((annotate("$clingAutoload$TEmcDigi.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TDigiEvent.h"))) TEmcDigi;
6660class __attribute__((annotate("$clingAutoload$TTofDigi.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TDigiEvent.h"))) TTofDigi;
6661class __attribute__((annotate("$clingAutoload$TMucDigi.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TDigiEvent.h"))) TMucDigi;
6662class __attribute__((annotate("$clingAutoload$TLumiDigi.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TDigiEvent.h"))) TLumiDigi;
6663class __attribute__((annotate(R"ATTRDUMP(Storage for Raw(Digi) event and subsystem data)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$../RootEventData/TDigiEvent.h"))) TDigiEvent;
6664class __attribute__((annotate("$clingAutoload$TRecMdcTrack.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TRecTrackEvent.h"))) TRecMdcTrack;
6665class __attribute__((annotate("$clingAutoload$TRecMdcKalTrack.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TRecTrackEvent.h"))) TRecMdcKalTrack;
6666class __attribute__((annotate("$clingAutoload$TRecMdcHit.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TRecTrackEvent.h"))) TRecMdcHit;
6667class __attribute__((annotate("$clingAutoload$TTofTrack.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TRecTrackEvent.h"))) TTofTrack;
6668class __attribute__((annotate("$clingAutoload$TRecTofTrack.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TRecTrackEvent.h"))) TRecTofTrack;
6669class __attribute__((annotate("$clingAutoload$TRecEmcHit.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TRecTrackEvent.h"))) TRecEmcHit;
6670class __attribute__((annotate("$clingAutoload$TRecEmcCluster.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TRecTrackEvent.h"))) TRecEmcCluster;
6671class __attribute__((annotate("$clingAutoload$TRecEmcShower.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TRecTrackEvent.h"))) TRecEmcShower;
6672class __attribute__((annotate("$clingAutoload$TRecMucTrack.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TRecTrackEvent.h"))) TRecMucTrack;
6673class __attribute__((annotate("$clingAutoload$TRecMdcDedx.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TRecTrackEvent.h"))) TRecMdcDedx;
6674class __attribute__((annotate("$clingAutoload$TRecMdcDedxHit.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TRecTrackEvent.h"))) TRecMdcDedxHit;
6675class __attribute__((annotate("$clingAutoload$TRecExtTrack.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TRecTrackEvent.h"))) TRecExtTrack;
6676class __attribute__((annotate("$clingAutoload$TRecEvTime.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TRecTrackEvent.h"))) TRecEvTime;
6677class __attribute__((annotate("$clingAutoload$TRecMdcKalHelixSeg.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TRecTrackEvent.h"))) TRecMdcKalHelixSeg;
6678class __attribute__((annotate("$clingAutoload$TRecZddChannel.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TRecTrackEvent.h"))) TRecZddChannel;
6679class __attribute__((annotate("$clingAutoload$../RootEventData/TRecTrackEvent.h"))) TRecTrackEvent;
6680class __attribute__((annotate("$clingAutoload$TMdcTrack.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TDstEvent.h"))) TMdcTrack;
6681class __attribute__((annotate("$clingAutoload$TEmcTrack.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TDstEvent.h"))) TEmcTrack;
6682class __attribute__((annotate("$clingAutoload$TMucTrack.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TDstEvent.h"))) TMucTrack;
6683class __attribute__((annotate("$clingAutoload$TMdcDedx.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TDstEvent.h"))) TMdcDedx;
6684class __attribute__((annotate("$clingAutoload$TExtTrack.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TDstEvent.h"))) TExtTrack;
6685class __attribute__((annotate("$clingAutoload$TMdcKalTrack.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TDstEvent.h"))) TMdcKalTrack;
6686class __attribute__((annotate("$clingAutoload$../RootEventData/TDstEvent.h"))) TDstEvent;
6687class __attribute__((annotate("$clingAutoload$TMdcMc.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TMcEvent.h"))) TMdcMc;
6688class __attribute__((annotate("$clingAutoload$TEmcMc.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TMcEvent.h"))) TEmcMc;
6689class __attribute__((annotate("$clingAutoload$TTofMc.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TMcEvent.h"))) TTofMc;
6690class __attribute__((annotate("$clingAutoload$TMucMc.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TMcEvent.h"))) TMucMc;
6691class __attribute__((annotate("$clingAutoload$TMcParticle.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TMcEvent.h"))) TMcParticle;
6692class __attribute__((annotate(R"ATTRDUMP(Storage for McTruth event and subsystem data)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$../RootEventData/TMcEvent.h"))) TMcEvent;
6693class __attribute__((annotate("$clingAutoload$../RootEventData/TEvtHeader.h"))) TEvtHeader;
6694class __attribute__((annotate("$clingAutoload$../RootEventData/TEvtNavigator.h"))) TEvtNavigator;
6695class __attribute__((annotate("$clingAutoload$TTrigData.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TTrigEvent.h"))) TTrigData;
6696class __attribute__((annotate(R"ATTRDUMP(Storage for trigger event and subsystem data)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$../RootEventData/TTrigEvent.h"))) TTrigEvent;
6697class __attribute__((annotate("$clingAutoload$THltRaw.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/THltEvent.h"))) THltRaw;
6698class __attribute__((annotate("$clingAutoload$THltInf.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/THltEvent.h"))) THltInf;
6699class __attribute__((annotate("$clingAutoload$TDstHltInf.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/THltEvent.h"))) TDstHltInf;
6700class __attribute__((annotate(R"ATTRDUMP(Storage for event filter and subsystem data)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$../RootEventData/THltEvent.h"))) THltEvent;
6701class __attribute__((annotate("$clingAutoload$../RootEventData/TDisTrack.h"))) TDisTrack;
6702class __attribute__((annotate("$clingAutoload$TEvtRecEvent.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TEvtRecObject.h"))) TEvtRecEvent;
6703class __attribute__((annotate("$clingAutoload$TEvtRecTrack.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TEvtRecObject.h"))) TEvtRecTrack;
6704class __attribute__((annotate("$clingAutoload$TEvtRecPrimaryVertex.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TEvtRecObject.h"))) TEvtRecPrimaryVertex;
6705class __attribute__((annotate("$clingAutoload$TEvtRecVeeVertex.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TEvtRecObject.h"))) TEvtRecVeeVertex;
6706class __attribute__((annotate("$clingAutoload$TEvtRecPi0.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TEvtRecObject.h"))) TEvtRecPi0;
6707class __attribute__((annotate("$clingAutoload$TEvtRecEtaToGG.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TEvtRecObject.h"))) TEvtRecEtaToGG;
6708class __attribute__((annotate("$clingAutoload$TEvtRecDTag.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TEvtRecObject.h"))) TEvtRecDTag;
6709class __attribute__((annotate("$clingAutoload$../RootEventData/TEvtRecObject.h"))) TEvtRecObject;
6710class __attribute__((annotate("$clingAutoload$TMcHitTof.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TMcHitEvent.h"))) TMcHitTof;
6711class __attribute__((annotate("$clingAutoload$TMcHitMdc.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TMcHitEvent.h"))) TMcHitMdc;
6712class __attribute__((annotate("$clingAutoload$TMcDigiEmc.h"))) __attribute__((annotate("$clingAutoload$../RootEventData/TMcHitEvent.h"))) TMcDigiEmc;
6713class __attribute__((annotate(R"ATTRDUMP(Storage for Raw(Digi) event and subsystem data)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$../RootEventData/TMcHitEvent.h"))) TMcHitEvent;
6714class __attribute__((annotate("$clingAutoload$../RootEventData/TBossFullEvent.h"))) TBossFullEvent;
6715)DICTFWDDCLS";
6716 static const char* payloadCode = R"DICTPAYLOAD(
6717#line 1 "RootEventData_rootcint dictionary payload"
6718
6719
6720#define _BACKWARD_BACKWARD_WARNING_H
6721// Inline headers
6722#include "../RootEventData/TJobInfo.h"
6723#include "../RootEventData/TDigiEvent.h"
6724#include "../RootEventData/TRecTrackEvent.h"
6725#include "../RootEventData/TMdcDigi.h"
6726#include "../RootEventData/TEmcDigi.h"
6727#include "../RootEventData/TTofDigi.h"
6728#include "../RootEventData/TMucDigi.h"
6729#include "../RootEventData/TLumiDigi.h"
6730#include "../RootEventData/TDstEvent.h"
6731#include "../RootEventData/TEmcTrack.h"
6732#include "../RootEventData/TMdcTrack.h"
6733#include "../RootEventData/TRecMdcHit.h"
6734#include "../RootEventData/TRecMdcTrack.h"
6735#include "../RootEventData/TRecMucTrack.h"
6736#include "../RootEventData/TTofTrack.h"
6737#include "../RootEventData/TMucTrack.h"
6738#include "../RootEventData/TExtTrack.h"
6739#include "../RootEventData/TRecExtTrack.h"
6740#include "../RootEventData/TMdcKalTrack.h"
6741#include "../RootEventData/TRecMdcKalTrack.h"
6742#include "../RootEventData/TRecMdcKalHelixSeg.h"
6743#include "../RootEventData/TMdcDedx.h"
6744#include "../RootEventData/TRecMdcDedx.h"
6745#include "../RootEventData/TRecMdcDedxHit.h"
6746#include "../RootEventData/TMcEvent.h"
6747#include "../RootEventData/TEmcMc.h"
6748#include "../RootEventData/TMdcMc.h"
6749#include "../RootEventData/TTofMc.h"
6750#include "../RootEventData/TMucMc.h"
6751#include "../RootEventData/TMcParticle.h"
6752#include "../RootEventData/TRecEmcHit.h"
6753#include "../RootEventData/TRecEmcCluster.h"
6754#include "../RootEventData/TRecEmcShower.h"
6755#include "../RootEventData/TRecMucTrack.h"
6756#include "../RootEventData/TRecEvTime.h"
6757#include "../RootEventData/TRecZddChannel.h"
6758#include "../RootEventData/TEvtHeader.h"
6759#include "../RootEventData/TEvtNavigator.h"
6760#include "../RootEventData/TTrigEvent.h"
6761#include "../RootEventData/TTrigData.h"
6762#include "../RootEventData/THltEvent.h"
6763#include "../RootEventData/THltRaw.h"
6764#include "../RootEventData/THltInf.h"
6765#include "../RootEventData/TDstHltInf.h"
6766#include "../RootEventData/TDisTrack.h"
6767#include "../RootEventData/TEvtRecObject.h"
6768#include "../RootEventData/TEvtRecEvent.h"
6769#include "../RootEventData/TEvtRecTrack.h"
6770#include "../RootEventData/TMcHitEvent.h"
6771#include "../RootEventData/TMcHitTof.h"
6772#include "../RootEventData/TMcHitMdc.h"
6773#include "../RootEventData/TMcDigiEmc.h"
6774#include "../RootEventData/TEvtRecPrimaryVertex.h"
6775#include "../RootEventData/TEvtRecVeeVertex.h"
6776#include "../RootEventData/TEvtRecDTag.h"
6777#include "../RootEventData/TEvtRecPi0.h"
6778#include "../RootEventData/TBossFullEvent.h"
6779
6780#undef _BACKWARD_BACKWARD_WARNING_H
6781)DICTPAYLOAD";
6782 static const char* classesHeaders[] = {
6783"TBossFullEvent", payloadCode, "@",
6784"TDigiEvent", payloadCode, "@",
6785"TDisTrack", payloadCode, "@",
6786"TDstEvent", payloadCode, "@",
6787"TDstHltInf", payloadCode, "@",
6788"TEmcDigi", payloadCode, "@",
6789"TEmcMc", payloadCode, "@",
6790"TEmcTrack", payloadCode, "@",
6791"TEvtHeader", payloadCode, "@",
6792"TEvtNavigator", payloadCode, "@",
6793"TEvtRecDTag", payloadCode, "@",
6794"TEvtRecEtaToGG", payloadCode, "@",
6795"TEvtRecEvent", payloadCode, "@",
6796"TEvtRecObject", payloadCode, "@",
6797"TEvtRecPi0", payloadCode, "@",
6798"TEvtRecPrimaryVertex", payloadCode, "@",
6799"TEvtRecTrack", payloadCode, "@",
6800"TEvtRecVeeVertex", payloadCode, "@",
6801"TExtTrack", payloadCode, "@",
6802"THltEvent", payloadCode, "@",
6803"THltInf", payloadCode, "@",
6804"THltRaw", payloadCode, "@",
6805"TJobInfo", payloadCode, "@",
6806"TLumiDigi", payloadCode, "@",
6807"TMcDigiEmc", payloadCode, "@",
6808"TMcEvent", payloadCode, "@",
6809"TMcHitEvent", payloadCode, "@",
6810"TMcHitMdc", payloadCode, "@",
6811"TMcHitTof", payloadCode, "@",
6812"TMcParticle", payloadCode, "@",
6813"TMdcDedx", payloadCode, "@",
6814"TMdcDigi", payloadCode, "@",
6815"TMdcKalTrack", payloadCode, "@",
6816"TMdcMc", payloadCode, "@",
6817"TMdcTrack", payloadCode, "@",
6818"TMucDigi", payloadCode, "@",
6819"TMucMc", payloadCode, "@",
6820"TMucTrack", payloadCode, "@",
6821"TRawData", payloadCode, "@",
6822"TRecEmcCluster", payloadCode, "@",
6823"TRecEmcHit", payloadCode, "@",
6824"TRecEmcShower", payloadCode, "@",
6825"TRecEvTime", payloadCode, "@",
6826"TRecExtTrack", payloadCode, "@",
6827"TRecMdcDedx", payloadCode, "@",
6828"TRecMdcDedxHit", payloadCode, "@",
6829"TRecMdcHit", payloadCode, "@",
6830"TRecMdcKalHelixSeg", payloadCode, "@",
6831"TRecMdcKalTrack", payloadCode, "@",
6832"TRecMdcTrack", payloadCode, "@",
6833"TRecMucTrack", payloadCode, "@",
6834"TRecTofTrack", payloadCode, "@",
6835"TRecTrackEvent", payloadCode, "@",
6836"TRecZddChannel", payloadCode, "@",
6837"TTofDigi", payloadCode, "@",
6838"TTofMc", payloadCode, "@",
6839"TTofTrack", payloadCode, "@",
6840"TTrigData", payloadCode, "@",
6841"TTrigEvent", payloadCode, "@",
6842nullptr
6843};
6844 static bool isInitialized = false;
6845 if (!isInitialized) {
6846 TROOT::RegisterModule("RootEventData_rootcint",
6847 headers, includePaths, payloadCode, fwdDeclCode,
6848 TriggerDictionaryInitialization_RootEventData_rootcint_Impl, {}, classesHeaders, /*hasCxxModule*/false);
6849 isInitialized = true;
6850 }
6851 }
6852 static struct DictInit {
6853 DictInit() {
6854 TriggerDictionaryInitialization_RootEventData_rootcint_Impl();
6855 }
6856 } __TheDictionaryInitializer;
6857}
6858void TriggerDictionaryInitialization_RootEventData_rootcint() {
6859 TriggerDictionaryInitialization_RootEventData_rootcint_Impl();
6860}
ROOT::R__UseDummy
R__UseDummy(_R__UNIQUE_DICT_(Init))
ROOT::GenerateInitInstance
TGenericClassInfo * GenerateInitInstance(const ::TJobInfo *)
Definition RootEventData/RootEventData_rootcint.cxx:125
TriggerDictionaryInitialization_RootEventData_rootcint
void TriggerDictionaryInitialization_RootEventData_rootcint()
Definition src/RootEventData_rootcint.cxx:6858