nusimdata_SimulationBase_dict.cpp
Go to the documentation of this file.
1 // Do NOT change. Changes will be lost next time file is generated
2 
3 #define R__DICTIONARY_FILENAME nusimdata_SimulationBase_dict
4 
5 /*******************************************************************/
6 #include <stddef.h>
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <string.h>
10 #include <assert.h>
11 #define G__DICTIONARY
12 #include "RConfig.h"
13 #include "TClass.h"
14 #include "TDictAttributeMap.h"
15 #include "TInterpreter.h"
16 #include "TROOT.h"
17 #include "TBuffer.h"
18 #include "TMemberInspector.h"
19 #include "TInterpreter.h"
20 #include "TVirtualMutex.h"
21 #include "TError.h"
22 
23 #ifndef G__ROOT
24 #define G__ROOT
25 #endif
26 
27 #include "RtypesImp.h"
28 #include "TIsAProxy.h"
29 #include "TFileMergeInfo.h"
30 #include <algorithm>
31 #include "TCollectionProxyInfo.h"
32 /*******************************************************************/
33 
34 #include "TDataMember.h"
35 
36 // Since CINT ignores the std namespace, we need to do so in this file.
37 namespace std {} using namespace std;
38 
39 // Header files passed as explicit arguments
40 #include "/scratch/workspace/build-nu-matrix/BUILDTYPE/debug/QUAL/s85-c2/label1/swarm/label2/SLF7/build/nusimdata/v1_16_04-buildFW/src/nusimdata/SimulationBase/classes.h"
41 
42 // Header files passed via #pragma extra_include
43 
44 namespace ROOT {
47  static void *new_pairlETLorentzVectorcOTLorentzVectorgR(void *p = 0);
48  static void *newArray_pairlETLorentzVectorcOTLorentzVectorgR(Long_t size, void *p);
52 
53  // Function generating the singleton type initializer
54  static TGenericClassInfo *GenerateInitInstanceLocal(const pair<TLorentzVector,TLorentzVector>*)
55  {
56  pair<TLorentzVector,TLorentzVector> *ptr = 0;
57  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<TLorentzVector,TLorentzVector>));
58  static ::ROOT::TGenericClassInfo
59  instance("pair<TLorentzVector,TLorentzVector>", "utility", 312,
60  typeid(pair<TLorentzVector,TLorentzVector>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
61  &pairlETLorentzVectorcOTLorentzVectorgR_Dictionary, isa_proxy, 4,
62  sizeof(pair<TLorentzVector,TLorentzVector>) );
63  instance.SetNew(&new_pairlETLorentzVectorcOTLorentzVectorgR);
64  instance.SetNewArray(&newArray_pairlETLorentzVectorcOTLorentzVectorgR);
65  instance.SetDelete(&delete_pairlETLorentzVectorcOTLorentzVectorgR);
66  instance.SetDeleteArray(&deleteArray_pairlETLorentzVectorcOTLorentzVectorgR);
67  instance.SetDestructor(&destruct_pairlETLorentzVectorcOTLorentzVectorgR);
68  return &instance;
69  }
70  // Static variable to force the class initialization
71  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const pair<TLorentzVector,TLorentzVector>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
72 
73  // Dictionary for non-ClassDef classes
75  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const pair<TLorentzVector,TLorentzVector>*)0x0)->GetClass();
77  return theClass;
78  }
79 
81  }
82 
83 } // end of namespace ROOT
84 
85 namespace ROOT {
88  static void *new_pairlEunsignedsPlongcOunsignedsPchargR(void *p = 0);
89  static void *newArray_pairlEunsignedsPlongcOunsignedsPchargR(Long_t size, void *p);
93 
94  // Function generating the singleton type initializer
95  static TGenericClassInfo *GenerateInitInstanceLocal(const pair<unsigned long,unsigned char>*)
96  {
97  pair<unsigned long,unsigned char> *ptr = 0;
98  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<unsigned long,unsigned char>));
99  static ::ROOT::TGenericClassInfo
100  instance("pair<unsigned long,unsigned char>", "utility", 312,
101  typeid(pair<unsigned long,unsigned char>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
102  &pairlEunsignedsPlongcOunsignedsPchargR_Dictionary, isa_proxy, 4,
103  sizeof(pair<unsigned long,unsigned char>) );
104  instance.SetNew(&new_pairlEunsignedsPlongcOunsignedsPchargR);
105  instance.SetNewArray(&newArray_pairlEunsignedsPlongcOunsignedsPchargR);
106  instance.SetDelete(&delete_pairlEunsignedsPlongcOunsignedsPchargR);
107  instance.SetDeleteArray(&deleteArray_pairlEunsignedsPlongcOunsignedsPchargR);
108  instance.SetDestructor(&destruct_pairlEunsignedsPlongcOunsignedsPchargR);
109 
110  ::ROOT::AddClassAlternate("pair<unsigned long,unsigned char>","pair<size_t,unsigned char>");
111  return &instance;
112  }
113  // Static variable to force the class initialization
114  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const pair<unsigned long,unsigned char>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
115 
116  // Dictionary for non-ClassDef classes
118  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const pair<unsigned long,unsigned char>*)0x0)->GetClass();
120  return theClass;
121  }
122 
124  }
125 
126 } // end of namespace ROOT
127 
128 namespace ROOT {
136 
137  // Function generating the singleton type initializer
139  {
140  pair<art::Ptr<bsim::NuChoice>,art::Ptr<simb::MCTruth> > *ptr = 0;
141  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<art::Ptr<bsim::NuChoice>,art::Ptr<simb::MCTruth> >));
142  static ::ROOT::TGenericClassInfo
143  instance("pair<art::Ptr<bsim::NuChoice>,art::Ptr<simb::MCTruth> >", "utility", 312,
144  typeid(pair<art::Ptr<bsim::NuChoice>,art::Ptr<simb::MCTruth> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
145  &pairlEartcLcLPtrlEbsimcLcLNuChoicegRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR_Dictionary, isa_proxy, 4,
147  instance.SetNew(&new_pairlEartcLcLPtrlEbsimcLcLNuChoicegRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
148  instance.SetNewArray(&newArray_pairlEartcLcLPtrlEbsimcLcLNuChoicegRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
149  instance.SetDelete(&delete_pairlEartcLcLPtrlEbsimcLcLNuChoicegRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
150  instance.SetDeleteArray(&deleteArray_pairlEartcLcLPtrlEbsimcLcLNuChoicegRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
151  instance.SetDestructor(&destruct_pairlEartcLcLPtrlEbsimcLcLNuChoicegRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
152  return &instance;
153  }
154  // Static variable to force the class initialization
156 
157  // Dictionary for non-ClassDef classes
159  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const pair<art::Ptr<bsim::NuChoice>,art::Ptr<simb::MCTruth> >*)0x0)->GetClass();
161  return theClass;
162  }
163 
165  }
166 
167 } // end of namespace ROOT
168 
169 namespace ROOT {
177 
178  // Function generating the singleton type initializer
180  {
181  pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::NuChoice> > *ptr = 0;
182  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::NuChoice> >));
183  static ::ROOT::TGenericClassInfo
184  instance("pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::NuChoice> >", "utility", 312,
185  typeid(pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::NuChoice> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
186  &pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEbsimcLcLNuChoicegRsPgR_Dictionary, isa_proxy, 4,
188  instance.SetNew(&new_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEbsimcLcLNuChoicegRsPgR);
189  instance.SetNewArray(&newArray_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEbsimcLcLNuChoicegRsPgR);
190  instance.SetDelete(&delete_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEbsimcLcLNuChoicegRsPgR);
191  instance.SetDeleteArray(&deleteArray_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEbsimcLcLNuChoicegRsPgR);
192  instance.SetDestructor(&destruct_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEbsimcLcLNuChoicegRsPgR);
193  return &instance;
194  }
195  // Static variable to force the class initialization
197 
198  // Dictionary for non-ClassDef classes
200  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::NuChoice> >*)0x0)->GetClass();
202  return theClass;
203  }
204 
206  }
207 
208 } // end of namespace ROOT
209 
210 namespace ROOT {
218 
219  // Function generating the singleton type initializer
221  {
222  pair<art::Ptr<bsim::Dk2Nu>,art::Ptr<simb::MCTruth> > *ptr = 0;
223  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<art::Ptr<bsim::Dk2Nu>,art::Ptr<simb::MCTruth> >));
224  static ::ROOT::TGenericClassInfo
225  instance("pair<art::Ptr<bsim::Dk2Nu>,art::Ptr<simb::MCTruth> >", "utility", 312,
226  typeid(pair<art::Ptr<bsim::Dk2Nu>,art::Ptr<simb::MCTruth> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
227  &pairlEartcLcLPtrlEbsimcLcLDk2NugRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR_Dictionary, isa_proxy, 4,
229  instance.SetNew(&new_pairlEartcLcLPtrlEbsimcLcLDk2NugRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
230  instance.SetNewArray(&newArray_pairlEartcLcLPtrlEbsimcLcLDk2NugRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
231  instance.SetDelete(&delete_pairlEartcLcLPtrlEbsimcLcLDk2NugRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
232  instance.SetDeleteArray(&deleteArray_pairlEartcLcLPtrlEbsimcLcLDk2NugRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
233  instance.SetDestructor(&destruct_pairlEartcLcLPtrlEbsimcLcLDk2NugRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
234  return &instance;
235  }
236  // Static variable to force the class initialization
238 
239  // Dictionary for non-ClassDef classes
241  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const pair<art::Ptr<bsim::Dk2Nu>,art::Ptr<simb::MCTruth> >*)0x0)->GetClass();
243  return theClass;
244  }
245 
247  }
248 
249 } // end of namespace ROOT
250 
251 namespace ROOT {
259 
260  // Function generating the singleton type initializer
262  {
263  pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::Dk2Nu> > *ptr = 0;
264  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::Dk2Nu> >));
265  static ::ROOT::TGenericClassInfo
266  instance("pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::Dk2Nu> >", "utility", 312,
267  typeid(pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::Dk2Nu> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
268  &pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEbsimcLcLDk2NugRsPgR_Dictionary, isa_proxy, 4,
270  instance.SetNew(&new_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEbsimcLcLDk2NugRsPgR);
271  instance.SetNewArray(&newArray_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEbsimcLcLDk2NugRsPgR);
272  instance.SetDelete(&delete_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEbsimcLcLDk2NugRsPgR);
273  instance.SetDeleteArray(&deleteArray_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEbsimcLcLDk2NugRsPgR);
274  instance.SetDestructor(&destruct_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEbsimcLcLDk2NugRsPgR);
275  return &instance;
276  }
277  // Static variable to force the class initialization
279 
280  // Dictionary for non-ClassDef classes
282  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::Dk2Nu> >*)0x0)->GetClass();
284  return theClass;
285  }
286 
288  }
289 
290 } // end of namespace ROOT
291 
292 namespace ROOT {
300 
301  // Function generating the singleton type initializer
303  {
304  pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCParticle> > *ptr = 0;
305  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCParticle> >));
306  static ::ROOT::TGenericClassInfo
307  instance("pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCParticle> >", "utility", 312,
308  typeid(pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCParticle> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
309  &pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEsimbcLcLMCParticlegRsPgR_Dictionary, isa_proxy, 4,
311  instance.SetNew(&new_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEsimbcLcLMCParticlegRsPgR);
312  instance.SetNewArray(&newArray_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEsimbcLcLMCParticlegRsPgR);
313  instance.SetDelete(&delete_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEsimbcLcLMCParticlegRsPgR);
314  instance.SetDeleteArray(&deleteArray_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEsimbcLcLMCParticlegRsPgR);
315  instance.SetDestructor(&destruct_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEsimbcLcLMCParticlegRsPgR);
316  return &instance;
317  }
318  // Static variable to force the class initialization
320 
321  // Dictionary for non-ClassDef classes
323  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCParticle> >*)0x0)->GetClass();
325  return theClass;
326  }
327 
329  }
330 
331 } // end of namespace ROOT
332 
333 namespace ROOT {
341 
342  // Function generating the singleton type initializer
344  {
345  pair<art::Ptr<simb::MCParticle>,art::Ptr<simb::MCTruth> > *ptr = 0;
346  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<art::Ptr<simb::MCParticle>,art::Ptr<simb::MCTruth> >));
347  static ::ROOT::TGenericClassInfo
348  instance("pair<art::Ptr<simb::MCParticle>,art::Ptr<simb::MCTruth> >", "utility", 312,
349  typeid(pair<art::Ptr<simb::MCParticle>,art::Ptr<simb::MCTruth> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
350  &pairlEartcLcLPtrlEsimbcLcLMCParticlegRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR_Dictionary, isa_proxy, 4,
352  instance.SetNew(&new_pairlEartcLcLPtrlEsimbcLcLMCParticlegRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
353  instance.SetNewArray(&newArray_pairlEartcLcLPtrlEsimbcLcLMCParticlegRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
354  instance.SetDelete(&delete_pairlEartcLcLPtrlEsimbcLcLMCParticlegRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
355  instance.SetDeleteArray(&deleteArray_pairlEartcLcLPtrlEsimbcLcLMCParticlegRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
356  instance.SetDestructor(&destruct_pairlEartcLcLPtrlEsimbcLcLMCParticlegRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
357  return &instance;
358  }
359  // Static variable to force the class initialization
361 
362  // Dictionary for non-ClassDef classes
364  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const pair<art::Ptr<simb::MCParticle>,art::Ptr<simb::MCTruth> >*)0x0)->GetClass();
366  return theClass;
367  }
368 
370  }
371 
372 } // end of namespace ROOT
373 
374 namespace ROOT {
382 
383  // Function generating the singleton type initializer
385  {
386  pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::GTruth> > *ptr = 0;
387  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::GTruth> >));
388  static ::ROOT::TGenericClassInfo
389  instance("pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::GTruth> >", "utility", 312,
390  typeid(pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::GTruth> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
391  &pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEsimbcLcLGTruthgRsPgR_Dictionary, isa_proxy, 4,
393  instance.SetNew(&new_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEsimbcLcLGTruthgRsPgR);
394  instance.SetNewArray(&newArray_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEsimbcLcLGTruthgRsPgR);
395  instance.SetDelete(&delete_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEsimbcLcLGTruthgRsPgR);
396  instance.SetDeleteArray(&deleteArray_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEsimbcLcLGTruthgRsPgR);
397  instance.SetDestructor(&destruct_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEsimbcLcLGTruthgRsPgR);
398  return &instance;
399  }
400  // Static variable to force the class initialization
402 
403  // Dictionary for non-ClassDef classes
405  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::GTruth> >*)0x0)->GetClass();
407  return theClass;
408  }
409 
411  }
412 
413 } // end of namespace ROOT
414 
415 namespace ROOT {
423 
424  // Function generating the singleton type initializer
426  {
427  pair<art::Ptr<simb::GTruth>,art::Ptr<simb::MCTruth> > *ptr = 0;
428  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<art::Ptr<simb::GTruth>,art::Ptr<simb::MCTruth> >));
429  static ::ROOT::TGenericClassInfo
430  instance("pair<art::Ptr<simb::GTruth>,art::Ptr<simb::MCTruth> >", "utility", 312,
431  typeid(pair<art::Ptr<simb::GTruth>,art::Ptr<simb::MCTruth> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
432  &pairlEartcLcLPtrlEsimbcLcLGTruthgRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR_Dictionary, isa_proxy, 4,
434  instance.SetNew(&new_pairlEartcLcLPtrlEsimbcLcLGTruthgRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
435  instance.SetNewArray(&newArray_pairlEartcLcLPtrlEsimbcLcLGTruthgRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
436  instance.SetDelete(&delete_pairlEartcLcLPtrlEsimbcLcLGTruthgRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
437  instance.SetDeleteArray(&deleteArray_pairlEartcLcLPtrlEsimbcLcLGTruthgRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
438  instance.SetDestructor(&destruct_pairlEartcLcLPtrlEsimbcLcLGTruthgRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
439  return &instance;
440  }
441  // Static variable to force the class initialization
443 
444  // Dictionary for non-ClassDef classes
446  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const pair<art::Ptr<simb::GTruth>,art::Ptr<simb::MCTruth> >*)0x0)->GetClass();
448  return theClass;
449  }
450 
452  }
453 
454 } // end of namespace ROOT
455 
456 namespace ROOT {
464 
465  // Function generating the singleton type initializer
467  {
468  pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCFlux> > *ptr = 0;
469  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCFlux> >));
470  static ::ROOT::TGenericClassInfo
471  instance("pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCFlux> >", "utility", 312,
472  typeid(pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCFlux> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
473  &pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEsimbcLcLMCFluxgRsPgR_Dictionary, isa_proxy, 4,
475  instance.SetNew(&new_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEsimbcLcLMCFluxgRsPgR);
476  instance.SetNewArray(&newArray_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEsimbcLcLMCFluxgRsPgR);
477  instance.SetDelete(&delete_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEsimbcLcLMCFluxgRsPgR);
478  instance.SetDeleteArray(&deleteArray_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEsimbcLcLMCFluxgRsPgR);
479  instance.SetDestructor(&destruct_pairlEartcLcLPtrlEsimbcLcLMCTruthgRcOartcLcLPtrlEsimbcLcLMCFluxgRsPgR);
480  return &instance;
481  }
482  // Static variable to force the class initialization
484 
485  // Dictionary for non-ClassDef classes
487  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCFlux> >*)0x0)->GetClass();
489  return theClass;
490  }
491 
493  }
494 
495 } // end of namespace ROOT
496 
497 namespace ROOT {
505 
506  // Function generating the singleton type initializer
508  {
509  pair<art::Ptr<simb::MCFlux>,art::Ptr<simb::MCTruth> > *ptr = 0;
510  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<art::Ptr<simb::MCFlux>,art::Ptr<simb::MCTruth> >));
511  static ::ROOT::TGenericClassInfo
512  instance("pair<art::Ptr<simb::MCFlux>,art::Ptr<simb::MCTruth> >", "utility", 312,
513  typeid(pair<art::Ptr<simb::MCFlux>,art::Ptr<simb::MCTruth> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
514  &pairlEartcLcLPtrlEsimbcLcLMCFluxgRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR_Dictionary, isa_proxy, 4,
516  instance.SetNew(&new_pairlEartcLcLPtrlEsimbcLcLMCFluxgRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
517  instance.SetNewArray(&newArray_pairlEartcLcLPtrlEsimbcLcLMCFluxgRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
518  instance.SetDelete(&delete_pairlEartcLcLPtrlEsimbcLcLMCFluxgRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
519  instance.SetDeleteArray(&deleteArray_pairlEartcLcLPtrlEsimbcLcLMCFluxgRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
520  instance.SetDestructor(&destruct_pairlEartcLcLPtrlEsimbcLcLMCFluxgRcOartcLcLPtrlEsimbcLcLMCTruthgRsPgR);
521  return &instance;
522  }
523  // Static variable to force the class initialization
525 
526  // Dictionary for non-ClassDef classes
528  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const pair<art::Ptr<simb::MCFlux>,art::Ptr<simb::MCTruth> >*)0x0)->GetClass();
530  return theClass;
531  }
532 
534  }
535 
536 } // end of namespace ROOT
537 
538 namespace ROOT {
546 
547  // Function generating the singleton type initializer
548  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Assns<bsim::NuChoice,simb::MCTruth,void>*)
549  {
551  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Assns<bsim::NuChoice,simb::MCTruth,void>));
552  static ::ROOT::TGenericClassInfo
553  instance("art::Assns<bsim::NuChoice,simb::MCTruth,void>", ::art::Assns<bsim::NuChoice,simb::MCTruth,void>::Class_Version(), "canvas/Persistency/Common/Assns.h", 123,
554  typeid(::art::Assns<bsim::NuChoice,simb::MCTruth,void>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
555  &artcLcLAssnslEbsimcLcLNuChoicecOsimbcLcLMCTruthcOvoidgR_Dictionary, isa_proxy, 4,
557  instance.SetNew(&new_artcLcLAssnslEbsimcLcLNuChoicecOsimbcLcLMCTruthcOvoidgR);
558  instance.SetNewArray(&newArray_artcLcLAssnslEbsimcLcLNuChoicecOsimbcLcLMCTruthcOvoidgR);
559  instance.SetDelete(&delete_artcLcLAssnslEbsimcLcLNuChoicecOsimbcLcLMCTruthcOvoidgR);
560  instance.SetDeleteArray(&deleteArray_artcLcLAssnslEbsimcLcLNuChoicecOsimbcLcLMCTruthcOvoidgR);
561  instance.SetDestructor(&destruct_artcLcLAssnslEbsimcLcLNuChoicecOsimbcLcLMCTruthcOvoidgR);
562  return &instance;
563  }
564  TGenericClassInfo *GenerateInitInstance(const ::art::Assns<bsim::NuChoice,simb::MCTruth,void>*)
565  {
567  }
568  // Static variable to force the class initialization
569  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Assns<bsim::NuChoice,simb::MCTruth,void>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
570 
571  // Dictionary for non-ClassDef classes
573  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Assns<bsim::NuChoice,simb::MCTruth,void>*)0x0)->GetClass();
575  return theClass;
576  }
577 
579  }
580 
581 } // end of namespace ROOT
582 
583 namespace ROOT {
591 
592  // Function generating the singleton type initializer
593  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Assns<simb::MCTruth,bsim::NuChoice,void>*)
594  {
596  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Assns<simb::MCTruth,bsim::NuChoice,void>));
597  static ::ROOT::TGenericClassInfo
598  instance("art::Assns<simb::MCTruth,bsim::NuChoice,void>", ::art::Assns<simb::MCTruth,bsim::NuChoice,void>::Class_Version(), "canvas/Persistency/Common/Assns.h", 123,
599  typeid(::art::Assns<simb::MCTruth,bsim::NuChoice,void>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
600  &artcLcLAssnslEsimbcLcLMCTruthcObsimcLcLNuChoicecOvoidgR_Dictionary, isa_proxy, 4,
602  instance.SetNew(&new_artcLcLAssnslEsimbcLcLMCTruthcObsimcLcLNuChoicecOvoidgR);
603  instance.SetNewArray(&newArray_artcLcLAssnslEsimbcLcLMCTruthcObsimcLcLNuChoicecOvoidgR);
604  instance.SetDelete(&delete_artcLcLAssnslEsimbcLcLMCTruthcObsimcLcLNuChoicecOvoidgR);
605  instance.SetDeleteArray(&deleteArray_artcLcLAssnslEsimbcLcLMCTruthcObsimcLcLNuChoicecOvoidgR);
606  instance.SetDestructor(&destruct_artcLcLAssnslEsimbcLcLMCTruthcObsimcLcLNuChoicecOvoidgR);
607  return &instance;
608  }
609  TGenericClassInfo *GenerateInitInstance(const ::art::Assns<simb::MCTruth,bsim::NuChoice,void>*)
610  {
612  }
613  // Static variable to force the class initialization
614  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Assns<simb::MCTruth,bsim::NuChoice,void>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
615 
616  // Dictionary for non-ClassDef classes
618  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Assns<simb::MCTruth,bsim::NuChoice,void>*)0x0)->GetClass();
620  return theClass;
621  }
622 
624  }
625 
626 } // end of namespace ROOT
627 
628 namespace ROOT {
636 
637  // Function generating the singleton type initializer
638  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Assns<bsim::Dk2Nu,simb::MCTruth,void>*)
639  {
641  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Assns<bsim::Dk2Nu,simb::MCTruth,void>));
642  static ::ROOT::TGenericClassInfo
643  instance("art::Assns<bsim::Dk2Nu,simb::MCTruth,void>", ::art::Assns<bsim::Dk2Nu,simb::MCTruth,void>::Class_Version(), "canvas/Persistency/Common/Assns.h", 123,
644  typeid(::art::Assns<bsim::Dk2Nu,simb::MCTruth,void>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
645  &artcLcLAssnslEbsimcLcLDk2NucOsimbcLcLMCTruthcOvoidgR_Dictionary, isa_proxy, 4,
647  instance.SetNew(&new_artcLcLAssnslEbsimcLcLDk2NucOsimbcLcLMCTruthcOvoidgR);
648  instance.SetNewArray(&newArray_artcLcLAssnslEbsimcLcLDk2NucOsimbcLcLMCTruthcOvoidgR);
649  instance.SetDelete(&delete_artcLcLAssnslEbsimcLcLDk2NucOsimbcLcLMCTruthcOvoidgR);
650  instance.SetDeleteArray(&deleteArray_artcLcLAssnslEbsimcLcLDk2NucOsimbcLcLMCTruthcOvoidgR);
651  instance.SetDestructor(&destruct_artcLcLAssnslEbsimcLcLDk2NucOsimbcLcLMCTruthcOvoidgR);
652  return &instance;
653  }
654  TGenericClassInfo *GenerateInitInstance(const ::art::Assns<bsim::Dk2Nu,simb::MCTruth,void>*)
655  {
657  }
658  // Static variable to force the class initialization
659  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Assns<bsim::Dk2Nu,simb::MCTruth,void>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
660 
661  // Dictionary for non-ClassDef classes
663  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Assns<bsim::Dk2Nu,simb::MCTruth,void>*)0x0)->GetClass();
665  return theClass;
666  }
667 
669  }
670 
671 } // end of namespace ROOT
672 
673 namespace ROOT {
681 
682  // Function generating the singleton type initializer
683  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Assns<simb::MCTruth,bsim::Dk2Nu,void>*)
684  {
686  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Assns<simb::MCTruth,bsim::Dk2Nu,void>));
687  static ::ROOT::TGenericClassInfo
688  instance("art::Assns<simb::MCTruth,bsim::Dk2Nu,void>", ::art::Assns<simb::MCTruth,bsim::Dk2Nu,void>::Class_Version(), "canvas/Persistency/Common/Assns.h", 123,
689  typeid(::art::Assns<simb::MCTruth,bsim::Dk2Nu,void>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
690  &artcLcLAssnslEsimbcLcLMCTruthcObsimcLcLDk2NucOvoidgR_Dictionary, isa_proxy, 4,
692  instance.SetNew(&new_artcLcLAssnslEsimbcLcLMCTruthcObsimcLcLDk2NucOvoidgR);
693  instance.SetNewArray(&newArray_artcLcLAssnslEsimbcLcLMCTruthcObsimcLcLDk2NucOvoidgR);
694  instance.SetDelete(&delete_artcLcLAssnslEsimbcLcLMCTruthcObsimcLcLDk2NucOvoidgR);
695  instance.SetDeleteArray(&deleteArray_artcLcLAssnslEsimbcLcLMCTruthcObsimcLcLDk2NucOvoidgR);
696  instance.SetDestructor(&destruct_artcLcLAssnslEsimbcLcLMCTruthcObsimcLcLDk2NucOvoidgR);
697  return &instance;
698  }
699  TGenericClassInfo *GenerateInitInstance(const ::art::Assns<simb::MCTruth,bsim::Dk2Nu,void>*)
700  {
702  }
703  // Static variable to force the class initialization
704  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Assns<simb::MCTruth,bsim::Dk2Nu,void>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
705 
706  // Dictionary for non-ClassDef classes
708  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Assns<simb::MCTruth,bsim::Dk2Nu,void>*)0x0)->GetClass();
710  return theClass;
711  }
712 
714  }
715 
716 } // end of namespace ROOT
717 
718 namespace ROOT {
726 
727  // Function generating the singleton type initializer
728  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Assns<simb::MCTruth,simb::MCParticle,void>*)
729  {
731  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Assns<simb::MCTruth,simb::MCParticle,void>));
732  static ::ROOT::TGenericClassInfo
733  instance("art::Assns<simb::MCTruth,simb::MCParticle,void>", ::art::Assns<simb::MCTruth,simb::MCParticle,void>::Class_Version(), "canvas/Persistency/Common/Assns.h", 123,
734  typeid(::art::Assns<simb::MCTruth,simb::MCParticle,void>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
735  &artcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCParticlecOvoidgR_Dictionary, isa_proxy, 4,
737  instance.SetNew(&new_artcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCParticlecOvoidgR);
738  instance.SetNewArray(&newArray_artcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCParticlecOvoidgR);
739  instance.SetDelete(&delete_artcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCParticlecOvoidgR);
740  instance.SetDeleteArray(&deleteArray_artcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCParticlecOvoidgR);
741  instance.SetDestructor(&destruct_artcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCParticlecOvoidgR);
742  return &instance;
743  }
744  TGenericClassInfo *GenerateInitInstance(const ::art::Assns<simb::MCTruth,simb::MCParticle,void>*)
745  {
747  }
748  // Static variable to force the class initialization
749  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Assns<simb::MCTruth,simb::MCParticle,void>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
750 
751  // Dictionary for non-ClassDef classes
753  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Assns<simb::MCTruth,simb::MCParticle,void>*)0x0)->GetClass();
755  return theClass;
756  }
757 
759  }
760 
761 } // end of namespace ROOT
762 
763 namespace ROOT {
771 
772  // Function generating the singleton type initializer
773  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Assns<simb::MCParticle,simb::MCTruth,void>*)
774  {
776  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Assns<simb::MCParticle,simb::MCTruth,void>));
777  static ::ROOT::TGenericClassInfo
778  instance("art::Assns<simb::MCParticle,simb::MCTruth,void>", ::art::Assns<simb::MCParticle,simb::MCTruth,void>::Class_Version(), "canvas/Persistency/Common/Assns.h", 123,
779  typeid(::art::Assns<simb::MCParticle,simb::MCTruth,void>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
780  &artcLcLAssnslEsimbcLcLMCParticlecOsimbcLcLMCTruthcOvoidgR_Dictionary, isa_proxy, 4,
782  instance.SetNew(&new_artcLcLAssnslEsimbcLcLMCParticlecOsimbcLcLMCTruthcOvoidgR);
783  instance.SetNewArray(&newArray_artcLcLAssnslEsimbcLcLMCParticlecOsimbcLcLMCTruthcOvoidgR);
784  instance.SetDelete(&delete_artcLcLAssnslEsimbcLcLMCParticlecOsimbcLcLMCTruthcOvoidgR);
785  instance.SetDeleteArray(&deleteArray_artcLcLAssnslEsimbcLcLMCParticlecOsimbcLcLMCTruthcOvoidgR);
786  instance.SetDestructor(&destruct_artcLcLAssnslEsimbcLcLMCParticlecOsimbcLcLMCTruthcOvoidgR);
787  return &instance;
788  }
789  TGenericClassInfo *GenerateInitInstance(const ::art::Assns<simb::MCParticle,simb::MCTruth,void>*)
790  {
792  }
793  // Static variable to force the class initialization
794  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Assns<simb::MCParticle,simb::MCTruth,void>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
795 
796  // Dictionary for non-ClassDef classes
798  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Assns<simb::MCParticle,simb::MCTruth,void>*)0x0)->GetClass();
800  return theClass;
801  }
802 
804  }
805 
806 } // end of namespace ROOT
807 
808 namespace ROOT {
816 
817  // Function generating the singleton type initializer
818  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Assns<simb::MCTruth,simb::GTruth,void>*)
819  {
821  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Assns<simb::MCTruth,simb::GTruth,void>));
822  static ::ROOT::TGenericClassInfo
823  instance("art::Assns<simb::MCTruth,simb::GTruth,void>", ::art::Assns<simb::MCTruth,simb::GTruth,void>::Class_Version(), "canvas/Persistency/Common/Assns.h", 123,
824  typeid(::art::Assns<simb::MCTruth,simb::GTruth,void>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
825  &artcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLGTruthcOvoidgR_Dictionary, isa_proxy, 4,
827  instance.SetNew(&new_artcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLGTruthcOvoidgR);
828  instance.SetNewArray(&newArray_artcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLGTruthcOvoidgR);
829  instance.SetDelete(&delete_artcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLGTruthcOvoidgR);
830  instance.SetDeleteArray(&deleteArray_artcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLGTruthcOvoidgR);
831  instance.SetDestructor(&destruct_artcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLGTruthcOvoidgR);
832  return &instance;
833  }
834  TGenericClassInfo *GenerateInitInstance(const ::art::Assns<simb::MCTruth,simb::GTruth,void>*)
835  {
837  }
838  // Static variable to force the class initialization
839  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Assns<simb::MCTruth,simb::GTruth,void>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
840 
841  // Dictionary for non-ClassDef classes
843  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Assns<simb::MCTruth,simb::GTruth,void>*)0x0)->GetClass();
845  return theClass;
846  }
847 
849  }
850 
851 } // end of namespace ROOT
852 
853 namespace ROOT {
861 
862  // Function generating the singleton type initializer
863  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Assns<simb::GTruth,simb::MCTruth,void>*)
864  {
866  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Assns<simb::GTruth,simb::MCTruth,void>));
867  static ::ROOT::TGenericClassInfo
868  instance("art::Assns<simb::GTruth,simb::MCTruth,void>", ::art::Assns<simb::GTruth,simb::MCTruth,void>::Class_Version(), "canvas/Persistency/Common/Assns.h", 123,
869  typeid(::art::Assns<simb::GTruth,simb::MCTruth,void>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
870  &artcLcLAssnslEsimbcLcLGTruthcOsimbcLcLMCTruthcOvoidgR_Dictionary, isa_proxy, 4,
872  instance.SetNew(&new_artcLcLAssnslEsimbcLcLGTruthcOsimbcLcLMCTruthcOvoidgR);
873  instance.SetNewArray(&newArray_artcLcLAssnslEsimbcLcLGTruthcOsimbcLcLMCTruthcOvoidgR);
874  instance.SetDelete(&delete_artcLcLAssnslEsimbcLcLGTruthcOsimbcLcLMCTruthcOvoidgR);
875  instance.SetDeleteArray(&deleteArray_artcLcLAssnslEsimbcLcLGTruthcOsimbcLcLMCTruthcOvoidgR);
876  instance.SetDestructor(&destruct_artcLcLAssnslEsimbcLcLGTruthcOsimbcLcLMCTruthcOvoidgR);
877  return &instance;
878  }
879  TGenericClassInfo *GenerateInitInstance(const ::art::Assns<simb::GTruth,simb::MCTruth,void>*)
880  {
882  }
883  // Static variable to force the class initialization
884  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Assns<simb::GTruth,simb::MCTruth,void>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
885 
886  // Dictionary for non-ClassDef classes
888  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Assns<simb::GTruth,simb::MCTruth,void>*)0x0)->GetClass();
890  return theClass;
891  }
892 
894  }
895 
896 } // end of namespace ROOT
897 
898 namespace ROOT {
906 
907  // Function generating the singleton type initializer
908  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Assns<simb::MCTruth,simb::MCFlux,void>*)
909  {
911  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Assns<simb::MCTruth,simb::MCFlux,void>));
912  static ::ROOT::TGenericClassInfo
913  instance("art::Assns<simb::MCTruth,simb::MCFlux,void>", ::art::Assns<simb::MCTruth,simb::MCFlux,void>::Class_Version(), "canvas/Persistency/Common/Assns.h", 123,
914  typeid(::art::Assns<simb::MCTruth,simb::MCFlux,void>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
915  &artcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCFluxcOvoidgR_Dictionary, isa_proxy, 4,
917  instance.SetNew(&new_artcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCFluxcOvoidgR);
918  instance.SetNewArray(&newArray_artcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCFluxcOvoidgR);
919  instance.SetDelete(&delete_artcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCFluxcOvoidgR);
920  instance.SetDeleteArray(&deleteArray_artcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCFluxcOvoidgR);
921  instance.SetDestructor(&destruct_artcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCFluxcOvoidgR);
922  return &instance;
923  }
924  TGenericClassInfo *GenerateInitInstance(const ::art::Assns<simb::MCTruth,simb::MCFlux,void>*)
925  {
927  }
928  // Static variable to force the class initialization
929  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Assns<simb::MCTruth,simb::MCFlux,void>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
930 
931  // Dictionary for non-ClassDef classes
933  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Assns<simb::MCTruth,simb::MCFlux,void>*)0x0)->GetClass();
935  return theClass;
936  }
937 
939  }
940 
941 } // end of namespace ROOT
942 
943 namespace ROOT {
951 
952  // Function generating the singleton type initializer
953  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Assns<simb::MCFlux,simb::MCTruth,void>*)
954  {
956  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Assns<simb::MCFlux,simb::MCTruth,void>));
957  static ::ROOT::TGenericClassInfo
958  instance("art::Assns<simb::MCFlux,simb::MCTruth,void>", ::art::Assns<simb::MCFlux,simb::MCTruth,void>::Class_Version(), "canvas/Persistency/Common/Assns.h", 123,
959  typeid(::art::Assns<simb::MCFlux,simb::MCTruth,void>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
960  &artcLcLAssnslEsimbcLcLMCFluxcOsimbcLcLMCTruthcOvoidgR_Dictionary, isa_proxy, 4,
962  instance.SetNew(&new_artcLcLAssnslEsimbcLcLMCFluxcOsimbcLcLMCTruthcOvoidgR);
963  instance.SetNewArray(&newArray_artcLcLAssnslEsimbcLcLMCFluxcOsimbcLcLMCTruthcOvoidgR);
964  instance.SetDelete(&delete_artcLcLAssnslEsimbcLcLMCFluxcOsimbcLcLMCTruthcOvoidgR);
965  instance.SetDeleteArray(&deleteArray_artcLcLAssnslEsimbcLcLMCFluxcOsimbcLcLMCTruthcOvoidgR);
966  instance.SetDestructor(&destruct_artcLcLAssnslEsimbcLcLMCFluxcOsimbcLcLMCTruthcOvoidgR);
967  return &instance;
968  }
969  TGenericClassInfo *GenerateInitInstance(const ::art::Assns<simb::MCFlux,simb::MCTruth,void>*)
970  {
972  }
973  // Static variable to force the class initialization
974  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Assns<simb::MCFlux,simb::MCTruth,void>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
975 
976  // Dictionary for non-ClassDef classes
978  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Assns<simb::MCFlux,simb::MCTruth,void>*)0x0)->GetClass();
980  return theClass;
981  }
982 
984  }
985 
986 } // end of namespace ROOT
987 
988 namespace ROOT {
990  static void artcLcLPtrlEbsimcLcLNuChoicegR_TClassManip(TClass*);
991  static void *new_artcLcLPtrlEbsimcLcLNuChoicegR(void *p = 0);
992  static void *newArray_artcLcLPtrlEbsimcLcLNuChoicegR(Long_t size, void *p);
993  static void delete_artcLcLPtrlEbsimcLcLNuChoicegR(void *p);
994  static void deleteArray_artcLcLPtrlEbsimcLcLNuChoicegR(void *p);
995  static void destruct_artcLcLPtrlEbsimcLcLNuChoicegR(void *p);
996 
997  // Function generating the singleton type initializer
998  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Ptr<bsim::NuChoice>*)
999  {
1000  ::art::Ptr<bsim::NuChoice> *ptr = 0;
1001  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Ptr<bsim::NuChoice>));
1002  static ::ROOT::TGenericClassInfo
1003  instance("art::Ptr<bsim::NuChoice>", ::art::Ptr<bsim::NuChoice>::Class_Version(), "canvas/Persistency/Common/Ptr.h", 100,
1004  typeid(::art::Ptr<bsim::NuChoice>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1005  &artcLcLPtrlEbsimcLcLNuChoicegR_Dictionary, isa_proxy, 4,
1006  sizeof(::art::Ptr<bsim::NuChoice>) );
1007  instance.SetNew(&new_artcLcLPtrlEbsimcLcLNuChoicegR);
1008  instance.SetNewArray(&newArray_artcLcLPtrlEbsimcLcLNuChoicegR);
1009  instance.SetDelete(&delete_artcLcLPtrlEbsimcLcLNuChoicegR);
1010  instance.SetDeleteArray(&deleteArray_artcLcLPtrlEbsimcLcLNuChoicegR);
1011  instance.SetDestructor(&destruct_artcLcLPtrlEbsimcLcLNuChoicegR);
1012  return &instance;
1013  }
1014  TGenericClassInfo *GenerateInitInstance(const ::art::Ptr<bsim::NuChoice>*)
1015  {
1017  }
1018  // Static variable to force the class initialization
1019  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Ptr<bsim::NuChoice>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1020 
1021  // Dictionary for non-ClassDef classes
1023  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Ptr<bsim::NuChoice>*)0x0)->GetClass();
1025  return theClass;
1026  }
1027 
1029  }
1030 
1031 } // end of namespace ROOT
1032 
1033 namespace ROOT {
1035  static void artcLcLPtrlEsimbcLcLMCTruthgR_TClassManip(TClass*);
1036  static void *new_artcLcLPtrlEsimbcLcLMCTruthgR(void *p = 0);
1037  static void *newArray_artcLcLPtrlEsimbcLcLMCTruthgR(Long_t size, void *p);
1038  static void delete_artcLcLPtrlEsimbcLcLMCTruthgR(void *p);
1039  static void deleteArray_artcLcLPtrlEsimbcLcLMCTruthgR(void *p);
1040  static void destruct_artcLcLPtrlEsimbcLcLMCTruthgR(void *p);
1041 
1042  // Function generating the singleton type initializer
1043  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Ptr<simb::MCTruth>*)
1044  {
1045  ::art::Ptr<simb::MCTruth> *ptr = 0;
1046  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Ptr<simb::MCTruth>));
1047  static ::ROOT::TGenericClassInfo
1048  instance("art::Ptr<simb::MCTruth>", ::art::Ptr<simb::MCTruth>::Class_Version(), "canvas/Persistency/Common/Ptr.h", 100,
1049  typeid(::art::Ptr<simb::MCTruth>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1050  &artcLcLPtrlEsimbcLcLMCTruthgR_Dictionary, isa_proxy, 4,
1051  sizeof(::art::Ptr<simb::MCTruth>) );
1052  instance.SetNew(&new_artcLcLPtrlEsimbcLcLMCTruthgR);
1053  instance.SetNewArray(&newArray_artcLcLPtrlEsimbcLcLMCTruthgR);
1054  instance.SetDelete(&delete_artcLcLPtrlEsimbcLcLMCTruthgR);
1055  instance.SetDeleteArray(&deleteArray_artcLcLPtrlEsimbcLcLMCTruthgR);
1056  instance.SetDestructor(&destruct_artcLcLPtrlEsimbcLcLMCTruthgR);
1057  return &instance;
1058  }
1059  TGenericClassInfo *GenerateInitInstance(const ::art::Ptr<simb::MCTruth>*)
1060  {
1062  }
1063  // Static variable to force the class initialization
1064  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Ptr<simb::MCTruth>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1065 
1066  // Dictionary for non-ClassDef classes
1068  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Ptr<simb::MCTruth>*)0x0)->GetClass();
1070  return theClass;
1071  }
1072 
1074  }
1075 
1076 } // end of namespace ROOT
1077 
1078 namespace ROOT {
1079  static TClass *artcLcLPtrlEbsimcLcLDk2NugR_Dictionary();
1080  static void artcLcLPtrlEbsimcLcLDk2NugR_TClassManip(TClass*);
1081  static void *new_artcLcLPtrlEbsimcLcLDk2NugR(void *p = 0);
1082  static void *newArray_artcLcLPtrlEbsimcLcLDk2NugR(Long_t size, void *p);
1083  static void delete_artcLcLPtrlEbsimcLcLDk2NugR(void *p);
1084  static void deleteArray_artcLcLPtrlEbsimcLcLDk2NugR(void *p);
1085  static void destruct_artcLcLPtrlEbsimcLcLDk2NugR(void *p);
1086 
1087  // Function generating the singleton type initializer
1088  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Ptr<bsim::Dk2Nu>*)
1089  {
1090  ::art::Ptr<bsim::Dk2Nu> *ptr = 0;
1091  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Ptr<bsim::Dk2Nu>));
1092  static ::ROOT::TGenericClassInfo
1093  instance("art::Ptr<bsim::Dk2Nu>", ::art::Ptr<bsim::Dk2Nu>::Class_Version(), "canvas/Persistency/Common/Ptr.h", 100,
1094  typeid(::art::Ptr<bsim::Dk2Nu>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1095  &artcLcLPtrlEbsimcLcLDk2NugR_Dictionary, isa_proxy, 4,
1096  sizeof(::art::Ptr<bsim::Dk2Nu>) );
1097  instance.SetNew(&new_artcLcLPtrlEbsimcLcLDk2NugR);
1098  instance.SetNewArray(&newArray_artcLcLPtrlEbsimcLcLDk2NugR);
1099  instance.SetDelete(&delete_artcLcLPtrlEbsimcLcLDk2NugR);
1100  instance.SetDeleteArray(&deleteArray_artcLcLPtrlEbsimcLcLDk2NugR);
1101  instance.SetDestructor(&destruct_artcLcLPtrlEbsimcLcLDk2NugR);
1102  return &instance;
1103  }
1104  TGenericClassInfo *GenerateInitInstance(const ::art::Ptr<bsim::Dk2Nu>*)
1105  {
1107  }
1108  // Static variable to force the class initialization
1109  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Ptr<bsim::Dk2Nu>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1110 
1111  // Dictionary for non-ClassDef classes
1113  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Ptr<bsim::Dk2Nu>*)0x0)->GetClass();
1115  return theClass;
1116  }
1117 
1119  }
1120 
1121 } // end of namespace ROOT
1122 
1123 namespace ROOT {
1125  static void artcLcLPtrlEsimbcLcLMCParticlegR_TClassManip(TClass*);
1126  static void *new_artcLcLPtrlEsimbcLcLMCParticlegR(void *p = 0);
1127  static void *newArray_artcLcLPtrlEsimbcLcLMCParticlegR(Long_t size, void *p);
1128  static void delete_artcLcLPtrlEsimbcLcLMCParticlegR(void *p);
1129  static void deleteArray_artcLcLPtrlEsimbcLcLMCParticlegR(void *p);
1130  static void destruct_artcLcLPtrlEsimbcLcLMCParticlegR(void *p);
1131 
1132  // Function generating the singleton type initializer
1133  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Ptr<simb::MCParticle>*)
1134  {
1136  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Ptr<simb::MCParticle>));
1137  static ::ROOT::TGenericClassInfo
1138  instance("art::Ptr<simb::MCParticle>", ::art::Ptr<simb::MCParticle>::Class_Version(), "canvas/Persistency/Common/Ptr.h", 100,
1139  typeid(::art::Ptr<simb::MCParticle>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1140  &artcLcLPtrlEsimbcLcLMCParticlegR_Dictionary, isa_proxy, 4,
1141  sizeof(::art::Ptr<simb::MCParticle>) );
1142  instance.SetNew(&new_artcLcLPtrlEsimbcLcLMCParticlegR);
1143  instance.SetNewArray(&newArray_artcLcLPtrlEsimbcLcLMCParticlegR);
1144  instance.SetDelete(&delete_artcLcLPtrlEsimbcLcLMCParticlegR);
1145  instance.SetDeleteArray(&deleteArray_artcLcLPtrlEsimbcLcLMCParticlegR);
1146  instance.SetDestructor(&destruct_artcLcLPtrlEsimbcLcLMCParticlegR);
1147  return &instance;
1148  }
1149  TGenericClassInfo *GenerateInitInstance(const ::art::Ptr<simb::MCParticle>*)
1150  {
1152  }
1153  // Static variable to force the class initialization
1154  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Ptr<simb::MCParticle>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1155 
1156  // Dictionary for non-ClassDef classes
1158  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Ptr<simb::MCParticle>*)0x0)->GetClass();
1160  return theClass;
1161  }
1162 
1164  }
1165 
1166 } // end of namespace ROOT
1167 
1168 namespace ROOT {
1169  static TClass *artcLcLPtrlEsimbcLcLGTruthgR_Dictionary();
1170  static void artcLcLPtrlEsimbcLcLGTruthgR_TClassManip(TClass*);
1171  static void *new_artcLcLPtrlEsimbcLcLGTruthgR(void *p = 0);
1172  static void *newArray_artcLcLPtrlEsimbcLcLGTruthgR(Long_t size, void *p);
1173  static void delete_artcLcLPtrlEsimbcLcLGTruthgR(void *p);
1174  static void deleteArray_artcLcLPtrlEsimbcLcLGTruthgR(void *p);
1175  static void destruct_artcLcLPtrlEsimbcLcLGTruthgR(void *p);
1176 
1177  // Function generating the singleton type initializer
1178  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Ptr<simb::GTruth>*)
1179  {
1180  ::art::Ptr<simb::GTruth> *ptr = 0;
1181  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Ptr<simb::GTruth>));
1182  static ::ROOT::TGenericClassInfo
1183  instance("art::Ptr<simb::GTruth>", ::art::Ptr<simb::GTruth>::Class_Version(), "canvas/Persistency/Common/Ptr.h", 100,
1184  typeid(::art::Ptr<simb::GTruth>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1185  &artcLcLPtrlEsimbcLcLGTruthgR_Dictionary, isa_proxy, 4,
1186  sizeof(::art::Ptr<simb::GTruth>) );
1187  instance.SetNew(&new_artcLcLPtrlEsimbcLcLGTruthgR);
1188  instance.SetNewArray(&newArray_artcLcLPtrlEsimbcLcLGTruthgR);
1189  instance.SetDelete(&delete_artcLcLPtrlEsimbcLcLGTruthgR);
1190  instance.SetDeleteArray(&deleteArray_artcLcLPtrlEsimbcLcLGTruthgR);
1191  instance.SetDestructor(&destruct_artcLcLPtrlEsimbcLcLGTruthgR);
1192  return &instance;
1193  }
1194  TGenericClassInfo *GenerateInitInstance(const ::art::Ptr<simb::GTruth>*)
1195  {
1197  }
1198  // Static variable to force the class initialization
1199  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Ptr<simb::GTruth>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1200 
1201  // Dictionary for non-ClassDef classes
1203  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Ptr<simb::GTruth>*)0x0)->GetClass();
1205  return theClass;
1206  }
1207 
1209  }
1210 
1211 } // end of namespace ROOT
1212 
1213 namespace ROOT {
1214  static TClass *artcLcLPtrlEsimbcLcLMCFluxgR_Dictionary();
1215  static void artcLcLPtrlEsimbcLcLMCFluxgR_TClassManip(TClass*);
1216  static void *new_artcLcLPtrlEsimbcLcLMCFluxgR(void *p = 0);
1217  static void *newArray_artcLcLPtrlEsimbcLcLMCFluxgR(Long_t size, void *p);
1218  static void delete_artcLcLPtrlEsimbcLcLMCFluxgR(void *p);
1219  static void deleteArray_artcLcLPtrlEsimbcLcLMCFluxgR(void *p);
1220  static void destruct_artcLcLPtrlEsimbcLcLMCFluxgR(void *p);
1221 
1222  // Function generating the singleton type initializer
1223  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Ptr<simb::MCFlux>*)
1224  {
1225  ::art::Ptr<simb::MCFlux> *ptr = 0;
1226  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Ptr<simb::MCFlux>));
1227  static ::ROOT::TGenericClassInfo
1228  instance("art::Ptr<simb::MCFlux>", ::art::Ptr<simb::MCFlux>::Class_Version(), "canvas/Persistency/Common/Ptr.h", 100,
1229  typeid(::art::Ptr<simb::MCFlux>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1230  &artcLcLPtrlEsimbcLcLMCFluxgR_Dictionary, isa_proxy, 4,
1231  sizeof(::art::Ptr<simb::MCFlux>) );
1232  instance.SetNew(&new_artcLcLPtrlEsimbcLcLMCFluxgR);
1233  instance.SetNewArray(&newArray_artcLcLPtrlEsimbcLcLMCFluxgR);
1234  instance.SetDelete(&delete_artcLcLPtrlEsimbcLcLMCFluxgR);
1235  instance.SetDeleteArray(&deleteArray_artcLcLPtrlEsimbcLcLMCFluxgR);
1236  instance.SetDestructor(&destruct_artcLcLPtrlEsimbcLcLMCFluxgR);
1237  return &instance;
1238  }
1239  TGenericClassInfo *GenerateInitInstance(const ::art::Ptr<simb::MCFlux>*)
1240  {
1242  }
1243  // Static variable to force the class initialization
1244  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Ptr<simb::MCFlux>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1245 
1246  // Dictionary for non-ClassDef classes
1248  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Ptr<simb::MCFlux>*)0x0)->GetClass();
1250  return theClass;
1251  }
1252 
1254  }
1255 
1256 } // end of namespace ROOT
1257 
1258 namespace ROOT {
1266 
1267  // Function generating the singleton type initializer
1268  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Wrapper<art::Assns<bsim::NuChoice,simb::MCTruth,void> >*)
1269  {
1271  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Wrapper<art::Assns<bsim::NuChoice,simb::MCTruth,void> >));
1272  static ::ROOT::TGenericClassInfo
1273  instance("art::Wrapper<art::Assns<bsim::NuChoice,simb::MCTruth,void> >", ::art::Wrapper<art::Assns<bsim::NuChoice,simb::MCTruth,void> >::Class_Version(), "canvas/Persistency/Common/Wrapper.h", 80,
1274  typeid(::art::Wrapper<art::Assns<bsim::NuChoice,simb::MCTruth,void> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1275  &artcLcLWrapperlEartcLcLAssnslEbsimcLcLNuChoicecOsimbcLcLMCTruthcOvoidgRsPgR_Dictionary, isa_proxy, 4,
1277  instance.SetNew(&new_artcLcLWrapperlEartcLcLAssnslEbsimcLcLNuChoicecOsimbcLcLMCTruthcOvoidgRsPgR);
1278  instance.SetNewArray(&newArray_artcLcLWrapperlEartcLcLAssnslEbsimcLcLNuChoicecOsimbcLcLMCTruthcOvoidgRsPgR);
1279  instance.SetDelete(&delete_artcLcLWrapperlEartcLcLAssnslEbsimcLcLNuChoicecOsimbcLcLMCTruthcOvoidgRsPgR);
1280  instance.SetDeleteArray(&deleteArray_artcLcLWrapperlEartcLcLAssnslEbsimcLcLNuChoicecOsimbcLcLMCTruthcOvoidgRsPgR);
1281  instance.SetDestructor(&destruct_artcLcLWrapperlEartcLcLAssnslEbsimcLcLNuChoicecOsimbcLcLMCTruthcOvoidgRsPgR);
1282  return &instance;
1283  }
1284  TGenericClassInfo *GenerateInitInstance(const ::art::Wrapper<art::Assns<bsim::NuChoice,simb::MCTruth,void> >*)
1285  {
1287  }
1288  // Static variable to force the class initialization
1289  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Wrapper<art::Assns<bsim::NuChoice,simb::MCTruth,void> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1290 
1291  // Dictionary for non-ClassDef classes
1293  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Wrapper<art::Assns<bsim::NuChoice,simb::MCTruth,void> >*)0x0)->GetClass();
1295  return theClass;
1296  }
1297 
1299  }
1300 
1301 } // end of namespace ROOT
1302 
1303 namespace ROOT {
1311 
1312  // Function generating the singleton type initializer
1313  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Wrapper<art::Assns<simb::MCTruth,bsim::NuChoice,void> >*)
1314  {
1316  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Wrapper<art::Assns<simb::MCTruth,bsim::NuChoice,void> >));
1317  static ::ROOT::TGenericClassInfo
1318  instance("art::Wrapper<art::Assns<simb::MCTruth,bsim::NuChoice,void> >", ::art::Wrapper<art::Assns<simb::MCTruth,bsim::NuChoice,void> >::Class_Version(), "canvas/Persistency/Common/Wrapper.h", 80,
1319  typeid(::art::Wrapper<art::Assns<simb::MCTruth,bsim::NuChoice,void> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1320  &artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcObsimcLcLNuChoicecOvoidgRsPgR_Dictionary, isa_proxy, 4,
1322  instance.SetNew(&new_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcObsimcLcLNuChoicecOvoidgRsPgR);
1323  instance.SetNewArray(&newArray_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcObsimcLcLNuChoicecOvoidgRsPgR);
1324  instance.SetDelete(&delete_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcObsimcLcLNuChoicecOvoidgRsPgR);
1325  instance.SetDeleteArray(&deleteArray_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcObsimcLcLNuChoicecOvoidgRsPgR);
1326  instance.SetDestructor(&destruct_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcObsimcLcLNuChoicecOvoidgRsPgR);
1327  return &instance;
1328  }
1329  TGenericClassInfo *GenerateInitInstance(const ::art::Wrapper<art::Assns<simb::MCTruth,bsim::NuChoice,void> >*)
1330  {
1332  }
1333  // Static variable to force the class initialization
1334  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Wrapper<art::Assns<simb::MCTruth,bsim::NuChoice,void> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1335 
1336  // Dictionary for non-ClassDef classes
1338  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Wrapper<art::Assns<simb::MCTruth,bsim::NuChoice,void> >*)0x0)->GetClass();
1340  return theClass;
1341  }
1342 
1344  }
1345 
1346 } // end of namespace ROOT
1347 
1348 namespace ROOT {
1351  static void *new_artcLcLWrapperlEvectorlEbsimcLcLNuChoicegRsPgR(void *p = 0);
1356 
1357  // Function generating the singleton type initializer
1358  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Wrapper<vector<bsim::NuChoice> >*)
1359  {
1361  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Wrapper<vector<bsim::NuChoice> >));
1362  static ::ROOT::TGenericClassInfo
1363  instance("art::Wrapper<vector<bsim::NuChoice> >", ::art::Wrapper<vector<bsim::NuChoice> >::Class_Version(), "canvas/Persistency/Common/Wrapper.h", 80,
1364  typeid(::art::Wrapper<vector<bsim::NuChoice> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1365  &artcLcLWrapperlEvectorlEbsimcLcLNuChoicegRsPgR_Dictionary, isa_proxy, 4,
1366  sizeof(::art::Wrapper<vector<bsim::NuChoice> >) );
1367  instance.SetNew(&new_artcLcLWrapperlEvectorlEbsimcLcLNuChoicegRsPgR);
1368  instance.SetNewArray(&newArray_artcLcLWrapperlEvectorlEbsimcLcLNuChoicegRsPgR);
1369  instance.SetDelete(&delete_artcLcLWrapperlEvectorlEbsimcLcLNuChoicegRsPgR);
1370  instance.SetDeleteArray(&deleteArray_artcLcLWrapperlEvectorlEbsimcLcLNuChoicegRsPgR);
1371  instance.SetDestructor(&destruct_artcLcLWrapperlEvectorlEbsimcLcLNuChoicegRsPgR);
1372 
1373  ::ROOT::AddClassAlternate("art::Wrapper<vector<bsim::NuChoice> >","art::Wrapper<std::vector<bsim::NuChoice> >");
1374  return &instance;
1375  }
1376  TGenericClassInfo *GenerateInitInstance(const ::art::Wrapper<vector<bsim::NuChoice> >*)
1377  {
1378  return GenerateInitInstanceLocal((::art::Wrapper<vector<bsim::NuChoice> >*)0);
1379  }
1380  // Static variable to force the class initialization
1381  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Wrapper<vector<bsim::NuChoice> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1382 
1383  // Dictionary for non-ClassDef classes
1385  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Wrapper<vector<bsim::NuChoice> >*)0x0)->GetClass();
1387  return theClass;
1388  }
1389 
1391  }
1392 
1393 } // end of namespace ROOT
1394 
1395 namespace ROOT {
1403 
1404  // Function generating the singleton type initializer
1405  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Wrapper<art::Assns<bsim::Dk2Nu,simb::MCTruth,void> >*)
1406  {
1408  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Wrapper<art::Assns<bsim::Dk2Nu,simb::MCTruth,void> >));
1409  static ::ROOT::TGenericClassInfo
1410  instance("art::Wrapper<art::Assns<bsim::Dk2Nu,simb::MCTruth,void> >", ::art::Wrapper<art::Assns<bsim::Dk2Nu,simb::MCTruth,void> >::Class_Version(), "canvas/Persistency/Common/Wrapper.h", 80,
1411  typeid(::art::Wrapper<art::Assns<bsim::Dk2Nu,simb::MCTruth,void> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1412  &artcLcLWrapperlEartcLcLAssnslEbsimcLcLDk2NucOsimbcLcLMCTruthcOvoidgRsPgR_Dictionary, isa_proxy, 4,
1414  instance.SetNew(&new_artcLcLWrapperlEartcLcLAssnslEbsimcLcLDk2NucOsimbcLcLMCTruthcOvoidgRsPgR);
1415  instance.SetNewArray(&newArray_artcLcLWrapperlEartcLcLAssnslEbsimcLcLDk2NucOsimbcLcLMCTruthcOvoidgRsPgR);
1416  instance.SetDelete(&delete_artcLcLWrapperlEartcLcLAssnslEbsimcLcLDk2NucOsimbcLcLMCTruthcOvoidgRsPgR);
1417  instance.SetDeleteArray(&deleteArray_artcLcLWrapperlEartcLcLAssnslEbsimcLcLDk2NucOsimbcLcLMCTruthcOvoidgRsPgR);
1418  instance.SetDestructor(&destruct_artcLcLWrapperlEartcLcLAssnslEbsimcLcLDk2NucOsimbcLcLMCTruthcOvoidgRsPgR);
1419  return &instance;
1420  }
1421  TGenericClassInfo *GenerateInitInstance(const ::art::Wrapper<art::Assns<bsim::Dk2Nu,simb::MCTruth,void> >*)
1422  {
1424  }
1425  // Static variable to force the class initialization
1426  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Wrapper<art::Assns<bsim::Dk2Nu,simb::MCTruth,void> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1427 
1428  // Dictionary for non-ClassDef classes
1430  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Wrapper<art::Assns<bsim::Dk2Nu,simb::MCTruth,void> >*)0x0)->GetClass();
1432  return theClass;
1433  }
1434 
1436  }
1437 
1438 } // end of namespace ROOT
1439 
1440 namespace ROOT {
1448 
1449  // Function generating the singleton type initializer
1450  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Wrapper<art::Assns<simb::MCTruth,bsim::Dk2Nu,void> >*)
1451  {
1453  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Wrapper<art::Assns<simb::MCTruth,bsim::Dk2Nu,void> >));
1454  static ::ROOT::TGenericClassInfo
1455  instance("art::Wrapper<art::Assns<simb::MCTruth,bsim::Dk2Nu,void> >", ::art::Wrapper<art::Assns<simb::MCTruth,bsim::Dk2Nu,void> >::Class_Version(), "canvas/Persistency/Common/Wrapper.h", 80,
1456  typeid(::art::Wrapper<art::Assns<simb::MCTruth,bsim::Dk2Nu,void> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1457  &artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcObsimcLcLDk2NucOvoidgRsPgR_Dictionary, isa_proxy, 4,
1459  instance.SetNew(&new_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcObsimcLcLDk2NucOvoidgRsPgR);
1460  instance.SetNewArray(&newArray_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcObsimcLcLDk2NucOvoidgRsPgR);
1461  instance.SetDelete(&delete_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcObsimcLcLDk2NucOvoidgRsPgR);
1462  instance.SetDeleteArray(&deleteArray_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcObsimcLcLDk2NucOvoidgRsPgR);
1463  instance.SetDestructor(&destruct_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcObsimcLcLDk2NucOvoidgRsPgR);
1464  return &instance;
1465  }
1466  TGenericClassInfo *GenerateInitInstance(const ::art::Wrapper<art::Assns<simb::MCTruth,bsim::Dk2Nu,void> >*)
1467  {
1469  }
1470  // Static variable to force the class initialization
1471  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Wrapper<art::Assns<simb::MCTruth,bsim::Dk2Nu,void> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1472 
1473  // Dictionary for non-ClassDef classes
1475  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Wrapper<art::Assns<simb::MCTruth,bsim::Dk2Nu,void> >*)0x0)->GetClass();
1477  return theClass;
1478  }
1479 
1481  }
1482 
1483 } // end of namespace ROOT
1484 
1485 namespace ROOT {
1488  static void *new_artcLcLWrapperlEvectorlEbsimcLcLDk2NugRsPgR(void *p = 0);
1489  static void *newArray_artcLcLWrapperlEvectorlEbsimcLcLDk2NugRsPgR(Long_t size, void *p);
1493 
1494  // Function generating the singleton type initializer
1495  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Wrapper<vector<bsim::Dk2Nu> >*)
1496  {
1498  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Wrapper<vector<bsim::Dk2Nu> >));
1499  static ::ROOT::TGenericClassInfo
1500  instance("art::Wrapper<vector<bsim::Dk2Nu> >", ::art::Wrapper<vector<bsim::Dk2Nu> >::Class_Version(), "canvas/Persistency/Common/Wrapper.h", 80,
1501  typeid(::art::Wrapper<vector<bsim::Dk2Nu> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1502  &artcLcLWrapperlEvectorlEbsimcLcLDk2NugRsPgR_Dictionary, isa_proxy, 4,
1503  sizeof(::art::Wrapper<vector<bsim::Dk2Nu> >) );
1504  instance.SetNew(&new_artcLcLWrapperlEvectorlEbsimcLcLDk2NugRsPgR);
1505  instance.SetNewArray(&newArray_artcLcLWrapperlEvectorlEbsimcLcLDk2NugRsPgR);
1506  instance.SetDelete(&delete_artcLcLWrapperlEvectorlEbsimcLcLDk2NugRsPgR);
1507  instance.SetDeleteArray(&deleteArray_artcLcLWrapperlEvectorlEbsimcLcLDk2NugRsPgR);
1508  instance.SetDestructor(&destruct_artcLcLWrapperlEvectorlEbsimcLcLDk2NugRsPgR);
1509 
1510  ::ROOT::AddClassAlternate("art::Wrapper<vector<bsim::Dk2Nu> >","art::Wrapper<std::vector<bsim::Dk2Nu> >");
1511  return &instance;
1512  }
1513  TGenericClassInfo *GenerateInitInstance(const ::art::Wrapper<vector<bsim::Dk2Nu> >*)
1514  {
1515  return GenerateInitInstanceLocal((::art::Wrapper<vector<bsim::Dk2Nu> >*)0);
1516  }
1517  // Static variable to force the class initialization
1518  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Wrapper<vector<bsim::Dk2Nu> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1519 
1520  // Dictionary for non-ClassDef classes
1522  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Wrapper<vector<bsim::Dk2Nu> >*)0x0)->GetClass();
1524  return theClass;
1525  }
1526 
1528  }
1529 
1530 } // end of namespace ROOT
1531 
1532 namespace ROOT {
1540 
1541  // Function generating the singleton type initializer
1542  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCParticle,void> >*)
1543  {
1545  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Wrapper<art::Assns<simb::MCTruth,simb::MCParticle,void> >));
1546  static ::ROOT::TGenericClassInfo
1547  instance("art::Wrapper<art::Assns<simb::MCTruth,simb::MCParticle,void> >", ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCParticle,void> >::Class_Version(), "canvas/Persistency/Common/Wrapper.h", 80,
1548  typeid(::art::Wrapper<art::Assns<simb::MCTruth,simb::MCParticle,void> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1549  &artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCParticlecOvoidgRsPgR_Dictionary, isa_proxy, 4,
1551  instance.SetNew(&new_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCParticlecOvoidgRsPgR);
1552  instance.SetNewArray(&newArray_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCParticlecOvoidgRsPgR);
1553  instance.SetDelete(&delete_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCParticlecOvoidgRsPgR);
1554  instance.SetDeleteArray(&deleteArray_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCParticlecOvoidgRsPgR);
1555  instance.SetDestructor(&destruct_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCParticlecOvoidgRsPgR);
1556  return &instance;
1557  }
1558  TGenericClassInfo *GenerateInitInstance(const ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCParticle,void> >*)
1559  {
1561  }
1562  // Static variable to force the class initialization
1563  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCParticle,void> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1564 
1565  // Dictionary for non-ClassDef classes
1567  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCParticle,void> >*)0x0)->GetClass();
1569  return theClass;
1570  }
1571 
1573  }
1574 
1575 } // end of namespace ROOT
1576 
1577 namespace ROOT {
1585 
1586  // Function generating the singleton type initializer
1587  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Wrapper<art::Assns<simb::MCParticle,simb::MCTruth,void> >*)
1588  {
1590  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Wrapper<art::Assns<simb::MCParticle,simb::MCTruth,void> >));
1591  static ::ROOT::TGenericClassInfo
1592  instance("art::Wrapper<art::Assns<simb::MCParticle,simb::MCTruth,void> >", ::art::Wrapper<art::Assns<simb::MCParticle,simb::MCTruth,void> >::Class_Version(), "canvas/Persistency/Common/Wrapper.h", 80,
1593  typeid(::art::Wrapper<art::Assns<simb::MCParticle,simb::MCTruth,void> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1594  &artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCParticlecOsimbcLcLMCTruthcOvoidgRsPgR_Dictionary, isa_proxy, 4,
1596  instance.SetNew(&new_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCParticlecOsimbcLcLMCTruthcOvoidgRsPgR);
1597  instance.SetNewArray(&newArray_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCParticlecOsimbcLcLMCTruthcOvoidgRsPgR);
1598  instance.SetDelete(&delete_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCParticlecOsimbcLcLMCTruthcOvoidgRsPgR);
1599  instance.SetDeleteArray(&deleteArray_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCParticlecOsimbcLcLMCTruthcOvoidgRsPgR);
1600  instance.SetDestructor(&destruct_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCParticlecOsimbcLcLMCTruthcOvoidgRsPgR);
1601  return &instance;
1602  }
1603  TGenericClassInfo *GenerateInitInstance(const ::art::Wrapper<art::Assns<simb::MCParticle,simb::MCTruth,void> >*)
1604  {
1606  }
1607  // Static variable to force the class initialization
1608  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Wrapper<art::Assns<simb::MCParticle,simb::MCTruth,void> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1609 
1610  // Dictionary for non-ClassDef classes
1612  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Wrapper<art::Assns<simb::MCParticle,simb::MCTruth,void> >*)0x0)->GetClass();
1614  return theClass;
1615  }
1616 
1618  }
1619 
1620 } // end of namespace ROOT
1621 
1622 namespace ROOT {
1630 
1631  // Function generating the singleton type initializer
1632  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Wrapper<art::Assns<simb::MCTruth,simb::GTruth,void> >*)
1633  {
1635  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Wrapper<art::Assns<simb::MCTruth,simb::GTruth,void> >));
1636  static ::ROOT::TGenericClassInfo
1637  instance("art::Wrapper<art::Assns<simb::MCTruth,simb::GTruth,void> >", ::art::Wrapper<art::Assns<simb::MCTruth,simb::GTruth,void> >::Class_Version(), "canvas/Persistency/Common/Wrapper.h", 80,
1638  typeid(::art::Wrapper<art::Assns<simb::MCTruth,simb::GTruth,void> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1639  &artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLGTruthcOvoidgRsPgR_Dictionary, isa_proxy, 4,
1641  instance.SetNew(&new_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLGTruthcOvoidgRsPgR);
1642  instance.SetNewArray(&newArray_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLGTruthcOvoidgRsPgR);
1643  instance.SetDelete(&delete_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLGTruthcOvoidgRsPgR);
1644  instance.SetDeleteArray(&deleteArray_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLGTruthcOvoidgRsPgR);
1645  instance.SetDestructor(&destruct_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLGTruthcOvoidgRsPgR);
1646  return &instance;
1647  }
1648  TGenericClassInfo *GenerateInitInstance(const ::art::Wrapper<art::Assns<simb::MCTruth,simb::GTruth,void> >*)
1649  {
1651  }
1652  // Static variable to force the class initialization
1653  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Wrapper<art::Assns<simb::MCTruth,simb::GTruth,void> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1654 
1655  // Dictionary for non-ClassDef classes
1657  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Wrapper<art::Assns<simb::MCTruth,simb::GTruth,void> >*)0x0)->GetClass();
1659  return theClass;
1660  }
1661 
1663  }
1664 
1665 } // end of namespace ROOT
1666 
1667 namespace ROOT {
1675 
1676  // Function generating the singleton type initializer
1677  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Wrapper<art::Assns<simb::GTruth,simb::MCTruth,void> >*)
1678  {
1680  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Wrapper<art::Assns<simb::GTruth,simb::MCTruth,void> >));
1681  static ::ROOT::TGenericClassInfo
1682  instance("art::Wrapper<art::Assns<simb::GTruth,simb::MCTruth,void> >", ::art::Wrapper<art::Assns<simb::GTruth,simb::MCTruth,void> >::Class_Version(), "canvas/Persistency/Common/Wrapper.h", 80,
1683  typeid(::art::Wrapper<art::Assns<simb::GTruth,simb::MCTruth,void> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1684  &artcLcLWrapperlEartcLcLAssnslEsimbcLcLGTruthcOsimbcLcLMCTruthcOvoidgRsPgR_Dictionary, isa_proxy, 4,
1686  instance.SetNew(&new_artcLcLWrapperlEartcLcLAssnslEsimbcLcLGTruthcOsimbcLcLMCTruthcOvoidgRsPgR);
1687  instance.SetNewArray(&newArray_artcLcLWrapperlEartcLcLAssnslEsimbcLcLGTruthcOsimbcLcLMCTruthcOvoidgRsPgR);
1688  instance.SetDelete(&delete_artcLcLWrapperlEartcLcLAssnslEsimbcLcLGTruthcOsimbcLcLMCTruthcOvoidgRsPgR);
1689  instance.SetDeleteArray(&deleteArray_artcLcLWrapperlEartcLcLAssnslEsimbcLcLGTruthcOsimbcLcLMCTruthcOvoidgRsPgR);
1690  instance.SetDestructor(&destruct_artcLcLWrapperlEartcLcLAssnslEsimbcLcLGTruthcOsimbcLcLMCTruthcOvoidgRsPgR);
1691  return &instance;
1692  }
1693  TGenericClassInfo *GenerateInitInstance(const ::art::Wrapper<art::Assns<simb::GTruth,simb::MCTruth,void> >*)
1694  {
1696  }
1697  // Static variable to force the class initialization
1698  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Wrapper<art::Assns<simb::GTruth,simb::MCTruth,void> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1699 
1700  // Dictionary for non-ClassDef classes
1702  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Wrapper<art::Assns<simb::GTruth,simb::MCTruth,void> >*)0x0)->GetClass();
1704  return theClass;
1705  }
1706 
1708  }
1709 
1710 } // end of namespace ROOT
1711 
1712 namespace ROOT {
1720 
1721  // Function generating the singleton type initializer
1722  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCFlux,void> >*)
1723  {
1725  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Wrapper<art::Assns<simb::MCTruth,simb::MCFlux,void> >));
1726  static ::ROOT::TGenericClassInfo
1727  instance("art::Wrapper<art::Assns<simb::MCTruth,simb::MCFlux,void> >", ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCFlux,void> >::Class_Version(), "canvas/Persistency/Common/Wrapper.h", 80,
1728  typeid(::art::Wrapper<art::Assns<simb::MCTruth,simb::MCFlux,void> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1729  &artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCFluxcOvoidgRsPgR_Dictionary, isa_proxy, 4,
1731  instance.SetNew(&new_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCFluxcOvoidgRsPgR);
1732  instance.SetNewArray(&newArray_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCFluxcOvoidgRsPgR);
1733  instance.SetDelete(&delete_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCFluxcOvoidgRsPgR);
1734  instance.SetDeleteArray(&deleteArray_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCFluxcOvoidgRsPgR);
1735  instance.SetDestructor(&destruct_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCTruthcOsimbcLcLMCFluxcOvoidgRsPgR);
1736  return &instance;
1737  }
1738  TGenericClassInfo *GenerateInitInstance(const ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCFlux,void> >*)
1739  {
1741  }
1742  // Static variable to force the class initialization
1743  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCFlux,void> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1744 
1745  // Dictionary for non-ClassDef classes
1747  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCFlux,void> >*)0x0)->GetClass();
1749  return theClass;
1750  }
1751 
1753  }
1754 
1755 } // end of namespace ROOT
1756 
1757 namespace ROOT {
1765 
1766  // Function generating the singleton type initializer
1767  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Wrapper<art::Assns<simb::MCFlux,simb::MCTruth,void> >*)
1768  {
1770  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Wrapper<art::Assns<simb::MCFlux,simb::MCTruth,void> >));
1771  static ::ROOT::TGenericClassInfo
1772  instance("art::Wrapper<art::Assns<simb::MCFlux,simb::MCTruth,void> >", ::art::Wrapper<art::Assns<simb::MCFlux,simb::MCTruth,void> >::Class_Version(), "canvas/Persistency/Common/Wrapper.h", 80,
1773  typeid(::art::Wrapper<art::Assns<simb::MCFlux,simb::MCTruth,void> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1774  &artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCFluxcOsimbcLcLMCTruthcOvoidgRsPgR_Dictionary, isa_proxy, 4,
1776  instance.SetNew(&new_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCFluxcOsimbcLcLMCTruthcOvoidgRsPgR);
1777  instance.SetNewArray(&newArray_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCFluxcOsimbcLcLMCTruthcOvoidgRsPgR);
1778  instance.SetDelete(&delete_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCFluxcOsimbcLcLMCTruthcOvoidgRsPgR);
1779  instance.SetDeleteArray(&deleteArray_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCFluxcOsimbcLcLMCTruthcOvoidgRsPgR);
1780  instance.SetDestructor(&destruct_artcLcLWrapperlEartcLcLAssnslEsimbcLcLMCFluxcOsimbcLcLMCTruthcOvoidgRsPgR);
1781  return &instance;
1782  }
1783  TGenericClassInfo *GenerateInitInstance(const ::art::Wrapper<art::Assns<simb::MCFlux,simb::MCTruth,void> >*)
1784  {
1786  }
1787  // Static variable to force the class initialization
1788  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Wrapper<art::Assns<simb::MCFlux,simb::MCTruth,void> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1789 
1790  // Dictionary for non-ClassDef classes
1792  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Wrapper<art::Assns<simb::MCFlux,simb::MCTruth,void> >*)0x0)->GetClass();
1794  return theClass;
1795  }
1796 
1798  }
1799 
1800 } // end of namespace ROOT
1801 
1802 namespace ROOT {
1805  static void *new_artcLcLWrapperlEvectorlEsimbcLcLGTruthgRsPgR(void *p = 0);
1806  static void *newArray_artcLcLWrapperlEvectorlEsimbcLcLGTruthgRsPgR(Long_t size, void *p);
1810 
1811  // Function generating the singleton type initializer
1812  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Wrapper<vector<simb::GTruth> >*)
1813  {
1815  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Wrapper<vector<simb::GTruth> >));
1816  static ::ROOT::TGenericClassInfo
1817  instance("art::Wrapper<vector<simb::GTruth> >", ::art::Wrapper<vector<simb::GTruth> >::Class_Version(), "canvas/Persistency/Common/Wrapper.h", 80,
1818  typeid(::art::Wrapper<vector<simb::GTruth> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1819  &artcLcLWrapperlEvectorlEsimbcLcLGTruthgRsPgR_Dictionary, isa_proxy, 4,
1820  sizeof(::art::Wrapper<vector<simb::GTruth> >) );
1821  instance.SetNew(&new_artcLcLWrapperlEvectorlEsimbcLcLGTruthgRsPgR);
1822  instance.SetNewArray(&newArray_artcLcLWrapperlEvectorlEsimbcLcLGTruthgRsPgR);
1823  instance.SetDelete(&delete_artcLcLWrapperlEvectorlEsimbcLcLGTruthgRsPgR);
1824  instance.SetDeleteArray(&deleteArray_artcLcLWrapperlEvectorlEsimbcLcLGTruthgRsPgR);
1825  instance.SetDestructor(&destruct_artcLcLWrapperlEvectorlEsimbcLcLGTruthgRsPgR);
1826 
1827  ::ROOT::AddClassAlternate("art::Wrapper<vector<simb::GTruth> >","art::Wrapper<std::vector<simb::GTruth> >");
1828  return &instance;
1829  }
1830  TGenericClassInfo *GenerateInitInstance(const ::art::Wrapper<vector<simb::GTruth> >*)
1831  {
1832  return GenerateInitInstanceLocal((::art::Wrapper<vector<simb::GTruth> >*)0);
1833  }
1834  // Static variable to force the class initialization
1835  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Wrapper<vector<simb::GTruth> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1836 
1837  // Dictionary for non-ClassDef classes
1839  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Wrapper<vector<simb::GTruth> >*)0x0)->GetClass();
1841  return theClass;
1842  }
1843 
1845  }
1846 
1847 } // end of namespace ROOT
1848 
1849 namespace ROOT {
1852  static void *new_artcLcLWrapperlEvectorlEsimbcLcLMCFluxgRsPgR(void *p = 0);
1853  static void *newArray_artcLcLWrapperlEvectorlEsimbcLcLMCFluxgRsPgR(Long_t size, void *p);
1857 
1858  // Function generating the singleton type initializer
1859  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Wrapper<vector<simb::MCFlux> >*)
1860  {
1862  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Wrapper<vector<simb::MCFlux> >));
1863  static ::ROOT::TGenericClassInfo
1864  instance("art::Wrapper<vector<simb::MCFlux> >", ::art::Wrapper<vector<simb::MCFlux> >::Class_Version(), "canvas/Persistency/Common/Wrapper.h", 80,
1865  typeid(::art::Wrapper<vector<simb::MCFlux> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1866  &artcLcLWrapperlEvectorlEsimbcLcLMCFluxgRsPgR_Dictionary, isa_proxy, 4,
1867  sizeof(::art::Wrapper<vector<simb::MCFlux> >) );
1868  instance.SetNew(&new_artcLcLWrapperlEvectorlEsimbcLcLMCFluxgRsPgR);
1869  instance.SetNewArray(&newArray_artcLcLWrapperlEvectorlEsimbcLcLMCFluxgRsPgR);
1870  instance.SetDelete(&delete_artcLcLWrapperlEvectorlEsimbcLcLMCFluxgRsPgR);
1871  instance.SetDeleteArray(&deleteArray_artcLcLWrapperlEvectorlEsimbcLcLMCFluxgRsPgR);
1872  instance.SetDestructor(&destruct_artcLcLWrapperlEvectorlEsimbcLcLMCFluxgRsPgR);
1873 
1874  ::ROOT::AddClassAlternate("art::Wrapper<vector<simb::MCFlux> >","art::Wrapper<std::vector<simb::MCFlux> >");
1875  return &instance;
1876  }
1877  TGenericClassInfo *GenerateInitInstance(const ::art::Wrapper<vector<simb::MCFlux> >*)
1878  {
1879  return GenerateInitInstanceLocal((::art::Wrapper<vector<simb::MCFlux> >*)0);
1880  }
1881  // Static variable to force the class initialization
1882  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Wrapper<vector<simb::MCFlux> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1883 
1884  // Dictionary for non-ClassDef classes
1886  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Wrapper<vector<simb::MCFlux> >*)0x0)->GetClass();
1888  return theClass;
1889  }
1890 
1892  }
1893 
1894 } // end of namespace ROOT
1895 
1896 namespace ROOT {
1899  static void *new_artcLcLWrapperlEvectorlEsimbcLcLMCTruthgRsPgR(void *p = 0);
1904 
1905  // Function generating the singleton type initializer
1906  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Wrapper<vector<simb::MCTruth> >*)
1907  {
1909  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Wrapper<vector<simb::MCTruth> >));
1910  static ::ROOT::TGenericClassInfo
1911  instance("art::Wrapper<vector<simb::MCTruth> >", ::art::Wrapper<vector<simb::MCTruth> >::Class_Version(), "canvas/Persistency/Common/Wrapper.h", 80,
1912  typeid(::art::Wrapper<vector<simb::MCTruth> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1913  &artcLcLWrapperlEvectorlEsimbcLcLMCTruthgRsPgR_Dictionary, isa_proxy, 4,
1914  sizeof(::art::Wrapper<vector<simb::MCTruth> >) );
1915  instance.SetNew(&new_artcLcLWrapperlEvectorlEsimbcLcLMCTruthgRsPgR);
1916  instance.SetNewArray(&newArray_artcLcLWrapperlEvectorlEsimbcLcLMCTruthgRsPgR);
1917  instance.SetDelete(&delete_artcLcLWrapperlEvectorlEsimbcLcLMCTruthgRsPgR);
1918  instance.SetDeleteArray(&deleteArray_artcLcLWrapperlEvectorlEsimbcLcLMCTruthgRsPgR);
1919  instance.SetDestructor(&destruct_artcLcLWrapperlEvectorlEsimbcLcLMCTruthgRsPgR);
1920 
1921  ::ROOT::AddClassAlternate("art::Wrapper<vector<simb::MCTruth> >","art::Wrapper<std::vector<simb::MCTruth> >");
1922  return &instance;
1923  }
1924  TGenericClassInfo *GenerateInitInstance(const ::art::Wrapper<vector<simb::MCTruth> >*)
1925  {
1926  return GenerateInitInstanceLocal((::art::Wrapper<vector<simb::MCTruth> >*)0);
1927  }
1928  // Static variable to force the class initialization
1929  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Wrapper<vector<simb::MCTruth> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1930 
1931  // Dictionary for non-ClassDef classes
1933  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Wrapper<vector<simb::MCTruth> >*)0x0)->GetClass();
1935  return theClass;
1936  }
1937 
1939  }
1940 
1941 } // end of namespace ROOT
1942 
1943 namespace ROOT {
1951 
1952  // Function generating the singleton type initializer
1953  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Wrapper<vector<simb::MCNeutrino> >*)
1954  {
1956  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Wrapper<vector<simb::MCNeutrino> >));
1957  static ::ROOT::TGenericClassInfo
1958  instance("art::Wrapper<vector<simb::MCNeutrino> >", ::art::Wrapper<vector<simb::MCNeutrino> >::Class_Version(), "canvas/Persistency/Common/Wrapper.h", 80,
1959  typeid(::art::Wrapper<vector<simb::MCNeutrino> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
1960  &artcLcLWrapperlEvectorlEsimbcLcLMCNeutrinogRsPgR_Dictionary, isa_proxy, 4,
1961  sizeof(::art::Wrapper<vector<simb::MCNeutrino> >) );
1962  instance.SetNew(&new_artcLcLWrapperlEvectorlEsimbcLcLMCNeutrinogRsPgR);
1963  instance.SetNewArray(&newArray_artcLcLWrapperlEvectorlEsimbcLcLMCNeutrinogRsPgR);
1964  instance.SetDelete(&delete_artcLcLWrapperlEvectorlEsimbcLcLMCNeutrinogRsPgR);
1965  instance.SetDeleteArray(&deleteArray_artcLcLWrapperlEvectorlEsimbcLcLMCNeutrinogRsPgR);
1966  instance.SetDestructor(&destruct_artcLcLWrapperlEvectorlEsimbcLcLMCNeutrinogRsPgR);
1967 
1968  ::ROOT::AddClassAlternate("art::Wrapper<vector<simb::MCNeutrino> >","art::Wrapper<std::vector<simb::MCNeutrino> >");
1969  return &instance;
1970  }
1971  TGenericClassInfo *GenerateInitInstance(const ::art::Wrapper<vector<simb::MCNeutrino> >*)
1972  {
1973  return GenerateInitInstanceLocal((::art::Wrapper<vector<simb::MCNeutrino> >*)0);
1974  }
1975  // Static variable to force the class initialization
1976  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Wrapper<vector<simb::MCNeutrino> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
1977 
1978  // Dictionary for non-ClassDef classes
1980  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Wrapper<vector<simb::MCNeutrino> >*)0x0)->GetClass();
1982  return theClass;
1983  }
1984 
1986  }
1987 
1988 } // end of namespace ROOT
1989 
1990 namespace ROOT {
1998 
1999  // Function generating the singleton type initializer
2000  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Wrapper<vector<simb::MCTrajectory> >*)
2001  {
2003  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Wrapper<vector<simb::MCTrajectory> >));
2004  static ::ROOT::TGenericClassInfo
2005  instance("art::Wrapper<vector<simb::MCTrajectory> >", ::art::Wrapper<vector<simb::MCTrajectory> >::Class_Version(), "canvas/Persistency/Common/Wrapper.h", 80,
2006  typeid(::art::Wrapper<vector<simb::MCTrajectory> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2007  &artcLcLWrapperlEvectorlEsimbcLcLMCTrajectorygRsPgR_Dictionary, isa_proxy, 4,
2008  sizeof(::art::Wrapper<vector<simb::MCTrajectory> >) );
2009  instance.SetNew(&new_artcLcLWrapperlEvectorlEsimbcLcLMCTrajectorygRsPgR);
2010  instance.SetNewArray(&newArray_artcLcLWrapperlEvectorlEsimbcLcLMCTrajectorygRsPgR);
2011  instance.SetDelete(&delete_artcLcLWrapperlEvectorlEsimbcLcLMCTrajectorygRsPgR);
2012  instance.SetDeleteArray(&deleteArray_artcLcLWrapperlEvectorlEsimbcLcLMCTrajectorygRsPgR);
2013  instance.SetDestructor(&destruct_artcLcLWrapperlEvectorlEsimbcLcLMCTrajectorygRsPgR);
2014 
2015  ::ROOT::AddClassAlternate("art::Wrapper<vector<simb::MCTrajectory> >","art::Wrapper<std::vector<simb::MCTrajectory> >");
2016  return &instance;
2017  }
2018  TGenericClassInfo *GenerateInitInstance(const ::art::Wrapper<vector<simb::MCTrajectory> >*)
2019  {
2020  return GenerateInitInstanceLocal((::art::Wrapper<vector<simb::MCTrajectory> >*)0);
2021  }
2022  // Static variable to force the class initialization
2023  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Wrapper<vector<simb::MCTrajectory> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2024 
2025  // Dictionary for non-ClassDef classes
2027  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Wrapper<vector<simb::MCTrajectory> >*)0x0)->GetClass();
2029  return theClass;
2030  }
2031 
2033  }
2034 
2035 } // end of namespace ROOT
2036 
2037 namespace ROOT {
2045 
2046  // Function generating the singleton type initializer
2047  static TGenericClassInfo *GenerateInitInstanceLocal(const ::art::Wrapper<vector<simb::MCParticle> >*)
2048  {
2050  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::art::Wrapper<vector<simb::MCParticle> >));
2051  static ::ROOT::TGenericClassInfo
2052  instance("art::Wrapper<vector<simb::MCParticle> >", ::art::Wrapper<vector<simb::MCParticle> >::Class_Version(), "canvas/Persistency/Common/Wrapper.h", 80,
2053  typeid(::art::Wrapper<vector<simb::MCParticle> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2054  &artcLcLWrapperlEvectorlEsimbcLcLMCParticlegRsPgR_Dictionary, isa_proxy, 4,
2055  sizeof(::art::Wrapper<vector<simb::MCParticle> >) );
2056  instance.SetNew(&new_artcLcLWrapperlEvectorlEsimbcLcLMCParticlegRsPgR);
2057  instance.SetNewArray(&newArray_artcLcLWrapperlEvectorlEsimbcLcLMCParticlegRsPgR);
2058  instance.SetDelete(&delete_artcLcLWrapperlEvectorlEsimbcLcLMCParticlegRsPgR);
2059  instance.SetDeleteArray(&deleteArray_artcLcLWrapperlEvectorlEsimbcLcLMCParticlegRsPgR);
2060  instance.SetDestructor(&destruct_artcLcLWrapperlEvectorlEsimbcLcLMCParticlegRsPgR);
2061 
2062  ::ROOT::AddClassAlternate("art::Wrapper<vector<simb::MCParticle> >","art::Wrapper<std::vector<simb::MCParticle> >");
2063  return &instance;
2064  }
2065  TGenericClassInfo *GenerateInitInstance(const ::art::Wrapper<vector<simb::MCParticle> >*)
2066  {
2067  return GenerateInitInstanceLocal((::art::Wrapper<vector<simb::MCParticle> >*)0);
2068  }
2069  // Static variable to force the class initialization
2070  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::art::Wrapper<vector<simb::MCParticle> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2071 
2072  // Dictionary for non-ClassDef classes
2074  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::art::Wrapper<vector<simb::MCParticle> >*)0x0)->GetClass();
2076  return theClass;
2077  }
2078 
2080  }
2081 
2082 } // end of namespace ROOT
2083 
2084 namespace ROOT {
2085  static TClass *simbcLcLMCGeneratorInfo_Dictionary();
2086  static void simbcLcLMCGeneratorInfo_TClassManip(TClass*);
2087  static void *new_simbcLcLMCGeneratorInfo(void *p = 0);
2088  static void *newArray_simbcLcLMCGeneratorInfo(Long_t size, void *p);
2089  static void delete_simbcLcLMCGeneratorInfo(void *p);
2090  static void deleteArray_simbcLcLMCGeneratorInfo(void *p);
2091  static void destruct_simbcLcLMCGeneratorInfo(void *p);
2092 
2093  // Function generating the singleton type initializer
2094  static TGenericClassInfo *GenerateInitInstanceLocal(const ::simb::MCGeneratorInfo*)
2095  {
2096  ::simb::MCGeneratorInfo *ptr = 0;
2097  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::simb::MCGeneratorInfo));
2098  static ::ROOT::TGenericClassInfo
2099  instance("simb::MCGeneratorInfo", 10, "nusimdata/SimulationBase/MCGeneratorInfo.h", 32,
2100  typeid(::simb::MCGeneratorInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2101  &simbcLcLMCGeneratorInfo_Dictionary, isa_proxy, 12,
2102  sizeof(::simb::MCGeneratorInfo) );
2103  instance.SetNew(&new_simbcLcLMCGeneratorInfo);
2104  instance.SetNewArray(&newArray_simbcLcLMCGeneratorInfo);
2105  instance.SetDelete(&delete_simbcLcLMCGeneratorInfo);
2106  instance.SetDeleteArray(&deleteArray_simbcLcLMCGeneratorInfo);
2107  instance.SetDestructor(&destruct_simbcLcLMCGeneratorInfo);
2108  return &instance;
2109  }
2110  TGenericClassInfo *GenerateInitInstance(const ::simb::MCGeneratorInfo*)
2111  {
2113  }
2114  // Static variable to force the class initialization
2115  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::simb::MCGeneratorInfo*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2116 
2117  // Dictionary for non-ClassDef classes
2119  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::simb::MCGeneratorInfo*)0x0)->GetClass();
2121  return theClass;
2122  }
2123 
2125  }
2126 
2127 } // end of namespace ROOT
2128 
2129 namespace ROOT {
2130  static TClass *simbcLcLMCTrajectory_Dictionary();
2131  static void simbcLcLMCTrajectory_TClassManip(TClass*);
2132  static void *new_simbcLcLMCTrajectory(void *p = 0);
2133  static void *newArray_simbcLcLMCTrajectory(Long_t size, void *p);
2134  static void delete_simbcLcLMCTrajectory(void *p);
2135  static void deleteArray_simbcLcLMCTrajectory(void *p);
2136  static void destruct_simbcLcLMCTrajectory(void *p);
2137 
2138  // Function generating the singleton type initializer
2139  static TGenericClassInfo *GenerateInitInstanceLocal(const ::simb::MCTrajectory*)
2140  {
2141  ::simb::MCTrajectory *ptr = 0;
2142  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::simb::MCTrajectory));
2143  static ::ROOT::TGenericClassInfo
2144  instance("simb::MCTrajectory", 12, "nusimdata/SimulationBase/MCTrajectory.h", 58,
2145  typeid(::simb::MCTrajectory), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2146  &simbcLcLMCTrajectory_Dictionary, isa_proxy, 12,
2147  sizeof(::simb::MCTrajectory) );
2148  instance.SetNew(&new_simbcLcLMCTrajectory);
2149  instance.SetNewArray(&newArray_simbcLcLMCTrajectory);
2150  instance.SetDelete(&delete_simbcLcLMCTrajectory);
2151  instance.SetDeleteArray(&deleteArray_simbcLcLMCTrajectory);
2152  instance.SetDestructor(&destruct_simbcLcLMCTrajectory);
2153  return &instance;
2154  }
2155  TGenericClassInfo *GenerateInitInstance(const ::simb::MCTrajectory*)
2156  {
2158  }
2159  // Static variable to force the class initialization
2160  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::simb::MCTrajectory*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2161 
2162  // Dictionary for non-ClassDef classes
2164  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::simb::MCTrajectory*)0x0)->GetClass();
2166  return theClass;
2167  }
2168 
2169  static void simbcLcLMCTrajectory_TClassManip(TClass* ){
2170  }
2171 
2172 } // end of namespace ROOT
2173 
2174 namespace ROOT {
2175  static TClass *simbcLcLMCParticle_Dictionary();
2176  static void simbcLcLMCParticle_TClassManip(TClass*);
2177  static void *new_simbcLcLMCParticle(void *p = 0);
2178  static void *newArray_simbcLcLMCParticle(Long_t size, void *p);
2179  static void delete_simbcLcLMCParticle(void *p);
2180  static void deleteArray_simbcLcLMCParticle(void *p);
2181  static void destruct_simbcLcLMCParticle(void *p);
2182 
2183  // Function generating the singleton type initializer
2184  static TGenericClassInfo *GenerateInitInstanceLocal(const ::simb::MCParticle*)
2185  {
2186  ::simb::MCParticle *ptr = 0;
2187  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::simb::MCParticle));
2188  static ::ROOT::TGenericClassInfo
2189  instance("simb::MCParticle", 18, "nusimdata/SimulationBase/MCParticle.h", 24,
2190  typeid(::simb::MCParticle), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2191  &simbcLcLMCParticle_Dictionary, isa_proxy, 12,
2192  sizeof(::simb::MCParticle) );
2193  instance.SetNew(&new_simbcLcLMCParticle);
2194  instance.SetNewArray(&newArray_simbcLcLMCParticle);
2195  instance.SetDelete(&delete_simbcLcLMCParticle);
2196  instance.SetDeleteArray(&deleteArray_simbcLcLMCParticle);
2197  instance.SetDestructor(&destruct_simbcLcLMCParticle);
2198  return &instance;
2199  }
2200  TGenericClassInfo *GenerateInitInstance(const ::simb::MCParticle*)
2201  {
2203  }
2204  // Static variable to force the class initialization
2205  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::simb::MCParticle*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2206 
2207  // Dictionary for non-ClassDef classes
2209  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::simb::MCParticle*)0x0)->GetClass();
2211  return theClass;
2212  }
2213 
2214  static void simbcLcLMCParticle_TClassManip(TClass* ){
2215  }
2216 
2217 } // end of namespace ROOT
2218 
2219 namespace ROOT {
2220  static TClass *simbcLcLMCNeutrino_Dictionary();
2221  static void simbcLcLMCNeutrino_TClassManip(TClass*);
2222  static void *new_simbcLcLMCNeutrino(void *p = 0);
2223  static void *newArray_simbcLcLMCNeutrino(Long_t size, void *p);
2224  static void delete_simbcLcLMCNeutrino(void *p);
2225  static void deleteArray_simbcLcLMCNeutrino(void *p);
2226  static void destruct_simbcLcLMCNeutrino(void *p);
2227 
2228  // Function generating the singleton type initializer
2229  static TGenericClassInfo *GenerateInitInstanceLocal(const ::simb::MCNeutrino*)
2230  {
2231  ::simb::MCNeutrino *ptr = 0;
2232  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::simb::MCNeutrino));
2233  static ::ROOT::TGenericClassInfo
2234  instance("simb::MCNeutrino", 10, "nusimdata/SimulationBase/MCNeutrino.h", 18,
2235  typeid(::simb::MCNeutrino), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2236  &simbcLcLMCNeutrino_Dictionary, isa_proxy, 12,
2237  sizeof(::simb::MCNeutrino) );
2238  instance.SetNew(&new_simbcLcLMCNeutrino);
2239  instance.SetNewArray(&newArray_simbcLcLMCNeutrino);
2240  instance.SetDelete(&delete_simbcLcLMCNeutrino);
2241  instance.SetDeleteArray(&deleteArray_simbcLcLMCNeutrino);
2242  instance.SetDestructor(&destruct_simbcLcLMCNeutrino);
2243  return &instance;
2244  }
2245  TGenericClassInfo *GenerateInitInstance(const ::simb::MCNeutrino*)
2246  {
2248  }
2249  // Static variable to force the class initialization
2250  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::simb::MCNeutrino*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2251 
2252  // Dictionary for non-ClassDef classes
2254  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::simb::MCNeutrino*)0x0)->GetClass();
2256  return theClass;
2257  }
2258 
2259  static void simbcLcLMCNeutrino_TClassManip(TClass* ){
2260  }
2261 
2262 } // end of namespace ROOT
2263 
2264 namespace ROOT {
2265  static TClass *simbcLcLMCTruth_Dictionary();
2266  static void simbcLcLMCTruth_TClassManip(TClass*);
2267  static void *new_simbcLcLMCTruth(void *p = 0);
2268  static void *newArray_simbcLcLMCTruth(Long_t size, void *p);
2269  static void delete_simbcLcLMCTruth(void *p);
2270  static void deleteArray_simbcLcLMCTruth(void *p);
2271  static void destruct_simbcLcLMCTruth(void *p);
2272 
2273  // Function generating the singleton type initializer
2274  static TGenericClassInfo *GenerateInitInstanceLocal(const ::simb::MCTruth*)
2275  {
2276  ::simb::MCTruth *ptr = 0;
2277  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::simb::MCTruth));
2278  static ::ROOT::TGenericClassInfo
2279  instance("simb::MCTruth", 12, "nusimdata/SimulationBase/MCTruth.h", 32,
2280  typeid(::simb::MCTruth), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2281  &simbcLcLMCTruth_Dictionary, isa_proxy, 12,
2282  sizeof(::simb::MCTruth) );
2283  instance.SetNew(&new_simbcLcLMCTruth);
2284  instance.SetNewArray(&newArray_simbcLcLMCTruth);
2285  instance.SetDelete(&delete_simbcLcLMCTruth);
2286  instance.SetDeleteArray(&deleteArray_simbcLcLMCTruth);
2287  instance.SetDestructor(&destruct_simbcLcLMCTruth);
2288  return &instance;
2289  }
2290  TGenericClassInfo *GenerateInitInstance(const ::simb::MCTruth*)
2291  {
2293  }
2294  // Static variable to force the class initialization
2295  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::simb::MCTruth*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2296 
2297  // Dictionary for non-ClassDef classes
2298  static TClass *simbcLcLMCTruth_Dictionary() {
2299  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::simb::MCTruth*)0x0)->GetClass();
2300  simbcLcLMCTruth_TClassManip(theClass);
2301  return theClass;
2302  }
2303 
2304  static void simbcLcLMCTruth_TClassManip(TClass* ){
2305  }
2306 
2307 } // end of namespace ROOT
2308 
2309 namespace ROOT {
2310  static TClass *simbcLcLMCFlux_Dictionary();
2311  static void simbcLcLMCFlux_TClassManip(TClass*);
2312  static void *new_simbcLcLMCFlux(void *p = 0);
2313  static void *newArray_simbcLcLMCFlux(Long_t size, void *p);
2314  static void delete_simbcLcLMCFlux(void *p);
2315  static void deleteArray_simbcLcLMCFlux(void *p);
2316  static void destruct_simbcLcLMCFlux(void *p);
2317 
2318  // Function generating the singleton type initializer
2319  static TGenericClassInfo *GenerateInitInstanceLocal(const ::simb::MCFlux*)
2320  {
2321  ::simb::MCFlux *ptr = 0;
2322  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::simb::MCFlux));
2323  static ::ROOT::TGenericClassInfo
2324  instance("simb::MCFlux", 11, "nusimdata/SimulationBase/MCFlux.h", 26,
2325  typeid(::simb::MCFlux), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2326  &simbcLcLMCFlux_Dictionary, isa_proxy, 12,
2327  sizeof(::simb::MCFlux) );
2328  instance.SetNew(&new_simbcLcLMCFlux);
2329  instance.SetNewArray(&newArray_simbcLcLMCFlux);
2330  instance.SetDelete(&delete_simbcLcLMCFlux);
2331  instance.SetDeleteArray(&deleteArray_simbcLcLMCFlux);
2332  instance.SetDestructor(&destruct_simbcLcLMCFlux);
2333  return &instance;
2334  }
2335  TGenericClassInfo *GenerateInitInstance(const ::simb::MCFlux*)
2336  {
2338  }
2339  // Static variable to force the class initialization
2340  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::simb::MCFlux*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2341 
2342  // Dictionary for non-ClassDef classes
2343  static TClass *simbcLcLMCFlux_Dictionary() {
2344  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::simb::MCFlux*)0x0)->GetClass();
2345  simbcLcLMCFlux_TClassManip(theClass);
2346  return theClass;
2347  }
2348 
2349  static void simbcLcLMCFlux_TClassManip(TClass* ){
2350  }
2351 
2352 } // end of namespace ROOT
2353 
2354 namespace ROOT {
2355  static TClass *simbcLcLGTruth_Dictionary();
2356  static void simbcLcLGTruth_TClassManip(TClass*);
2357  static void *new_simbcLcLGTruth(void *p = 0);
2358  static void *newArray_simbcLcLGTruth(Long_t size, void *p);
2359  static void delete_simbcLcLGTruth(void *p);
2360  static void deleteArray_simbcLcLGTruth(void *p);
2361  static void destruct_simbcLcLGTruth(void *p);
2362 
2363  // Function generating the singleton type initializer
2364  static TGenericClassInfo *GenerateInitInstanceLocal(const ::simb::GTruth*)
2365  {
2366  ::simb::GTruth *ptr = 0;
2367  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::simb::GTruth));
2368  static ::ROOT::TGenericClassInfo
2369  instance("simb::GTruth", 13, "nusimdata/SimulationBase/GTruth.h", 19,
2370  typeid(::simb::GTruth), ::ROOT::Internal::DefineBehavior(ptr, ptr),
2371  &simbcLcLGTruth_Dictionary, isa_proxy, 12,
2372  sizeof(::simb::GTruth) );
2373  instance.SetNew(&new_simbcLcLGTruth);
2374  instance.SetNewArray(&newArray_simbcLcLGTruth);
2375  instance.SetDelete(&delete_simbcLcLGTruth);
2376  instance.SetDeleteArray(&deleteArray_simbcLcLGTruth);
2377  instance.SetDestructor(&destruct_simbcLcLGTruth);
2378  return &instance;
2379  }
2380  TGenericClassInfo *GenerateInitInstance(const ::simb::GTruth*)
2381  {
2383  }
2384  // Static variable to force the class initialization
2385  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::simb::GTruth*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
2386 
2387  // Dictionary for non-ClassDef classes
2388  static TClass *simbcLcLGTruth_Dictionary() {
2389  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::simb::GTruth*)0x0)->GetClass();
2390  simbcLcLGTruth_TClassManip(theClass);
2391  return theClass;
2392  }
2393 
2394  static void simbcLcLGTruth_TClassManip(TClass* ){
2395  }
2396 
2397 } // end of namespace ROOT
2398 
2399 namespace ROOT {
2400  // Wrappers around operator new
2402  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<TLorentzVector,TLorentzVector> : new pair<TLorentzVector,TLorentzVector>;
2403  }
2404  static void *newArray_pairlETLorentzVectorcOTLorentzVectorgR(Long_t nElements, void *p) {
2405  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<TLorentzVector,TLorentzVector>[nElements] : new pair<TLorentzVector,TLorentzVector>[nElements];
2406  }
2407  // Wrapper around operator delete
2409  delete ((pair<TLorentzVector,TLorentzVector>*)p);
2410  }
2412  delete [] ((pair<TLorentzVector,TLorentzVector>*)p);
2413  }
2415  typedef pair<TLorentzVector,TLorentzVector> current_t;
2416  ((current_t*)p)->~current_t();
2417  }
2418 } // end of namespace ROOT for class pair<TLorentzVector,TLorentzVector>
2419 
2420 namespace ROOT {
2421  // Wrappers around operator new
2423  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<unsigned long,unsigned char> : new pair<unsigned long,unsigned char>;
2424  }
2425  static void *newArray_pairlEunsignedsPlongcOunsignedsPchargR(Long_t nElements, void *p) {
2426  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<unsigned long,unsigned char>[nElements] : new pair<unsigned long,unsigned char>[nElements];
2427  }
2428  // Wrapper around operator delete
2430  delete ((pair<unsigned long,unsigned char>*)p);
2431  }
2433  delete [] ((pair<unsigned long,unsigned char>*)p);
2434  }
2436  typedef pair<unsigned long,unsigned char> current_t;
2437  ((current_t*)p)->~current_t();
2438  }
2439 } // end of namespace ROOT for class pair<unsigned long,unsigned char>
2440 
2441 namespace ROOT {
2442  // Wrappers around operator new
2444  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<art::Ptr<bsim::NuChoice>,art::Ptr<simb::MCTruth> > : new pair<art::Ptr<bsim::NuChoice>,art::Ptr<simb::MCTruth> >;
2445  }
2447  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<art::Ptr<bsim::NuChoice>,art::Ptr<simb::MCTruth> >[nElements] : new pair<art::Ptr<bsim::NuChoice>,art::Ptr<simb::MCTruth> >[nElements];
2448  }
2449  // Wrapper around operator delete
2451  delete ((pair<art::Ptr<bsim::NuChoice>,art::Ptr<simb::MCTruth> >*)p);
2452  }
2454  delete [] ((pair<art::Ptr<bsim::NuChoice>,art::Ptr<simb::MCTruth> >*)p);
2455  }
2457  typedef pair<art::Ptr<bsim::NuChoice>,art::Ptr<simb::MCTruth> > current_t;
2458  ((current_t*)p)->~current_t();
2459  }
2460 } // end of namespace ROOT for class pair<art::Ptr<bsim::NuChoice>,art::Ptr<simb::MCTruth> >
2461 
2462 namespace ROOT {
2463  // Wrappers around operator new
2465  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::NuChoice> > : new pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::NuChoice> >;
2466  }
2468  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::NuChoice> >[nElements] : new pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::NuChoice> >[nElements];
2469  }
2470  // Wrapper around operator delete
2472  delete ((pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::NuChoice> >*)p);
2473  }
2475  delete [] ((pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::NuChoice> >*)p);
2476  }
2478  typedef pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::NuChoice> > current_t;
2479  ((current_t*)p)->~current_t();
2480  }
2481 } // end of namespace ROOT for class pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::NuChoice> >
2482 
2483 namespace ROOT {
2484  // Wrappers around operator new
2486  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<art::Ptr<bsim::Dk2Nu>,art::Ptr<simb::MCTruth> > : new pair<art::Ptr<bsim::Dk2Nu>,art::Ptr<simb::MCTruth> >;
2487  }
2489  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<art::Ptr<bsim::Dk2Nu>,art::Ptr<simb::MCTruth> >[nElements] : new pair<art::Ptr<bsim::Dk2Nu>,art::Ptr<simb::MCTruth> >[nElements];
2490  }
2491  // Wrapper around operator delete
2493  delete ((pair<art::Ptr<bsim::Dk2Nu>,art::Ptr<simb::MCTruth> >*)p);
2494  }
2496  delete [] ((pair<art::Ptr<bsim::Dk2Nu>,art::Ptr<simb::MCTruth> >*)p);
2497  }
2499  typedef pair<art::Ptr<bsim::Dk2Nu>,art::Ptr<simb::MCTruth> > current_t;
2500  ((current_t*)p)->~current_t();
2501  }
2502 } // end of namespace ROOT for class pair<art::Ptr<bsim::Dk2Nu>,art::Ptr<simb::MCTruth> >
2503 
2504 namespace ROOT {
2505  // Wrappers around operator new
2507  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::Dk2Nu> > : new pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::Dk2Nu> >;
2508  }
2510  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::Dk2Nu> >[nElements] : new pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::Dk2Nu> >[nElements];
2511  }
2512  // Wrapper around operator delete
2514  delete ((pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::Dk2Nu> >*)p);
2515  }
2517  delete [] ((pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::Dk2Nu> >*)p);
2518  }
2520  typedef pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::Dk2Nu> > current_t;
2521  ((current_t*)p)->~current_t();
2522  }
2523 } // end of namespace ROOT for class pair<art::Ptr<simb::MCTruth>,art::Ptr<bsim::Dk2Nu> >
2524 
2525 namespace ROOT {
2526  // Wrappers around operator new
2528  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCParticle> > : new pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCParticle> >;
2529  }
2531  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCParticle> >[nElements] : new pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCParticle> >[nElements];
2532  }
2533  // Wrapper around operator delete
2535  delete ((pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCParticle> >*)p);
2536  }
2538  delete [] ((pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCParticle> >*)p);
2539  }
2541  typedef pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCParticle> > current_t;
2542  ((current_t*)p)->~current_t();
2543  }
2544 } // end of namespace ROOT for class pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCParticle> >
2545 
2546 namespace ROOT {
2547  // Wrappers around operator new
2549  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<art::Ptr<simb::MCParticle>,art::Ptr<simb::MCTruth> > : new pair<art::Ptr<simb::MCParticle>,art::Ptr<simb::MCTruth> >;
2550  }
2552  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<art::Ptr<simb::MCParticle>,art::Ptr<simb::MCTruth> >[nElements] : new pair<art::Ptr<simb::MCParticle>,art::Ptr<simb::MCTruth> >[nElements];
2553  }
2554  // Wrapper around operator delete
2556  delete ((pair<art::Ptr<simb::MCParticle>,art::Ptr<simb::MCTruth> >*)p);
2557  }
2559  delete [] ((pair<art::Ptr<simb::MCParticle>,art::Ptr<simb::MCTruth> >*)p);
2560  }
2562  typedef pair<art::Ptr<simb::MCParticle>,art::Ptr<simb::MCTruth> > current_t;
2563  ((current_t*)p)->~current_t();
2564  }
2565 } // end of namespace ROOT for class pair<art::Ptr<simb::MCParticle>,art::Ptr<simb::MCTruth> >
2566 
2567 namespace ROOT {
2568  // Wrappers around operator new
2570  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::GTruth> > : new pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::GTruth> >;
2571  }
2573  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::GTruth> >[nElements] : new pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::GTruth> >[nElements];
2574  }
2575  // Wrapper around operator delete
2577  delete ((pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::GTruth> >*)p);
2578  }
2580  delete [] ((pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::GTruth> >*)p);
2581  }
2583  typedef pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::GTruth> > current_t;
2584  ((current_t*)p)->~current_t();
2585  }
2586 } // end of namespace ROOT for class pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::GTruth> >
2587 
2588 namespace ROOT {
2589  // Wrappers around operator new
2591  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<art::Ptr<simb::GTruth>,art::Ptr<simb::MCTruth> > : new pair<art::Ptr<simb::GTruth>,art::Ptr<simb::MCTruth> >;
2592  }
2594  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<art::Ptr<simb::GTruth>,art::Ptr<simb::MCTruth> >[nElements] : new pair<art::Ptr<simb::GTruth>,art::Ptr<simb::MCTruth> >[nElements];
2595  }
2596  // Wrapper around operator delete
2598  delete ((pair<art::Ptr<simb::GTruth>,art::Ptr<simb::MCTruth> >*)p);
2599  }
2601  delete [] ((pair<art::Ptr<simb::GTruth>,art::Ptr<simb::MCTruth> >*)p);
2602  }
2604  typedef pair<art::Ptr<simb::GTruth>,art::Ptr<simb::MCTruth> > current_t;
2605  ((current_t*)p)->~current_t();
2606  }
2607 } // end of namespace ROOT for class pair<art::Ptr<simb::GTruth>,art::Ptr<simb::MCTruth> >
2608 
2609 namespace ROOT {
2610  // Wrappers around operator new
2612  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCFlux> > : new pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCFlux> >;
2613  }
2615  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCFlux> >[nElements] : new pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCFlux> >[nElements];
2616  }
2617  // Wrapper around operator delete
2619  delete ((pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCFlux> >*)p);
2620  }
2622  delete [] ((pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCFlux> >*)p);
2623  }
2625  typedef pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCFlux> > current_t;
2626  ((current_t*)p)->~current_t();
2627  }
2628 } // end of namespace ROOT for class pair<art::Ptr<simb::MCTruth>,art::Ptr<simb::MCFlux> >
2629 
2630 namespace ROOT {
2631  // Wrappers around operator new
2633  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<art::Ptr<simb::MCFlux>,art::Ptr<simb::MCTruth> > : new pair<art::Ptr<simb::MCFlux>,art::Ptr<simb::MCTruth> >;
2634  }
2636  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair<art::Ptr<simb::MCFlux>,art::Ptr<simb::MCTruth> >[nElements] : new pair<art::Ptr<simb::MCFlux>,art::Ptr<simb::MCTruth> >[nElements];
2637  }
2638  // Wrapper around operator delete
2640  delete ((pair<art::Ptr<simb::MCFlux>,art::Ptr<simb::MCTruth> >*)p);
2641  }
2643  delete [] ((pair<art::Ptr<simb::MCFlux>,art::Ptr<simb::MCTruth> >*)p);
2644  }
2646  typedef pair<art::Ptr<simb::MCFlux>,art::Ptr<simb::MCTruth> > current_t;
2647  ((current_t*)p)->~current_t();
2648  }
2649 } // end of namespace ROOT for class pair<art::Ptr<simb::MCFlux>,art::Ptr<simb::MCTruth> >
2650 
2651 namespace ROOT {
2652  // Wrappers around operator new
2654  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Assns<bsim::NuChoice,simb::MCTruth,void> : new ::art::Assns<bsim::NuChoice,simb::MCTruth,void>;
2655  }
2657  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Assns<bsim::NuChoice,simb::MCTruth,void>[nElements] : new ::art::Assns<bsim::NuChoice,simb::MCTruth,void>[nElements];
2658  }
2659  // Wrapper around operator delete
2662  }
2665  }
2667  typedef ::art::Assns<bsim::NuChoice,simb::MCTruth,void> current_t;
2668  ((current_t*)p)->~current_t();
2669  }
2670 } // end of namespace ROOT for class ::art::Assns<bsim::NuChoice,simb::MCTruth,void>
2671 
2672 namespace ROOT {
2673  // Wrappers around operator new
2675  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Assns<simb::MCTruth,bsim::NuChoice,void> : new ::art::Assns<simb::MCTruth,bsim::NuChoice,void>;
2676  }
2678  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Assns<simb::MCTruth,bsim::NuChoice,void>[nElements] : new ::art::Assns<simb::MCTruth,bsim::NuChoice,void>[nElements];
2679  }
2680  // Wrapper around operator delete
2683  }
2686  }
2688  typedef ::art::Assns<simb::MCTruth,bsim::NuChoice,void> current_t;
2689  ((current_t*)p)->~current_t();
2690  }
2691 } // end of namespace ROOT for class ::art::Assns<simb::MCTruth,bsim::NuChoice,void>
2692 
2693 namespace ROOT {
2694  // Wrappers around operator new
2696  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Assns<bsim::Dk2Nu,simb::MCTruth,void> : new ::art::Assns<bsim::Dk2Nu,simb::MCTruth,void>;
2697  }
2699  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Assns<bsim::Dk2Nu,simb::MCTruth,void>[nElements] : new ::art::Assns<bsim::Dk2Nu,simb::MCTruth,void>[nElements];
2700  }
2701  // Wrapper around operator delete
2704  }
2707  }
2709  typedef ::art::Assns<bsim::Dk2Nu,simb::MCTruth,void> current_t;
2710  ((current_t*)p)->~current_t();
2711  }
2712 } // end of namespace ROOT for class ::art::Assns<bsim::Dk2Nu,simb::MCTruth,void>
2713 
2714 namespace ROOT {
2715  // Wrappers around operator new
2717  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Assns<simb::MCTruth,bsim::Dk2Nu,void> : new ::art::Assns<simb::MCTruth,bsim::Dk2Nu,void>;
2718  }
2720  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Assns<simb::MCTruth,bsim::Dk2Nu,void>[nElements] : new ::art::Assns<simb::MCTruth,bsim::Dk2Nu,void>[nElements];
2721  }
2722  // Wrapper around operator delete
2725  }
2728  }
2730  typedef ::art::Assns<simb::MCTruth,bsim::Dk2Nu,void> current_t;
2731  ((current_t*)p)->~current_t();
2732  }
2733 } // end of namespace ROOT for class ::art::Assns<simb::MCTruth,bsim::Dk2Nu,void>
2734 
2735 namespace ROOT {
2736  // Wrappers around operator new
2738  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Assns<simb::MCTruth,simb::MCParticle,void> : new ::art::Assns<simb::MCTruth,simb::MCParticle,void>;
2739  }
2741  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Assns<simb::MCTruth,simb::MCParticle,void>[nElements] : new ::art::Assns<simb::MCTruth,simb::MCParticle,void>[nElements];
2742  }
2743  // Wrapper around operator delete
2746  }
2749  }
2751  typedef ::art::Assns<simb::MCTruth,simb::MCParticle,void> current_t;
2752  ((current_t*)p)->~current_t();
2753  }
2754 } // end of namespace ROOT for class ::art::Assns<simb::MCTruth,simb::MCParticle,void>
2755 
2756 namespace ROOT {
2757  // Wrappers around operator new
2759  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Assns<simb::MCParticle,simb::MCTruth,void> : new ::art::Assns<simb::MCParticle,simb::MCTruth,void>;
2760  }
2762  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Assns<simb::MCParticle,simb::MCTruth,void>[nElements] : new ::art::Assns<simb::MCParticle,simb::MCTruth,void>[nElements];
2763  }
2764  // Wrapper around operator delete
2767  }
2770  }
2772  typedef ::art::Assns<simb::MCParticle,simb::MCTruth,void> current_t;
2773  ((current_t*)p)->~current_t();
2774  }
2775 } // end of namespace ROOT for class ::art::Assns<simb::MCParticle,simb::MCTruth,void>
2776 
2777 namespace ROOT {
2778  // Wrappers around operator new
2780  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Assns<simb::MCTruth,simb::GTruth,void> : new ::art::Assns<simb::MCTruth,simb::GTruth,void>;
2781  }
2783  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Assns<simb::MCTruth,simb::GTruth,void>[nElements] : new ::art::Assns<simb::MCTruth,simb::GTruth,void>[nElements];
2784  }
2785  // Wrapper around operator delete
2788  }
2791  }
2793  typedef ::art::Assns<simb::MCTruth,simb::GTruth,void> current_t;
2794  ((current_t*)p)->~current_t();
2795  }
2796 } // end of namespace ROOT for class ::art::Assns<simb::MCTruth,simb::GTruth,void>
2797 
2798 namespace ROOT {
2799  // Wrappers around operator new
2801  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Assns<simb::GTruth,simb::MCTruth,void> : new ::art::Assns<simb::GTruth,simb::MCTruth,void>;
2802  }
2804  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Assns<simb::GTruth,simb::MCTruth,void>[nElements] : new ::art::Assns<simb::GTruth,simb::MCTruth,void>[nElements];
2805  }
2806  // Wrapper around operator delete
2809  }
2812  }
2814  typedef ::art::Assns<simb::GTruth,simb::MCTruth,void> current_t;
2815  ((current_t*)p)->~current_t();
2816  }
2817 } // end of namespace ROOT for class ::art::Assns<simb::GTruth,simb::MCTruth,void>
2818 
2819 namespace ROOT {
2820  // Wrappers around operator new
2822  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Assns<simb::MCTruth,simb::MCFlux,void> : new ::art::Assns<simb::MCTruth,simb::MCFlux,void>;
2823  }
2825  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Assns<simb::MCTruth,simb::MCFlux,void>[nElements] : new ::art::Assns<simb::MCTruth,simb::MCFlux,void>[nElements];
2826  }
2827  // Wrapper around operator delete
2830  }
2833  }
2835  typedef ::art::Assns<simb::MCTruth,simb::MCFlux,void> current_t;
2836  ((current_t*)p)->~current_t();
2837  }
2838 } // end of namespace ROOT for class ::art::Assns<simb::MCTruth,simb::MCFlux,void>
2839 
2840 namespace ROOT {
2841  // Wrappers around operator new
2843  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Assns<simb::MCFlux,simb::MCTruth,void> : new ::art::Assns<simb::MCFlux,simb::MCTruth,void>;
2844  }
2846  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Assns<simb::MCFlux,simb::MCTruth,void>[nElements] : new ::art::Assns<simb::MCFlux,simb::MCTruth,void>[nElements];
2847  }
2848  // Wrapper around operator delete
2851  }
2854  }
2856  typedef ::art::Assns<simb::MCFlux,simb::MCTruth,void> current_t;
2857  ((current_t*)p)->~current_t();
2858  }
2859 } // end of namespace ROOT for class ::art::Assns<simb::MCFlux,simb::MCTruth,void>
2860 
2861 namespace ROOT {
2862  // Wrappers around operator new
2864  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Ptr<bsim::NuChoice> : new ::art::Ptr<bsim::NuChoice>;
2865  }
2866  static void *newArray_artcLcLPtrlEbsimcLcLNuChoicegR(Long_t nElements, void *p) {
2867  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Ptr<bsim::NuChoice>[nElements] : new ::art::Ptr<bsim::NuChoice>[nElements];
2868  }
2869  // Wrapper around operator delete
2871  delete ((::art::Ptr<bsim::NuChoice>*)p);
2872  }
2874  delete [] ((::art::Ptr<bsim::NuChoice>*)p);
2875  }
2877  typedef ::art::Ptr<bsim::NuChoice> current_t;
2878  ((current_t*)p)->~current_t();
2879  }
2880 } // end of namespace ROOT for class ::art::Ptr<bsim::NuChoice>
2881 
2882 namespace ROOT {
2883  // Wrappers around operator new
2884  static void *new_artcLcLPtrlEsimbcLcLMCTruthgR(void *p) {
2885  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Ptr<simb::MCTruth> : new ::art::Ptr<simb::MCTruth>;
2886  }
2887  static void *newArray_artcLcLPtrlEsimbcLcLMCTruthgR(Long_t nElements, void *p) {
2888  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Ptr<simb::MCTruth>[nElements] : new ::art::Ptr<simb::MCTruth>[nElements];
2889  }
2890  // Wrapper around operator delete
2892  delete ((::art::Ptr<simb::MCTruth>*)p);
2893  }
2895  delete [] ((::art::Ptr<simb::MCTruth>*)p);
2896  }
2898  typedef ::art::Ptr<simb::MCTruth> current_t;
2899  ((current_t*)p)->~current_t();
2900  }
2901 } // end of namespace ROOT for class ::art::Ptr<simb::MCTruth>
2902 
2903 namespace ROOT {
2904  // Wrappers around operator new
2905  static void *new_artcLcLPtrlEbsimcLcLDk2NugR(void *p) {
2906  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Ptr<bsim::Dk2Nu> : new ::art::Ptr<bsim::Dk2Nu>;
2907  }
2908  static void *newArray_artcLcLPtrlEbsimcLcLDk2NugR(Long_t nElements, void *p) {
2909  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Ptr<bsim::Dk2Nu>[nElements] : new ::art::Ptr<bsim::Dk2Nu>[nElements];
2910  }
2911  // Wrapper around operator delete
2913  delete ((::art::Ptr<bsim::Dk2Nu>*)p);
2914  }
2916  delete [] ((::art::Ptr<bsim::Dk2Nu>*)p);
2917  }
2919  typedef ::art::Ptr<bsim::Dk2Nu> current_t;
2920  ((current_t*)p)->~current_t();
2921  }
2922 } // end of namespace ROOT for class ::art::Ptr<bsim::Dk2Nu>
2923 
2924 namespace ROOT {
2925  // Wrappers around operator new
2927  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Ptr<simb::MCParticle> : new ::art::Ptr<simb::MCParticle>;
2928  }
2929  static void *newArray_artcLcLPtrlEsimbcLcLMCParticlegR(Long_t nElements, void *p) {
2930  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Ptr<simb::MCParticle>[nElements] : new ::art::Ptr<simb::MCParticle>[nElements];
2931  }
2932  // Wrapper around operator delete
2934  delete ((::art::Ptr<simb::MCParticle>*)p);
2935  }
2937  delete [] ((::art::Ptr<simb::MCParticle>*)p);
2938  }
2940  typedef ::art::Ptr<simb::MCParticle> current_t;
2941  ((current_t*)p)->~current_t();
2942  }
2943 } // end of namespace ROOT for class ::art::Ptr<simb::MCParticle>
2944 
2945 namespace ROOT {
2946  // Wrappers around operator new
2947  static void *new_artcLcLPtrlEsimbcLcLGTruthgR(void *p) {
2948  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Ptr<simb::GTruth> : new ::art::Ptr<simb::GTruth>;
2949  }
2950  static void *newArray_artcLcLPtrlEsimbcLcLGTruthgR(Long_t nElements, void *p) {
2951  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Ptr<simb::GTruth>[nElements] : new ::art::Ptr<simb::GTruth>[nElements];
2952  }
2953  // Wrapper around operator delete
2955  delete ((::art::Ptr<simb::GTruth>*)p);
2956  }
2958  delete [] ((::art::Ptr<simb::GTruth>*)p);
2959  }
2961  typedef ::art::Ptr<simb::GTruth> current_t;
2962  ((current_t*)p)->~current_t();
2963  }
2964 } // end of namespace ROOT for class ::art::Ptr<simb::GTruth>
2965 
2966 namespace ROOT {
2967  // Wrappers around operator new
2968  static void *new_artcLcLPtrlEsimbcLcLMCFluxgR(void *p) {
2969  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Ptr<simb::MCFlux> : new ::art::Ptr<simb::MCFlux>;
2970  }
2971  static void *newArray_artcLcLPtrlEsimbcLcLMCFluxgR(Long_t nElements, void *p) {
2972  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Ptr<simb::MCFlux>[nElements] : new ::art::Ptr<simb::MCFlux>[nElements];
2973  }
2974  // Wrapper around operator delete
2976  delete ((::art::Ptr<simb::MCFlux>*)p);
2977  }
2979  delete [] ((::art::Ptr<simb::MCFlux>*)p);
2980  }
2982  typedef ::art::Ptr<simb::MCFlux> current_t;
2983  ((current_t*)p)->~current_t();
2984  }
2985 } // end of namespace ROOT for class ::art::Ptr<simb::MCFlux>
2986 
2987 namespace ROOT {
2988  // Wrappers around operator new
2990  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<art::Assns<bsim::NuChoice,simb::MCTruth,void> > : new ::art::Wrapper<art::Assns<bsim::NuChoice,simb::MCTruth,void> >;
2991  }
2993  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<art::Assns<bsim::NuChoice,simb::MCTruth,void> >[nElements] : new ::art::Wrapper<art::Assns<bsim::NuChoice,simb::MCTruth,void> >[nElements];
2994  }
2995  // Wrapper around operator delete
2998  }
3001  }
3003  typedef ::art::Wrapper<art::Assns<bsim::NuChoice,simb::MCTruth,void> > current_t;
3004  ((current_t*)p)->~current_t();
3005  }
3006 } // end of namespace ROOT for class ::art::Wrapper<art::Assns<bsim::NuChoice,simb::MCTruth,void> >
3007 
3008 namespace ROOT {
3009  // Wrappers around operator new
3011  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<art::Assns<simb::MCTruth,bsim::NuChoice,void> > : new ::art::Wrapper<art::Assns<simb::MCTruth,bsim::NuChoice,void> >;
3012  }
3014  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<art::Assns<simb::MCTruth,bsim::NuChoice,void> >[nElements] : new ::art::Wrapper<art::Assns<simb::MCTruth,bsim::NuChoice,void> >[nElements];
3015  }
3016  // Wrapper around operator delete
3019  }
3022  }
3024  typedef ::art::Wrapper<art::Assns<simb::MCTruth,bsim::NuChoice,void> > current_t;
3025  ((current_t*)p)->~current_t();
3026  }
3027 } // end of namespace ROOT for class ::art::Wrapper<art::Assns<simb::MCTruth,bsim::NuChoice,void> >
3028 
3029 namespace ROOT {
3030  // Wrappers around operator new
3032  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<vector<bsim::NuChoice> > : new ::art::Wrapper<vector<bsim::NuChoice> >;
3033  }
3034  static void *newArray_artcLcLWrapperlEvectorlEbsimcLcLNuChoicegRsPgR(Long_t nElements, void *p) {
3035  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<vector<bsim::NuChoice> >[nElements] : new ::art::Wrapper<vector<bsim::NuChoice> >[nElements];
3036  }
3037  // Wrapper around operator delete
3040  }
3042  delete [] ((::art::Wrapper<vector<bsim::NuChoice> >*)p);
3043  }
3045  typedef ::art::Wrapper<vector<bsim::NuChoice> > current_t;
3046  ((current_t*)p)->~current_t();
3047  }
3048 } // end of namespace ROOT for class ::art::Wrapper<vector<bsim::NuChoice> >
3049 
3050 namespace ROOT {
3051  // Wrappers around operator new
3053  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<art::Assns<bsim::Dk2Nu,simb::MCTruth,void> > : new ::art::Wrapper<art::Assns<bsim::Dk2Nu,simb::MCTruth,void> >;
3054  }
3056  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<art::Assns<bsim::Dk2Nu,simb::MCTruth,void> >[nElements] : new ::art::Wrapper<art::Assns<bsim::Dk2Nu,simb::MCTruth,void> >[nElements];
3057  }
3058  // Wrapper around operator delete
3061  }
3064  }
3066  typedef ::art::Wrapper<art::Assns<bsim::Dk2Nu,simb::MCTruth,void> > current_t;
3067  ((current_t*)p)->~current_t();
3068  }
3069 } // end of namespace ROOT for class ::art::Wrapper<art::Assns<bsim::Dk2Nu,simb::MCTruth,void> >
3070 
3071 namespace ROOT {
3072  // Wrappers around operator new
3074  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<art::Assns<simb::MCTruth,bsim::Dk2Nu,void> > : new ::art::Wrapper<art::Assns<simb::MCTruth,bsim::Dk2Nu,void> >;
3075  }
3077  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<art::Assns<simb::MCTruth,bsim::Dk2Nu,void> >[nElements] : new ::art::Wrapper<art::Assns<simb::MCTruth,bsim::Dk2Nu,void> >[nElements];
3078  }
3079  // Wrapper around operator delete
3082  }
3085  }
3087  typedef ::art::Wrapper<art::Assns<simb::MCTruth,bsim::Dk2Nu,void> > current_t;
3088  ((current_t*)p)->~current_t();
3089  }
3090 } // end of namespace ROOT for class ::art::Wrapper<art::Assns<simb::MCTruth,bsim::Dk2Nu,void> >
3091 
3092 namespace ROOT {
3093  // Wrappers around operator new
3095  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<vector<bsim::Dk2Nu> > : new ::art::Wrapper<vector<bsim::Dk2Nu> >;
3096  }
3097  static void *newArray_artcLcLWrapperlEvectorlEbsimcLcLDk2NugRsPgR(Long_t nElements, void *p) {
3098  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<vector<bsim::Dk2Nu> >[nElements] : new ::art::Wrapper<vector<bsim::Dk2Nu> >[nElements];
3099  }
3100  // Wrapper around operator delete
3102  delete ((::art::Wrapper<vector<bsim::Dk2Nu> >*)p);
3103  }
3105  delete [] ((::art::Wrapper<vector<bsim::Dk2Nu> >*)p);
3106  }
3108  typedef ::art::Wrapper<vector<bsim::Dk2Nu> > current_t;
3109  ((current_t*)p)->~current_t();
3110  }
3111 } // end of namespace ROOT for class ::art::Wrapper<vector<bsim::Dk2Nu> >
3112 
3113 namespace ROOT {
3114  // Wrappers around operator new
3116  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCParticle,void> > : new ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCParticle,void> >;
3117  }
3119  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCParticle,void> >[nElements] : new ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCParticle,void> >[nElements];
3120  }
3121  // Wrapper around operator delete
3124  }
3127  }
3129  typedef ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCParticle,void> > current_t;
3130  ((current_t*)p)->~current_t();
3131  }
3132 } // end of namespace ROOT for class ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCParticle,void> >
3133 
3134 namespace ROOT {
3135  // Wrappers around operator new
3137  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<art::Assns<simb::MCParticle,simb::MCTruth,void> > : new ::art::Wrapper<art::Assns<simb::MCParticle,simb::MCTruth,void> >;
3138  }
3140  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<art::Assns<simb::MCParticle,simb::MCTruth,void> >[nElements] : new ::art::Wrapper<art::Assns<simb::MCParticle,simb::MCTruth,void> >[nElements];
3141  }
3142  // Wrapper around operator delete
3145  }
3148  }
3150  typedef ::art::Wrapper<art::Assns<simb::MCParticle,simb::MCTruth,void> > current_t;
3151  ((current_t*)p)->~current_t();
3152  }
3153 } // end of namespace ROOT for class ::art::Wrapper<art::Assns<simb::MCParticle,simb::MCTruth,void> >
3154 
3155 namespace ROOT {
3156  // Wrappers around operator new
3158  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<art::Assns<simb::MCTruth,simb::GTruth,void> > : new ::art::Wrapper<art::Assns<simb::MCTruth,simb::GTruth,void> >;
3159  }
3161  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<art::Assns<simb::MCTruth,simb::GTruth,void> >[nElements] : new ::art::Wrapper<art::Assns<simb::MCTruth,simb::GTruth,void> >[nElements];
3162  }
3163  // Wrapper around operator delete
3166  }
3169  }
3171  typedef ::art::Wrapper<art::Assns<simb::MCTruth,simb::GTruth,void> > current_t;
3172  ((current_t*)p)->~current_t();
3173  }
3174 } // end of namespace ROOT for class ::art::Wrapper<art::Assns<simb::MCTruth,simb::GTruth,void> >
3175 
3176 namespace ROOT {
3177  // Wrappers around operator new
3179  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<art::Assns<simb::GTruth,simb::MCTruth,void> > : new ::art::Wrapper<art::Assns<simb::GTruth,simb::MCTruth,void> >;
3180  }
3182  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<art::Assns<simb::GTruth,simb::MCTruth,void> >[nElements] : new ::art::Wrapper<art::Assns<simb::GTruth,simb::MCTruth,void> >[nElements];
3183  }
3184  // Wrapper around operator delete
3187  }
3190  }
3192  typedef ::art::Wrapper<art::Assns<simb::GTruth,simb::MCTruth,void> > current_t;
3193  ((current_t*)p)->~current_t();
3194  }
3195 } // end of namespace ROOT for class ::art::Wrapper<art::Assns<simb::GTruth,simb::MCTruth,void> >
3196 
3197 namespace ROOT {
3198  // Wrappers around operator new
3200  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCFlux,void> > : new ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCFlux,void> >;
3201  }
3203  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCFlux,void> >[nElements] : new ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCFlux,void> >[nElements];
3204  }
3205  // Wrapper around operator delete
3208  }
3211  }
3213  typedef ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCFlux,void> > current_t;
3214  ((current_t*)p)->~current_t();
3215  }
3216 } // end of namespace ROOT for class ::art::Wrapper<art::Assns<simb::MCTruth,simb::MCFlux,void> >
3217 
3218 namespace ROOT {
3219  // Wrappers around operator new
3221  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<art::Assns<simb::MCFlux,simb::MCTruth,void> > : new ::art::Wrapper<art::Assns<simb::MCFlux,simb::MCTruth,void> >;
3222  }
3224  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<art::Assns<simb::MCFlux,simb::MCTruth,void> >[nElements] : new ::art::Wrapper<art::Assns<simb::MCFlux,simb::MCTruth,void> >[nElements];
3225  }
3226  // Wrapper around operator delete
3229  }
3232  }
3234  typedef ::art::Wrapper<art::Assns<simb::MCFlux,simb::MCTruth,void> > current_t;
3235  ((current_t*)p)->~current_t();
3236  }
3237 } // end of namespace ROOT for class ::art::Wrapper<art::Assns<simb::MCFlux,simb::MCTruth,void> >
3238 
3239 namespace ROOT {
3240  // Wrappers around operator new
3242  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<vector<simb::GTruth> > : new ::art::Wrapper<vector<simb::GTruth> >;
3243  }
3244  static void *newArray_artcLcLWrapperlEvectorlEsimbcLcLGTruthgRsPgR(Long_t nElements, void *p) {
3245  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<vector<simb::GTruth> >[nElements] : new ::art::Wrapper<vector<simb::GTruth> >[nElements];
3246  }
3247  // Wrapper around operator delete
3249  delete ((::art::Wrapper<vector<simb::GTruth> >*)p);
3250  }
3252  delete [] ((::art::Wrapper<vector<simb::GTruth> >*)p);
3253  }
3255  typedef ::art::Wrapper<vector<simb::GTruth> > current_t;
3256  ((current_t*)p)->~current_t();
3257  }
3258 } // end of namespace ROOT for class ::art::Wrapper<vector<simb::GTruth> >
3259 
3260 namespace ROOT {
3261  // Wrappers around operator new
3263  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<vector<simb::MCFlux> > : new ::art::Wrapper<vector<simb::MCFlux> >;
3264  }
3265  static void *newArray_artcLcLWrapperlEvectorlEsimbcLcLMCFluxgRsPgR(Long_t nElements, void *p) {
3266  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<vector<simb::MCFlux> >[nElements] : new ::art::Wrapper<vector<simb::MCFlux> >[nElements];
3267  }
3268  // Wrapper around operator delete
3270  delete ((::art::Wrapper<vector<simb::MCFlux> >*)p);
3271  }
3273  delete [] ((::art::Wrapper<vector<simb::MCFlux> >*)p);
3274  }
3276  typedef ::art::Wrapper<vector<simb::MCFlux> > current_t;
3277  ((current_t*)p)->~current_t();
3278  }
3279 } // end of namespace ROOT for class ::art::Wrapper<vector<simb::MCFlux> >
3280 
3281 namespace ROOT {
3282  // Wrappers around operator new
3284  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<vector<simb::MCTruth> > : new ::art::Wrapper<vector<simb::MCTruth> >;
3285  }
3286  static void *newArray_artcLcLWrapperlEvectorlEsimbcLcLMCTruthgRsPgR(Long_t nElements, void *p) {
3287  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<vector<simb::MCTruth> >[nElements] : new ::art::Wrapper<vector<simb::MCTruth> >[nElements];
3288  }
3289  // Wrapper around operator delete
3291  delete ((::art::Wrapper<vector<simb::MCTruth> >*)p);
3292  }
3294  delete [] ((::art::Wrapper<vector<simb::MCTruth> >*)p);
3295  }
3297  typedef ::art::Wrapper<vector<simb::MCTruth> > current_t;
3298  ((current_t*)p)->~current_t();
3299  }
3300 } // end of namespace ROOT for class ::art::Wrapper<vector<simb::MCTruth> >
3301 
3302 namespace ROOT {
3303  // Wrappers around operator new
3305  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<vector<simb::MCNeutrino> > : new ::art::Wrapper<vector<simb::MCNeutrino> >;
3306  }
3307  static void *newArray_artcLcLWrapperlEvectorlEsimbcLcLMCNeutrinogRsPgR(Long_t nElements, void *p) {
3308  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<vector<simb::MCNeutrino> >[nElements] : new ::art::Wrapper<vector<simb::MCNeutrino> >[nElements];
3309  }
3310  // Wrapper around operator delete
3313  }
3315  delete [] ((::art::Wrapper<vector<simb::MCNeutrino> >*)p);
3316  }
3318  typedef ::art::Wrapper<vector<simb::MCNeutrino> > current_t;
3319  ((current_t*)p)->~current_t();
3320  }
3321 } // end of namespace ROOT for class ::art::Wrapper<vector<simb::MCNeutrino> >
3322 
3323 namespace ROOT {
3324  // Wrappers around operator new
3326  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<vector<simb::MCTrajectory> > : new ::art::Wrapper<vector<simb::MCTrajectory> >;
3327  }
3328  static void *newArray_artcLcLWrapperlEvectorlEsimbcLcLMCTrajectorygRsPgR(Long_t nElements, void *p) {
3329  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<vector<simb::MCTrajectory> >[nElements] : new ::art::Wrapper<vector<simb::MCTrajectory> >[nElements];
3330  }
3331  // Wrapper around operator delete
3334  }
3337  }
3339  typedef ::art::Wrapper<vector<simb::MCTrajectory> > current_t;
3340  ((current_t*)p)->~current_t();
3341  }
3342 } // end of namespace ROOT for class ::art::Wrapper<vector<simb::MCTrajectory> >
3343 
3344 namespace ROOT {
3345  // Wrappers around operator new
3347  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<vector<simb::MCParticle> > : new ::art::Wrapper<vector<simb::MCParticle> >;
3348  }
3349  static void *newArray_artcLcLWrapperlEvectorlEsimbcLcLMCParticlegRsPgR(Long_t nElements, void *p) {
3350  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::art::Wrapper<vector<simb::MCParticle> >[nElements] : new ::art::Wrapper<vector<simb::MCParticle> >[nElements];
3351  }
3352  // Wrapper around operator delete
3355  }
3357  delete [] ((::art::Wrapper<vector<simb::MCParticle> >*)p);
3358  }
3360  typedef ::art::Wrapper<vector<simb::MCParticle> > current_t;
3361  ((current_t*)p)->~current_t();
3362  }
3363 } // end of namespace ROOT for class ::art::Wrapper<vector<simb::MCParticle> >
3364 
3365 namespace ROOT {
3366  // Wrappers around operator new
3367  static void *new_simbcLcLMCGeneratorInfo(void *p) {
3368  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::simb::MCGeneratorInfo : new ::simb::MCGeneratorInfo;
3369  }
3370  static void *newArray_simbcLcLMCGeneratorInfo(Long_t nElements, void *p) {
3371  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::simb::MCGeneratorInfo[nElements] : new ::simb::MCGeneratorInfo[nElements];
3372  }
3373  // Wrapper around operator delete
3374  static void delete_simbcLcLMCGeneratorInfo(void *p) {
3375  delete ((::simb::MCGeneratorInfo*)p);
3376  }
3378  delete [] ((::simb::MCGeneratorInfo*)p);
3379  }
3381  typedef ::simb::MCGeneratorInfo current_t;
3382  ((current_t*)p)->~current_t();
3383  }
3384 } // end of namespace ROOT for class ::simb::MCGeneratorInfo
3385 
3386 namespace ROOT {
3387  // Wrappers around operator new
3388  static void *new_simbcLcLMCTrajectory(void *p) {
3389  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::simb::MCTrajectory : new ::simb::MCTrajectory;
3390  }
3391  static void *newArray_simbcLcLMCTrajectory(Long_t nElements, void *p) {
3392  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::simb::MCTrajectory[nElements] : new ::simb::MCTrajectory[nElements];
3393  }
3394  // Wrapper around operator delete
3395  static void delete_simbcLcLMCTrajectory(void *p) {
3396  delete ((::simb::MCTrajectory*)p);
3397  }
3399  delete [] ((::simb::MCTrajectory*)p);
3400  }
3401  static void destruct_simbcLcLMCTrajectory(void *p) {
3402  typedef ::simb::MCTrajectory current_t;
3403  ((current_t*)p)->~current_t();
3404  }
3405 } // end of namespace ROOT for class ::simb::MCTrajectory
3406 
3407 namespace ROOT {
3408  // Wrappers around operator new
3409  static void *new_simbcLcLMCParticle(void *p) {
3410  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::simb::MCParticle : new ::simb::MCParticle;
3411  }
3412  static void *newArray_simbcLcLMCParticle(Long_t nElements, void *p) {
3413  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::simb::MCParticle[nElements] : new ::simb::MCParticle[nElements];
3414  }
3415  // Wrapper around operator delete
3416  static void delete_simbcLcLMCParticle(void *p) {
3417  delete ((::simb::MCParticle*)p);
3418  }
3419  static void deleteArray_simbcLcLMCParticle(void *p) {
3420  delete [] ((::simb::MCParticle*)p);
3421  }
3422  static void destruct_simbcLcLMCParticle(void *p) {
3423  typedef ::simb::MCParticle current_t;
3424  ((current_t*)p)->~current_t();
3425  }
3426 } // end of namespace ROOT for class ::simb::MCParticle
3427 
3428 namespace ROOT {
3429  // Wrappers around operator new
3430  static void *new_simbcLcLMCNeutrino(void *p) {
3431  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::simb::MCNeutrino : new ::simb::MCNeutrino;
3432  }
3433  static void *newArray_simbcLcLMCNeutrino(Long_t nElements, void *p) {
3434  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::simb::MCNeutrino[nElements] : new ::simb::MCNeutrino[nElements];
3435  }
3436  // Wrapper around operator delete
3437  static void delete_simbcLcLMCNeutrino(void *p) {
3438  delete ((::simb::MCNeutrino*)p);
3439  }
3440  static void deleteArray_simbcLcLMCNeutrino(void *p) {
3441  delete [] ((::simb::MCNeutrino*)p);
3442  }
3443  static void destruct_simbcLcLMCNeutrino(void *p) {
3444  typedef ::simb::MCNeutrino current_t;
3445  ((current_t*)p)->~current_t();
3446  }
3447 } // end of namespace ROOT for class ::simb::MCNeutrino
3448 
3449 namespace ROOT {
3450  // Wrappers around operator new
3451  static void *new_simbcLcLMCTruth(void *p) {
3452  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::simb::MCTruth : new ::simb::MCTruth;
3453  }
3454  static void *newArray_simbcLcLMCTruth(Long_t nElements, void *p) {
3455  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::simb::MCTruth[nElements] : new ::simb::MCTruth[nElements];
3456  }
3457  // Wrapper around operator delete
3458  static void delete_simbcLcLMCTruth(void *p) {
3459  delete ((::simb::MCTruth*)p);
3460  }
3461  static void deleteArray_simbcLcLMCTruth(void *p) {
3462  delete [] ((::simb::MCTruth*)p);
3463  }
3464  static void destruct_simbcLcLMCTruth(void *p) {
3465  typedef ::simb::MCTruth current_t;
3466  ((current_t*)p)->~current_t();
3467  }
3468 } // end of namespace ROOT for class ::simb::MCTruth
3469 
3470 namespace ROOT {
3471  // Wrappers around operator new
3472  static void *new_simbcLcLMCFlux(void *p) {
3473  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::simb::MCFlux : new ::simb::MCFlux;
3474  }
3475  static void *newArray_simbcLcLMCFlux(Long_t nElements, void *p) {
3476  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::simb::MCFlux[nElements] : new ::simb::MCFlux[nElements];
3477  }
3478  // Wrapper around operator delete
3479  static void delete_simbcLcLMCFlux(void *p) {
3480  delete ((::simb::MCFlux*)p);
3481  }
3482  static void deleteArray_simbcLcLMCFlux(void *p) {
3483  delete [] ((::simb::MCFlux*)p);
3484  }
3485  static void destruct_simbcLcLMCFlux(void *p) {
3486  typedef ::simb::MCFlux current_t;
3487  ((current_t*)p)->~current_t();
3488  }
3489 } // end of namespace ROOT for class ::simb::MCFlux
3490 
3491 namespace ROOT {
3492  // Wrappers around operator new
3493  static void *new_simbcLcLGTruth(void *p) {
3494  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::simb::GTruth : new ::simb::GTruth;
3495  }
3496  static void *newArray_simbcLcLGTruth(Long_t nElements, void *p) {
3497  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::simb::GTruth[nElements] : new ::simb::GTruth[nElements];
3498  }
3499  // Wrapper around operator delete
3500  static void delete_simbcLcLGTruth(void *p) {
3501  delete ((::simb::GTruth*)p);
3502  }
3503  static void deleteArray_simbcLcLGTruth(void *p) {
3504  delete [] ((::simb::GTruth*)p);
3505  }
3506  static void destruct_simbcLcLGTruth(void *p) {
3507  typedef ::simb::GTruth current_t;
3508  ((current_t*)p)->~current_t();
3509  }
3510 } // end of namespace ROOT for class ::simb::GTruth
3511 
3512 namespace ROOT {
3513  static TClass *vectorlEsimbcLcLMCTruthgR_Dictionary();
3514  static void vectorlEsimbcLcLMCTruthgR_TClassManip(TClass*);
3515  static void *new_vectorlEsimbcLcLMCTruthgR(void *p = 0);
3516  static void *newArray_vectorlEsimbcLcLMCTruthgR(Long_t size, void *p);
3517  static void delete_vectorlEsimbcLcLMCTruthgR(void *p);
3518  static void deleteArray_vectorlEsimbcLcLMCTruthgR(void *p);
3519  static void destruct_vectorlEsimbcLcLMCTruthgR(void *p);
3520 
3521  // Function generating the singleton type initializer
3522  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<simb::MCTruth>*)
3523  {
3524  vector<simb::MCTruth> *ptr = 0;
3525  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<simb::MCTruth>));
3526  static ::ROOT::TGenericClassInfo
3527  instance("vector<simb::MCTruth>", -2, "vector", 447,
3528  typeid(vector<simb::MCTruth>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3529  &vectorlEsimbcLcLMCTruthgR_Dictionary, isa_proxy, 4,
3530  sizeof(vector<simb::MCTruth>) );
3531  instance.SetNew(&new_vectorlEsimbcLcLMCTruthgR);
3532  instance.SetNewArray(&newArray_vectorlEsimbcLcLMCTruthgR);
3533  instance.SetDelete(&delete_vectorlEsimbcLcLMCTruthgR);
3534  instance.SetDeleteArray(&deleteArray_vectorlEsimbcLcLMCTruthgR);
3535  instance.SetDestructor(&destruct_vectorlEsimbcLcLMCTruthgR);
3536  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<simb::MCTruth> >()));
3537  return &instance;
3538  }
3539  // Static variable to force the class initialization
3540  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<simb::MCTruth>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3541 
3542  // Dictionary for non-ClassDef classes
3544  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<simb::MCTruth>*)0x0)->GetClass();
3546  return theClass;
3547  }
3548 
3550  }
3551 
3552 } // end of namespace ROOT
3553 
3554 namespace ROOT {
3555  // Wrappers around operator new
3556  static void *new_vectorlEsimbcLcLMCTruthgR(void *p) {
3557  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<simb::MCTruth> : new vector<simb::MCTruth>;
3558  }
3559  static void *newArray_vectorlEsimbcLcLMCTruthgR(Long_t nElements, void *p) {
3560  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<simb::MCTruth>[nElements] : new vector<simb::MCTruth>[nElements];
3561  }
3562  // Wrapper around operator delete
3564  delete ((vector<simb::MCTruth>*)p);
3565  }
3567  delete [] ((vector<simb::MCTruth>*)p);
3568  }
3570  typedef vector<simb::MCTruth> current_t;
3571  ((current_t*)p)->~current_t();
3572  }
3573 } // end of namespace ROOT for class vector<simb::MCTruth>
3574 
3575 namespace ROOT {
3577  static void vectorlEsimbcLcLMCTrajectorygR_TClassManip(TClass*);
3578  static void *new_vectorlEsimbcLcLMCTrajectorygR(void *p = 0);
3579  static void *newArray_vectorlEsimbcLcLMCTrajectorygR(Long_t size, void *p);
3580  static void delete_vectorlEsimbcLcLMCTrajectorygR(void *p);
3581  static void deleteArray_vectorlEsimbcLcLMCTrajectorygR(void *p);
3582  static void destruct_vectorlEsimbcLcLMCTrajectorygR(void *p);
3583 
3584  // Function generating the singleton type initializer
3585  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<simb::MCTrajectory>*)
3586  {
3587  vector<simb::MCTrajectory> *ptr = 0;
3588  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<simb::MCTrajectory>));
3589  static ::ROOT::TGenericClassInfo
3590  instance("vector<simb::MCTrajectory>", -2, "vector", 447,
3591  typeid(vector<simb::MCTrajectory>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3592  &vectorlEsimbcLcLMCTrajectorygR_Dictionary, isa_proxy, 4,
3593  sizeof(vector<simb::MCTrajectory>) );
3594  instance.SetNew(&new_vectorlEsimbcLcLMCTrajectorygR);
3595  instance.SetNewArray(&newArray_vectorlEsimbcLcLMCTrajectorygR);
3596  instance.SetDelete(&delete_vectorlEsimbcLcLMCTrajectorygR);
3597  instance.SetDeleteArray(&deleteArray_vectorlEsimbcLcLMCTrajectorygR);
3598  instance.SetDestructor(&destruct_vectorlEsimbcLcLMCTrajectorygR);
3599  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<simb::MCTrajectory> >()));
3600  return &instance;
3601  }
3602  // Static variable to force the class initialization
3603  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<simb::MCTrajectory>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3604 
3605  // Dictionary for non-ClassDef classes
3607  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<simb::MCTrajectory>*)0x0)->GetClass();
3609  return theClass;
3610  }
3611 
3613  }
3614 
3615 } // end of namespace ROOT
3616 
3617 namespace ROOT {
3618  // Wrappers around operator new
3620  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<simb::MCTrajectory> : new vector<simb::MCTrajectory>;
3621  }
3622  static void *newArray_vectorlEsimbcLcLMCTrajectorygR(Long_t nElements, void *p) {
3623  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<simb::MCTrajectory>[nElements] : new vector<simb::MCTrajectory>[nElements];
3624  }
3625  // Wrapper around operator delete
3627  delete ((vector<simb::MCTrajectory>*)p);
3628  }
3630  delete [] ((vector<simb::MCTrajectory>*)p);
3631  }
3633  typedef vector<simb::MCTrajectory> current_t;
3634  ((current_t*)p)->~current_t();
3635  }
3636 } // end of namespace ROOT for class vector<simb::MCTrajectory>
3637 
3638 namespace ROOT {
3639  static TClass *vectorlEsimbcLcLMCParticlegR_Dictionary();
3640  static void vectorlEsimbcLcLMCParticlegR_TClassManip(TClass*);
3641  static void *new_vectorlEsimbcLcLMCParticlegR(void *p = 0);
3642  static void *newArray_vectorlEsimbcLcLMCParticlegR(Long_t size, void *p);
3643  static void delete_vectorlEsimbcLcLMCParticlegR(void *p);
3644  static void deleteArray_vectorlEsimbcLcLMCParticlegR(void *p);
3645  static void destruct_vectorlEsimbcLcLMCParticlegR(void *p);
3646 
3647  // Function generating the singleton type initializer
3648  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<simb::MCParticle>*)
3649  {
3650  vector<simb::MCParticle> *ptr = 0;
3651  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<simb::MCParticle>));
3652  static ::ROOT::TGenericClassInfo
3653  instance("vector<simb::MCParticle>", -2, "vector", 447,
3654  typeid(vector<simb::MCParticle>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3655  &vectorlEsimbcLcLMCParticlegR_Dictionary, isa_proxy, 4,
3656  sizeof(vector<simb::MCParticle>) );
3657  instance.SetNew(&new_vectorlEsimbcLcLMCParticlegR);
3658  instance.SetNewArray(&newArray_vectorlEsimbcLcLMCParticlegR);
3659  instance.SetDelete(&delete_vectorlEsimbcLcLMCParticlegR);
3660  instance.SetDeleteArray(&deleteArray_vectorlEsimbcLcLMCParticlegR);
3661  instance.SetDestructor(&destruct_vectorlEsimbcLcLMCParticlegR);
3662  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<simb::MCParticle> >()));
3663  return &instance;
3664  }
3665  // Static variable to force the class initialization
3666  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<simb::MCParticle>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3667 
3668  // Dictionary for non-ClassDef classes
3670  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<simb::MCParticle>*)0x0)->GetClass();
3672  return theClass;
3673  }
3674 
3676  }
3677 
3678 } // end of namespace ROOT
3679 
3680 namespace ROOT {
3681  // Wrappers around operator new
3682  static void *new_vectorlEsimbcLcLMCParticlegR(void *p) {
3683  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<simb::MCParticle> : new vector<simb::MCParticle>;
3684  }
3685  static void *newArray_vectorlEsimbcLcLMCParticlegR(Long_t nElements, void *p) {
3686  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<simb::MCParticle>[nElements] : new vector<simb::MCParticle>[nElements];
3687  }
3688  // Wrapper around operator delete
3690  delete ((vector<simb::MCParticle>*)p);
3691  }
3693  delete [] ((vector<simb::MCParticle>*)p);
3694  }
3696  typedef vector<simb::MCParticle> current_t;
3697  ((current_t*)p)->~current_t();
3698  }
3699 } // end of namespace ROOT for class vector<simb::MCParticle>
3700 
3701 namespace ROOT {
3702  static TClass *vectorlEsimbcLcLMCNeutrinogR_Dictionary();
3703  static void vectorlEsimbcLcLMCNeutrinogR_TClassManip(TClass*);
3704  static void *new_vectorlEsimbcLcLMCNeutrinogR(void *p = 0);
3705  static void *newArray_vectorlEsimbcLcLMCNeutrinogR(Long_t size, void *p);
3706  static void delete_vectorlEsimbcLcLMCNeutrinogR(void *p);
3707  static void deleteArray_vectorlEsimbcLcLMCNeutrinogR(void *p);
3708  static void destruct_vectorlEsimbcLcLMCNeutrinogR(void *p);
3709 
3710  // Function generating the singleton type initializer
3711  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<simb::MCNeutrino>*)
3712  {
3713  vector<simb::MCNeutrino> *ptr = 0;
3714  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<simb::MCNeutrino>));
3715  static ::ROOT::TGenericClassInfo
3716  instance("vector<simb::MCNeutrino>", -2, "vector", 447,
3717  typeid(vector<simb::MCNeutrino>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3718  &vectorlEsimbcLcLMCNeutrinogR_Dictionary, isa_proxy, 4,
3719  sizeof(vector<simb::MCNeutrino>) );
3720  instance.SetNew(&new_vectorlEsimbcLcLMCNeutrinogR);
3721  instance.SetNewArray(&newArray_vectorlEsimbcLcLMCNeutrinogR);
3722  instance.SetDelete(&delete_vectorlEsimbcLcLMCNeutrinogR);
3723  instance.SetDeleteArray(&deleteArray_vectorlEsimbcLcLMCNeutrinogR);
3724  instance.SetDestructor(&destruct_vectorlEsimbcLcLMCNeutrinogR);
3725  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<simb::MCNeutrino> >()));
3726  return &instance;
3727  }
3728  // Static variable to force the class initialization
3729  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<simb::MCNeutrino>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3730 
3731  // Dictionary for non-ClassDef classes
3733  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<simb::MCNeutrino>*)0x0)->GetClass();
3735  return theClass;
3736  }
3737 
3739  }
3740 
3741 } // end of namespace ROOT
3742 
3743 namespace ROOT {
3744  // Wrappers around operator new
3745  static void *new_vectorlEsimbcLcLMCNeutrinogR(void *p) {
3746  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<simb::MCNeutrino> : new vector<simb::MCNeutrino>;
3747  }
3748  static void *newArray_vectorlEsimbcLcLMCNeutrinogR(Long_t nElements, void *p) {
3749  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<simb::MCNeutrino>[nElements] : new vector<simb::MCNeutrino>[nElements];
3750  }
3751  // Wrapper around operator delete
3753  delete ((vector<simb::MCNeutrino>*)p);
3754  }
3756  delete [] ((vector<simb::MCNeutrino>*)p);
3757  }
3759  typedef vector<simb::MCNeutrino> current_t;
3760  ((current_t*)p)->~current_t();
3761  }
3762 } // end of namespace ROOT for class vector<simb::MCNeutrino>
3763 
3764 namespace ROOT {
3765  static TClass *vectorlEsimbcLcLMCFluxgR_Dictionary();
3766  static void vectorlEsimbcLcLMCFluxgR_TClassManip(TClass*);
3767  static void *new_vectorlEsimbcLcLMCFluxgR(void *p = 0);
3768  static void *newArray_vectorlEsimbcLcLMCFluxgR(Long_t size, void *p);
3769  static void delete_vectorlEsimbcLcLMCFluxgR(void *p);
3770  static void deleteArray_vectorlEsimbcLcLMCFluxgR(void *p);
3771  static void destruct_vectorlEsimbcLcLMCFluxgR(void *p);
3772 
3773  // Function generating the singleton type initializer
3774  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<simb::MCFlux>*)
3775  {
3776  vector<simb::MCFlux> *ptr = 0;
3777  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<simb::MCFlux>));
3778  static ::ROOT::TGenericClassInfo
3779  instance("vector<simb::MCFlux>", -2, "vector", 447,
3780  typeid(vector<simb::MCFlux>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3781  &vectorlEsimbcLcLMCFluxgR_Dictionary, isa_proxy, 4,
3782  sizeof(vector<simb::MCFlux>) );
3783  instance.SetNew(&new_vectorlEsimbcLcLMCFluxgR);
3784  instance.SetNewArray(&newArray_vectorlEsimbcLcLMCFluxgR);
3785  instance.SetDelete(&delete_vectorlEsimbcLcLMCFluxgR);
3786  instance.SetDeleteArray(&deleteArray_vectorlEsimbcLcLMCFluxgR);
3787  instance.SetDestructor(&destruct_vectorlEsimbcLcLMCFluxgR);
3788  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<simb::MCFlux> >()));
3789  return &instance;
3790  }
3791  // Static variable to force the class initialization
3792  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<simb::MCFlux>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3793 
3794  // Dictionary for non-ClassDef classes
3796  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<simb::MCFlux>*)0x0)->GetClass();
3798  return theClass;
3799  }
3800 
3802  }
3803 
3804 } // end of namespace ROOT
3805 
3806 namespace ROOT {
3807  // Wrappers around operator new
3808  static void *new_vectorlEsimbcLcLMCFluxgR(void *p) {
3809  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<simb::MCFlux> : new vector<simb::MCFlux>;
3810  }
3811  static void *newArray_vectorlEsimbcLcLMCFluxgR(Long_t nElements, void *p) {
3812  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<simb::MCFlux>[nElements] : new vector<simb::MCFlux>[nElements];
3813  }
3814  // Wrapper around operator delete
3815  static void delete_vectorlEsimbcLcLMCFluxgR(void *p) {
3816  delete ((vector<simb::MCFlux>*)p);
3817  }
3819  delete [] ((vector<simb::MCFlux>*)p);
3820  }
3822  typedef vector<simb::MCFlux> current_t;
3823  ((current_t*)p)->~current_t();
3824  }
3825 } // end of namespace ROOT for class vector<simb::MCFlux>
3826 
3827 namespace ROOT {
3828  static TClass *vectorlEsimbcLcLGTruthgR_Dictionary();
3829  static void vectorlEsimbcLcLGTruthgR_TClassManip(TClass*);
3830  static void *new_vectorlEsimbcLcLGTruthgR(void *p = 0);
3831  static void *newArray_vectorlEsimbcLcLGTruthgR(Long_t size, void *p);
3832  static void delete_vectorlEsimbcLcLGTruthgR(void *p);
3833  static void deleteArray_vectorlEsimbcLcLGTruthgR(void *p);
3834  static void destruct_vectorlEsimbcLcLGTruthgR(void *p);
3835 
3836  // Function generating the singleton type initializer
3837  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<simb::GTruth>*)
3838  {
3839  vector<simb::GTruth> *ptr = 0;
3840  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<simb::GTruth>));
3841  static ::ROOT::TGenericClassInfo
3842  instance("vector<simb::GTruth>", -2, "vector", 447,
3843  typeid(vector<simb::GTruth>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3844  &vectorlEsimbcLcLGTruthgR_Dictionary, isa_proxy, 4,
3845  sizeof(vector<simb::GTruth>) );
3846  instance.SetNew(&new_vectorlEsimbcLcLGTruthgR);
3847  instance.SetNewArray(&newArray_vectorlEsimbcLcLGTruthgR);
3848  instance.SetDelete(&delete_vectorlEsimbcLcLGTruthgR);
3849  instance.SetDeleteArray(&deleteArray_vectorlEsimbcLcLGTruthgR);
3850  instance.SetDestructor(&destruct_vectorlEsimbcLcLGTruthgR);
3851  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<simb::GTruth> >()));
3852  return &instance;
3853  }
3854  // Static variable to force the class initialization
3855  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<simb::GTruth>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3856 
3857  // Dictionary for non-ClassDef classes
3859  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<simb::GTruth>*)0x0)->GetClass();
3861  return theClass;
3862  }
3863 
3865  }
3866 
3867 } // end of namespace ROOT
3868 
3869 namespace ROOT {
3870  // Wrappers around operator new
3871  static void *new_vectorlEsimbcLcLGTruthgR(void *p) {
3872  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<simb::GTruth> : new vector<simb::GTruth>;
3873  }
3874  static void *newArray_vectorlEsimbcLcLGTruthgR(Long_t nElements, void *p) {
3875  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<simb::GTruth>[nElements] : new vector<simb::GTruth>[nElements];
3876  }
3877  // Wrapper around operator delete
3878  static void delete_vectorlEsimbcLcLGTruthgR(void *p) {
3879  delete ((vector<simb::GTruth>*)p);
3880  }
3882  delete [] ((vector<simb::GTruth>*)p);
3883  }
3885  typedef vector<simb::GTruth> current_t;
3886  ((current_t*)p)->~current_t();
3887  }
3888 } // end of namespace ROOT for class vector<simb::GTruth>
3889 
3890 namespace ROOT {
3898 
3899  // Function generating the singleton type initializer
3900  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<pair<unsigned long,unsigned char> >*)
3901  {
3902  vector<pair<unsigned long,unsigned char> > *ptr = 0;
3903  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<pair<unsigned long,unsigned char> >));
3904  static ::ROOT::TGenericClassInfo
3905  instance("vector<pair<unsigned long,unsigned char> >", -2, "vector", 447,
3906  typeid(vector<pair<unsigned long,unsigned char> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3907  &vectorlEpairlEunsignedsPlongcOunsignedsPchargRsPgR_Dictionary, isa_proxy, 4,
3908  sizeof(vector<pair<unsigned long,unsigned char> >) );
3909  instance.SetNew(&new_vectorlEpairlEunsignedsPlongcOunsignedsPchargRsPgR);
3910  instance.SetNewArray(&newArray_vectorlEpairlEunsignedsPlongcOunsignedsPchargRsPgR);
3911  instance.SetDelete(&delete_vectorlEpairlEunsignedsPlongcOunsignedsPchargRsPgR);
3912  instance.SetDeleteArray(&deleteArray_vectorlEpairlEunsignedsPlongcOunsignedsPchargRsPgR);
3913  instance.SetDestructor(&destruct_vectorlEpairlEunsignedsPlongcOunsignedsPchargRsPgR);
3914  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<pair<unsigned long,unsigned char> > >()));
3915  return &instance;
3916  }
3917  // Static variable to force the class initialization
3918  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<pair<unsigned long,unsigned char> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3919 
3920  // Dictionary for non-ClassDef classes
3922  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<pair<unsigned long,unsigned char> >*)0x0)->GetClass();
3924  return theClass;
3925  }
3926 
3928  }
3929 
3930 } // end of namespace ROOT
3931 
3932 namespace ROOT {
3933  // Wrappers around operator new
3935  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<pair<unsigned long,unsigned char> > : new vector<pair<unsigned long,unsigned char> >;
3936  }
3937  static void *newArray_vectorlEpairlEunsignedsPlongcOunsignedsPchargRsPgR(Long_t nElements, void *p) {
3938  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<pair<unsigned long,unsigned char> >[nElements] : new vector<pair<unsigned long,unsigned char> >[nElements];
3939  }
3940  // Wrapper around operator delete
3942  delete ((vector<pair<unsigned long,unsigned char> >*)p);
3943  }
3945  delete [] ((vector<pair<unsigned long,unsigned char> >*)p);
3946  }
3948  typedef vector<pair<unsigned long,unsigned char> > current_t;
3949  ((current_t*)p)->~current_t();
3950  }
3951 } // end of namespace ROOT for class vector<pair<unsigned long,unsigned char> >
3952 
3953 namespace ROOT {
3961 
3962  // Function generating the singleton type initializer
3963  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<pair<TLorentzVector,TLorentzVector> >*)
3964  {
3965  vector<pair<TLorentzVector,TLorentzVector> > *ptr = 0;
3966  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<pair<TLorentzVector,TLorentzVector> >));
3967  static ::ROOT::TGenericClassInfo
3968  instance("vector<pair<TLorentzVector,TLorentzVector> >", -2, "vector", 447,
3969  typeid(vector<pair<TLorentzVector,TLorentzVector> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
3970  &vectorlEpairlETLorentzVectorcOTLorentzVectorgRsPgR_Dictionary, isa_proxy, 4,
3971  sizeof(vector<pair<TLorentzVector,TLorentzVector> >) );
3972  instance.SetNew(&new_vectorlEpairlETLorentzVectorcOTLorentzVectorgRsPgR);
3973  instance.SetNewArray(&newArray_vectorlEpairlETLorentzVectorcOTLorentzVectorgRsPgR);
3974  instance.SetDelete(&delete_vectorlEpairlETLorentzVectorcOTLorentzVectorgRsPgR);
3975  instance.SetDeleteArray(&deleteArray_vectorlEpairlETLorentzVectorcOTLorentzVectorgRsPgR);
3976  instance.SetDestructor(&destruct_vectorlEpairlETLorentzVectorcOTLorentzVectorgRsPgR);
3977  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<pair<TLorentzVector,TLorentzVector> > >()));
3978  return &instance;
3979  }
3980  // Static variable to force the class initialization
3981  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<pair<TLorentzVector,TLorentzVector> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
3982 
3983  // Dictionary for non-ClassDef classes
3985  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<pair<TLorentzVector,TLorentzVector> >*)0x0)->GetClass();
3987  return theClass;
3988  }
3989 
3991  }
3992 
3993 } // end of namespace ROOT
3994 
3995 namespace ROOT {
3996  // Wrappers around operator new
3998  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<pair<TLorentzVector,TLorentzVector> > : new vector<pair<TLorentzVector,TLorentzVector> >;
3999  }
4000  static void *newArray_vectorlEpairlETLorentzVectorcOTLorentzVectorgRsPgR(Long_t nElements, void *p) {
4001  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<pair<TLorentzVector,TLorentzVector> >[nElements] : new vector<pair<TLorentzVector,TLorentzVector> >[nElements];
4002  }
4003  // Wrapper around operator delete
4005  delete ((vector<pair<TLorentzVector,TLorentzVector> >*)p);
4006  }
4008  delete [] ((vector<pair<TLorentzVector,TLorentzVector> >*)p);
4009  }
4011  typedef vector<pair<TLorentzVector,TLorentzVector> > current_t;
4012  ((current_t*)p)->~current_t();
4013  }
4014 } // end of namespace ROOT for class vector<pair<TLorentzVector,TLorentzVector> >
4015 
4016 namespace ROOT {
4017  static TClass *vectorlEbsimcLcLNuChoicegR_Dictionary();
4018  static void vectorlEbsimcLcLNuChoicegR_TClassManip(TClass*);
4019  static void *new_vectorlEbsimcLcLNuChoicegR(void *p = 0);
4020  static void *newArray_vectorlEbsimcLcLNuChoicegR(Long_t size, void *p);
4021  static void delete_vectorlEbsimcLcLNuChoicegR(void *p);
4022  static void deleteArray_vectorlEbsimcLcLNuChoicegR(void *p);
4023  static void destruct_vectorlEbsimcLcLNuChoicegR(void *p);
4024 
4025  // Function generating the singleton type initializer
4026  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<bsim::NuChoice>*)
4027  {
4028  vector<bsim::NuChoice> *ptr = 0;
4029  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<bsim::NuChoice>));
4030  static ::ROOT::TGenericClassInfo
4031  instance("vector<bsim::NuChoice>", -2, "vector", 447,
4032  typeid(vector<bsim::NuChoice>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4033  &vectorlEbsimcLcLNuChoicegR_Dictionary, isa_proxy, 4,
4034  sizeof(vector<bsim::NuChoice>) );
4035  instance.SetNew(&new_vectorlEbsimcLcLNuChoicegR);
4036  instance.SetNewArray(&newArray_vectorlEbsimcLcLNuChoicegR);
4037  instance.SetDelete(&delete_vectorlEbsimcLcLNuChoicegR);
4038  instance.SetDeleteArray(&deleteArray_vectorlEbsimcLcLNuChoicegR);
4039  instance.SetDestructor(&destruct_vectorlEbsimcLcLNuChoicegR);
4040  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<bsim::NuChoice> >()));
4041  return &instance;
4042  }
4043  // Static variable to force the class initialization
4044  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<bsim::NuChoice>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4045 
4046  // Dictionary for non-ClassDef classes
4048  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<bsim::NuChoice>*)0x0)->GetClass();
4050  return theClass;
4051  }
4052 
4054  }
4055 
4056 } // end of namespace ROOT
4057 
4058 namespace ROOT {
4059  // Wrappers around operator new
4060  static void *new_vectorlEbsimcLcLNuChoicegR(void *p) {
4061  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<bsim::NuChoice> : new vector<bsim::NuChoice>;
4062  }
4063  static void *newArray_vectorlEbsimcLcLNuChoicegR(Long_t nElements, void *p) {
4064  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<bsim::NuChoice>[nElements] : new vector<bsim::NuChoice>[nElements];
4065  }
4066  // Wrapper around operator delete
4068  delete ((vector<bsim::NuChoice>*)p);
4069  }
4071  delete [] ((vector<bsim::NuChoice>*)p);
4072  }
4074  typedef vector<bsim::NuChoice> current_t;
4075  ((current_t*)p)->~current_t();
4076  }
4077 } // end of namespace ROOT for class vector<bsim::NuChoice>
4078 
4079 namespace ROOT {
4080  static TClass *vectorlEbsimcLcLDk2NugR_Dictionary();
4081  static void vectorlEbsimcLcLDk2NugR_TClassManip(TClass*);
4082  static void *new_vectorlEbsimcLcLDk2NugR(void *p = 0);
4083  static void *newArray_vectorlEbsimcLcLDk2NugR(Long_t size, void *p);
4084  static void delete_vectorlEbsimcLcLDk2NugR(void *p);
4085  static void deleteArray_vectorlEbsimcLcLDk2NugR(void *p);
4086  static void destruct_vectorlEbsimcLcLDk2NugR(void *p);
4087 
4088  // Function generating the singleton type initializer
4089  static TGenericClassInfo *GenerateInitInstanceLocal(const vector<bsim::Dk2Nu>*)
4090  {
4091  vector<bsim::Dk2Nu> *ptr = 0;
4092  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<bsim::Dk2Nu>));
4093  static ::ROOT::TGenericClassInfo
4094  instance("vector<bsim::Dk2Nu>", -2, "vector", 447,
4095  typeid(vector<bsim::Dk2Nu>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4096  &vectorlEbsimcLcLDk2NugR_Dictionary, isa_proxy, 4,
4097  sizeof(vector<bsim::Dk2Nu>) );
4098  instance.SetNew(&new_vectorlEbsimcLcLDk2NugR);
4099  instance.SetNewArray(&newArray_vectorlEbsimcLcLDk2NugR);
4100  instance.SetDelete(&delete_vectorlEbsimcLcLDk2NugR);
4101  instance.SetDeleteArray(&deleteArray_vectorlEbsimcLcLDk2NugR);
4102  instance.SetDestructor(&destruct_vectorlEbsimcLcLDk2NugR);
4103  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<bsim::Dk2Nu> >()));
4104  return &instance;
4105  }
4106  // Static variable to force the class initialization
4107  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<bsim::Dk2Nu>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4108 
4109  // Dictionary for non-ClassDef classes
4111  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<bsim::Dk2Nu>*)0x0)->GetClass();
4113  return theClass;
4114  }
4115 
4117  }
4118 
4119 } // end of namespace ROOT
4120 
4121 namespace ROOT {
4122  // Wrappers around operator new
4123  static void *new_vectorlEbsimcLcLDk2NugR(void *p) {
4124  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<bsim::Dk2Nu> : new vector<bsim::Dk2Nu>;
4125  }
4126  static void *newArray_vectorlEbsimcLcLDk2NugR(Long_t nElements, void *p) {
4127  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<bsim::Dk2Nu>[nElements] : new vector<bsim::Dk2Nu>[nElements];
4128  }
4129  // Wrapper around operator delete
4130  static void delete_vectorlEbsimcLcLDk2NugR(void *p) {
4131  delete ((vector<bsim::Dk2Nu>*)p);
4132  }
4134  delete [] ((vector<bsim::Dk2Nu>*)p);
4135  }
4137  typedef vector<bsim::Dk2Nu> current_t;
4138  ((current_t*)p)->~current_t();
4139  }
4140 } // end of namespace ROOT for class vector<bsim::Dk2Nu>
4141 
4142 namespace ROOT {
4144  static void unordered_maplEstringcOstringgR_TClassManip(TClass*);
4145  static void *new_unordered_maplEstringcOstringgR(void *p = 0);
4146  static void *newArray_unordered_maplEstringcOstringgR(Long_t size, void *p);
4147  static void delete_unordered_maplEstringcOstringgR(void *p);
4148  static void deleteArray_unordered_maplEstringcOstringgR(void *p);
4149  static void destruct_unordered_maplEstringcOstringgR(void *p);
4150 
4151  // Function generating the singleton type initializer
4152  static TGenericClassInfo *GenerateInitInstanceLocal(const unordered_map<string,string>*)
4153  {
4154  unordered_map<string,string> *ptr = 0;
4155  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(unordered_map<string,string>));
4156  static ::ROOT::TGenericClassInfo
4157  instance("unordered_map<string,string>", -2, "unordered_map", 743,
4158  typeid(unordered_map<string,string>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4159  &unordered_maplEstringcOstringgR_Dictionary, isa_proxy, 4,
4160  sizeof(unordered_map<string,string>) );
4161  instance.SetNew(&new_unordered_maplEstringcOstringgR);
4162  instance.SetNewArray(&newArray_unordered_maplEstringcOstringgR);
4163  instance.SetDelete(&delete_unordered_maplEstringcOstringgR);
4164  instance.SetDeleteArray(&deleteArray_unordered_maplEstringcOstringgR);
4165  instance.SetDestructor(&destruct_unordered_maplEstringcOstringgR);
4166  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< unordered_map<string,string> >()));
4167  return &instance;
4168  }
4169  // Static variable to force the class initialization
4170  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const unordered_map<string,string>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4171 
4172  // Dictionary for non-ClassDef classes
4174  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const unordered_map<string,string>*)0x0)->GetClass();
4176  return theClass;
4177  }
4178 
4180  }
4181 
4182 } // end of namespace ROOT
4183 
4184 namespace ROOT {
4185  // Wrappers around operator new
4187  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) unordered_map<string,string> : new unordered_map<string,string>;
4188  }
4189  static void *newArray_unordered_maplEstringcOstringgR(Long_t nElements, void *p) {
4190  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) unordered_map<string,string>[nElements] : new unordered_map<string,string>[nElements];
4191  }
4192  // Wrapper around operator delete
4194  delete ((unordered_map<string,string>*)p);
4195  }
4197  delete [] ((unordered_map<string,string>*)p);
4198  }
4200  typedef unordered_map<string,string> current_t;
4201  ((current_t*)p)->~current_t();
4202  }
4203 } // end of namespace ROOT for class unordered_map<string,string>
4204 
4205 namespace ROOT {
4206  static TClass *setlEintgR_Dictionary();
4207  static void setlEintgR_TClassManip(TClass*);
4208  static void *new_setlEintgR(void *p = 0);
4209  static void *newArray_setlEintgR(Long_t size, void *p);
4210  static void delete_setlEintgR(void *p);
4211  static void deleteArray_setlEintgR(void *p);
4212  static void destruct_setlEintgR(void *p);
4213 
4214  // Function generating the singleton type initializer
4215  static TGenericClassInfo *GenerateInitInstanceLocal(const set<int>*)
4216  {
4217  set<int> *ptr = 0;
4218  static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(set<int>));
4219  static ::ROOT::TGenericClassInfo
4220  instance("set<int>", -2, "set", 400,
4221  typeid(set<int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
4222  &setlEintgR_Dictionary, isa_proxy, 4,
4223  sizeof(set<int>) );
4224  instance.SetNew(&new_setlEintgR);
4225  instance.SetNewArray(&newArray_setlEintgR);
4226  instance.SetDelete(&delete_setlEintgR);
4227  instance.SetDeleteArray(&deleteArray_setlEintgR);
4228  instance.SetDestructor(&destruct_setlEintgR);
4229  instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Insert< set<int> >()));
4230  return &instance;
4231  }
4232  // Static variable to force the class initialization
4233  static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const set<int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
4234 
4235  // Dictionary for non-ClassDef classes
4236  static TClass *setlEintgR_Dictionary() {
4237  TClass* theClass =::ROOT::GenerateInitInstanceLocal((const set<int>*)0x0)->GetClass();
4238  setlEintgR_TClassManip(theClass);
4239  return theClass;
4240  }
4241 
4242  static void setlEintgR_TClassManip(TClass* ){
4243  }
4244 
4245 } // end of namespace ROOT
4246 
4247 namespace ROOT {
4248  // Wrappers around operator new
4249  static void *new_setlEintgR(void *p) {
4250  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) set<int> : new set<int>;
4251  }
4252  static void *newArray_setlEintgR(Long_t nElements, void *p) {
4253  return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) set<int>[nElements] : new set<int>[nElements];
4254  }
4255  // Wrapper around operator delete
4256  static void delete_setlEintgR(void *p) {
4257  delete ((set<int>*)p);
4258  }
4259  static void deleteArray_setlEintgR(void *p) {
4260  delete [] ((set<int>*)p);
4261  }
4262  static void destruct_setlEintgR(void *p) {
4263  typedef set<int> current_t;
4264  ((current_t*)p)->~current_t();
4265  }
4266 } // end of namespace ROOT for class set<int>
4267 
4268 namespace {
4269  void TriggerDictionaryInitialization_libnusimdata_SimulationBase_dict_Impl() {
4270  static const char* headers[] = {
4271 0 };
4272  static const char* includePaths[] = {
4273 0
4274  };
4275  static const char* fwdDeclCode = R"DICTFWDDCLS(
4276 #line 1 "libnusimdata_SimulationBase_dict dictionary forward declarations' payload"
4277 #pragma clang diagnostic ignored "-Wkeyword-compat"
4278 #pragma clang diagnostic ignored "-Wignored-attributes"
4279 #pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
4280 extern int __Cling_Autoloading_Map;
4281 class __attribute__((annotate("$clingAutoload$TLorentzVector.h"))) __attribute__((annotate("$clingAutoload$nusimdata/SimulationBase/MCTruth.h"))) TLorentzVector;
4282 namespace std{inline namespace __1{template <class T1, class T2> struct __attribute__((annotate("$clingAutoload$boost/container/detail/std_fwd.hpp"))) __attribute__((annotate("$clingAutoload$canvas/Persistency/Common/Wrapper.h"))) pair;
4283 }}
4284 namespace bsim{class __attribute__((annotate("$clingAutoload$dk2nu/tree/NuChoice.h"))) NuChoice;}
4285 namespace art{template <typename T> class __attribute__((annotate("$clingAutoload$canvas/Persistency/Common/Ptr.h"))) __attribute__((annotate("$clingAutoload$canvas/Persistency/Common/Wrapper.h"))) Ptr;
4286 }
4287 namespace simb{class __attribute__((annotate("$clingAutoload$nusimdata/SimulationBase/MCTruth.h"))) MCTruth;}
4288 namespace bsim{class __attribute__((annotate("$clingAutoload$dk2nu/tree/dk2nu.h"))) Dk2Nu;}
4289 namespace simb{class __attribute__((annotate("$clingAutoload$nusimdata/SimulationBase/MCParticle.h"))) __attribute__((annotate("$clingAutoload$nusimdata/SimulationBase/MCTruth.h"))) MCParticle;}
4290 namespace simb{class __attribute__((annotate("$clingAutoload$nusimdata/SimulationBase/GTruth.h"))) GTruth;}
4291 namespace simb{class __attribute__((annotate("$clingAutoload$nusimdata/SimulationBase/MCFlux.h"))) MCFlux;}
4292 namespace std{inline namespace __1{template <class _Tp> class __attribute__((annotate("$clingAutoload$iosfwd"))) __attribute__((annotate("$clingAutoload$string"))) allocator;
4293 }}
4294 namespace simb{class __attribute__((annotate("$clingAutoload$nusimdata/SimulationBase/MCNeutrino.h"))) __attribute__((annotate("$clingAutoload$nusimdata/SimulationBase/MCTruth.h"))) MCNeutrino;}
4295 namespace simb{class __attribute__((annotate("$clingAutoload$nusimdata/SimulationBase/MCTrajectory.h"))) __attribute__((annotate("$clingAutoload$nusimdata/SimulationBase/MCTruth.h"))) MCTrajectory;}
4296 namespace art{template <typename L, typename R, typename D = void> class __attribute__((annotate("$clingAutoload$canvas/Persistency/Common/Assns.h"))) Assns;
4297 }
4298 namespace art{template <typename T> class __attribute__((annotate("$clingAutoload$canvas/Persistency/Common/Wrapper.h"))) Wrapper;
4299 }
4300 namespace std{inline namespace __1{template <class T = void> struct __attribute__((annotate("$clingAutoload$boost/container/detail/std_fwd.hpp"))) __attribute__((annotate("$clingAutoload$canvas/Persistency/Common/Wrapper.h"))) less;
4301 }}
4302 namespace std{inline namespace __1{template <class _CharT> struct __attribute__((annotate("$clingAutoload$__string"))) __attribute__((annotate("$clingAutoload$string"))) char_traits;
4303 }}
4304 namespace simb{struct __attribute__((annotate("$clingAutoload$nusimdata/SimulationBase/MCGeneratorInfo.h"))) MCGeneratorInfo;}
4305 )DICTFWDDCLS";
4306  static const char* payloadCode = R"DICTPAYLOAD(
4307 #line 1 "libnusimdata_SimulationBase_dict dictionary payload"
4308 
4309 #ifndef G__VECTOR_HAS_CLASS_ITERATOR
4310  #define G__VECTOR_HAS_CLASS_ITERATOR 1
4311 #endif
4312 
4313 #define _BACKWARD_BACKWARD_WARNING_H
4314 //
4315 // Build a dictionary.
4316 //
4317 // $Id: classes.h,v 1.9 2012-10-29 16:42:11 brebel Exp $
4318 // $Author: brebel $
4319 // $Date: 2012-10-29 16:42:11 $
4320 //
4321 // Original author Rob Kutschke, modified by klg, rhatcher
4322 
4323 #include "canvas/Persistency/Common/Wrapper.h"
4324 #include "canvas/Persistency/Common/Assns.h"
4325 
4326 // nusimdata includes
4327 #include "nusimdata/SimulationBase/MCGeneratorInfo.h"
4328 #include "nusimdata/SimulationBase/MCTruth.h"
4329 #include "nusimdata/SimulationBase/MCTrajectory.h"
4330 #include "nusimdata/SimulationBase/MCParticle.h"
4331 #include "nusimdata/SimulationBase/MCNeutrino.h"
4332 #include "nusimdata/SimulationBase/MCFlux.h"
4333 #include "nusimdata/SimulationBase/GTruth.h"
4334 #include <TLorentzVector.h>
4335 
4336 // MCTruth/MCFlux will be associated with these
4337 #include "dk2nu/tree/dk2nu.h"
4338 #include "dk2nu/tree/NuChoice.h"
4339 
4340 
4341 #undef _BACKWARD_BACKWARD_WARNING_H
4342 )DICTPAYLOAD";
4343  static const char* classesHeaders[]={
4344 "art::Assns<bsim::Dk2Nu,simb::MCTruth,void>", payloadCode, "@",
4345 "art::Assns<bsim::NuChoice,simb::MCTruth,void>", payloadCode, "@",
4346 "art::Assns<simb::GTruth,simb::MCTruth,void>", payloadCode, "@",
4347 "art::Assns<simb::MCFlux,simb::MCTruth,void>", payloadCode, "@",
4348 "art::Assns<simb::MCParticle,simb::MCTruth,void>", payloadCode, "@",
4349 "art::Assns<simb::MCTruth,bsim::Dk2Nu,void>", payloadCode, "@",
4350 "art::Assns<simb::MCTruth,bsim::NuChoice,void>", payloadCode, "@",
4351 "art::Assns<simb::MCTruth,simb::GTruth,void>", payloadCode, "@",
4352 "art::Assns<simb::MCTruth,simb::MCFlux,void>", payloadCode, "@",
4353 "art::Assns<simb::MCTruth,simb::MCParticle,void>", payloadCode, "@",
4354 "art::Ptr<bsim::Dk2Nu>", payloadCode, "@",
4355 "art::Ptr<bsim::NuChoice>", payloadCode, "@",
4356 "art::Ptr<simb::GTruth>", payloadCode, "@",
4357 "art::Ptr<simb::MCFlux>", payloadCode, "@",
4358 "art::Ptr<simb::MCParticle>", payloadCode, "@",
4359 "art::Ptr<simb::MCTruth>", payloadCode, "@",
4360 "art::Wrapper<art::Assns<bsim::Dk2Nu,simb::MCTruth,void> >", payloadCode, "@",
4361 "art::Wrapper<art::Assns<bsim::NuChoice,simb::MCTruth,void> >", payloadCode, "@",
4362 "art::Wrapper<art::Assns<simb::GTruth,simb::MCTruth,void> >", payloadCode, "@",
4363 "art::Wrapper<art::Assns<simb::MCFlux,simb::MCTruth,void> >", payloadCode, "@",
4364 "art::Wrapper<art::Assns<simb::MCParticle,simb::MCTruth,void> >", payloadCode, "@",
4365 "art::Wrapper<art::Assns<simb::MCTruth,bsim::Dk2Nu,void> >", payloadCode, "@",
4366 "art::Wrapper<art::Assns<simb::MCTruth,bsim::NuChoice,void> >", payloadCode, "@",
4367 "art::Wrapper<art::Assns<simb::MCTruth,simb::GTruth,void> >", payloadCode, "@",
4368 "art::Wrapper<art::Assns<simb::MCTruth,simb::MCFlux,void> >", payloadCode, "@",
4369 "art::Wrapper<art::Assns<simb::MCTruth,simb::MCParticle,void> >", payloadCode, "@",
4370 "art::Wrapper<std::vector<bsim::Dk2Nu> >", payloadCode, "@",
4371 "art::Wrapper<std::vector<bsim::NuChoice> >", payloadCode, "@",
4372 "art::Wrapper<std::vector<simb::GTruth> >", payloadCode, "@",
4373 "art::Wrapper<std::vector<simb::MCFlux> >", payloadCode, "@",
4374 "art::Wrapper<std::vector<simb::MCNeutrino> >", payloadCode, "@",
4375 "art::Wrapper<std::vector<simb::MCParticle> >", payloadCode, "@",
4376 "art::Wrapper<std::vector<simb::MCTrajectory> >", payloadCode, "@",
4377 "art::Wrapper<std::vector<simb::MCTruth> >", payloadCode, "@",
4378 "art::Wrapper<vector<bsim::Dk2Nu> >", payloadCode, "@",
4379 "art::Wrapper<vector<bsim::NuChoice> >", payloadCode, "@",
4380 "art::Wrapper<vector<simb::GTruth> >", payloadCode, "@",
4381 "art::Wrapper<vector<simb::MCFlux> >", payloadCode, "@",
4382 "art::Wrapper<vector<simb::MCNeutrino> >", payloadCode, "@",
4383 "art::Wrapper<vector<simb::MCParticle> >", payloadCode, "@",
4384 "art::Wrapper<vector<simb::MCTrajectory> >", payloadCode, "@",
4385 "art::Wrapper<vector<simb::MCTruth> >", payloadCode, "@",
4386 "simb::GTruth", payloadCode, "@",
4387 "simb::MCFlux", payloadCode, "@",
4388 "simb::MCGeneratorInfo", payloadCode, "@",
4389 "simb::MCNeutrino", payloadCode, "@",
4390 "simb::MCParticle", payloadCode, "@",
4391 "simb::MCTrajectory", payloadCode, "@",
4392 "simb::MCTruth", payloadCode, "@",
4393 "simb::_ev_generator", payloadCode, "@",
4394 "simb::_ev_origin", payloadCode, "@",
4395 "simb::curr_type_", payloadCode, "@",
4396 "simb::flux_code_", payloadCode, "@",
4397 "simb::int_type_", payloadCode, "@",
4398 nullptr};
4399 
4400  static bool isInitialized = false;
4401  if (!isInitialized) {
4402  TROOT::RegisterModule("libnusimdata_SimulationBase_dict",
4403  headers, includePaths, payloadCode, fwdDeclCode,
4404  TriggerDictionaryInitialization_libnusimdata_SimulationBase_dict_Impl, {}, classesHeaders, /*has no C++ module*/