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