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