Bug Summary

File:libraries/HDDM/hddm_s.c
Location:line 8850, column 10
Description:Value stored to 'pbuf' is never read

Annotated Source Code

1/*
2 * hddm_s.c - DO NOT EDIT THIS FILE
3 *
4 * This file was generated automatically by hddm-c from the file
5 * event.xml
6
7 * This c file contains the i/o interface to the c structures
8 * described in the data model (from event.xml).
9 *
10 * The hddm data model tool set was written by
11 * Richard Jones, University of Connecticut.
12 *
13 * For more information see the following web site
14 *
15 * http://zeus.phys.uconn.edu/halld/datamodel/doc
16 */
17
18int hddm_s_nullTarget=0;
19#define HDDM_NULL(void*)&hddm_s_nullTarget (void*)&hddm_s_nullTarget
20
21#include "hddm_s.h"
22
23
24s_HDDM_t* make_s_HDDM()
25{
26 int size = sizeof(s_HDDM_t);
27 s_HDDM_t* p = (s_HDDM_t*)MALLOC(size,"s_HDDM_t")malloc(size);
28 p->physicsEvents = (s_PhysicsEvents_t*)&hddm_s_nullTarget;
29 return p;
30}
31
32s_PhysicsEvents_t* make_s_PhysicsEvents(int n)
33{
34 int i;
35 int rep = (n > 1) ? n-1 : 0;
36 int size = sizeof(s_PhysicsEvents_t) + rep * sizeof(s_PhysicsEvent_t);
37 s_PhysicsEvents_t* p = (s_PhysicsEvents_t*)MALLOC(size,"s_PhysicsEvents_t")malloc(size);
38 p->mult = 0;
39 for (i=0; i<n; i++) {
40 s_PhysicsEvent_t* pp = &p->in[i];
41 pp->eventNo = 0;
42 pp->runNo = 0;
43 pp->reactions = (s_Reactions_t*)&hddm_s_nullTarget;
44 pp->hitView = (s_HitView_t*)&hddm_s_nullTarget;
45 pp->reconView = (s_ReconView_t*)&hddm_s_nullTarget;
46 }
47 return p;
48}
49
50s_Reactions_t* make_s_Reactions(int n)
51{
52 int i;
53 int rep = (n > 1) ? n-1 : 0;
54 int size = sizeof(s_Reactions_t) + rep * sizeof(s_Reaction_t);
55 s_Reactions_t* p = (s_Reactions_t*)MALLOC(size,"s_Reactions_t")malloc(size);
56 p->mult = 0;
57 for (i=0; i<n; i++) {
58 s_Reaction_t* pp = &p->in[i];
59 pp->type = 0;
60 pp->weight = 0;
61 pp->beam = (s_Beam_t*)&hddm_s_nullTarget;
62 pp->target = (s_Target_t*)&hddm_s_nullTarget;
63 pp->vertices = (s_Vertices_t*)&hddm_s_nullTarget;
64 pp->random = (s_Random_t*)&hddm_s_nullTarget;
65 }
66 return p;
67}
68
69s_Beam_t* make_s_Beam()
70{
71 int size = sizeof(s_Beam_t);
72 s_Beam_t* p = (s_Beam_t*)MALLOC(size,"s_Beam_t")malloc(size);
73 p->type = (Particle_t)0;
74 p->momentum = (s_Momentum_t*)&hddm_s_nullTarget;
75 p->properties = (s_Properties_t*)&hddm_s_nullTarget;
76 return p;
77}
78
79s_Momentum_t* make_s_Momentum()
80{
81 int size = sizeof(s_Momentum_t);
82 s_Momentum_t* p = (s_Momentum_t*)MALLOC(size,"s_Momentum_t")malloc(size);
83 p->E = 0;
84 p->px = 0;
85 p->py = 0;
86 p->pz = 0;
87 return p;
88}
89
90s_Properties_t* make_s_Properties()
91{
92 int size = sizeof(s_Properties_t);
93 s_Properties_t* p = (s_Properties_t*)MALLOC(size,"s_Properties_t")malloc(size);
94 p->charge = 0;
95 p->mass = 0;
96 return p;
97}
98
99s_Target_t* make_s_Target()
100{
101 int size = sizeof(s_Target_t);
102 s_Target_t* p = (s_Target_t*)MALLOC(size,"s_Target_t")malloc(size);
103 p->type = (Particle_t)0;
104 p->momentum = (s_Momentum_t*)&hddm_s_nullTarget;
105 p->properties = (s_Properties_t*)&hddm_s_nullTarget;
106 return p;
107}
108
109s_Vertices_t* make_s_Vertices(int n)
110{
111 int i;
112 int rep = (n > 1) ? n-1 : 0;
113 int size = sizeof(s_Vertices_t) + rep * sizeof(s_Vertex_t);
114 s_Vertices_t* p = (s_Vertices_t*)MALLOC(size,"s_Vertices_t")malloc(size);
115 p->mult = 0;
116 for (i=0; i<n; i++) {
117 s_Vertex_t* pp = &p->in[i];
118 pp->products = (s_Products_t*)&hddm_s_nullTarget;
119 pp->origin = (s_Origin_t*)&hddm_s_nullTarget;
120 }
121 return p;
122}
123
124s_Products_t* make_s_Products(int n)
125{
126 int i;
127 int rep = (n > 1) ? n-1 : 0;
128 int size = sizeof(s_Products_t) + rep * sizeof(s_Product_t);
129 s_Products_t* p = (s_Products_t*)MALLOC(size,"s_Products_t")malloc(size);
130 p->mult = 0;
131 for (i=0; i<n; i++) {
132 s_Product_t* pp = &p->in[i];
133 pp->decayVertex = 0;
134 pp->id = 0;
135 pp->mech = 0;
136 pp->parentid = 0;
137 pp->pdgtype = 0;
138 pp->type = (Particle_t)0;
139 pp->momentum = (s_Momentum_t*)&hddm_s_nullTarget;
140 pp->properties = (s_Properties_t*)&hddm_s_nullTarget;
141 }
142 return p;
143}
144
145s_Origin_t* make_s_Origin()
146{
147 int size = sizeof(s_Origin_t);
148 s_Origin_t* p = (s_Origin_t*)MALLOC(size,"s_Origin_t")malloc(size);
149 p->t = 0;
150 p->vx = 0;
151 p->vy = 0;
152 p->vz = 0;
153 return p;
154}
155
156s_Random_t* make_s_Random()
157{
158 int size = sizeof(s_Random_t);
159 s_Random_t* p = (s_Random_t*)MALLOC(size,"s_Random_t")malloc(size);
160 p->seed1 = 0;
161 p->seed2 = 0;
162 p->seed_mcsmear1 = 0;
163 p->seed_mcsmear2 = 0;
164 p->seed_mcsmear3 = 0;
165 return p;
166}
167
168s_HitView_t* make_s_HitView()
169{
170 int size = sizeof(s_HitView_t);
171 s_HitView_t* p = (s_HitView_t*)MALLOC(size,"s_HitView_t")malloc(size);
172 p->centralDC = (s_CentralDC_t*)&hddm_s_nullTarget;
173 p->forwardDC = (s_ForwardDC_t*)&hddm_s_nullTarget;
174 p->startCntr = (s_StartCntr_t*)&hddm_s_nullTarget;
175 p->barrelEMcal = (s_BarrelEMcal_t*)&hddm_s_nullTarget;
176 p->gapEMcal = (s_GapEMcal_t*)&hddm_s_nullTarget;
177 p->Cerenkov = (s_Cerenkov_t*)&hddm_s_nullTarget;
178 p->forwardTOF = (s_ForwardTOF_t*)&hddm_s_nullTarget;
179 p->forwardEMcal = (s_ForwardEMcal_t*)&hddm_s_nullTarget;
180 p->ComptonEMcal = (s_ComptonEMcal_t*)&hddm_s_nullTarget;
181 p->upstreamEMveto = (s_UpstreamEMveto_t*)&hddm_s_nullTarget;
182 p->tagger = (s_Tagger_t*)&hddm_s_nullTarget;
183 p->mcTrajectory = (s_McTrajectory_t*)&hddm_s_nullTarget;
184 return p;
185}
186
187s_CentralDC_t* make_s_CentralDC()
188{
189 int size = sizeof(s_CentralDC_t);
190 s_CentralDC_t* p = (s_CentralDC_t*)MALLOC(size,"s_CentralDC_t")malloc(size);
191 p->cdcStraws = (s_CdcStraws_t*)&hddm_s_nullTarget;
192 p->cdcTruthPoints = (s_CdcTruthPoints_t*)&hddm_s_nullTarget;
193 return p;
194}
195
196s_CdcStraws_t* make_s_CdcStraws(int n)
197{
198 int i;
199 int rep = (n > 1) ? n-1 : 0;
200 int size = sizeof(s_CdcStraws_t) + rep * sizeof(s_CdcStraw_t);
201 s_CdcStraws_t* p = (s_CdcStraws_t*)MALLOC(size,"s_CdcStraws_t")malloc(size);
202 p->mult = 0;
203 for (i=0; i<n; i++) {
204 s_CdcStraw_t* pp = &p->in[i];
205 pp->ring = 0;
206 pp->straw = 0;
207 pp->cdcStrawHits = (s_CdcStrawHits_t*)&hddm_s_nullTarget;
208 pp->cdcStrawTruthHits = (s_CdcStrawTruthHits_t*)&hddm_s_nullTarget;
209 }
210 return p;
211}
212
213s_CdcStrawHits_t* make_s_CdcStrawHits(int n)
214{
215 int i;
216 int rep = (n > 1) ? n-1 : 0;
217 int size = sizeof(s_CdcStrawHits_t) + rep * sizeof(s_CdcStrawHit_t);
218 s_CdcStrawHits_t* p = (s_CdcStrawHits_t*)MALLOC(size,"s_CdcStrawHits_t")malloc(size);
219 p->mult = 0;
220 for (i=0; i<n; i++) {
221 s_CdcStrawHit_t* pp = &p->in[i];
222 pp->d = 0;
223 pp->dE = 0;
224 pp->itrack = 0;
225 pp->ptype = 0;
226 pp->t = 0;
227 }
228 return p;
229}
230
231s_CdcStrawTruthHits_t* make_s_CdcStrawTruthHits(int n)
232{
233 int i;
234 int rep = (n > 1) ? n-1 : 0;
235 int size = sizeof(s_CdcStrawTruthHits_t) + rep * sizeof(s_CdcStrawTruthHit_t);
236 s_CdcStrawTruthHits_t* p = (s_CdcStrawTruthHits_t*)MALLOC(size,"s_CdcStrawTruthHits_t")malloc(size);
237 p->mult = 0;
238 for (i=0; i<n; i++) {
239 s_CdcStrawTruthHit_t* pp = &p->in[i];
240 pp->d = 0;
241 pp->dE = 0;
242 pp->itrack = 0;
243 pp->ptype = 0;
244 pp->t = 0;
245 }
246 return p;
247}
248
249s_CdcTruthPoints_t* make_s_CdcTruthPoints(int n)
250{
251 int i;
252 int rep = (n > 1) ? n-1 : 0;
253 int size = sizeof(s_CdcTruthPoints_t) + rep * sizeof(s_CdcTruthPoint_t);
254 s_CdcTruthPoints_t* p = (s_CdcTruthPoints_t*)MALLOC(size,"s_CdcTruthPoints_t")malloc(size);
255 p->mult = 0;
256 for (i=0; i<n; i++) {
257 s_CdcTruthPoint_t* pp = &p->in[i];
258 pp->dEdx = 0;
259 pp->dradius = 0;
260 pp->phi = 0;
261 pp->primary = 0;
262 pp->ptype = 0;
263 pp->px = 0;
264 pp->py = 0;
265 pp->pz = 0;
266 pp->r = 0;
267 pp->t = 0;
268 pp->track = 0;
269 pp->z = 0;
270 }
271 return p;
272}
273
274s_ForwardDC_t* make_s_ForwardDC()
275{
276 int size = sizeof(s_ForwardDC_t);
277 s_ForwardDC_t* p = (s_ForwardDC_t*)MALLOC(size,"s_ForwardDC_t")malloc(size);
278 p->fdcChambers = (s_FdcChambers_t*)&hddm_s_nullTarget;
279 return p;
280}
281
282s_FdcChambers_t* make_s_FdcChambers(int n)
283{
284 int i;
285 int rep = (n > 1) ? n-1 : 0;
286 int size = sizeof(s_FdcChambers_t) + rep * sizeof(s_FdcChamber_t);
287 s_FdcChambers_t* p = (s_FdcChambers_t*)MALLOC(size,"s_FdcChambers_t")malloc(size);
288 p->mult = 0;
289 for (i=0; i<n; i++) {
290 s_FdcChamber_t* pp = &p->in[i];
291 pp->layer = 0;
292 pp->module = 0;
293 pp->fdcAnodeWires = (s_FdcAnodeWires_t*)&hddm_s_nullTarget;
294 pp->fdcCathodeStrips = (s_FdcCathodeStrips_t*)&hddm_s_nullTarget;
295 pp->fdcTruthPoints = (s_FdcTruthPoints_t*)&hddm_s_nullTarget;
296 }
297 return p;
298}
299
300s_FdcAnodeWires_t* make_s_FdcAnodeWires(int n)
301{
302 int i;
303 int rep = (n > 1) ? n-1 : 0;
304 int size = sizeof(s_FdcAnodeWires_t) + rep * sizeof(s_FdcAnodeWire_t);
305 s_FdcAnodeWires_t* p = (s_FdcAnodeWires_t*)MALLOC(size,"s_FdcAnodeWires_t")malloc(size);
306 p->mult = 0;
307 for (i=0; i<n; i++) {
308 s_FdcAnodeWire_t* pp = &p->in[i];
309 pp->wire = 0;
310 pp->fdcAnodeHits = (s_FdcAnodeHits_t*)&hddm_s_nullTarget;
311 pp->fdcAnodeTruthHits = (s_FdcAnodeTruthHits_t*)&hddm_s_nullTarget;
312 }
313 return p;
314}
315
316s_FdcAnodeHits_t* make_s_FdcAnodeHits(int n)
317{
318 int i;
319 int rep = (n > 1) ? n-1 : 0;
320 int size = sizeof(s_FdcAnodeHits_t) + rep * sizeof(s_FdcAnodeHit_t);
321 s_FdcAnodeHits_t* p = (s_FdcAnodeHits_t*)MALLOC(size,"s_FdcAnodeHits_t")malloc(size);
322 p->mult = 0;
323 for (i=0; i<n; i++) {
324 s_FdcAnodeHit_t* pp = &p->in[i];
325 pp->d = 0;
326 pp->dE = 0;
327 pp->itrack = 0;
328 pp->ptype = 0;
329 pp->t = 0;
330 }
331 return p;
332}
333
334s_FdcAnodeTruthHits_t* make_s_FdcAnodeTruthHits(int n)
335{
336 int i;
337 int rep = (n > 1) ? n-1 : 0;
338 int size = sizeof(s_FdcAnodeTruthHits_t) + rep * sizeof(s_FdcAnodeTruthHit_t);
339 s_FdcAnodeTruthHits_t* p = (s_FdcAnodeTruthHits_t*)MALLOC(size,"s_FdcAnodeTruthHits_t")malloc(size);
340 p->mult = 0;
341 for (i=0; i<n; i++) {
342 s_FdcAnodeTruthHit_t* pp = &p->in[i];
343 pp->d = 0;
344 pp->dE = 0;
345 pp->itrack = 0;
346 pp->ptype = 0;
347 pp->t = 0;
348 pp->t_unsmeared = 0;
349 }
350 return p;
351}
352
353s_FdcCathodeStrips_t* make_s_FdcCathodeStrips(int n)
354{
355 int i;
356 int rep = (n > 1) ? n-1 : 0;
357 int size = sizeof(s_FdcCathodeStrips_t) + rep * sizeof(s_FdcCathodeStrip_t);
358 s_FdcCathodeStrips_t* p = (s_FdcCathodeStrips_t*)MALLOC(size,"s_FdcCathodeStrips_t")malloc(size);
359 p->mult = 0;
360 for (i=0; i<n; i++) {
361 s_FdcCathodeStrip_t* pp = &p->in[i];
362 pp->plane = 0;
363 pp->strip = 0;
364 pp->fdcCathodeHits = (s_FdcCathodeHits_t*)&hddm_s_nullTarget;
365 pp->fdcCathodeTruthHits = (s_FdcCathodeTruthHits_t*)&hddm_s_nullTarget;
366 }
367 return p;
368}
369
370s_FdcCathodeHits_t* make_s_FdcCathodeHits(int n)
371{
372 int i;
373 int rep = (n > 1) ? n-1 : 0;
374 int size = sizeof(s_FdcCathodeHits_t) + rep * sizeof(s_FdcCathodeHit_t);
375 s_FdcCathodeHits_t* p = (s_FdcCathodeHits_t*)MALLOC(size,"s_FdcCathodeHits_t")malloc(size);
376 p->mult = 0;
377 for (i=0; i<n; i++) {
378 s_FdcCathodeHit_t* pp = &p->in[i];
379 pp->itrack = 0;
380 pp->ptype = 0;
381 pp->q = 0;
382 pp->t = 0;
383 }
384 return p;
385}
386
387s_FdcCathodeTruthHits_t* make_s_FdcCathodeTruthHits(int n)
388{
389 int i;
390 int rep = (n > 1) ? n-1 : 0;
391 int size = sizeof(s_FdcCathodeTruthHits_t) + rep * sizeof(s_FdcCathodeTruthHit_t);
392 s_FdcCathodeTruthHits_t* p = (s_FdcCathodeTruthHits_t*)MALLOC(size,"s_FdcCathodeTruthHits_t")malloc(size);
393 p->mult = 0;
394 for (i=0; i<n; i++) {
395 s_FdcCathodeTruthHit_t* pp = &p->in[i];
396 pp->itrack = 0;
397 pp->ptype = 0;
398 pp->q = 0;
399 pp->t = 0;
400 }
401 return p;
402}
403
404s_FdcTruthPoints_t* make_s_FdcTruthPoints(int n)
405{
406 int i;
407 int rep = (n > 1) ? n-1 : 0;
408 int size = sizeof(s_FdcTruthPoints_t) + rep * sizeof(s_FdcTruthPoint_t);
409 s_FdcTruthPoints_t* p = (s_FdcTruthPoints_t*)MALLOC(size,"s_FdcTruthPoints_t")malloc(size);
410 p->mult = 0;
411 for (i=0; i<n; i++) {
412 s_FdcTruthPoint_t* pp = &p->in[i];
413 pp->E = 0;
414 pp->dEdx = 0;
415 pp->dradius = 0;
416 pp->primary = 0;
417 pp->ptype = 0;
418 pp->px = 0;
419 pp->py = 0;
420 pp->pz = 0;
421 pp->t = 0;
422 pp->track = 0;
423 pp->x = 0;
424 pp->y = 0;
425 pp->z = 0;
426 }
427 return p;
428}
429
430s_StartCntr_t* make_s_StartCntr()
431{
432 int size = sizeof(s_StartCntr_t);
433 s_StartCntr_t* p = (s_StartCntr_t*)MALLOC(size,"s_StartCntr_t")malloc(size);
434 p->stcPaddles = (s_StcPaddles_t*)&hddm_s_nullTarget;
435 p->stcTruthPoints = (s_StcTruthPoints_t*)&hddm_s_nullTarget;
436 return p;
437}
438
439s_StcPaddles_t* make_s_StcPaddles(int n)
440{
441 int i;
442 int rep = (n > 1) ? n-1 : 0;
443 int size = sizeof(s_StcPaddles_t) + rep * sizeof(s_StcPaddle_t);
444 s_StcPaddles_t* p = (s_StcPaddles_t*)MALLOC(size,"s_StcPaddles_t")malloc(size);
445 p->mult = 0;
446 for (i=0; i<n; i++) {
447 s_StcPaddle_t* pp = &p->in[i];
448 pp->sector = 0;
449 pp->stcHits = (s_StcHits_t*)&hddm_s_nullTarget;
450 pp->stcTruthHits = (s_StcTruthHits_t*)&hddm_s_nullTarget;
451 }
452 return p;
453}
454
455s_StcHits_t* make_s_StcHits(int n)
456{
457 int i;
458 int rep = (n > 1) ? n-1 : 0;
459 int size = sizeof(s_StcHits_t) + rep * sizeof(s_StcHit_t);
460 s_StcHits_t* p = (s_StcHits_t*)MALLOC(size,"s_StcHits_t")malloc(size);
461 p->mult = 0;
462 for (i=0; i<n; i++) {
463 s_StcHit_t* pp = &p->in[i];
464 pp->dE = 0;
465 pp->t = 0;
466 }
467 return p;
468}
469
470s_StcTruthHits_t* make_s_StcTruthHits(int n)
471{
472 int i;
473 int rep = (n > 1) ? n-1 : 0;
474 int size = sizeof(s_StcTruthHits_t) + rep * sizeof(s_StcTruthHit_t);
475 s_StcTruthHits_t* p = (s_StcTruthHits_t*)MALLOC(size,"s_StcTruthHits_t")malloc(size);
476 p->mult = 0;
477 for (i=0; i<n; i++) {
478 s_StcTruthHit_t* pp = &p->in[i];
479 pp->dE = 0;
480 pp->t = 0;
481 }
482 return p;
483}
484
485s_StcTruthPoints_t* make_s_StcTruthPoints(int n)
486{
487 int i;
488 int rep = (n > 1) ? n-1 : 0;
489 int size = sizeof(s_StcTruthPoints_t) + rep * sizeof(s_StcTruthPoint_t);
490 s_StcTruthPoints_t* p = (s_StcTruthPoints_t*)MALLOC(size,"s_StcTruthPoints_t")malloc(size);
491 p->mult = 0;
492 for (i=0; i<n; i++) {
493 s_StcTruthPoint_t* pp = &p->in[i];
494 pp->E = 0;
495 pp->dEdx = 0;
496 pp->phi = 0;
497 pp->primary = 0;
498 pp->ptype = 0;
499 pp->px = 0;
500 pp->py = 0;
501 pp->pz = 0;
502 pp->r = 0;
503 pp->sector = 0;
504 pp->t = 0;
505 pp->track = 0;
506 pp->z = 0;
507 }
508 return p;
509}
510
511s_BarrelEMcal_t* make_s_BarrelEMcal()
512{
513 int size = sizeof(s_BarrelEMcal_t);
514 s_BarrelEMcal_t* p = (s_BarrelEMcal_t*)MALLOC(size,"s_BarrelEMcal_t")malloc(size);
515 p->bcalCells = (s_BcalCells_t*)&hddm_s_nullTarget;
516 p->bcalIncidentParticles = (s_BcalIncidentParticles_t*)&hddm_s_nullTarget;
517 p->bcalSiPMSpectrums = (s_BcalSiPMSpectrums_t*)&hddm_s_nullTarget;
518 p->bcalfADCCells = (s_BcalfADCCells_t*)&hddm_s_nullTarget;
519 p->bcalTDCHits = (s_BcalTDCHits_t*)&hddm_s_nullTarget;
520 p->bcalTruthShowers = (s_BcalTruthShowers_t*)&hddm_s_nullTarget;
521 return p;
522}
523
524s_BcalCells_t* make_s_BcalCells(int n)
525{
526 int i;
527 int rep = (n > 1) ? n-1 : 0;
528 int size = sizeof(s_BcalCells_t) + rep * sizeof(s_BcalCell_t);
529 s_BcalCells_t* p = (s_BcalCells_t*)MALLOC(size,"s_BcalCells_t")malloc(size);
530 p->mult = 0;
531 for (i=0; i<n; i++) {
532 s_BcalCell_t* pp = &p->in[i];
533 pp->layer = 0;
534 pp->module = 0;
535 pp->sector = 0;
536 pp->bcalSiPMUpHits = (s_BcalSiPMUpHits_t*)&hddm_s_nullTarget;
537 pp->bcalSiPMDownHits = (s_BcalSiPMDownHits_t*)&hddm_s_nullTarget;
538 pp->bcalHits = (s_BcalHits_t*)&hddm_s_nullTarget;
539 }
540 return p;
541}
542
543s_BcalSiPMUpHits_t* make_s_BcalSiPMUpHits(int n)
544{
545 int i;
546 int rep = (n > 1) ? n-1 : 0;
547 int size = sizeof(s_BcalSiPMUpHits_t) + rep * sizeof(s_BcalSiPMUpHit_t);
548 s_BcalSiPMUpHits_t* p = (s_BcalSiPMUpHits_t*)MALLOC(size,"s_BcalSiPMUpHits_t")malloc(size);
549 p->mult = 0;
550 for (i=0; i<n; i++) {
551 s_BcalSiPMUpHit_t* pp = &p->in[i];
552 pp->E = 0;
553 pp->t = 0;
554 }
555 return p;
556}
557
558s_BcalSiPMDownHits_t* make_s_BcalSiPMDownHits(int n)
559{
560 int i;
561 int rep = (n > 1) ? n-1 : 0;
562 int size = sizeof(s_BcalSiPMDownHits_t) + rep * sizeof(s_BcalSiPMDownHit_t);
563 s_BcalSiPMDownHits_t* p = (s_BcalSiPMDownHits_t*)MALLOC(size,"s_BcalSiPMDownHits_t")malloc(size);
564 p->mult = 0;
565 for (i=0; i<n; i++) {
566 s_BcalSiPMDownHit_t* pp = &p->in[i];
567 pp->E = 0;
568 pp->t = 0;
569 }
570 return p;
571}
572
573s_BcalHits_t* make_s_BcalHits(int n)
574{
575 int i;
576 int rep = (n > 1) ? n-1 : 0;
577 int size = sizeof(s_BcalHits_t) + rep * sizeof(s_BcalHit_t);
578 s_BcalHits_t* p = (s_BcalHits_t*)MALLOC(size,"s_BcalHits_t")malloc(size);
579 p->mult = 0;
580 for (i=0; i<n; i++) {
581 s_BcalHit_t* pp = &p->in[i];
582 pp->E = 0;
583 pp->t = 0;
584 pp->zLocal = 0;
585 }
586 return p;
587}
588
589s_BcalIncidentParticles_t* make_s_BcalIncidentParticles(int n)
590{
591 int i;
592 int rep = (n > 1) ? n-1 : 0;
593 int size = sizeof(s_BcalIncidentParticles_t) + rep * sizeof(s_BcalIncidentParticle_t);
594 s_BcalIncidentParticles_t* p = (s_BcalIncidentParticles_t*)MALLOC(size,"s_BcalIncidentParticles_t")malloc(size);
595 p->mult = 0;
596 for (i=0; i<n; i++) {
597 s_BcalIncidentParticle_t* pp = &p->in[i];
598 pp->id = 0;
599 pp->ptype = 0;
600 pp->px = 0;
601 pp->py = 0;
602 pp->pz = 0;
603 pp->x = 0;
604 pp->y = 0;
605 pp->z = 0;
606 }
607 return p;
608}
609
610s_BcalSiPMSpectrums_t* make_s_BcalSiPMSpectrums(int n)
611{
612 int i;
613 int rep = (n > 1) ? n-1 : 0;
614 int size = sizeof(s_BcalSiPMSpectrums_t) + rep * sizeof(s_BcalSiPMSpectrum_t);
615 s_BcalSiPMSpectrums_t* p = (s_BcalSiPMSpectrums_t*)MALLOC(size,"s_BcalSiPMSpectrums_t")malloc(size);
616 p->mult = 0;
617 for (i=0; i<n; i++) {
618 s_BcalSiPMSpectrum_t* pp = &p->in[i];
619 pp->Etruth = 0;
620 pp->bin_width = 0;
621 pp->end = 0;
622 pp->incident_id = 0;
623 pp->layer = 0;
624 pp->module = 0;
625 pp->sector = 0;
626 pp->tstart = 0;
627 pp->vals = (string_t)&hddm_s_nullTarget;
628 }
629 return p;
630}
631
632s_BcalfADCCells_t* make_s_BcalfADCCells(int n)
633{
634 int i;
635 int rep = (n > 1) ? n-1 : 0;
636 int size = sizeof(s_BcalfADCCells_t) + rep * sizeof(s_BcalfADCCell_t);
637 s_BcalfADCCells_t* p = (s_BcalfADCCells_t*)MALLOC(size,"s_BcalfADCCells_t")malloc(size);
638 p->mult = 0;
639 for (i=0; i<n; i++) {
640 s_BcalfADCCell_t* pp = &p->in[i];
641 pp->layer = 0;
642 pp->module = 0;
643 pp->sector = 0;
644 pp->bcalfADCUpHits = (s_BcalfADCUpHits_t*)&hddm_s_nullTarget;
645 pp->bcalfADCDownHits = (s_BcalfADCDownHits_t*)&hddm_s_nullTarget;
646 }
647 return p;
648}
649
650s_BcalfADCUpHits_t* make_s_BcalfADCUpHits(int n)
651{
652 int i;
653 int rep = (n > 1) ? n-1 : 0;
654 int size = sizeof(s_BcalfADCUpHits_t) + rep * sizeof(s_BcalfADCUpHit_t);
655 s_BcalfADCUpHits_t* p = (s_BcalfADCUpHits_t*)MALLOC(size,"s_BcalfADCUpHits_t")malloc(size);
656 p->mult = 0;
657 for (i=0; i<n; i++) {
658 s_BcalfADCUpHit_t* pp = &p->in[i];
659 pp->E = 0;
660 pp->t = 0;
661 }
662 return p;
663}
664
665s_BcalfADCDownHits_t* make_s_BcalfADCDownHits(int n)
666{
667 int i;
668 int rep = (n > 1) ? n-1 : 0;
669 int size = sizeof(s_BcalfADCDownHits_t) + rep * sizeof(s_BcalfADCDownHit_t);
670 s_BcalfADCDownHits_t* p = (s_BcalfADCDownHits_t*)MALLOC(size,"s_BcalfADCDownHits_t")malloc(size);
671 p->mult = 0;
672 for (i=0; i<n; i++) {
673 s_BcalfADCDownHit_t* pp = &p->in[i];
674 pp->E = 0;
675 pp->t = 0;
676 }
677 return p;
678}
679
680s_BcalTDCHits_t* make_s_BcalTDCHits(int n)
681{
682 int i;
683 int rep = (n > 1) ? n-1 : 0;
684 int size = sizeof(s_BcalTDCHits_t) + rep * sizeof(s_BcalTDCHit_t);
685 s_BcalTDCHits_t* p = (s_BcalTDCHits_t*)MALLOC(size,"s_BcalTDCHits_t")malloc(size);
686 p->mult = 0;
687 for (i=0; i<n; i++) {
688 s_BcalTDCHit_t* pp = &p->in[i];
689 pp->end = 0;
690 pp->layer = 0;
691 pp->module = 0;
692 pp->sector = 0;
693 pp->t = 0;
694 }
695 return p;
696}
697
698s_BcalTruthShowers_t* make_s_BcalTruthShowers(int n)
699{
700 int i;
701 int rep = (n > 1) ? n-1 : 0;
702 int size = sizeof(s_BcalTruthShowers_t) + rep * sizeof(s_BcalTruthShower_t);
703 s_BcalTruthShowers_t* p = (s_BcalTruthShowers_t*)MALLOC(size,"s_BcalTruthShowers_t")malloc(size);
704 p->mult = 0;
705 for (i=0; i<n; i++) {
706 s_BcalTruthShower_t* pp = &p->in[i];
707 pp->E = 0;
708 pp->phi = 0;
709 pp->primary = 0;
710 pp->ptype = 0;
711 pp->px = 0;
712 pp->py = 0;
713 pp->pz = 0;
714 pp->r = 0;
715 pp->t = 0;
716 pp->track = 0;
717 pp->z = 0;
718 }
719 return p;
720}
721
722s_GapEMcal_t* make_s_GapEMcal()
723{
724 int size = sizeof(s_GapEMcal_t);
725 s_GapEMcal_t* p = (s_GapEMcal_t*)MALLOC(size,"s_GapEMcal_t")malloc(size);
726 p->gcalCells = (s_GcalCells_t*)&hddm_s_nullTarget;
727 p->gcalTruthShowers = (s_GcalTruthShowers_t*)&hddm_s_nullTarget;
728 return p;
729}
730
731s_GcalCells_t* make_s_GcalCells(int n)
732{
733 int i;
734 int rep = (n > 1) ? n-1 : 0;
735 int size = sizeof(s_GcalCells_t) + rep * sizeof(s_GcalCell_t);
736 s_GcalCells_t* p = (s_GcalCells_t*)MALLOC(size,"s_GcalCells_t")malloc(size);
737 p->mult = 0;
738 for (i=0; i<n; i++) {
739 s_GcalCell_t* pp = &p->in[i];
740 pp->module = 0;
741 pp->gcalHits = (s_GcalHits_t*)&hddm_s_nullTarget;
742 }
743 return p;
744}
745
746s_GcalHits_t* make_s_GcalHits(int n)
747{
748 int i;
749 int rep = (n > 1) ? n-1 : 0;
750 int size = sizeof(s_GcalHits_t) + rep * sizeof(s_GcalHit_t);
751 s_GcalHits_t* p = (s_GcalHits_t*)MALLOC(size,"s_GcalHits_t")malloc(size);
752 p->mult = 0;
753 for (i=0; i<n; i++) {
754 s_GcalHit_t* pp = &p->in[i];
755 pp->E = 0;
756 pp->t = 0;
757 pp->zLocal = 0;
758 }
759 return p;
760}
761
762s_GcalTruthShowers_t* make_s_GcalTruthShowers(int n)
763{
764 int i;
765 int rep = (n > 1) ? n-1 : 0;
766 int size = sizeof(s_GcalTruthShowers_t) + rep * sizeof(s_GcalTruthShower_t);
767 s_GcalTruthShowers_t* p = (s_GcalTruthShowers_t*)MALLOC(size,"s_GcalTruthShowers_t")malloc(size);
768 p->mult = 0;
769 for (i=0; i<n; i++) {
770 s_GcalTruthShower_t* pp = &p->in[i];
771 pp->E = 0;
772 pp->phi = 0;
773 pp->primary = 0;
774 pp->ptype = 0;
775 pp->px = 0;
776 pp->py = 0;
777 pp->pz = 0;
778 pp->r = 0;
779 pp->t = 0;
780 pp->track = 0;
781 pp->z = 0;
782 }
783 return p;
784}
785
786s_Cerenkov_t* make_s_Cerenkov()
787{
788 int size = sizeof(s_Cerenkov_t);
789 s_Cerenkov_t* p = (s_Cerenkov_t*)MALLOC(size,"s_Cerenkov_t")malloc(size);
790 p->cereSections = (s_CereSections_t*)&hddm_s_nullTarget;
791 p->cereTruthPoints = (s_CereTruthPoints_t*)&hddm_s_nullTarget;
792 return p;
793}
794
795s_CereSections_t* make_s_CereSections(int n)
796{
797 int i;
798 int rep = (n > 1) ? n-1 : 0;
799 int size = sizeof(s_CereSections_t) + rep * sizeof(s_CereSection_t);
800 s_CereSections_t* p = (s_CereSections_t*)MALLOC(size,"s_CereSections_t")malloc(size);
801 p->mult = 0;
802 for (i=0; i<n; i++) {
803 s_CereSection_t* pp = &p->in[i];
804 pp->sector = 0;
805 pp->cereHits = (s_CereHits_t*)&hddm_s_nullTarget;
806 }
807 return p;
808}
809
810s_CereHits_t* make_s_CereHits(int n)
811{
812 int i;
813 int rep = (n > 1) ? n-1 : 0;
814 int size = sizeof(s_CereHits_t) + rep * sizeof(s_CereHit_t);
815 s_CereHits_t* p = (s_CereHits_t*)MALLOC(size,"s_CereHits_t")malloc(size);
816 p->mult = 0;
817 for (i=0; i<n; i++) {
818 s_CereHit_t* pp = &p->in[i];
819 pp->pe = 0;
820 pp->t = 0;
821 }
822 return p;
823}
824
825s_CereTruthPoints_t* make_s_CereTruthPoints(int n)
826{
827 int i;
828 int rep = (n > 1) ? n-1 : 0;
829 int size = sizeof(s_CereTruthPoints_t) + rep * sizeof(s_CereTruthPoint_t);
830 s_CereTruthPoints_t* p = (s_CereTruthPoints_t*)MALLOC(size,"s_CereTruthPoints_t")malloc(size);
831 p->mult = 0;
832 for (i=0; i<n; i++) {
833 s_CereTruthPoint_t* pp = &p->in[i];
834 pp->E = 0;
835 pp->primary = 0;
836 pp->ptype = 0;
837 pp->px = 0;
838 pp->py = 0;
839 pp->pz = 0;
840 pp->t = 0;
841 pp->track = 0;
842 pp->x = 0;
843 pp->y = 0;
844 pp->z = 0;
845 }
846 return p;
847}
848
849s_ForwardTOF_t* make_s_ForwardTOF()
850{
851 int size = sizeof(s_ForwardTOF_t);
852 s_ForwardTOF_t* p = (s_ForwardTOF_t*)MALLOC(size,"s_ForwardTOF_t")malloc(size);
853 p->ftofCounters = (s_FtofCounters_t*)&hddm_s_nullTarget;
854 p->ftofTruthPoints = (s_FtofTruthPoints_t*)&hddm_s_nullTarget;
855 return p;
856}
857
858s_FtofCounters_t* make_s_FtofCounters(int n)
859{
860 int i;
861 int rep = (n > 1) ? n-1 : 0;
862 int size = sizeof(s_FtofCounters_t) + rep * sizeof(s_FtofCounter_t);
863 s_FtofCounters_t* p = (s_FtofCounters_t*)MALLOC(size,"s_FtofCounters_t")malloc(size);
864 p->mult = 0;
865 for (i=0; i<n; i++) {
866 s_FtofCounter_t* pp = &p->in[i];
867 pp->bar = 0;
868 pp->plane = 0;
869 pp->ftofNorthTruthHits = (s_FtofNorthTruthHits_t*)&hddm_s_nullTarget;
870 pp->ftofSouthTruthHits = (s_FtofSouthTruthHits_t*)&hddm_s_nullTarget;
871 pp->ftofNorthHits = (s_FtofNorthHits_t*)&hddm_s_nullTarget;
872 pp->ftofSouthHits = (s_FtofSouthHits_t*)&hddm_s_nullTarget;
873 }
874 return p;
875}
876
877s_FtofNorthTruthHits_t* make_s_FtofNorthTruthHits(int n)
878{
879 int i;
880 int rep = (n > 1) ? n-1 : 0;
881 int size = sizeof(s_FtofNorthTruthHits_t) + rep * sizeof(s_FtofNorthTruthHit_t);
882 s_FtofNorthTruthHits_t* p = (s_FtofNorthTruthHits_t*)MALLOC(size,"s_FtofNorthTruthHits_t")malloc(size);
883 p->mult = 0;
884 for (i=0; i<n; i++) {
885 s_FtofNorthTruthHit_t* pp = &p->in[i];
886 pp->dE = 0;
887 pp->t = 0;
888 pp->ftofMCHits = (s_FtofMCHits_t*)&hddm_s_nullTarget;
889 }
890 return p;
891}
892
893s_FtofMCHits_t* make_s_FtofMCHits(int n)
894{
895 int i;
896 int rep = (n > 1) ? n-1 : 0;
897 int size = sizeof(s_FtofMCHits_t) + rep * sizeof(s_FtofMCHit_t);
898 s_FtofMCHits_t* p = (s_FtofMCHits_t*)MALLOC(size,"s_FtofMCHits_t")malloc(size);
899 p->mult = 0;
900 for (i=0; i<n; i++) {
901 s_FtofMCHit_t* pp = &p->in[i];
902 pp->E = 0;
903 pp->dist = 0;
904 pp->itrack = 0;
905 pp->ptype = 0;
906 pp->px = 0;
907 pp->py = 0;
908 pp->pz = 0;
909 pp->x = 0;
910 pp->y = 0;
911 pp->z = 0;
912 }
913 return p;
914}
915
916s_FtofSouthTruthHits_t* make_s_FtofSouthTruthHits(int n)
917{
918 int i;
919 int rep = (n > 1) ? n-1 : 0;
920 int size = sizeof(s_FtofSouthTruthHits_t) + rep * sizeof(s_FtofSouthTruthHit_t);
921 s_FtofSouthTruthHits_t* p = (s_FtofSouthTruthHits_t*)MALLOC(size,"s_FtofSouthTruthHits_t")malloc(size);
922 p->mult = 0;
923 for (i=0; i<n; i++) {
924 s_FtofSouthTruthHit_t* pp = &p->in[i];
925 pp->dE = 0;
926 pp->t = 0;
927 pp->ftofMCHits = (s_FtofMCHits_t*)&hddm_s_nullTarget;
928 }
929 return p;
930}
931
932s_FtofNorthHits_t* make_s_FtofNorthHits(int n)
933{
934 int i;
935 int rep = (n > 1) ? n-1 : 0;
936 int size = sizeof(s_FtofNorthHits_t) + rep * sizeof(s_FtofNorthHit_t);
937 s_FtofNorthHits_t* p = (s_FtofNorthHits_t*)MALLOC(size,"s_FtofNorthHits_t")malloc(size);
938 p->mult = 0;
939 for (i=0; i<n; i++) {
940 s_FtofNorthHit_t* pp = &p->in[i];
941 pp->dE = 0;
942 pp->t = 0;
943 }
944 return p;
945}
946
947s_FtofSouthHits_t* make_s_FtofSouthHits(int n)
948{
949 int i;
950 int rep = (n > 1) ? n-1 : 0;
951 int size = sizeof(s_FtofSouthHits_t) + rep * sizeof(s_FtofSouthHit_t);
952 s_FtofSouthHits_t* p = (s_FtofSouthHits_t*)MALLOC(size,"s_FtofSouthHits_t")malloc(size);
953 p->mult = 0;
954 for (i=0; i<n; i++) {
955 s_FtofSouthHit_t* pp = &p->in[i];
956 pp->dE = 0;
957 pp->t = 0;
958 }
959 return p;
960}
961
962s_FtofTruthPoints_t* make_s_FtofTruthPoints(int n)
963{
964 int i;
965 int rep = (n > 1) ? n-1 : 0;
966 int size = sizeof(s_FtofTruthPoints_t) + rep * sizeof(s_FtofTruthPoint_t);
967 s_FtofTruthPoints_t* p = (s_FtofTruthPoints_t*)MALLOC(size,"s_FtofTruthPoints_t")malloc(size);
968 p->mult = 0;
969 for (i=0; i<n; i++) {
970 s_FtofTruthPoint_t* pp = &p->in[i];
971 pp->E = 0;
972 pp->primary = 0;
973 pp->ptype = 0;
974 pp->px = 0;
975 pp->py = 0;
976 pp->pz = 0;
977 pp->t = 0;
978 pp->track = 0;
979 pp->x = 0;
980 pp->y = 0;
981 pp->z = 0;
982 }
983 return p;
984}
985
986s_ForwardEMcal_t* make_s_ForwardEMcal()
987{
988 int size = sizeof(s_ForwardEMcal_t);
989 s_ForwardEMcal_t* p = (s_ForwardEMcal_t*)MALLOC(size,"s_ForwardEMcal_t")malloc(size);
990 p->fcalBlocks = (s_FcalBlocks_t*)&hddm_s_nullTarget;
991 p->fcalTruthShowers = (s_FcalTruthShowers_t*)&hddm_s_nullTarget;
992 return p;
993}
994
995s_FcalBlocks_t* make_s_FcalBlocks(int n)
996{
997 int i;
998 int rep = (n > 1) ? n-1 : 0;
999 int size = sizeof(s_FcalBlocks_t) + rep * sizeof(s_FcalBlock_t);
1000 s_FcalBlocks_t* p = (s_FcalBlocks_t*)MALLOC(size,"s_FcalBlocks_t")malloc(size);
1001 p->mult = 0;
1002 for (i=0; i<n; i++) {
1003 s_FcalBlock_t* pp = &p->in[i];
1004 pp->column = 0;
1005 pp->row = 0;
1006 pp->fcalHits = (s_FcalHits_t*)&hddm_s_nullTarget;
1007 pp->fcalTruthHits = (s_FcalTruthHits_t*)&hddm_s_nullTarget;
1008 }
1009 return p;
1010}
1011
1012s_FcalHits_t* make_s_FcalHits(int n)
1013{
1014 int i;
1015 int rep = (n > 1) ? n-1 : 0;
1016 int size = sizeof(s_FcalHits_t) + rep * sizeof(s_FcalHit_t);
1017 s_FcalHits_t* p = (s_FcalHits_t*)MALLOC(size,"s_FcalHits_t")malloc(size);
1018 p->mult = 0;
1019 for (i=0; i<n; i++) {
1020 s_FcalHit_t* pp = &p->in[i];
1021 pp->E = 0;
1022 pp->t = 0;
1023 }
1024 return p;
1025}
1026
1027s_FcalTruthHits_t* make_s_FcalTruthHits(int n)
1028{
1029 int i;
1030 int rep = (n > 1) ? n-1 : 0;
1031 int size = sizeof(s_FcalTruthHits_t) + rep * sizeof(s_FcalTruthHit_t);
1032 s_FcalTruthHits_t* p = (s_FcalTruthHits_t*)MALLOC(size,"s_FcalTruthHits_t")malloc(size);
1033 p->mult = 0;
1034 for (i=0; i<n; i++) {
1035 s_FcalTruthHit_t* pp = &p->in[i];
1036 pp->E = 0;
1037 pp->t = 0;
1038 }
1039 return p;
1040}
1041
1042s_FcalTruthShowers_t* make_s_FcalTruthShowers(int n)
1043{
1044 int i;
1045 int rep = (n > 1) ? n-1 : 0;
1046 int size = sizeof(s_FcalTruthShowers_t) + rep * sizeof(s_FcalTruthShower_t);
1047 s_FcalTruthShowers_t* p = (s_FcalTruthShowers_t*)MALLOC(size,"s_FcalTruthShowers_t")malloc(size);
1048 p->mult = 0;
1049 for (i=0; i<n; i++) {
1050 s_FcalTruthShower_t* pp = &p->in[i];
1051 pp->E = 0;
1052 pp->primary = 0;
1053 pp->ptype = 0;
1054 pp->px = 0;
1055 pp->py = 0;
1056 pp->pz = 0;
1057 pp->t = 0;
1058 pp->track = 0;
1059 pp->x = 0;
1060 pp->y = 0;
1061 pp->z = 0;
1062 }
1063 return p;
1064}
1065
1066s_ComptonEMcal_t* make_s_ComptonEMcal()
1067{
1068 int size = sizeof(s_ComptonEMcal_t);
1069 s_ComptonEMcal_t* p = (s_ComptonEMcal_t*)MALLOC(size,"s_ComptonEMcal_t")malloc(size);
1070 p->ccalBlocks = (s_CcalBlocks_t*)&hddm_s_nullTarget;
1071 p->ccalTruthShowers = (s_CcalTruthShowers_t*)&hddm_s_nullTarget;
1072 return p;
1073}
1074
1075s_CcalBlocks_t* make_s_CcalBlocks(int n)
1076{
1077 int i;
1078 int rep = (n > 1) ? n-1 : 0;
1079 int size = sizeof(s_CcalBlocks_t) + rep * sizeof(s_CcalBlock_t);
1080 s_CcalBlocks_t* p = (s_CcalBlocks_t*)MALLOC(size,"s_CcalBlocks_t")malloc(size);
1081 p->mult = 0;
1082 for (i=0; i<n; i++) {
1083 s_CcalBlock_t* pp = &p->in[i];
1084 pp->column = 0;
1085 pp->row = 0;
1086 pp->ccalHits = (s_CcalHits_t*)&hddm_s_nullTarget;
1087 pp->ccalTruthHits = (s_CcalTruthHits_t*)&hddm_s_nullTarget;
1088 }
1089 return p;
1090}
1091
1092s_CcalHits_t* make_s_CcalHits(int n)
1093{
1094 int i;
1095 int rep = (n > 1) ? n-1 : 0;
1096 int size = sizeof(s_CcalHits_t) + rep * sizeof(s_CcalHit_t);
1097 s_CcalHits_t* p = (s_CcalHits_t*)MALLOC(size,"s_CcalHits_t")malloc(size);
1098 p->mult = 0;
1099 for (i=0; i<n; i++) {
1100 s_CcalHit_t* pp = &p->in[i];
1101 pp->E = 0;
1102 pp->t = 0;
1103 }
1104 return p;
1105}
1106
1107s_CcalTruthHits_t* make_s_CcalTruthHits(int n)
1108{
1109 int i;
1110 int rep = (n > 1) ? n-1 : 0;
1111 int size = sizeof(s_CcalTruthHits_t) + rep * sizeof(s_CcalTruthHit_t);
1112 s_CcalTruthHits_t* p = (s_CcalTruthHits_t*)MALLOC(size,"s_CcalTruthHits_t")malloc(size);
1113 p->mult = 0;
1114 for (i=0; i<n; i++) {
1115 s_CcalTruthHit_t* pp = &p->in[i];
1116 pp->E = 0;
1117 pp->t = 0;
1118 }
1119 return p;
1120}
1121
1122s_CcalTruthShowers_t* make_s_CcalTruthShowers(int n)
1123{
1124 int i;
1125 int rep = (n > 1) ? n-1 : 0;
1126 int size = sizeof(s_CcalTruthShowers_t) + rep * sizeof(s_CcalTruthShower_t);
1127 s_CcalTruthShowers_t* p = (s_CcalTruthShowers_t*)MALLOC(size,"s_CcalTruthShowers_t")malloc(size);
1128 p->mult = 0;
1129 for (i=0; i<n; i++) {
1130 s_CcalTruthShower_t* pp = &p->in[i];
1131 pp->E = 0;
1132 pp->primary = 0;
1133 pp->ptype = 0;
1134 pp->px = 0;
1135 pp->py = 0;
1136 pp->pz = 0;
1137 pp->t = 0;
1138 pp->track = 0;
1139 pp->x = 0;
1140 pp->y = 0;
1141 pp->z = 0;
1142 }
1143 return p;
1144}
1145
1146s_UpstreamEMveto_t* make_s_UpstreamEMveto()
1147{
1148 int size = sizeof(s_UpstreamEMveto_t);
1149 s_UpstreamEMveto_t* p = (s_UpstreamEMveto_t*)MALLOC(size,"s_UpstreamEMveto_t")malloc(size);
1150 p->upvPaddles = (s_UpvPaddles_t*)&hddm_s_nullTarget;
1151 p->upvTruthShowers = (s_UpvTruthShowers_t*)&hddm_s_nullTarget;
1152 return p;
1153}
1154
1155s_UpvPaddles_t* make_s_UpvPaddles(int n)
1156{
1157 int i;
1158 int rep = (n > 1) ? n-1 : 0;
1159 int size = sizeof(s_UpvPaddles_t) + rep * sizeof(s_UpvPaddle_t);
1160 s_UpvPaddles_t* p = (s_UpvPaddles_t*)MALLOC(size,"s_UpvPaddles_t")malloc(size);
1161 p->mult = 0;
1162 for (i=0; i<n; i++) {
1163 s_UpvPaddle_t* pp = &p->in[i];
1164 pp->layer = 0;
1165 pp->row = 0;
1166 pp->upvLeftHits = (s_UpvLeftHits_t*)&hddm_s_nullTarget;
1167 pp->upvRightHits = (s_UpvRightHits_t*)&hddm_s_nullTarget;
1168 }
1169 return p;
1170}
1171
1172s_UpvLeftHits_t* make_s_UpvLeftHits(int n)
1173{
1174 int i;
1175 int rep = (n > 1) ? n-1 : 0;
1176 int size = sizeof(s_UpvLeftHits_t) + rep * sizeof(s_UpvLeftHit_t);
1177 s_UpvLeftHits_t* p = (s_UpvLeftHits_t*)MALLOC(size,"s_UpvLeftHits_t")malloc(size);
1178 p->mult = 0;
1179 for (i=0; i<n; i++) {
1180 s_UpvLeftHit_t* pp = &p->in[i];
1181 pp->E = 0;
1182 pp->t = 0;
1183 }
1184 return p;
1185}
1186
1187s_UpvRightHits_t* make_s_UpvRightHits(int n)
1188{
1189 int i;
1190 int rep = (n > 1) ? n-1 : 0;
1191 int size = sizeof(s_UpvRightHits_t) + rep * sizeof(s_UpvRightHit_t);
1192 s_UpvRightHits_t* p = (s_UpvRightHits_t*)MALLOC(size,"s_UpvRightHits_t")malloc(size);
1193 p->mult = 0;
1194 for (i=0; i<n; i++) {
1195 s_UpvRightHit_t* pp = &p->in[i];
1196 pp->E = 0;
1197 pp->t = 0;
1198 }
1199 return p;
1200}
1201
1202s_UpvTruthShowers_t* make_s_UpvTruthShowers(int n)
1203{
1204 int i;
1205 int rep = (n > 1) ? n-1 : 0;
1206 int size = sizeof(s_UpvTruthShowers_t) + rep * sizeof(s_UpvTruthShower_t);
1207 s_UpvTruthShowers_t* p = (s_UpvTruthShowers_t*)MALLOC(size,"s_UpvTruthShowers_t")malloc(size);
1208 p->mult = 0;
1209 for (i=0; i<n; i++) {
1210 s_UpvTruthShower_t* pp = &p->in[i];
1211 pp->E = 0;
1212 pp->primary = 0;
1213 pp->ptype = 0;
1214 pp->px = 0;
1215 pp->py = 0;
1216 pp->pz = 0;
1217 pp->t = 0;
1218 pp->track = 0;
1219 pp->x = 0;
1220 pp->y = 0;
1221 pp->z = 0;
1222 }
1223 return p;
1224}
1225
1226s_Tagger_t* make_s_Tagger()
1227{
1228 int size = sizeof(s_Tagger_t);
1229 s_Tagger_t* p = (s_Tagger_t*)MALLOC(size,"s_Tagger_t")malloc(size);
1230 p->microChannels = (s_MicroChannels_t*)&hddm_s_nullTarget;
1231 return p;
1232}
1233
1234s_MicroChannels_t* make_s_MicroChannels(int n)
1235{
1236 int i;
1237 int rep = (n > 1) ? n-1 : 0;
1238 int size = sizeof(s_MicroChannels_t) + rep * sizeof(s_MicroChannel_t);
1239 s_MicroChannels_t* p = (s_MicroChannels_t*)MALLOC(size,"s_MicroChannels_t")malloc(size);
1240 p->mult = 0;
1241 for (i=0; i<n; i++) {
1242 s_MicroChannel_t* pp = &p->in[i];
1243 pp->E = 0;
1244 pp->column = 0;
1245 pp->row = 0;
1246 pp->taggerHits = (s_TaggerHits_t*)&hddm_s_nullTarget;
1247 }
1248 return p;
1249}
1250
1251s_TaggerHits_t* make_s_TaggerHits(int n)
1252{
1253 int i;
1254 int rep = (n > 1) ? n-1 : 0;
1255 int size = sizeof(s_TaggerHits_t) + rep * sizeof(s_TaggerHit_t);
1256 s_TaggerHits_t* p = (s_TaggerHits_t*)MALLOC(size,"s_TaggerHits_t")malloc(size);
1257 p->mult = 0;
1258 for (i=0; i<n; i++) {
1259 s_TaggerHit_t* pp = &p->in[i];
1260 pp->t = 0;
1261 }
1262 return p;
1263}
1264
1265s_McTrajectory_t* make_s_McTrajectory()
1266{
1267 int size = sizeof(s_McTrajectory_t);
1268 s_McTrajectory_t* p = (s_McTrajectory_t*)MALLOC(size,"s_McTrajectory_t")malloc(size);
1269 p->mcTrajectoryPoints = (s_McTrajectoryPoints_t*)&hddm_s_nullTarget;
1270 return p;
1271}
1272
1273s_McTrajectoryPoints_t* make_s_McTrajectoryPoints(int n)
1274{
1275 int i;
1276 int rep = (n > 1) ? n-1 : 0;
1277 int size = sizeof(s_McTrajectoryPoints_t) + rep * sizeof(s_McTrajectoryPoint_t);
1278 s_McTrajectoryPoints_t* p = (s_McTrajectoryPoints_t*)MALLOC(size,"s_McTrajectoryPoints_t")malloc(size);
1279 p->mult = 0;
1280 for (i=0; i<n; i++) {
1281 s_McTrajectoryPoint_t* pp = &p->in[i];
1282 pp->E = 0;
1283 pp->dE = 0;
1284 pp->mech = 0;
1285 pp->part = 0;
1286 pp->primary_track = 0;
1287 pp->px = 0;
1288 pp->py = 0;
1289 pp->pz = 0;
1290 pp->radlen = 0;
1291 pp->step = 0;
1292 pp->t = 0;
1293 pp->track = 0;
1294 pp->x = 0;
1295 pp->y = 0;
1296 pp->z = 0;
1297 }
1298 return p;
1299}
1300
1301s_ReconView_t* make_s_ReconView()
1302{
1303 int size = sizeof(s_ReconView_t);
1304 s_ReconView_t* p = (s_ReconView_t*)MALLOC(size,"s_ReconView_t")malloc(size);
1305 p->tracktimebaseds = (s_Tracktimebaseds_t*)&hddm_s_nullTarget;
1306 return p;
1307}
1308
1309s_Tracktimebaseds_t* make_s_Tracktimebaseds(int n)
1310{
1311 int i;
1312 int rep = (n > 1) ? n-1 : 0;
1313 int size = sizeof(s_Tracktimebaseds_t) + rep * sizeof(s_Tracktimebased_t);
1314 s_Tracktimebaseds_t* p = (s_Tracktimebaseds_t*)MALLOC(size,"s_Tracktimebaseds_t")malloc(size);
1315 p->mult = 0;
1316 for (i=0; i<n; i++) {
1317 s_Tracktimebased_t* pp = &p->in[i];
1318 pp->FOM = 0;
1319 pp->Ndof = 0;
1320 pp->candidateid = 0;
1321 pp->chisq = 0;
1322 pp->id = 0;
1323 pp->trackid = 0;
1324 pp->momentum = (s_Momentum_t*)&hddm_s_nullTarget;
1325 pp->properties = (s_Properties_t*)&hddm_s_nullTarget;
1326 pp->origin = (s_Origin_t*)&hddm_s_nullTarget;
1327 pp->errorMatrix = (s_ErrorMatrix_t*)&hddm_s_nullTarget;
1328 pp->TrackingErrorMatrix = (s_TrackingErrorMatrix_t*)&hddm_s_nullTarget;
1329 }
1330 return p;
1331}
1332
1333s_ErrorMatrix_t* make_s_ErrorMatrix()
1334{
1335 int size = sizeof(s_ErrorMatrix_t);
1336 s_ErrorMatrix_t* p = (s_ErrorMatrix_t*)MALLOC(size,"s_ErrorMatrix_t")malloc(size);
1337 p->Ncols = 0;
1338 p->Nrows = 0;
1339 p->type = (string_t)&hddm_s_nullTarget;
1340 p->vals = (string_t)&hddm_s_nullTarget;
1341 return p;
1342}
1343
1344s_TrackingErrorMatrix_t* make_s_TrackingErrorMatrix()
1345{
1346 int size = sizeof(s_TrackingErrorMatrix_t);
1347 s_TrackingErrorMatrix_t* p = (s_TrackingErrorMatrix_t*)MALLOC(size,"s_TrackingErrorMatrix_t")malloc(size);
1348 p->Ncols = 0;
1349 p->Nrows = 0;
1350 p->type = (string_t)&hddm_s_nullTarget;
1351 p->vals = (string_t)&hddm_s_nullTarget;
1352 return p;
1353}
1354
1355char HDDM_s_DocumentString[] =
1356"<HDDM class=\"s\" version=\"1.0\" xmlns=\"http://www.gluex.org/hddm\">\n"
1357" <physicsEvent eventNo=\"int\" maxOccurs=\"unbounded\" runNo=\"int\">\n"
1358" <reaction maxOccurs=\"unbounded\" minOccurs=\"0\" type=\"int\" weight=\"float\">\n"
1359" <beam minOccurs=\"0\" type=\"Particle_t\">\n"
1360" <momentum E=\"float\" px=\"float\" py=\"float\" pz=\"float\" />\n"
1361" <properties charge=\"int\" mass=\"float\" />\n"
1362" </beam>\n"
1363" <target minOccurs=\"0\" type=\"Particle_t\">\n"
1364" <momentum E=\"float\" px=\"float\" py=\"float\" pz=\"float\" />\n"
1365" <properties charge=\"int\" mass=\"float\" />\n"
1366" </target>\n"
1367" <vertex maxOccurs=\"unbounded\">\n"
1368" <product decayVertex=\"int\" id=\"int\" maxOccurs=\"unbounded\" mech=\"int\" parentid=\"int\" pdgtype=\"int\" type=\"Particle_t\">\n"
1369" <momentum E=\"float\" px=\"float\" py=\"float\" pz=\"float\" />\n"
1370" <properties charge=\"int\" mass=\"float\" minOccurs=\"0\" />\n"
1371" </product>\n"
1372" <origin t=\"float\" vx=\"float\" vy=\"float\" vz=\"float\" />\n"
1373" </vertex>\n"
1374" <random maxOccurs=\"1\" minOccurs=\"0\" seed1=\"int\" seed2=\"int\" seed_mcsmear1=\"int\" seed_mcsmear2=\"int\" seed_mcsmear3=\"int\" />\n"
1375" </reaction>\n"
1376" <hitView minOccurs=\"0\" version=\"2.0\">\n"
1377" <centralDC minOccurs=\"0\">\n"
1378" <cdcStraw maxOccurs=\"unbounded\" minOccurs=\"0\" ring=\"int\" straw=\"int\">\n"
1379" <cdcStrawHit d=\"float\" dE=\"float\" itrack=\"int\" maxOccurs=\"unbounded\" ptype=\"int\" t=\"float\" />\n"
1380" <cdcStrawTruthHit d=\"float\" dE=\"float\" itrack=\"int\" maxOccurs=\"unbounded\" ptype=\"int\" t=\"float\" />\n"
1381" </cdcStraw>\n"
1382" <cdcTruthPoint dEdx=\"float\" dradius=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" phi=\"float\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" r=\"float\" t=\"float\" track=\"int\" z=\"float\" />\n"
1383" </centralDC>\n"
1384" <forwardDC minOccurs=\"0\">\n"
1385" <fdcChamber layer=\"int\" maxOccurs=\"unbounded\" module=\"int\">\n"
1386" <fdcAnodeWire maxOccurs=\"unbounded\" minOccurs=\"0\" wire=\"int\">\n"
1387" <fdcAnodeHit d=\"float\" dE=\"float\" itrack=\"int\" maxOccurs=\"unbounded\" ptype=\"int\" t=\"float\" />\n"
1388" <fdcAnodeTruthHit d=\"float\" dE=\"float\" itrack=\"int\" maxOccurs=\"unbounded\" ptype=\"int\" t=\"float\" t_unsmeared=\"float\" />\n"
1389" </fdcAnodeWire>\n"
1390" <fdcCathodeStrip maxOccurs=\"unbounded\" minOccurs=\"0\" plane=\"int\" strip=\"int\">\n"
1391" <fdcCathodeHit itrack=\"int\" maxOccurs=\"unbounded\" ptype=\"int\" q=\"float\" t=\"float\" />\n"
1392" <fdcCathodeTruthHit itrack=\"int\" maxOccurs=\"unbounded\" ptype=\"int\" q=\"float\" t=\"float\" />\n"
1393" </fdcCathodeStrip>\n"
1394" <fdcTruthPoint E=\"float\" dEdx=\"float\" dradius=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
1395" </fdcChamber>\n"
1396" </forwardDC>\n"
1397" <startCntr minOccurs=\"0\">\n"
1398" <stcPaddle maxOccurs=\"unbounded\" minOccurs=\"0\" sector=\"int\">\n"
1399" <stcHit dE=\"float\" maxOccurs=\"unbounded\" t=\"float\" />\n"
1400" <stcTruthHit dE=\"float\" maxOccurs=\"unbounded\" t=\"float\" />\n"
1401" </stcPaddle>\n"
1402" <stcTruthPoint E=\"float\" dEdx=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" phi=\"float\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" r=\"float\" sector=\"int\" t=\"float\" track=\"int\" z=\"float\" />\n"
1403" </startCntr>\n"
1404" <barrelEMcal minOccurs=\"0\">\n"
1405" <bcalCell layer=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" module=\"int\" sector=\"int\">\n"
1406" <bcalSiPMUpHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
1407" <bcalSiPMDownHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
1408" <bcalHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" zLocal=\"float\" />\n"
1409" </bcalCell>\n"
1410" <bcalIncidentParticle id=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" x=\"float\" y=\"float\" z=\"float\" />\n"
1411" <bcalSiPMSpectrum Etruth=\"float\" bin_width=\"float\" end=\"int\" incident_id=\"int\" layer=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" module=\"int\" sector=\"int\" tstart=\"float\" vals=\"string\" />\n"
1412" <bcalfADCCell layer=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" module=\"int\" sector=\"int\">\n"
1413" <bcalfADCUpHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
1414" <bcalfADCDownHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
1415" </bcalfADCCell>\n"
1416" <bcalTDCHit end=\"int\" layer=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" module=\"int\" sector=\"int\" t=\"float\" />\n"
1417" <bcalTruthShower E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" phi=\"float\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" r=\"float\" t=\"float\" track=\"int\" z=\"float\" />\n"
1418" </barrelEMcal>\n"
1419" <gapEMcal minOccurs=\"0\">\n"
1420" <gcalCell maxOccurs=\"48\" minOccurs=\"0\" module=\"int\">\n"
1421" <gcalHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" zLocal=\"float\" />\n"
1422" </gcalCell>\n"
1423" <gcalTruthShower E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" phi=\"float\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" r=\"float\" t=\"float\" track=\"int\" z=\"float\" />\n"
1424" </gapEMcal>\n"
1425" <Cerenkov minOccurs=\"0\">\n"
1426" <cereSection maxOccurs=\"unbounded\" minOccurs=\"0\" sector=\"int\">\n"
1427" <cereHit maxOccurs=\"unbounded\" pe=\"float\" t=\"float\" />\n"
1428" </cereSection>\n"
1429" <cereTruthPoint E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
1430" </Cerenkov>\n"
1431" <forwardTOF minOccurs=\"0\">\n"
1432" <ftofCounter bar=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" plane=\"int\">\n"
1433" <ftofNorthTruthHit dE=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\">\n"
1434" <ftofMCHit E=\"float\" dist=\"float\" itrack=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" x=\"float\" y=\"float\" z=\"float\" />\n"
1435" </ftofNorthTruthHit>\n"
1436" <ftofSouthTruthHit dE=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\">\n"
1437" <ftofMCHit E=\"float\" dist=\"float\" itrack=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" x=\"float\" y=\"float\" z=\"float\" />\n"
1438" </ftofSouthTruthHit>\n"
1439" <ftofNorthHit dE=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
1440" <ftofSouthHit dE=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
1441" </ftofCounter>\n"
1442" <ftofTruthPoint E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
1443" </forwardTOF>\n"
1444" <forwardEMcal minOccurs=\"0\">\n"
1445" <fcalBlock column=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" row=\"int\">\n"
1446" <fcalHit E=\"float\" maxOccurs=\"unbounded\" t=\"float\" />\n"
1447" <fcalTruthHit E=\"float\" maxOccurs=\"unbounded\" t=\"float\" />\n"
1448" </fcalBlock>\n"
1449" <fcalTruthShower E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
1450" </forwardEMcal>\n"
1451" <ComptonEMcal minOccurs=\"0\">\n"
1452" <ccalBlock column=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" row=\"int\">\n"
1453" <ccalHit E=\"float\" maxOccurs=\"unbounded\" t=\"float\" />\n"
1454" <ccalTruthHit E=\"float\" maxOccurs=\"unbounded\" t=\"float\" />\n"
1455" </ccalBlock>\n"
1456" <ccalTruthShower E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
1457" </ComptonEMcal>\n"
1458" <upstreamEMveto minOccurs=\"0\">\n"
1459" <upvPaddle layer=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" row=\"int\">\n"
1460" <upvLeftHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
1461" <upvRightHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
1462" </upvPaddle>\n"
1463" <upvTruthShower E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
1464" </upstreamEMveto>\n"
1465" <tagger minOccurs=\"0\">\n"
1466" <microChannel E=\"float\" column=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" row=\"int\">\n"
1467" <taggerHit maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
1468" </microChannel>\n"
1469" </tagger>\n"
1470" <mcTrajectory minOccurs=\"0\">\n"
1471" <mcTrajectoryPoint E=\"float\" dE=\"float\" maxOccurs=\"unbounded\" mech=\"int\" minOccurs=\"0\" part=\"int\" primary_track=\"int\" px=\"float\" py=\"float\" pz=\"float\" radlen=\"float\" step=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
1472" </mcTrajectory>\n"
1473" </hitView>\n"
1474" <reconView minOccurs=\"0\" version=\"1.0\">\n"
1475" <tracktimebased FOM=\"float\" Ndof=\"int\" candidateid=\"int\" chisq=\"float\" id=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" trackid=\"int\">\n"
1476" <momentum E=\"float\" px=\"float\" py=\"float\" pz=\"float\" />\n"
1477" <properties charge=\"int\" mass=\"float\" />\n"
1478" <origin t=\"float\" vx=\"float\" vy=\"float\" vz=\"float\" />\n"
1479" <errorMatrix Ncols=\"int\" Nrows=\"int\" type=\"string\" vals=\"string\" />\n"
1480" <TrackingErrorMatrix Ncols=\"int\" Nrows=\"int\" type=\"string\" vals=\"string\" />\n"
1481" </tracktimebased>\n"
1482" </reconView>\n"
1483" </physicsEvent>\n"
1484"</HDDM>\n"
1485;
1486
1487#ifndef _FILE_OFFSET_BITS64
1488# define _FILE_OFFSET_BITS64 64
1489#endif
1490
1491static off_t xdr_getpos64(XDR *xdrs)
1492{
1493 if (xdrs->x_base == 0) {
1494 return ftello((FILE *)xdrs->x_private);
1495 }
1496 off_t pos = xdr_getpos(xdrs)(*(xdrs)->x_ops->x_getpostn)(xdrs);
1497 return pos;
1498}
1499
1500static bool_t xdr_setpos64(XDR *xdrs, off_t pos)
1501{
1502 if (xdrs->x_base == 0) {
1503 return ((fseeko((FILE *)xdrs->x_private, pos, 0) < 0)? FALSE(0) : TRUE(1));
1504 }
1505 return xdr_setpos(xdrs,pos)(*(xdrs)->x_ops->x_setpostn)(xdrs, pos);
1506}
1507
1508
1509static s_HDDM_t* unpack_s_HDDM(XDR* xdrs, popNode* pop)
1510{
1511 s_HDDM_t* this1 = (s_HDDM_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
1512 unsigned int size;
1513 if (! xdr_u_int(xdrs,&size))
1514 {
1515 return this1;
1516 }
1517 else if (size == 1)
1518 {
1519 fprintf(stderrstderr,"hddm error - "
1520 "compressed data found in input stream.\n"
1521 "Compression/decompression is not supported "
1522 "by the hddm c i/o interface.\n");
1523 fprintf(stderrstderr,"You must use the c++ "
1524 "interface to read this file.\n");
1525 exit(9);
1526 }
1527 else if (size > 0)
1528 {
1529 off_t start = xdr_getpos64(xdrs);
1530 this1 = make_s_HDDM();
1531 {
1532 int p;
1533 void* (*ptr) = (void**) &this1->physicsEvents;
1534 for (p = 0; p < pop->popListLength; p++)
1535 {
1536 popNode* pnode = pop->popList[p];
1537 if (pnode)
1538 {
1539 int kid = pnode->inParent;
1540 ptr[kid] = pnode->unpacker(xdrs,pnode);
1541 }
1542 else
1543 {
1544 unsigned int skip;
1545 xdr_u_int(xdrs,&skip);
1546 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
1547 }
1548 }
1549 }
1550 xdr_setpos64(xdrs,start+size);
1551 }
1552 return this1;
1553}
1554
1555static s_PhysicsEvents_t* unpack_s_PhysicsEvents(XDR* xdrs, popNode* pop)
1556{
1557 s_PhysicsEvents_t* this1 = (s_PhysicsEvents_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
1558 unsigned int size;
1559 if (! xdr_u_int(xdrs,&size))
1560 {
1561 return this1;
1562 }
1563 else if (size == 1)
1564 {
1565 fprintf(stderrstderr,"hddm error - "
1566 "compressed data found in input stream.\n"
1567 "Compression/decompression is not supported "
1568 "by the hddm c i/o interface.\n");
1569 fprintf(stderrstderr,"You must use the c++ "
1570 "interface to read this file.\n");
1571 exit(9);
1572 }
1573 else if (size > 0)
1574 {
1575 off_t start = xdr_getpos64(xdrs);
1576 int m;
1577 unsigned int mult;
1578 xdr_u_int(xdrs,&mult);
1579 this1 = make_s_PhysicsEvents(mult);
1580 this1->mult = mult;
1581 for (m = 0; m < mult; m++ )
1582 {
1583 int p;
1584 void* (*ptr) = (void**) &this1->in[m].reactions;
1585 xdr_int(xdrs,&this1->in[m].eventNo);
1586 xdr_int(xdrs,&this1->in[m].runNo);
1587 for (p = 0; p < pop->popListLength; p++)
1588 {
1589 popNode* pnode = pop->popList[p];
1590 if (pnode)
1591 {
1592 int kid = pnode->inParent;
1593 ptr[kid] = pnode->unpacker(xdrs,pnode);
1594 }
1595 else
1596 {
1597 unsigned int skip;
1598 xdr_u_int(xdrs,&skip);
1599 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
1600 }
1601 }
1602 }
1603 xdr_setpos64(xdrs,start+size);
1604 }
1605 return this1;
1606}
1607
1608static s_Reactions_t* unpack_s_Reactions(XDR* xdrs, popNode* pop)
1609{
1610 s_Reactions_t* this1 = (s_Reactions_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
1611 unsigned int size;
1612 if (! xdr_u_int(xdrs,&size))
1613 {
1614 return this1;
1615 }
1616 else if (size == 1)
1617 {
1618 fprintf(stderrstderr,"hddm error - "
1619 "compressed data found in input stream.\n"
1620 "Compression/decompression is not supported "
1621 "by the hddm c i/o interface.\n");
1622 fprintf(stderrstderr,"You must use the c++ "
1623 "interface to read this file.\n");
1624 exit(9);
1625 }
1626 else if (size > 0)
1627 {
1628 off_t start = xdr_getpos64(xdrs);
1629 int m;
1630 unsigned int mult;
1631 xdr_u_int(xdrs,&mult);
1632 this1 = make_s_Reactions(mult);
1633 this1->mult = mult;
1634 for (m = 0; m < mult; m++ )
1635 {
1636 int p;
1637 void* (*ptr) = (void**) &this1->in[m].beam;
1638 xdr_int(xdrs,&this1->in[m].type);
1639 xdr_float(xdrs,&this1->in[m].weight);
1640 for (p = 0; p < pop->popListLength; p++)
1641 {
1642 popNode* pnode = pop->popList[p];
1643 if (pnode)
1644 {
1645 int kid = pnode->inParent;
1646 ptr[kid] = pnode->unpacker(xdrs,pnode);
1647 }
1648 else
1649 {
1650 unsigned int skip;
1651 xdr_u_int(xdrs,&skip);
1652 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
1653 }
1654 }
1655 }
1656 xdr_setpos64(xdrs,start+size);
1657 }
1658 return this1;
1659}
1660
1661static s_Beam_t* unpack_s_Beam(XDR* xdrs, popNode* pop)
1662{
1663 s_Beam_t* this1 = (s_Beam_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
1664 unsigned int size;
1665 if (! xdr_u_int(xdrs,&size))
1666 {
1667 return this1;
1668 }
1669 else if (size == 1)
1670 {
1671 fprintf(stderrstderr,"hddm error - "
1672 "compressed data found in input stream.\n"
1673 "Compression/decompression is not supported "
1674 "by the hddm c i/o interface.\n");
1675 fprintf(stderrstderr,"You must use the c++ "
1676 "interface to read this file.\n");
1677 exit(9);
1678 }
1679 else if (size > 0)
1680 {
1681 off_t start = xdr_getpos64(xdrs);
1682 this1 = make_s_Beam();
1683 {
1684 int p;
1685 void* (*ptr) = (void**) &this1->momentum;
1686 xdr_int(xdrs,(int*)&this1->type);
1687 for (p = 0; p < pop->popListLength; p++)
1688 {
1689 popNode* pnode = pop->popList[p];
1690 if (pnode)
1691 {
1692 int kid = pnode->inParent;
1693 ptr[kid] = pnode->unpacker(xdrs,pnode);
1694 }
1695 else
1696 {
1697 unsigned int skip;
1698 xdr_u_int(xdrs,&skip);
1699 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
1700 }
1701 }
1702 }
1703 xdr_setpos64(xdrs,start+size);
1704 }
1705 return this1;
1706}
1707
1708static s_Momentum_t* unpack_s_Momentum(XDR* xdrs, popNode* pop)
1709{
1710 s_Momentum_t* this1 = (s_Momentum_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
1711 unsigned int size;
1712 if (! xdr_u_int(xdrs,&size))
1713 {
1714 return this1;
1715 }
1716 else if (size == 1)
1717 {
1718 fprintf(stderrstderr,"hddm error - "
1719 "compressed data found in input stream.\n"
1720 "Compression/decompression is not supported "
1721 "by the hddm c i/o interface.\n");
1722 fprintf(stderrstderr,"You must use the c++ "
1723 "interface to read this file.\n");
1724 exit(9);
1725 }
1726 else if (size > 0)
1727 {
1728 off_t start = xdr_getpos64(xdrs);
1729 this1 = make_s_Momentum();
1730 {
1731 xdr_float(xdrs,&this1->E);
1732 xdr_float(xdrs,&this1->px);
1733 xdr_float(xdrs,&this1->py);
1734 xdr_float(xdrs,&this1->pz);
1735 }
1736 xdr_setpos64(xdrs,start+size);
1737 }
1738 return this1;
1739}
1740
1741static s_Properties_t* unpack_s_Properties(XDR* xdrs, popNode* pop)
1742{
1743 s_Properties_t* this1 = (s_Properties_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
1744 unsigned int size;
1745 if (! xdr_u_int(xdrs,&size))
1746 {
1747 return this1;
1748 }
1749 else if (size == 1)
1750 {
1751 fprintf(stderrstderr,"hddm error - "
1752 "compressed data found in input stream.\n"
1753 "Compression/decompression is not supported "
1754 "by the hddm c i/o interface.\n");
1755 fprintf(stderrstderr,"You must use the c++ "
1756 "interface to read this file.\n");
1757 exit(9);
1758 }
1759 else if (size > 0)
1760 {
1761 off_t start = xdr_getpos64(xdrs);
1762 this1 = make_s_Properties();
1763 {
1764 xdr_int(xdrs,&this1->charge);
1765 xdr_float(xdrs,&this1->mass);
1766 }
1767 xdr_setpos64(xdrs,start+size);
1768 }
1769 return this1;
1770}
1771
1772static s_Target_t* unpack_s_Target(XDR* xdrs, popNode* pop)
1773{
1774 s_Target_t* this1 = (s_Target_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
1775 unsigned int size;
1776 if (! xdr_u_int(xdrs,&size))
1777 {
1778 return this1;
1779 }
1780 else if (size == 1)
1781 {
1782 fprintf(stderrstderr,"hddm error - "
1783 "compressed data found in input stream.\n"
1784 "Compression/decompression is not supported "
1785 "by the hddm c i/o interface.\n");
1786 fprintf(stderrstderr,"You must use the c++ "
1787 "interface to read this file.\n");
1788 exit(9);
1789 }
1790 else if (size > 0)
1791 {
1792 off_t start = xdr_getpos64(xdrs);
1793 this1 = make_s_Target();
1794 {
1795 int p;
1796 void* (*ptr) = (void**) &this1->momentum;
1797 xdr_int(xdrs,(int*)&this1->type);
1798 for (p = 0; p < pop->popListLength; p++)
1799 {
1800 popNode* pnode = pop->popList[p];
1801 if (pnode)
1802 {
1803 int kid = pnode->inParent;
1804 ptr[kid] = pnode->unpacker(xdrs,pnode);
1805 }
1806 else
1807 {
1808 unsigned int skip;
1809 xdr_u_int(xdrs,&skip);
1810 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
1811 }
1812 }
1813 }
1814 xdr_setpos64(xdrs,start+size);
1815 }
1816 return this1;
1817}
1818
1819static s_Vertices_t* unpack_s_Vertices(XDR* xdrs, popNode* pop)
1820{
1821 s_Vertices_t* this1 = (s_Vertices_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
1822 unsigned int size;
1823 if (! xdr_u_int(xdrs,&size))
1824 {
1825 return this1;
1826 }
1827 else if (size == 1)
1828 {
1829 fprintf(stderrstderr,"hddm error - "
1830 "compressed data found in input stream.\n"
1831 "Compression/decompression is not supported "
1832 "by the hddm c i/o interface.\n");
1833 fprintf(stderrstderr,"You must use the c++ "
1834 "interface to read this file.\n");
1835 exit(9);
1836 }
1837 else if (size > 0)
1838 {
1839 off_t start = xdr_getpos64(xdrs);
1840 int m;
1841 unsigned int mult;
1842 xdr_u_int(xdrs,&mult);
1843 this1 = make_s_Vertices(mult);
1844 this1->mult = mult;
1845 for (m = 0; m < mult; m++ )
1846 {
1847 int p;
1848 void* (*ptr) = (void**) &this1->in[m].products;
1849 for (p = 0; p < pop->popListLength; p++)
1850 {
1851 popNode* pnode = pop->popList[p];
1852 if (pnode)
1853 {
1854 int kid = pnode->inParent;
1855 ptr[kid] = pnode->unpacker(xdrs,pnode);
1856 }
1857 else
1858 {
1859 unsigned int skip;
1860 xdr_u_int(xdrs,&skip);
1861 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
1862 }
1863 }
1864 }
1865 xdr_setpos64(xdrs,start+size);
1866 }
1867 return this1;
1868}
1869
1870static s_Products_t* unpack_s_Products(XDR* xdrs, popNode* pop)
1871{
1872 s_Products_t* this1 = (s_Products_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
1873 unsigned int size;
1874 if (! xdr_u_int(xdrs,&size))
1875 {
1876 return this1;
1877 }
1878 else if (size == 1)
1879 {
1880 fprintf(stderrstderr,"hddm error - "
1881 "compressed data found in input stream.\n"
1882 "Compression/decompression is not supported "
1883 "by the hddm c i/o interface.\n");
1884 fprintf(stderrstderr,"You must use the c++ "
1885 "interface to read this file.\n");
1886 exit(9);
1887 }
1888 else if (size > 0)
1889 {
1890 off_t start = xdr_getpos64(xdrs);
1891 int m;
1892 unsigned int mult;
1893 xdr_u_int(xdrs,&mult);
1894 this1 = make_s_Products(mult);
1895 this1->mult = mult;
1896 for (m = 0; m < mult; m++ )
1897 {
1898 int p;
1899 void* (*ptr) = (void**) &this1->in[m].momentum;
1900 xdr_int(xdrs,&this1->in[m].decayVertex);
1901 xdr_int(xdrs,&this1->in[m].id);
1902 xdr_int(xdrs,&this1->in[m].mech);
1903 xdr_int(xdrs,&this1->in[m].parentid);
1904 xdr_int(xdrs,&this1->in[m].pdgtype);
1905 xdr_int(xdrs,(int*)&this1->in[m].type);
1906 for (p = 0; p < pop->popListLength; p++)
1907 {
1908 popNode* pnode = pop->popList[p];
1909 if (pnode)
1910 {
1911 int kid = pnode->inParent;
1912 ptr[kid] = pnode->unpacker(xdrs,pnode);
1913 }
1914 else
1915 {
1916 unsigned int skip;
1917 xdr_u_int(xdrs,&skip);
1918 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
1919 }
1920 }
1921 }
1922 xdr_setpos64(xdrs,start+size);
1923 }
1924 return this1;
1925}
1926
1927static s_Origin_t* unpack_s_Origin(XDR* xdrs, popNode* pop)
1928{
1929 s_Origin_t* this1 = (s_Origin_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
1930 unsigned int size;
1931 if (! xdr_u_int(xdrs,&size))
1932 {
1933 return this1;
1934 }
1935 else if (size == 1)
1936 {
1937 fprintf(stderrstderr,"hddm error - "
1938 "compressed data found in input stream.\n"
1939 "Compression/decompression is not supported "
1940 "by the hddm c i/o interface.\n");
1941 fprintf(stderrstderr,"You must use the c++ "
1942 "interface to read this file.\n");
1943 exit(9);
1944 }
1945 else if (size > 0)
1946 {
1947 off_t start = xdr_getpos64(xdrs);
1948 this1 = make_s_Origin();
1949 {
1950 xdr_float(xdrs,&this1->t);
1951 xdr_float(xdrs,&this1->vx);
1952 xdr_float(xdrs,&this1->vy);
1953 xdr_float(xdrs,&this1->vz);
1954 }
1955 xdr_setpos64(xdrs,start+size);
1956 }
1957 return this1;
1958}
1959
1960static s_Random_t* unpack_s_Random(XDR* xdrs, popNode* pop)
1961{
1962 s_Random_t* this1 = (s_Random_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
1963 unsigned int size;
1964 if (! xdr_u_int(xdrs,&size))
1965 {
1966 return this1;
1967 }
1968 else if (size == 1)
1969 {
1970 fprintf(stderrstderr,"hddm error - "
1971 "compressed data found in input stream.\n"
1972 "Compression/decompression is not supported "
1973 "by the hddm c i/o interface.\n");
1974 fprintf(stderrstderr,"You must use the c++ "
1975 "interface to read this file.\n");
1976 exit(9);
1977 }
1978 else if (size > 0)
1979 {
1980 off_t start = xdr_getpos64(xdrs);
1981 this1 = make_s_Random();
1982 {
1983 xdr_int(xdrs,&this1->seed1);
1984 xdr_int(xdrs,&this1->seed2);
1985 xdr_int(xdrs,&this1->seed_mcsmear1);
1986 xdr_int(xdrs,&this1->seed_mcsmear2);
1987 xdr_int(xdrs,&this1->seed_mcsmear3);
1988 }
1989 xdr_setpos64(xdrs,start+size);
1990 }
1991 return this1;
1992}
1993
1994static s_HitView_t* unpack_s_HitView(XDR* xdrs, popNode* pop)
1995{
1996 s_HitView_t* this1 = (s_HitView_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
1997 unsigned int size;
1998 if (! xdr_u_int(xdrs,&size))
1999 {
2000 return this1;
2001 }
2002 else if (size == 1)
2003 {
2004 fprintf(stderrstderr,"hddm error - "
2005 "compressed data found in input stream.\n"
2006 "Compression/decompression is not supported "
2007 "by the hddm c i/o interface.\n");
2008 fprintf(stderrstderr,"You must use the c++ "
2009 "interface to read this file.\n");
2010 exit(9);
2011 }
2012 else if (size > 0)
2013 {
2014 off_t start = xdr_getpos64(xdrs);
2015 this1 = make_s_HitView();
2016 {
2017 int p;
2018 void* (*ptr) = (void**) &this1->centralDC;
2019 for (p = 0; p < pop->popListLength; p++)
2020 {
2021 popNode* pnode = pop->popList[p];
2022 if (pnode)
2023 {
2024 int kid = pnode->inParent;
2025 ptr[kid] = pnode->unpacker(xdrs,pnode);
2026 }
2027 else
2028 {
2029 unsigned int skip;
2030 xdr_u_int(xdrs,&skip);
2031 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
2032 }
2033 }
2034 }
2035 xdr_setpos64(xdrs,start+size);
2036 }
2037 return this1;
2038}
2039
2040static s_CentralDC_t* unpack_s_CentralDC(XDR* xdrs, popNode* pop)
2041{
2042 s_CentralDC_t* this1 = (s_CentralDC_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2043 unsigned int size;
2044 if (! xdr_u_int(xdrs,&size))
2045 {
2046 return this1;
2047 }
2048 else if (size == 1)
2049 {
2050 fprintf(stderrstderr,"hddm error - "
2051 "compressed data found in input stream.\n"
2052 "Compression/decompression is not supported "
2053 "by the hddm c i/o interface.\n");
2054 fprintf(stderrstderr,"You must use the c++ "
2055 "interface to read this file.\n");
2056 exit(9);
2057 }
2058 else if (size > 0)
2059 {
2060 off_t start = xdr_getpos64(xdrs);
2061 this1 = make_s_CentralDC();
2062 {
2063 int p;
2064 void* (*ptr) = (void**) &this1->cdcStraws;
2065 for (p = 0; p < pop->popListLength; p++)
2066 {
2067 popNode* pnode = pop->popList[p];
2068 if (pnode)
2069 {
2070 int kid = pnode->inParent;
2071 ptr[kid] = pnode->unpacker(xdrs,pnode);
2072 }
2073 else
2074 {
2075 unsigned int skip;
2076 xdr_u_int(xdrs,&skip);
2077 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
2078 }
2079 }
2080 }
2081 xdr_setpos64(xdrs,start+size);
2082 }
2083 return this1;
2084}
2085
2086static s_CdcStraws_t* unpack_s_CdcStraws(XDR* xdrs, popNode* pop)
2087{
2088 s_CdcStraws_t* this1 = (s_CdcStraws_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2089 unsigned int size;
2090 if (! xdr_u_int(xdrs,&size))
2091 {
2092 return this1;
2093 }
2094 else if (size == 1)
2095 {
2096 fprintf(stderrstderr,"hddm error - "
2097 "compressed data found in input stream.\n"
2098 "Compression/decompression is not supported "
2099 "by the hddm c i/o interface.\n");
2100 fprintf(stderrstderr,"You must use the c++ "
2101 "interface to read this file.\n");
2102 exit(9);
2103 }
2104 else if (size > 0)
2105 {
2106 off_t start = xdr_getpos64(xdrs);
2107 int m;
2108 unsigned int mult;
2109 xdr_u_int(xdrs,&mult);
2110 this1 = make_s_CdcStraws(mult);
2111 this1->mult = mult;
2112 for (m = 0; m < mult; m++ )
2113 {
2114 int p;
2115 void* (*ptr) = (void**) &this1->in[m].cdcStrawHits;
2116 xdr_int(xdrs,&this1->in[m].ring);
2117 xdr_int(xdrs,&this1->in[m].straw);
2118 for (p = 0; p < pop->popListLength; p++)
2119 {
2120 popNode* pnode = pop->popList[p];
2121 if (pnode)
2122 {
2123 int kid = pnode->inParent;
2124 ptr[kid] = pnode->unpacker(xdrs,pnode);
2125 }
2126 else
2127 {
2128 unsigned int skip;
2129 xdr_u_int(xdrs,&skip);
2130 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
2131 }
2132 }
2133 }
2134 xdr_setpos64(xdrs,start+size);
2135 }
2136 return this1;
2137}
2138
2139static s_CdcStrawHits_t* unpack_s_CdcStrawHits(XDR* xdrs, popNode* pop)
2140{
2141 s_CdcStrawHits_t* this1 = (s_CdcStrawHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2142 unsigned int size;
2143 if (! xdr_u_int(xdrs,&size))
2144 {
2145 return this1;
2146 }
2147 else if (size == 1)
2148 {
2149 fprintf(stderrstderr,"hddm error - "
2150 "compressed data found in input stream.\n"
2151 "Compression/decompression is not supported "
2152 "by the hddm c i/o interface.\n");
2153 fprintf(stderrstderr,"You must use the c++ "
2154 "interface to read this file.\n");
2155 exit(9);
2156 }
2157 else if (size > 0)
2158 {
2159 off_t start = xdr_getpos64(xdrs);
2160 int m;
2161 unsigned int mult;
2162 xdr_u_int(xdrs,&mult);
2163 this1 = make_s_CdcStrawHits(mult);
2164 this1->mult = mult;
2165 for (m = 0; m < mult; m++ )
2166 {
2167 xdr_float(xdrs,&this1->in[m].d);
2168 xdr_float(xdrs,&this1->in[m].dE);
2169 xdr_int(xdrs,&this1->in[m].itrack);
2170 xdr_int(xdrs,&this1->in[m].ptype);
2171 xdr_float(xdrs,&this1->in[m].t);
2172 }
2173 xdr_setpos64(xdrs,start+size);
2174 }
2175 return this1;
2176}
2177
2178static s_CdcStrawTruthHits_t* unpack_s_CdcStrawTruthHits(XDR* xdrs, popNode* pop)
2179{
2180 s_CdcStrawTruthHits_t* this1 = (s_CdcStrawTruthHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2181 unsigned int size;
2182 if (! xdr_u_int(xdrs,&size))
2183 {
2184 return this1;
2185 }
2186 else if (size == 1)
2187 {
2188 fprintf(stderrstderr,"hddm error - "
2189 "compressed data found in input stream.\n"
2190 "Compression/decompression is not supported "
2191 "by the hddm c i/o interface.\n");
2192 fprintf(stderrstderr,"You must use the c++ "
2193 "interface to read this file.\n");
2194 exit(9);
2195 }
2196 else if (size > 0)
2197 {
2198 off_t start = xdr_getpos64(xdrs);
2199 int m;
2200 unsigned int mult;
2201 xdr_u_int(xdrs,&mult);
2202 this1 = make_s_CdcStrawTruthHits(mult);
2203 this1->mult = mult;
2204 for (m = 0; m < mult; m++ )
2205 {
2206 xdr_float(xdrs,&this1->in[m].d);
2207 xdr_float(xdrs,&this1->in[m].dE);
2208 xdr_int(xdrs,&this1->in[m].itrack);
2209 xdr_int(xdrs,&this1->in[m].ptype);
2210 xdr_float(xdrs,&this1->in[m].t);
2211 }
2212 xdr_setpos64(xdrs,start+size);
2213 }
2214 return this1;
2215}
2216
2217static s_CdcTruthPoints_t* unpack_s_CdcTruthPoints(XDR* xdrs, popNode* pop)
2218{
2219 s_CdcTruthPoints_t* this1 = (s_CdcTruthPoints_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2220 unsigned int size;
2221 if (! xdr_u_int(xdrs,&size))
2222 {
2223 return this1;
2224 }
2225 else if (size == 1)
2226 {
2227 fprintf(stderrstderr,"hddm error - "
2228 "compressed data found in input stream.\n"
2229 "Compression/decompression is not supported "
2230 "by the hddm c i/o interface.\n");
2231 fprintf(stderrstderr,"You must use the c++ "
2232 "interface to read this file.\n");
2233 exit(9);
2234 }
2235 else if (size > 0)
2236 {
2237 off_t start = xdr_getpos64(xdrs);
2238 int m;
2239 unsigned int mult;
2240 xdr_u_int(xdrs,&mult);
2241 this1 = make_s_CdcTruthPoints(mult);
2242 this1->mult = mult;
2243 for (m = 0; m < mult; m++ )
2244 {
2245 xdr_float(xdrs,&this1->in[m].dEdx);
2246 xdr_float(xdrs,&this1->in[m].dradius);
2247 xdr_float(xdrs,&this1->in[m].phi);
2248 xdr_bool(xdrs,&this1->in[m].primary);
2249 xdr_int(xdrs,&this1->in[m].ptype);
2250 xdr_float(xdrs,&this1->in[m].px);
2251 xdr_float(xdrs,&this1->in[m].py);
2252 xdr_float(xdrs,&this1->in[m].pz);
2253 xdr_float(xdrs,&this1->in[m].r);
2254 xdr_float(xdrs,&this1->in[m].t);
2255 xdr_int(xdrs,&this1->in[m].track);
2256 xdr_float(xdrs,&this1->in[m].z);
2257 }
2258 xdr_setpos64(xdrs,start+size);
2259 }
2260 return this1;
2261}
2262
2263static s_ForwardDC_t* unpack_s_ForwardDC(XDR* xdrs, popNode* pop)
2264{
2265 s_ForwardDC_t* this1 = (s_ForwardDC_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2266 unsigned int size;
2267 if (! xdr_u_int(xdrs,&size))
2268 {
2269 return this1;
2270 }
2271 else if (size == 1)
2272 {
2273 fprintf(stderrstderr,"hddm error - "
2274 "compressed data found in input stream.\n"
2275 "Compression/decompression is not supported "
2276 "by the hddm c i/o interface.\n");
2277 fprintf(stderrstderr,"You must use the c++ "
2278 "interface to read this file.\n");
2279 exit(9);
2280 }
2281 else if (size > 0)
2282 {
2283 off_t start = xdr_getpos64(xdrs);
2284 this1 = make_s_ForwardDC();
2285 {
2286 int p;
2287 void* (*ptr) = (void**) &this1->fdcChambers;
2288 for (p = 0; p < pop->popListLength; p++)
2289 {
2290 popNode* pnode = pop->popList[p];
2291 if (pnode)
2292 {
2293 int kid = pnode->inParent;
2294 ptr[kid] = pnode->unpacker(xdrs,pnode);
2295 }
2296 else
2297 {
2298 unsigned int skip;
2299 xdr_u_int(xdrs,&skip);
2300 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
2301 }
2302 }
2303 }
2304 xdr_setpos64(xdrs,start+size);
2305 }
2306 return this1;
2307}
2308
2309static s_FdcChambers_t* unpack_s_FdcChambers(XDR* xdrs, popNode* pop)
2310{
2311 s_FdcChambers_t* this1 = (s_FdcChambers_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2312 unsigned int size;
2313 if (! xdr_u_int(xdrs,&size))
2314 {
2315 return this1;
2316 }
2317 else if (size == 1)
2318 {
2319 fprintf(stderrstderr,"hddm error - "
2320 "compressed data found in input stream.\n"
2321 "Compression/decompression is not supported "
2322 "by the hddm c i/o interface.\n");
2323 fprintf(stderrstderr,"You must use the c++ "
2324 "interface to read this file.\n");
2325 exit(9);
2326 }
2327 else if (size > 0)
2328 {
2329 off_t start = xdr_getpos64(xdrs);
2330 int m;
2331 unsigned int mult;
2332 xdr_u_int(xdrs,&mult);
2333 this1 = make_s_FdcChambers(mult);
2334 this1->mult = mult;
2335 for (m = 0; m < mult; m++ )
2336 {
2337 int p;
2338 void* (*ptr) = (void**) &this1->in[m].fdcAnodeWires;
2339 xdr_int(xdrs,&this1->in[m].layer);
2340 xdr_int(xdrs,&this1->in[m].module);
2341 for (p = 0; p < pop->popListLength; p++)
2342 {
2343 popNode* pnode = pop->popList[p];
2344 if (pnode)
2345 {
2346 int kid = pnode->inParent;
2347 ptr[kid] = pnode->unpacker(xdrs,pnode);
2348 }
2349 else
2350 {
2351 unsigned int skip;
2352 xdr_u_int(xdrs,&skip);
2353 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
2354 }
2355 }
2356 }
2357 xdr_setpos64(xdrs,start+size);
2358 }
2359 return this1;
2360}
2361
2362static s_FdcAnodeWires_t* unpack_s_FdcAnodeWires(XDR* xdrs, popNode* pop)
2363{
2364 s_FdcAnodeWires_t* this1 = (s_FdcAnodeWires_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2365 unsigned int size;
2366 if (! xdr_u_int(xdrs,&size))
2367 {
2368 return this1;
2369 }
2370 else if (size == 1)
2371 {
2372 fprintf(stderrstderr,"hddm error - "
2373 "compressed data found in input stream.\n"
2374 "Compression/decompression is not supported "
2375 "by the hddm c i/o interface.\n");
2376 fprintf(stderrstderr,"You must use the c++ "
2377 "interface to read this file.\n");
2378 exit(9);
2379 }
2380 else if (size > 0)
2381 {
2382 off_t start = xdr_getpos64(xdrs);
2383 int m;
2384 unsigned int mult;
2385 xdr_u_int(xdrs,&mult);
2386 this1 = make_s_FdcAnodeWires(mult);
2387 this1->mult = mult;
2388 for (m = 0; m < mult; m++ )
2389 {
2390 int p;
2391 void* (*ptr) = (void**) &this1->in[m].fdcAnodeHits;
2392 xdr_int(xdrs,&this1->in[m].wire);
2393 for (p = 0; p < pop->popListLength; p++)
2394 {
2395 popNode* pnode = pop->popList[p];
2396 if (pnode)
2397 {
2398 int kid = pnode->inParent;
2399 ptr[kid] = pnode->unpacker(xdrs,pnode);
2400 }
2401 else
2402 {
2403 unsigned int skip;
2404 xdr_u_int(xdrs,&skip);
2405 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
2406 }
2407 }
2408 }
2409 xdr_setpos64(xdrs,start+size);
2410 }
2411 return this1;
2412}
2413
2414static s_FdcAnodeHits_t* unpack_s_FdcAnodeHits(XDR* xdrs, popNode* pop)
2415{
2416 s_FdcAnodeHits_t* this1 = (s_FdcAnodeHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2417 unsigned int size;
2418 if (! xdr_u_int(xdrs,&size))
2419 {
2420 return this1;
2421 }
2422 else if (size == 1)
2423 {
2424 fprintf(stderrstderr,"hddm error - "
2425 "compressed data found in input stream.\n"
2426 "Compression/decompression is not supported "
2427 "by the hddm c i/o interface.\n");
2428 fprintf(stderrstderr,"You must use the c++ "
2429 "interface to read this file.\n");
2430 exit(9);
2431 }
2432 else if (size > 0)
2433 {
2434 off_t start = xdr_getpos64(xdrs);
2435 int m;
2436 unsigned int mult;
2437 xdr_u_int(xdrs,&mult);
2438 this1 = make_s_FdcAnodeHits(mult);
2439 this1->mult = mult;
2440 for (m = 0; m < mult; m++ )
2441 {
2442 xdr_float(xdrs,&this1->in[m].d);
2443 xdr_float(xdrs,&this1->in[m].dE);
2444 xdr_int(xdrs,&this1->in[m].itrack);
2445 xdr_int(xdrs,&this1->in[m].ptype);
2446 xdr_float(xdrs,&this1->in[m].t);
2447 }
2448 xdr_setpos64(xdrs,start+size);
2449 }
2450 return this1;
2451}
2452
2453static s_FdcAnodeTruthHits_t* unpack_s_FdcAnodeTruthHits(XDR* xdrs, popNode* pop)
2454{
2455 s_FdcAnodeTruthHits_t* this1 = (s_FdcAnodeTruthHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2456 unsigned int size;
2457 if (! xdr_u_int(xdrs,&size))
2458 {
2459 return this1;
2460 }
2461 else if (size == 1)
2462 {
2463 fprintf(stderrstderr,"hddm error - "
2464 "compressed data found in input stream.\n"
2465 "Compression/decompression is not supported "
2466 "by the hddm c i/o interface.\n");
2467 fprintf(stderrstderr,"You must use the c++ "
2468 "interface to read this file.\n");
2469 exit(9);
2470 }
2471 else if (size > 0)
2472 {
2473 off_t start = xdr_getpos64(xdrs);
2474 int m;
2475 unsigned int mult;
2476 xdr_u_int(xdrs,&mult);
2477 this1 = make_s_FdcAnodeTruthHits(mult);
2478 this1->mult = mult;
2479 for (m = 0; m < mult; m++ )
2480 {
2481 xdr_float(xdrs,&this1->in[m].d);
2482 xdr_float(xdrs,&this1->in[m].dE);
2483 xdr_int(xdrs,&this1->in[m].itrack);
2484 xdr_int(xdrs,&this1->in[m].ptype);
2485 xdr_float(xdrs,&this1->in[m].t);
2486 xdr_float(xdrs,&this1->in[m].t_unsmeared);
2487 }
2488 xdr_setpos64(xdrs,start+size);
2489 }
2490 return this1;
2491}
2492
2493static s_FdcCathodeStrips_t* unpack_s_FdcCathodeStrips(XDR* xdrs, popNode* pop)
2494{
2495 s_FdcCathodeStrips_t* this1 = (s_FdcCathodeStrips_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2496 unsigned int size;
2497 if (! xdr_u_int(xdrs,&size))
2498 {
2499 return this1;
2500 }
2501 else if (size == 1)
2502 {
2503 fprintf(stderrstderr,"hddm error - "
2504 "compressed data found in input stream.\n"
2505 "Compression/decompression is not supported "
2506 "by the hddm c i/o interface.\n");
2507 fprintf(stderrstderr,"You must use the c++ "
2508 "interface to read this file.\n");
2509 exit(9);
2510 }
2511 else if (size > 0)
2512 {
2513 off_t start = xdr_getpos64(xdrs);
2514 int m;
2515 unsigned int mult;
2516 xdr_u_int(xdrs,&mult);
2517 this1 = make_s_FdcCathodeStrips(mult);
2518 this1->mult = mult;
2519 for (m = 0; m < mult; m++ )
2520 {
2521 int p;
2522 void* (*ptr) = (void**) &this1->in[m].fdcCathodeHits;
2523 xdr_int(xdrs,&this1->in[m].plane);
2524 xdr_int(xdrs,&this1->in[m].strip);
2525 for (p = 0; p < pop->popListLength; p++)
2526 {
2527 popNode* pnode = pop->popList[p];
2528 if (pnode)
2529 {
2530 int kid = pnode->inParent;
2531 ptr[kid] = pnode->unpacker(xdrs,pnode);
2532 }
2533 else
2534 {
2535 unsigned int skip;
2536 xdr_u_int(xdrs,&skip);
2537 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
2538 }
2539 }
2540 }
2541 xdr_setpos64(xdrs,start+size);
2542 }
2543 return this1;
2544}
2545
2546static s_FdcCathodeHits_t* unpack_s_FdcCathodeHits(XDR* xdrs, popNode* pop)
2547{
2548 s_FdcCathodeHits_t* this1 = (s_FdcCathodeHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2549 unsigned int size;
2550 if (! xdr_u_int(xdrs,&size))
2551 {
2552 return this1;
2553 }
2554 else if (size == 1)
2555 {
2556 fprintf(stderrstderr,"hddm error - "
2557 "compressed data found in input stream.\n"
2558 "Compression/decompression is not supported "
2559 "by the hddm c i/o interface.\n");
2560 fprintf(stderrstderr,"You must use the c++ "
2561 "interface to read this file.\n");
2562 exit(9);
2563 }
2564 else if (size > 0)
2565 {
2566 off_t start = xdr_getpos64(xdrs);
2567 int m;
2568 unsigned int mult;
2569 xdr_u_int(xdrs,&mult);
2570 this1 = make_s_FdcCathodeHits(mult);
2571 this1->mult = mult;
2572 for (m = 0; m < mult; m++ )
2573 {
2574 xdr_int(xdrs,&this1->in[m].itrack);
2575 xdr_int(xdrs,&this1->in[m].ptype);
2576 xdr_float(xdrs,&this1->in[m].q);
2577 xdr_float(xdrs,&this1->in[m].t);
2578 }
2579 xdr_setpos64(xdrs,start+size);
2580 }
2581 return this1;
2582}
2583
2584static s_FdcCathodeTruthHits_t* unpack_s_FdcCathodeTruthHits(XDR* xdrs, popNode* pop)
2585{
2586 s_FdcCathodeTruthHits_t* this1 = (s_FdcCathodeTruthHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2587 unsigned int size;
2588 if (! xdr_u_int(xdrs,&size))
2589 {
2590 return this1;
2591 }
2592 else if (size == 1)
2593 {
2594 fprintf(stderrstderr,"hddm error - "
2595 "compressed data found in input stream.\n"
2596 "Compression/decompression is not supported "
2597 "by the hddm c i/o interface.\n");
2598 fprintf(stderrstderr,"You must use the c++ "
2599 "interface to read this file.\n");
2600 exit(9);
2601 }
2602 else if (size > 0)
2603 {
2604 off_t start = xdr_getpos64(xdrs);
2605 int m;
2606 unsigned int mult;
2607 xdr_u_int(xdrs,&mult);
2608 this1 = make_s_FdcCathodeTruthHits(mult);
2609 this1->mult = mult;
2610 for (m = 0; m < mult; m++ )
2611 {
2612 xdr_int(xdrs,&this1->in[m].itrack);
2613 xdr_int(xdrs,&this1->in[m].ptype);
2614 xdr_float(xdrs,&this1->in[m].q);
2615 xdr_float(xdrs,&this1->in[m].t);
2616 }
2617 xdr_setpos64(xdrs,start+size);
2618 }
2619 return this1;
2620}
2621
2622static s_FdcTruthPoints_t* unpack_s_FdcTruthPoints(XDR* xdrs, popNode* pop)
2623{
2624 s_FdcTruthPoints_t* this1 = (s_FdcTruthPoints_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2625 unsigned int size;
2626 if (! xdr_u_int(xdrs,&size))
2627 {
2628 return this1;
2629 }
2630 else if (size == 1)
2631 {
2632 fprintf(stderrstderr,"hddm error - "
2633 "compressed data found in input stream.\n"
2634 "Compression/decompression is not supported "
2635 "by the hddm c i/o interface.\n");
2636 fprintf(stderrstderr,"You must use the c++ "
2637 "interface to read this file.\n");
2638 exit(9);
2639 }
2640 else if (size > 0)
2641 {
2642 off_t start = xdr_getpos64(xdrs);
2643 int m;
2644 unsigned int mult;
2645 xdr_u_int(xdrs,&mult);
2646 this1 = make_s_FdcTruthPoints(mult);
2647 this1->mult = mult;
2648 for (m = 0; m < mult; m++ )
2649 {
2650 xdr_float(xdrs,&this1->in[m].E);
2651 xdr_float(xdrs,&this1->in[m].dEdx);
2652 xdr_float(xdrs,&this1->in[m].dradius);
2653 xdr_bool(xdrs,&this1->in[m].primary);
2654 xdr_int(xdrs,&this1->in[m].ptype);
2655 xdr_float(xdrs,&this1->in[m].px);
2656 xdr_float(xdrs,&this1->in[m].py);
2657 xdr_float(xdrs,&this1->in[m].pz);
2658 xdr_float(xdrs,&this1->in[m].t);
2659 xdr_int(xdrs,&this1->in[m].track);
2660 xdr_float(xdrs,&this1->in[m].x);
2661 xdr_float(xdrs,&this1->in[m].y);
2662 xdr_float(xdrs,&this1->in[m].z);
2663 }
2664 xdr_setpos64(xdrs,start+size);
2665 }
2666 return this1;
2667}
2668
2669static s_StartCntr_t* unpack_s_StartCntr(XDR* xdrs, popNode* pop)
2670{
2671 s_StartCntr_t* this1 = (s_StartCntr_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2672 unsigned int size;
2673 if (! xdr_u_int(xdrs,&size))
2674 {
2675 return this1;
2676 }
2677 else if (size == 1)
2678 {
2679 fprintf(stderrstderr,"hddm error - "
2680 "compressed data found in input stream.\n"
2681 "Compression/decompression is not supported "
2682 "by the hddm c i/o interface.\n");
2683 fprintf(stderrstderr,"You must use the c++ "
2684 "interface to read this file.\n");
2685 exit(9);
2686 }
2687 else if (size > 0)
2688 {
2689 off_t start = xdr_getpos64(xdrs);
2690 this1 = make_s_StartCntr();
2691 {
2692 int p;
2693 void* (*ptr) = (void**) &this1->stcPaddles;
2694 for (p = 0; p < pop->popListLength; p++)
2695 {
2696 popNode* pnode = pop->popList[p];
2697 if (pnode)
2698 {
2699 int kid = pnode->inParent;
2700 ptr[kid] = pnode->unpacker(xdrs,pnode);
2701 }
2702 else
2703 {
2704 unsigned int skip;
2705 xdr_u_int(xdrs,&skip);
2706 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
2707 }
2708 }
2709 }
2710 xdr_setpos64(xdrs,start+size);
2711 }
2712 return this1;
2713}
2714
2715static s_StcPaddles_t* unpack_s_StcPaddles(XDR* xdrs, popNode* pop)
2716{
2717 s_StcPaddles_t* this1 = (s_StcPaddles_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2718 unsigned int size;
2719 if (! xdr_u_int(xdrs,&size))
2720 {
2721 return this1;
2722 }
2723 else if (size == 1)
2724 {
2725 fprintf(stderrstderr,"hddm error - "
2726 "compressed data found in input stream.\n"
2727 "Compression/decompression is not supported "
2728 "by the hddm c i/o interface.\n");
2729 fprintf(stderrstderr,"You must use the c++ "
2730 "interface to read this file.\n");
2731 exit(9);
2732 }
2733 else if (size > 0)
2734 {
2735 off_t start = xdr_getpos64(xdrs);
2736 int m;
2737 unsigned int mult;
2738 xdr_u_int(xdrs,&mult);
2739 this1 = make_s_StcPaddles(mult);
2740 this1->mult = mult;
2741 for (m = 0; m < mult; m++ )
2742 {
2743 int p;
2744 void* (*ptr) = (void**) &this1->in[m].stcHits;
2745 xdr_int(xdrs,&this1->in[m].sector);
2746 for (p = 0; p < pop->popListLength; p++)
2747 {
2748 popNode* pnode = pop->popList[p];
2749 if (pnode)
2750 {
2751 int kid = pnode->inParent;
2752 ptr[kid] = pnode->unpacker(xdrs,pnode);
2753 }
2754 else
2755 {
2756 unsigned int skip;
2757 xdr_u_int(xdrs,&skip);
2758 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
2759 }
2760 }
2761 }
2762 xdr_setpos64(xdrs,start+size);
2763 }
2764 return this1;
2765}
2766
2767static s_StcHits_t* unpack_s_StcHits(XDR* xdrs, popNode* pop)
2768{
2769 s_StcHits_t* this1 = (s_StcHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2770 unsigned int size;
2771 if (! xdr_u_int(xdrs,&size))
2772 {
2773 return this1;
2774 }
2775 else if (size == 1)
2776 {
2777 fprintf(stderrstderr,"hddm error - "
2778 "compressed data found in input stream.\n"
2779 "Compression/decompression is not supported "
2780 "by the hddm c i/o interface.\n");
2781 fprintf(stderrstderr,"You must use the c++ "
2782 "interface to read this file.\n");
2783 exit(9);
2784 }
2785 else if (size > 0)
2786 {
2787 off_t start = xdr_getpos64(xdrs);
2788 int m;
2789 unsigned int mult;
2790 xdr_u_int(xdrs,&mult);
2791 this1 = make_s_StcHits(mult);
2792 this1->mult = mult;
2793 for (m = 0; m < mult; m++ )
2794 {
2795 xdr_float(xdrs,&this1->in[m].dE);
2796 xdr_float(xdrs,&this1->in[m].t);
2797 }
2798 xdr_setpos64(xdrs,start+size);
2799 }
2800 return this1;
2801}
2802
2803static s_StcTruthHits_t* unpack_s_StcTruthHits(XDR* xdrs, popNode* pop)
2804{
2805 s_StcTruthHits_t* this1 = (s_StcTruthHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2806 unsigned int size;
2807 if (! xdr_u_int(xdrs,&size))
2808 {
2809 return this1;
2810 }
2811 else if (size == 1)
2812 {
2813 fprintf(stderrstderr,"hddm error - "
2814 "compressed data found in input stream.\n"
2815 "Compression/decompression is not supported "
2816 "by the hddm c i/o interface.\n");
2817 fprintf(stderrstderr,"You must use the c++ "
2818 "interface to read this file.\n");
2819 exit(9);
2820 }
2821 else if (size > 0)
2822 {
2823 off_t start = xdr_getpos64(xdrs);
2824 int m;
2825 unsigned int mult;
2826 xdr_u_int(xdrs,&mult);
2827 this1 = make_s_StcTruthHits(mult);
2828 this1->mult = mult;
2829 for (m = 0; m < mult; m++ )
2830 {
2831 xdr_float(xdrs,&this1->in[m].dE);
2832 xdr_float(xdrs,&this1->in[m].t);
2833 }
2834 xdr_setpos64(xdrs,start+size);
2835 }
2836 return this1;
2837}
2838
2839static s_StcTruthPoints_t* unpack_s_StcTruthPoints(XDR* xdrs, popNode* pop)
2840{
2841 s_StcTruthPoints_t* this1 = (s_StcTruthPoints_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2842 unsigned int size;
2843 if (! xdr_u_int(xdrs,&size))
2844 {
2845 return this1;
2846 }
2847 else if (size == 1)
2848 {
2849 fprintf(stderrstderr,"hddm error - "
2850 "compressed data found in input stream.\n"
2851 "Compression/decompression is not supported "
2852 "by the hddm c i/o interface.\n");
2853 fprintf(stderrstderr,"You must use the c++ "
2854 "interface to read this file.\n");
2855 exit(9);
2856 }
2857 else if (size > 0)
2858 {
2859 off_t start = xdr_getpos64(xdrs);
2860 int m;
2861 unsigned int mult;
2862 xdr_u_int(xdrs,&mult);
2863 this1 = make_s_StcTruthPoints(mult);
2864 this1->mult = mult;
2865 for (m = 0; m < mult; m++ )
2866 {
2867 xdr_float(xdrs,&this1->in[m].E);
2868 xdr_float(xdrs,&this1->in[m].dEdx);
2869 xdr_float(xdrs,&this1->in[m].phi);
2870 xdr_bool(xdrs,&this1->in[m].primary);
2871 xdr_int(xdrs,&this1->in[m].ptype);
2872 xdr_float(xdrs,&this1->in[m].px);
2873 xdr_float(xdrs,&this1->in[m].py);
2874 xdr_float(xdrs,&this1->in[m].pz);
2875 xdr_float(xdrs,&this1->in[m].r);
2876 xdr_int(xdrs,&this1->in[m].sector);
2877 xdr_float(xdrs,&this1->in[m].t);
2878 xdr_int(xdrs,&this1->in[m].track);
2879 xdr_float(xdrs,&this1->in[m].z);
2880 }
2881 xdr_setpos64(xdrs,start+size);
2882 }
2883 return this1;
2884}
2885
2886static s_BarrelEMcal_t* unpack_s_BarrelEMcal(XDR* xdrs, popNode* pop)
2887{
2888 s_BarrelEMcal_t* this1 = (s_BarrelEMcal_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2889 unsigned int size;
2890 if (! xdr_u_int(xdrs,&size))
2891 {
2892 return this1;
2893 }
2894 else if (size == 1)
2895 {
2896 fprintf(stderrstderr,"hddm error - "
2897 "compressed data found in input stream.\n"
2898 "Compression/decompression is not supported "
2899 "by the hddm c i/o interface.\n");
2900 fprintf(stderrstderr,"You must use the c++ "
2901 "interface to read this file.\n");
2902 exit(9);
2903 }
2904 else if (size > 0)
2905 {
2906 off_t start = xdr_getpos64(xdrs);
2907 this1 = make_s_BarrelEMcal();
2908 {
2909 int p;
2910 void* (*ptr) = (void**) &this1->bcalCells;
2911 for (p = 0; p < pop->popListLength; p++)
2912 {
2913 popNode* pnode = pop->popList[p];
2914 if (pnode)
2915 {
2916 int kid = pnode->inParent;
2917 ptr[kid] = pnode->unpacker(xdrs,pnode);
2918 }
2919 else
2920 {
2921 unsigned int skip;
2922 xdr_u_int(xdrs,&skip);
2923 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
2924 }
2925 }
2926 }
2927 xdr_setpos64(xdrs,start+size);
2928 }
2929 return this1;
2930}
2931
2932static s_BcalCells_t* unpack_s_BcalCells(XDR* xdrs, popNode* pop)
2933{
2934 s_BcalCells_t* this1 = (s_BcalCells_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2935 unsigned int size;
2936 if (! xdr_u_int(xdrs,&size))
2937 {
2938 return this1;
2939 }
2940 else if (size == 1)
2941 {
2942 fprintf(stderrstderr,"hddm error - "
2943 "compressed data found in input stream.\n"
2944 "Compression/decompression is not supported "
2945 "by the hddm c i/o interface.\n");
2946 fprintf(stderrstderr,"You must use the c++ "
2947 "interface to read this file.\n");
2948 exit(9);
2949 }
2950 else if (size > 0)
2951 {
2952 off_t start = xdr_getpos64(xdrs);
2953 int m;
2954 unsigned int mult;
2955 xdr_u_int(xdrs,&mult);
2956 this1 = make_s_BcalCells(mult);
2957 this1->mult = mult;
2958 for (m = 0; m < mult; m++ )
2959 {
2960 int p;
2961 void* (*ptr) = (void**) &this1->in[m].bcalSiPMUpHits;
2962 xdr_int(xdrs,&this1->in[m].layer);
2963 xdr_int(xdrs,&this1->in[m].module);
2964 xdr_int(xdrs,&this1->in[m].sector);
2965 for (p = 0; p < pop->popListLength; p++)
2966 {
2967 popNode* pnode = pop->popList[p];
2968 if (pnode)
2969 {
2970 int kid = pnode->inParent;
2971 ptr[kid] = pnode->unpacker(xdrs,pnode);
2972 }
2973 else
2974 {
2975 unsigned int skip;
2976 xdr_u_int(xdrs,&skip);
2977 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
2978 }
2979 }
2980 }
2981 xdr_setpos64(xdrs,start+size);
2982 }
2983 return this1;
2984}
2985
2986static s_BcalSiPMUpHits_t* unpack_s_BcalSiPMUpHits(XDR* xdrs, popNode* pop)
2987{
2988 s_BcalSiPMUpHits_t* this1 = (s_BcalSiPMUpHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
2989 unsigned int size;
2990 if (! xdr_u_int(xdrs,&size))
2991 {
2992 return this1;
2993 }
2994 else if (size == 1)
2995 {
2996 fprintf(stderrstderr,"hddm error - "
2997 "compressed data found in input stream.\n"
2998 "Compression/decompression is not supported "
2999 "by the hddm c i/o interface.\n");
3000 fprintf(stderrstderr,"You must use the c++ "
3001 "interface to read this file.\n");
3002 exit(9);
3003 }
3004 else if (size > 0)
3005 {
3006 off_t start = xdr_getpos64(xdrs);
3007 int m;
3008 unsigned int mult;
3009 xdr_u_int(xdrs,&mult);
3010 this1 = make_s_BcalSiPMUpHits(mult);
3011 this1->mult = mult;
3012 for (m = 0; m < mult; m++ )
3013 {
3014 xdr_float(xdrs,&this1->in[m].E);
3015 xdr_float(xdrs,&this1->in[m].t);
3016 }
3017 xdr_setpos64(xdrs,start+size);
3018 }
3019 return this1;
3020}
3021
3022static s_BcalSiPMDownHits_t* unpack_s_BcalSiPMDownHits(XDR* xdrs, popNode* pop)
3023{
3024 s_BcalSiPMDownHits_t* this1 = (s_BcalSiPMDownHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3025 unsigned int size;
3026 if (! xdr_u_int(xdrs,&size))
3027 {
3028 return this1;
3029 }
3030 else if (size == 1)
3031 {
3032 fprintf(stderrstderr,"hddm error - "
3033 "compressed data found in input stream.\n"
3034 "Compression/decompression is not supported "
3035 "by the hddm c i/o interface.\n");
3036 fprintf(stderrstderr,"You must use the c++ "
3037 "interface to read this file.\n");
3038 exit(9);
3039 }
3040 else if (size > 0)
3041 {
3042 off_t start = xdr_getpos64(xdrs);
3043 int m;
3044 unsigned int mult;
3045 xdr_u_int(xdrs,&mult);
3046 this1 = make_s_BcalSiPMDownHits(mult);
3047 this1->mult = mult;
3048 for (m = 0; m < mult; m++ )
3049 {
3050 xdr_float(xdrs,&this1->in[m].E);
3051 xdr_float(xdrs,&this1->in[m].t);
3052 }
3053 xdr_setpos64(xdrs,start+size);
3054 }
3055 return this1;
3056}
3057
3058static s_BcalHits_t* unpack_s_BcalHits(XDR* xdrs, popNode* pop)
3059{
3060 s_BcalHits_t* this1 = (s_BcalHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3061 unsigned int size;
3062 if (! xdr_u_int(xdrs,&size))
3063 {
3064 return this1;
3065 }
3066 else if (size == 1)
3067 {
3068 fprintf(stderrstderr,"hddm error - "
3069 "compressed data found in input stream.\n"
3070 "Compression/decompression is not supported "
3071 "by the hddm c i/o interface.\n");
3072 fprintf(stderrstderr,"You must use the c++ "
3073 "interface to read this file.\n");
3074 exit(9);
3075 }
3076 else if (size > 0)
3077 {
3078 off_t start = xdr_getpos64(xdrs);
3079 int m;
3080 unsigned int mult;
3081 xdr_u_int(xdrs,&mult);
3082 this1 = make_s_BcalHits(mult);
3083 this1->mult = mult;
3084 for (m = 0; m < mult; m++ )
3085 {
3086 xdr_float(xdrs,&this1->in[m].E);
3087 xdr_float(xdrs,&this1->in[m].t);
3088 xdr_float(xdrs,&this1->in[m].zLocal);
3089 }
3090 xdr_setpos64(xdrs,start+size);
3091 }
3092 return this1;
3093}
3094
3095static s_BcalIncidentParticles_t* unpack_s_BcalIncidentParticles(XDR* xdrs, popNode* pop)
3096{
3097 s_BcalIncidentParticles_t* this1 = (s_BcalIncidentParticles_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3098 unsigned int size;
3099 if (! xdr_u_int(xdrs,&size))
3100 {
3101 return this1;
3102 }
3103 else if (size == 1)
3104 {
3105 fprintf(stderrstderr,"hddm error - "
3106 "compressed data found in input stream.\n"
3107 "Compression/decompression is not supported "
3108 "by the hddm c i/o interface.\n");
3109 fprintf(stderrstderr,"You must use the c++ "
3110 "interface to read this file.\n");
3111 exit(9);
3112 }
3113 else if (size > 0)
3114 {
3115 off_t start = xdr_getpos64(xdrs);
3116 int m;
3117 unsigned int mult;
3118 xdr_u_int(xdrs,&mult);
3119 this1 = make_s_BcalIncidentParticles(mult);
3120 this1->mult = mult;
3121 for (m = 0; m < mult; m++ )
3122 {
3123 xdr_int(xdrs,&this1->in[m].id);
3124 xdr_int(xdrs,&this1->in[m].ptype);
3125 xdr_float(xdrs,&this1->in[m].px);
3126 xdr_float(xdrs,&this1->in[m].py);
3127 xdr_float(xdrs,&this1->in[m].pz);
3128 xdr_float(xdrs,&this1->in[m].x);
3129 xdr_float(xdrs,&this1->in[m].y);
3130 xdr_float(xdrs,&this1->in[m].z);
3131 }
3132 xdr_setpos64(xdrs,start+size);
3133 }
3134 return this1;
3135}
3136
3137static s_BcalSiPMSpectrums_t* unpack_s_BcalSiPMSpectrums(XDR* xdrs, popNode* pop)
3138{
3139 s_BcalSiPMSpectrums_t* this1 = (s_BcalSiPMSpectrums_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3140 unsigned int size;
3141 if (! xdr_u_int(xdrs,&size))
3142 {
3143 return this1;
3144 }
3145 else if (size == 1)
3146 {
3147 fprintf(stderrstderr,"hddm error - "
3148 "compressed data found in input stream.\n"
3149 "Compression/decompression is not supported "
3150 "by the hddm c i/o interface.\n");
3151 fprintf(stderrstderr,"You must use the c++ "
3152 "interface to read this file.\n");
3153 exit(9);
3154 }
3155 else if (size > 0)
3156 {
3157 off_t start = xdr_getpos64(xdrs);
3158 int m;
3159 unsigned int mult;
3160 xdr_u_int(xdrs,&mult);
3161 this1 = make_s_BcalSiPMSpectrums(mult);
3162 this1->mult = mult;
3163 for (m = 0; m < mult; m++ )
3164 {
3165 xdr_float(xdrs,&this1->in[m].Etruth);
3166 xdr_float(xdrs,&this1->in[m].bin_width);
3167 xdr_int(xdrs,&this1->in[m].end);
3168 xdr_int(xdrs,&this1->in[m].incident_id);
3169 xdr_int(xdrs,&this1->in[m].layer);
3170 xdr_int(xdrs,&this1->in[m].module);
3171 xdr_int(xdrs,&this1->in[m].sector);
3172 xdr_float(xdrs,&this1->in[m].tstart);
3173 this1->in[m].vals = 0;
3174 xdr_string(xdrs, &this1->in[m].vals, 1000000);
3175 }
3176 xdr_setpos64(xdrs,start+size);
3177 }
3178 return this1;
3179}
3180
3181static s_BcalfADCCells_t* unpack_s_BcalfADCCells(XDR* xdrs, popNode* pop)
3182{
3183 s_BcalfADCCells_t* this1 = (s_BcalfADCCells_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3184 unsigned int size;
3185 if (! xdr_u_int(xdrs,&size))
3186 {
3187 return this1;
3188 }
3189 else if (size == 1)
3190 {
3191 fprintf(stderrstderr,"hddm error - "
3192 "compressed data found in input stream.\n"
3193 "Compression/decompression is not supported "
3194 "by the hddm c i/o interface.\n");
3195 fprintf(stderrstderr,"You must use the c++ "
3196 "interface to read this file.\n");
3197 exit(9);
3198 }
3199 else if (size > 0)
3200 {
3201 off_t start = xdr_getpos64(xdrs);
3202 int m;
3203 unsigned int mult;
3204 xdr_u_int(xdrs,&mult);
3205 this1 = make_s_BcalfADCCells(mult);
3206 this1->mult = mult;
3207 for (m = 0; m < mult; m++ )
3208 {
3209 int p;
3210 void* (*ptr) = (void**) &this1->in[m].bcalfADCUpHits;
3211 xdr_int(xdrs,&this1->in[m].layer);
3212 xdr_int(xdrs,&this1->in[m].module);
3213 xdr_int(xdrs,&this1->in[m].sector);
3214 for (p = 0; p < pop->popListLength; p++)
3215 {
3216 popNode* pnode = pop->popList[p];
3217 if (pnode)
3218 {
3219 int kid = pnode->inParent;
3220 ptr[kid] = pnode->unpacker(xdrs,pnode);
3221 }
3222 else
3223 {
3224 unsigned int skip;
3225 xdr_u_int(xdrs,&skip);
3226 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
3227 }
3228 }
3229 }
3230 xdr_setpos64(xdrs,start+size);
3231 }
3232 return this1;
3233}
3234
3235static s_BcalfADCUpHits_t* unpack_s_BcalfADCUpHits(XDR* xdrs, popNode* pop)
3236{
3237 s_BcalfADCUpHits_t* this1 = (s_BcalfADCUpHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3238 unsigned int size;
3239 if (! xdr_u_int(xdrs,&size))
3240 {
3241 return this1;
3242 }
3243 else if (size == 1)
3244 {
3245 fprintf(stderrstderr,"hddm error - "
3246 "compressed data found in input stream.\n"
3247 "Compression/decompression is not supported "
3248 "by the hddm c i/o interface.\n");
3249 fprintf(stderrstderr,"You must use the c++ "
3250 "interface to read this file.\n");
3251 exit(9);
3252 }
3253 else if (size > 0)
3254 {
3255 off_t start = xdr_getpos64(xdrs);
3256 int m;
3257 unsigned int mult;
3258 xdr_u_int(xdrs,&mult);
3259 this1 = make_s_BcalfADCUpHits(mult);
3260 this1->mult = mult;
3261 for (m = 0; m < mult; m++ )
3262 {
3263 xdr_float(xdrs,&this1->in[m].E);
3264 xdr_float(xdrs,&this1->in[m].t);
3265 }
3266 xdr_setpos64(xdrs,start+size);
3267 }
3268 return this1;
3269}
3270
3271static s_BcalfADCDownHits_t* unpack_s_BcalfADCDownHits(XDR* xdrs, popNode* pop)
3272{
3273 s_BcalfADCDownHits_t* this1 = (s_BcalfADCDownHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3274 unsigned int size;
3275 if (! xdr_u_int(xdrs,&size))
3276 {
3277 return this1;
3278 }
3279 else if (size == 1)
3280 {
3281 fprintf(stderrstderr,"hddm error - "
3282 "compressed data found in input stream.\n"
3283 "Compression/decompression is not supported "
3284 "by the hddm c i/o interface.\n");
3285 fprintf(stderrstderr,"You must use the c++ "
3286 "interface to read this file.\n");
3287 exit(9);
3288 }
3289 else if (size > 0)
3290 {
3291 off_t start = xdr_getpos64(xdrs);
3292 int m;
3293 unsigned int mult;
3294 xdr_u_int(xdrs,&mult);
3295 this1 = make_s_BcalfADCDownHits(mult);
3296 this1->mult = mult;
3297 for (m = 0; m < mult; m++ )
3298 {
3299 xdr_float(xdrs,&this1->in[m].E);
3300 xdr_float(xdrs,&this1->in[m].t);
3301 }
3302 xdr_setpos64(xdrs,start+size);
3303 }
3304 return this1;
3305}
3306
3307static s_BcalTDCHits_t* unpack_s_BcalTDCHits(XDR* xdrs, popNode* pop)
3308{
3309 s_BcalTDCHits_t* this1 = (s_BcalTDCHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3310 unsigned int size;
3311 if (! xdr_u_int(xdrs,&size))
3312 {
3313 return this1;
3314 }
3315 else if (size == 1)
3316 {
3317 fprintf(stderrstderr,"hddm error - "
3318 "compressed data found in input stream.\n"
3319 "Compression/decompression is not supported "
3320 "by the hddm c i/o interface.\n");
3321 fprintf(stderrstderr,"You must use the c++ "
3322 "interface to read this file.\n");
3323 exit(9);
3324 }
3325 else if (size > 0)
3326 {
3327 off_t start = xdr_getpos64(xdrs);
3328 int m;
3329 unsigned int mult;
3330 xdr_u_int(xdrs,&mult);
3331 this1 = make_s_BcalTDCHits(mult);
3332 this1->mult = mult;
3333 for (m = 0; m < mult; m++ )
3334 {
3335 xdr_int(xdrs,&this1->in[m].end);
3336 xdr_int(xdrs,&this1->in[m].layer);
3337 xdr_int(xdrs,&this1->in[m].module);
3338 xdr_int(xdrs,&this1->in[m].sector);
3339 xdr_float(xdrs,&this1->in[m].t);
3340 }
3341 xdr_setpos64(xdrs,start+size);
3342 }
3343 return this1;
3344}
3345
3346static s_BcalTruthShowers_t* unpack_s_BcalTruthShowers(XDR* xdrs, popNode* pop)
3347{
3348 s_BcalTruthShowers_t* this1 = (s_BcalTruthShowers_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3349 unsigned int size;
3350 if (! xdr_u_int(xdrs,&size))
3351 {
3352 return this1;
3353 }
3354 else if (size == 1)
3355 {
3356 fprintf(stderrstderr,"hddm error - "
3357 "compressed data found in input stream.\n"
3358 "Compression/decompression is not supported "
3359 "by the hddm c i/o interface.\n");
3360 fprintf(stderrstderr,"You must use the c++ "
3361 "interface to read this file.\n");
3362 exit(9);
3363 }
3364 else if (size > 0)
3365 {
3366 off_t start = xdr_getpos64(xdrs);
3367 int m;
3368 unsigned int mult;
3369 xdr_u_int(xdrs,&mult);
3370 this1 = make_s_BcalTruthShowers(mult);
3371 this1->mult = mult;
3372 for (m = 0; m < mult; m++ )
3373 {
3374 xdr_float(xdrs,&this1->in[m].E);
3375 xdr_float(xdrs,&this1->in[m].phi);
3376 xdr_bool(xdrs,&this1->in[m].primary);
3377 xdr_int(xdrs,&this1->in[m].ptype);
3378 xdr_float(xdrs,&this1->in[m].px);
3379 xdr_float(xdrs,&this1->in[m].py);
3380 xdr_float(xdrs,&this1->in[m].pz);
3381 xdr_float(xdrs,&this1->in[m].r);
3382 xdr_float(xdrs,&this1->in[m].t);
3383 xdr_int(xdrs,&this1->in[m].track);
3384 xdr_float(xdrs,&this1->in[m].z);
3385 }
3386 xdr_setpos64(xdrs,start+size);
3387 }
3388 return this1;
3389}
3390
3391static s_GapEMcal_t* unpack_s_GapEMcal(XDR* xdrs, popNode* pop)
3392{
3393 s_GapEMcal_t* this1 = (s_GapEMcal_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3394 unsigned int size;
3395 if (! xdr_u_int(xdrs,&size))
3396 {
3397 return this1;
3398 }
3399 else if (size == 1)
3400 {
3401 fprintf(stderrstderr,"hddm error - "
3402 "compressed data found in input stream.\n"
3403 "Compression/decompression is not supported "
3404 "by the hddm c i/o interface.\n");
3405 fprintf(stderrstderr,"You must use the c++ "
3406 "interface to read this file.\n");
3407 exit(9);
3408 }
3409 else if (size > 0)
3410 {
3411 off_t start = xdr_getpos64(xdrs);
3412 this1 = make_s_GapEMcal();
3413 {
3414 int p;
3415 void* (*ptr) = (void**) &this1->gcalCells;
3416 for (p = 0; p < pop->popListLength; p++)
3417 {
3418 popNode* pnode = pop->popList[p];
3419 if (pnode)
3420 {
3421 int kid = pnode->inParent;
3422 ptr[kid] = pnode->unpacker(xdrs,pnode);
3423 }
3424 else
3425 {
3426 unsigned int skip;
3427 xdr_u_int(xdrs,&skip);
3428 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
3429 }
3430 }
3431 }
3432 xdr_setpos64(xdrs,start+size);
3433 }
3434 return this1;
3435}
3436
3437static s_GcalCells_t* unpack_s_GcalCells(XDR* xdrs, popNode* pop)
3438{
3439 s_GcalCells_t* this1 = (s_GcalCells_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3440 unsigned int size;
3441 if (! xdr_u_int(xdrs,&size))
3442 {
3443 return this1;
3444 }
3445 else if (size == 1)
3446 {
3447 fprintf(stderrstderr,"hddm error - "
3448 "compressed data found in input stream.\n"
3449 "Compression/decompression is not supported "
3450 "by the hddm c i/o interface.\n");
3451 fprintf(stderrstderr,"You must use the c++ "
3452 "interface to read this file.\n");
3453 exit(9);
3454 }
3455 else if (size > 0)
3456 {
3457 off_t start = xdr_getpos64(xdrs);
3458 int m;
3459 unsigned int mult;
3460 xdr_u_int(xdrs,&mult);
3461 this1 = make_s_GcalCells(mult);
3462 this1->mult = mult;
3463 for (m = 0; m < mult; m++ )
3464 {
3465 int p;
3466 void* (*ptr) = (void**) &this1->in[m].gcalHits;
3467 xdr_int(xdrs,&this1->in[m].module);
3468 for (p = 0; p < pop->popListLength; p++)
3469 {
3470 popNode* pnode = pop->popList[p];
3471 if (pnode)
3472 {
3473 int kid = pnode->inParent;
3474 ptr[kid] = pnode->unpacker(xdrs,pnode);
3475 }
3476 else
3477 {
3478 unsigned int skip;
3479 xdr_u_int(xdrs,&skip);
3480 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
3481 }
3482 }
3483 }
3484 xdr_setpos64(xdrs,start+size);
3485 }
3486 return this1;
3487}
3488
3489static s_GcalHits_t* unpack_s_GcalHits(XDR* xdrs, popNode* pop)
3490{
3491 s_GcalHits_t* this1 = (s_GcalHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3492 unsigned int size;
3493 if (! xdr_u_int(xdrs,&size))
3494 {
3495 return this1;
3496 }
3497 else if (size == 1)
3498 {
3499 fprintf(stderrstderr,"hddm error - "
3500 "compressed data found in input stream.\n"
3501 "Compression/decompression is not supported "
3502 "by the hddm c i/o interface.\n");
3503 fprintf(stderrstderr,"You must use the c++ "
3504 "interface to read this file.\n");
3505 exit(9);
3506 }
3507 else if (size > 0)
3508 {
3509 off_t start = xdr_getpos64(xdrs);
3510 int m;
3511 unsigned int mult;
3512 xdr_u_int(xdrs,&mult);
3513 this1 = make_s_GcalHits(mult);
3514 this1->mult = mult;
3515 for (m = 0; m < mult; m++ )
3516 {
3517 xdr_float(xdrs,&this1->in[m].E);
3518 xdr_float(xdrs,&this1->in[m].t);
3519 xdr_float(xdrs,&this1->in[m].zLocal);
3520 }
3521 xdr_setpos64(xdrs,start+size);
3522 }
3523 return this1;
3524}
3525
3526static s_GcalTruthShowers_t* unpack_s_GcalTruthShowers(XDR* xdrs, popNode* pop)
3527{
3528 s_GcalTruthShowers_t* this1 = (s_GcalTruthShowers_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3529 unsigned int size;
3530 if (! xdr_u_int(xdrs,&size))
3531 {
3532 return this1;
3533 }
3534 else if (size == 1)
3535 {
3536 fprintf(stderrstderr,"hddm error - "
3537 "compressed data found in input stream.\n"
3538 "Compression/decompression is not supported "
3539 "by the hddm c i/o interface.\n");
3540 fprintf(stderrstderr,"You must use the c++ "
3541 "interface to read this file.\n");
3542 exit(9);
3543 }
3544 else if (size > 0)
3545 {
3546 off_t start = xdr_getpos64(xdrs);
3547 int m;
3548 unsigned int mult;
3549 xdr_u_int(xdrs,&mult);
3550 this1 = make_s_GcalTruthShowers(mult);
3551 this1->mult = mult;
3552 for (m = 0; m < mult; m++ )
3553 {
3554 xdr_float(xdrs,&this1->in[m].E);
3555 xdr_float(xdrs,&this1->in[m].phi);
3556 xdr_bool(xdrs,&this1->in[m].primary);
3557 xdr_int(xdrs,&this1->in[m].ptype);
3558 xdr_float(xdrs,&this1->in[m].px);
3559 xdr_float(xdrs,&this1->in[m].py);
3560 xdr_float(xdrs,&this1->in[m].pz);
3561 xdr_float(xdrs,&this1->in[m].r);
3562 xdr_float(xdrs,&this1->in[m].t);
3563 xdr_int(xdrs,&this1->in[m].track);
3564 xdr_float(xdrs,&this1->in[m].z);
3565 }
3566 xdr_setpos64(xdrs,start+size);
3567 }
3568 return this1;
3569}
3570
3571static s_Cerenkov_t* unpack_s_Cerenkov(XDR* xdrs, popNode* pop)
3572{
3573 s_Cerenkov_t* this1 = (s_Cerenkov_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3574 unsigned int size;
3575 if (! xdr_u_int(xdrs,&size))
3576 {
3577 return this1;
3578 }
3579 else if (size == 1)
3580 {
3581 fprintf(stderrstderr,"hddm error - "
3582 "compressed data found in input stream.\n"
3583 "Compression/decompression is not supported "
3584 "by the hddm c i/o interface.\n");
3585 fprintf(stderrstderr,"You must use the c++ "
3586 "interface to read this file.\n");
3587 exit(9);
3588 }
3589 else if (size > 0)
3590 {
3591 off_t start = xdr_getpos64(xdrs);
3592 this1 = make_s_Cerenkov();
3593 {
3594 int p;
3595 void* (*ptr) = (void**) &this1->cereSections;
3596 for (p = 0; p < pop->popListLength; p++)
3597 {
3598 popNode* pnode = pop->popList[p];
3599 if (pnode)
3600 {
3601 int kid = pnode->inParent;
3602 ptr[kid] = pnode->unpacker(xdrs,pnode);
3603 }
3604 else
3605 {
3606 unsigned int skip;
3607 xdr_u_int(xdrs,&skip);
3608 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
3609 }
3610 }
3611 }
3612 xdr_setpos64(xdrs,start+size);
3613 }
3614 return this1;
3615}
3616
3617static s_CereSections_t* unpack_s_CereSections(XDR* xdrs, popNode* pop)
3618{
3619 s_CereSections_t* this1 = (s_CereSections_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3620 unsigned int size;
3621 if (! xdr_u_int(xdrs,&size))
3622 {
3623 return this1;
3624 }
3625 else if (size == 1)
3626 {
3627 fprintf(stderrstderr,"hddm error - "
3628 "compressed data found in input stream.\n"
3629 "Compression/decompression is not supported "
3630 "by the hddm c i/o interface.\n");
3631 fprintf(stderrstderr,"You must use the c++ "
3632 "interface to read this file.\n");
3633 exit(9);
3634 }
3635 else if (size > 0)
3636 {
3637 off_t start = xdr_getpos64(xdrs);
3638 int m;
3639 unsigned int mult;
3640 xdr_u_int(xdrs,&mult);
3641 this1 = make_s_CereSections(mult);
3642 this1->mult = mult;
3643 for (m = 0; m < mult; m++ )
3644 {
3645 int p;
3646 void* (*ptr) = (void**) &this1->in[m].cereHits;
3647 xdr_int(xdrs,&this1->in[m].sector);
3648 for (p = 0; p < pop->popListLength; p++)
3649 {
3650 popNode* pnode = pop->popList[p];
3651 if (pnode)
3652 {
3653 int kid = pnode->inParent;
3654 ptr[kid] = pnode->unpacker(xdrs,pnode);
3655 }
3656 else
3657 {
3658 unsigned int skip;
3659 xdr_u_int(xdrs,&skip);
3660 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
3661 }
3662 }
3663 }
3664 xdr_setpos64(xdrs,start+size);
3665 }
3666 return this1;
3667}
3668
3669static s_CereHits_t* unpack_s_CereHits(XDR* xdrs, popNode* pop)
3670{
3671 s_CereHits_t* this1 = (s_CereHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3672 unsigned int size;
3673 if (! xdr_u_int(xdrs,&size))
3674 {
3675 return this1;
3676 }
3677 else if (size == 1)
3678 {
3679 fprintf(stderrstderr,"hddm error - "
3680 "compressed data found in input stream.\n"
3681 "Compression/decompression is not supported "
3682 "by the hddm c i/o interface.\n");
3683 fprintf(stderrstderr,"You must use the c++ "
3684 "interface to read this file.\n");
3685 exit(9);
3686 }
3687 else if (size > 0)
3688 {
3689 off_t start = xdr_getpos64(xdrs);
3690 int m;
3691 unsigned int mult;
3692 xdr_u_int(xdrs,&mult);
3693 this1 = make_s_CereHits(mult);
3694 this1->mult = mult;
3695 for (m = 0; m < mult; m++ )
3696 {
3697 xdr_float(xdrs,&this1->in[m].pe);
3698 xdr_float(xdrs,&this1->in[m].t);
3699 }
3700 xdr_setpos64(xdrs,start+size);
3701 }
3702 return this1;
3703}
3704
3705static s_CereTruthPoints_t* unpack_s_CereTruthPoints(XDR* xdrs, popNode* pop)
3706{
3707 s_CereTruthPoints_t* this1 = (s_CereTruthPoints_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3708 unsigned int size;
3709 if (! xdr_u_int(xdrs,&size))
3710 {
3711 return this1;
3712 }
3713 else if (size == 1)
3714 {
3715 fprintf(stderrstderr,"hddm error - "
3716 "compressed data found in input stream.\n"
3717 "Compression/decompression is not supported "
3718 "by the hddm c i/o interface.\n");
3719 fprintf(stderrstderr,"You must use the c++ "
3720 "interface to read this file.\n");
3721 exit(9);
3722 }
3723 else if (size > 0)
3724 {
3725 off_t start = xdr_getpos64(xdrs);
3726 int m;
3727 unsigned int mult;
3728 xdr_u_int(xdrs,&mult);
3729 this1 = make_s_CereTruthPoints(mult);
3730 this1->mult = mult;
3731 for (m = 0; m < mult; m++ )
3732 {
3733 xdr_float(xdrs,&this1->in[m].E);
3734 xdr_bool(xdrs,&this1->in[m].primary);
3735 xdr_int(xdrs,&this1->in[m].ptype);
3736 xdr_float(xdrs,&this1->in[m].px);
3737 xdr_float(xdrs,&this1->in[m].py);
3738 xdr_float(xdrs,&this1->in[m].pz);
3739 xdr_float(xdrs,&this1->in[m].t);
3740 xdr_int(xdrs,&this1->in[m].track);
3741 xdr_float(xdrs,&this1->in[m].x);
3742 xdr_float(xdrs,&this1->in[m].y);
3743 xdr_float(xdrs,&this1->in[m].z);
3744 }
3745 xdr_setpos64(xdrs,start+size);
3746 }
3747 return this1;
3748}
3749
3750static s_ForwardTOF_t* unpack_s_ForwardTOF(XDR* xdrs, popNode* pop)
3751{
3752 s_ForwardTOF_t* this1 = (s_ForwardTOF_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3753 unsigned int size;
3754 if (! xdr_u_int(xdrs,&size))
3755 {
3756 return this1;
3757 }
3758 else if (size == 1)
3759 {
3760 fprintf(stderrstderr,"hddm error - "
3761 "compressed data found in input stream.\n"
3762 "Compression/decompression is not supported "
3763 "by the hddm c i/o interface.\n");
3764 fprintf(stderrstderr,"You must use the c++ "
3765 "interface to read this file.\n");
3766 exit(9);
3767 }
3768 else if (size > 0)
3769 {
3770 off_t start = xdr_getpos64(xdrs);
3771 this1 = make_s_ForwardTOF();
3772 {
3773 int p;
3774 void* (*ptr) = (void**) &this1->ftofCounters;
3775 for (p = 0; p < pop->popListLength; p++)
3776 {
3777 popNode* pnode = pop->popList[p];
3778 if (pnode)
3779 {
3780 int kid = pnode->inParent;
3781 ptr[kid] = pnode->unpacker(xdrs,pnode);
3782 }
3783 else
3784 {
3785 unsigned int skip;
3786 xdr_u_int(xdrs,&skip);
3787 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
3788 }
3789 }
3790 }
3791 xdr_setpos64(xdrs,start+size);
3792 }
3793 return this1;
3794}
3795
3796static s_FtofCounters_t* unpack_s_FtofCounters(XDR* xdrs, popNode* pop)
3797{
3798 s_FtofCounters_t* this1 = (s_FtofCounters_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3799 unsigned int size;
3800 if (! xdr_u_int(xdrs,&size))
3801 {
3802 return this1;
3803 }
3804 else if (size == 1)
3805 {
3806 fprintf(stderrstderr,"hddm error - "
3807 "compressed data found in input stream.\n"
3808 "Compression/decompression is not supported "
3809 "by the hddm c i/o interface.\n");
3810 fprintf(stderrstderr,"You must use the c++ "
3811 "interface to read this file.\n");
3812 exit(9);
3813 }
3814 else if (size > 0)
3815 {
3816 off_t start = xdr_getpos64(xdrs);
3817 int m;
3818 unsigned int mult;
3819 xdr_u_int(xdrs,&mult);
3820 this1 = make_s_FtofCounters(mult);
3821 this1->mult = mult;
3822 for (m = 0; m < mult; m++ )
3823 {
3824 int p;
3825 void* (*ptr) = (void**) &this1->in[m].ftofNorthTruthHits;
3826 xdr_int(xdrs,&this1->in[m].bar);
3827 xdr_int(xdrs,&this1->in[m].plane);
3828 for (p = 0; p < pop->popListLength; p++)
3829 {
3830 popNode* pnode = pop->popList[p];
3831 if (pnode)
3832 {
3833 int kid = pnode->inParent;
3834 ptr[kid] = pnode->unpacker(xdrs,pnode);
3835 }
3836 else
3837 {
3838 unsigned int skip;
3839 xdr_u_int(xdrs,&skip);
3840 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
3841 }
3842 }
3843 }
3844 xdr_setpos64(xdrs,start+size);
3845 }
3846 return this1;
3847}
3848
3849static s_FtofNorthTruthHits_t* unpack_s_FtofNorthTruthHits(XDR* xdrs, popNode* pop)
3850{
3851 s_FtofNorthTruthHits_t* this1 = (s_FtofNorthTruthHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3852 unsigned int size;
3853 if (! xdr_u_int(xdrs,&size))
3854 {
3855 return this1;
3856 }
3857 else if (size == 1)
3858 {
3859 fprintf(stderrstderr,"hddm error - "
3860 "compressed data found in input stream.\n"
3861 "Compression/decompression is not supported "
3862 "by the hddm c i/o interface.\n");
3863 fprintf(stderrstderr,"You must use the c++ "
3864 "interface to read this file.\n");
3865 exit(9);
3866 }
3867 else if (size > 0)
3868 {
3869 off_t start = xdr_getpos64(xdrs);
3870 int m;
3871 unsigned int mult;
3872 xdr_u_int(xdrs,&mult);
3873 this1 = make_s_FtofNorthTruthHits(mult);
3874 this1->mult = mult;
3875 for (m = 0; m < mult; m++ )
3876 {
3877 int p;
3878 void* (*ptr) = (void**) &this1->in[m].ftofMCHits;
3879 xdr_float(xdrs,&this1->in[m].dE);
3880 xdr_float(xdrs,&this1->in[m].t);
3881 for (p = 0; p < pop->popListLength; p++)
3882 {
3883 popNode* pnode = pop->popList[p];
3884 if (pnode)
3885 {
3886 int kid = pnode->inParent;
3887 ptr[kid] = pnode->unpacker(xdrs,pnode);
3888 }
3889 else
3890 {
3891 unsigned int skip;
3892 xdr_u_int(xdrs,&skip);
3893 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
3894 }
3895 }
3896 }
3897 xdr_setpos64(xdrs,start+size);
3898 }
3899 return this1;
3900}
3901
3902static s_FtofMCHits_t* unpack_s_FtofMCHits(XDR* xdrs, popNode* pop)
3903{
3904 s_FtofMCHits_t* this1 = (s_FtofMCHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3905 unsigned int size;
3906 if (! xdr_u_int(xdrs,&size))
3907 {
3908 return this1;
3909 }
3910 else if (size == 1)
3911 {
3912 fprintf(stderrstderr,"hddm error - "
3913 "compressed data found in input stream.\n"
3914 "Compression/decompression is not supported "
3915 "by the hddm c i/o interface.\n");
3916 fprintf(stderrstderr,"You must use the c++ "
3917 "interface to read this file.\n");
3918 exit(9);
3919 }
3920 else if (size > 0)
3921 {
3922 off_t start = xdr_getpos64(xdrs);
3923 int m;
3924 unsigned int mult;
3925 xdr_u_int(xdrs,&mult);
3926 this1 = make_s_FtofMCHits(mult);
3927 this1->mult = mult;
3928 for (m = 0; m < mult; m++ )
3929 {
3930 xdr_float(xdrs,&this1->in[m].E);
3931 xdr_float(xdrs,&this1->in[m].dist);
3932 xdr_int(xdrs,&this1->in[m].itrack);
3933 xdr_int(xdrs,&this1->in[m].ptype);
3934 xdr_float(xdrs,&this1->in[m].px);
3935 xdr_float(xdrs,&this1->in[m].py);
3936 xdr_float(xdrs,&this1->in[m].pz);
3937 xdr_float(xdrs,&this1->in[m].x);
3938 xdr_float(xdrs,&this1->in[m].y);
3939 xdr_float(xdrs,&this1->in[m].z);
3940 }
3941 xdr_setpos64(xdrs,start+size);
3942 }
3943 return this1;
3944}
3945
3946static s_FtofSouthTruthHits_t* unpack_s_FtofSouthTruthHits(XDR* xdrs, popNode* pop)
3947{
3948 s_FtofSouthTruthHits_t* this1 = (s_FtofSouthTruthHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
3949 unsigned int size;
3950 if (! xdr_u_int(xdrs,&size))
3951 {
3952 return this1;
3953 }
3954 else if (size == 1)
3955 {
3956 fprintf(stderrstderr,"hddm error - "
3957 "compressed data found in input stream.\n"
3958 "Compression/decompression is not supported "
3959 "by the hddm c i/o interface.\n");
3960 fprintf(stderrstderr,"You must use the c++ "
3961 "interface to read this file.\n");
3962 exit(9);
3963 }
3964 else if (size > 0)
3965 {
3966 off_t start = xdr_getpos64(xdrs);
3967 int m;
3968 unsigned int mult;
3969 xdr_u_int(xdrs,&mult);
3970 this1 = make_s_FtofSouthTruthHits(mult);
3971 this1->mult = mult;
3972 for (m = 0; m < mult; m++ )
3973 {
3974 int p;
3975 void* (*ptr) = (void**) &this1->in[m].ftofMCHits;
3976 xdr_float(xdrs,&this1->in[m].dE);
3977 xdr_float(xdrs,&this1->in[m].t);
3978 for (p = 0; p < pop->popListLength; p++)
3979 {
3980 popNode* pnode = pop->popList[p];
3981 if (pnode)
3982 {
3983 int kid = pnode->inParent;
3984 ptr[kid] = pnode->unpacker(xdrs,pnode);
3985 }
3986 else
3987 {
3988 unsigned int skip;
3989 xdr_u_int(xdrs,&skip);
3990 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
3991 }
3992 }
3993 }
3994 xdr_setpos64(xdrs,start+size);
3995 }
3996 return this1;
3997}
3998
3999static s_FtofNorthHits_t* unpack_s_FtofNorthHits(XDR* xdrs, popNode* pop)
4000{
4001 s_FtofNorthHits_t* this1 = (s_FtofNorthHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4002 unsigned int size;
4003 if (! xdr_u_int(xdrs,&size))
4004 {
4005 return this1;
4006 }
4007 else if (size == 1)
4008 {
4009 fprintf(stderrstderr,"hddm error - "
4010 "compressed data found in input stream.\n"
4011 "Compression/decompression is not supported "
4012 "by the hddm c i/o interface.\n");
4013 fprintf(stderrstderr,"You must use the c++ "
4014 "interface to read this file.\n");
4015 exit(9);
4016 }
4017 else if (size > 0)
4018 {
4019 off_t start = xdr_getpos64(xdrs);
4020 int m;
4021 unsigned int mult;
4022 xdr_u_int(xdrs,&mult);
4023 this1 = make_s_FtofNorthHits(mult);
4024 this1->mult = mult;
4025 for (m = 0; m < mult; m++ )
4026 {
4027 xdr_float(xdrs,&this1->in[m].dE);
4028 xdr_float(xdrs,&this1->in[m].t);
4029 }
4030 xdr_setpos64(xdrs,start+size);
4031 }
4032 return this1;
4033}
4034
4035static s_FtofSouthHits_t* unpack_s_FtofSouthHits(XDR* xdrs, popNode* pop)
4036{
4037 s_FtofSouthHits_t* this1 = (s_FtofSouthHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4038 unsigned int size;
4039 if (! xdr_u_int(xdrs,&size))
4040 {
4041 return this1;
4042 }
4043 else if (size == 1)
4044 {
4045 fprintf(stderrstderr,"hddm error - "
4046 "compressed data found in input stream.\n"
4047 "Compression/decompression is not supported "
4048 "by the hddm c i/o interface.\n");
4049 fprintf(stderrstderr,"You must use the c++ "
4050 "interface to read this file.\n");
4051 exit(9);
4052 }
4053 else if (size > 0)
4054 {
4055 off_t start = xdr_getpos64(xdrs);
4056 int m;
4057 unsigned int mult;
4058 xdr_u_int(xdrs,&mult);
4059 this1 = make_s_FtofSouthHits(mult);
4060 this1->mult = mult;
4061 for (m = 0; m < mult; m++ )
4062 {
4063 xdr_float(xdrs,&this1->in[m].dE);
4064 xdr_float(xdrs,&this1->in[m].t);
4065 }
4066 xdr_setpos64(xdrs,start+size);
4067 }
4068 return this1;
4069}
4070
4071static s_FtofTruthPoints_t* unpack_s_FtofTruthPoints(XDR* xdrs, popNode* pop)
4072{
4073 s_FtofTruthPoints_t* this1 = (s_FtofTruthPoints_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4074 unsigned int size;
4075 if (! xdr_u_int(xdrs,&size))
4076 {
4077 return this1;
4078 }
4079 else if (size == 1)
4080 {
4081 fprintf(stderrstderr,"hddm error - "
4082 "compressed data found in input stream.\n"
4083 "Compression/decompression is not supported "
4084 "by the hddm c i/o interface.\n");
4085 fprintf(stderrstderr,"You must use the c++ "
4086 "interface to read this file.\n");
4087 exit(9);
4088 }
4089 else if (size > 0)
4090 {
4091 off_t start = xdr_getpos64(xdrs);
4092 int m;
4093 unsigned int mult;
4094 xdr_u_int(xdrs,&mult);
4095 this1 = make_s_FtofTruthPoints(mult);
4096 this1->mult = mult;
4097 for (m = 0; m < mult; m++ )
4098 {
4099 xdr_float(xdrs,&this1->in[m].E);
4100 xdr_bool(xdrs,&this1->in[m].primary);
4101 xdr_int(xdrs,&this1->in[m].ptype);
4102 xdr_float(xdrs,&this1->in[m].px);
4103 xdr_float(xdrs,&this1->in[m].py);
4104 xdr_float(xdrs,&this1->in[m].pz);
4105 xdr_float(xdrs,&this1->in[m].t);
4106 xdr_int(xdrs,&this1->in[m].track);
4107 xdr_float(xdrs,&this1->in[m].x);
4108 xdr_float(xdrs,&this1->in[m].y);
4109 xdr_float(xdrs,&this1->in[m].z);
4110 }
4111 xdr_setpos64(xdrs,start+size);
4112 }
4113 return this1;
4114}
4115
4116static s_ForwardEMcal_t* unpack_s_ForwardEMcal(XDR* xdrs, popNode* pop)
4117{
4118 s_ForwardEMcal_t* this1 = (s_ForwardEMcal_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4119 unsigned int size;
4120 if (! xdr_u_int(xdrs,&size))
4121 {
4122 return this1;
4123 }
4124 else if (size == 1)
4125 {
4126 fprintf(stderrstderr,"hddm error - "
4127 "compressed data found in input stream.\n"
4128 "Compression/decompression is not supported "
4129 "by the hddm c i/o interface.\n");
4130 fprintf(stderrstderr,"You must use the c++ "
4131 "interface to read this file.\n");
4132 exit(9);
4133 }
4134 else if (size > 0)
4135 {
4136 off_t start = xdr_getpos64(xdrs);
4137 this1 = make_s_ForwardEMcal();
4138 {
4139 int p;
4140 void* (*ptr) = (void**) &this1->fcalBlocks;
4141 for (p = 0; p < pop->popListLength; p++)
4142 {
4143 popNode* pnode = pop->popList[p];
4144 if (pnode)
4145 {
4146 int kid = pnode->inParent;
4147 ptr[kid] = pnode->unpacker(xdrs,pnode);
4148 }
4149 else
4150 {
4151 unsigned int skip;
4152 xdr_u_int(xdrs,&skip);
4153 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
4154 }
4155 }
4156 }
4157 xdr_setpos64(xdrs,start+size);
4158 }
4159 return this1;
4160}
4161
4162static s_FcalBlocks_t* unpack_s_FcalBlocks(XDR* xdrs, popNode* pop)
4163{
4164 s_FcalBlocks_t* this1 = (s_FcalBlocks_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4165 unsigned int size;
4166 if (! xdr_u_int(xdrs,&size))
4167 {
4168 return this1;
4169 }
4170 else if (size == 1)
4171 {
4172 fprintf(stderrstderr,"hddm error - "
4173 "compressed data found in input stream.\n"
4174 "Compression/decompression is not supported "
4175 "by the hddm c i/o interface.\n");
4176 fprintf(stderrstderr,"You must use the c++ "
4177 "interface to read this file.\n");
4178 exit(9);
4179 }
4180 else if (size > 0)
4181 {
4182 off_t start = xdr_getpos64(xdrs);
4183 int m;
4184 unsigned int mult;
4185 xdr_u_int(xdrs,&mult);
4186 this1 = make_s_FcalBlocks(mult);
4187 this1->mult = mult;
4188 for (m = 0; m < mult; m++ )
4189 {
4190 int p;
4191 void* (*ptr) = (void**) &this1->in[m].fcalHits;
4192 xdr_int(xdrs,&this1->in[m].column);
4193 xdr_int(xdrs,&this1->in[m].row);
4194 for (p = 0; p < pop->popListLength; p++)
4195 {
4196 popNode* pnode = pop->popList[p];
4197 if (pnode)
4198 {
4199 int kid = pnode->inParent;
4200 ptr[kid] = pnode->unpacker(xdrs,pnode);
4201 }
4202 else
4203 {
4204 unsigned int skip;
4205 xdr_u_int(xdrs,&skip);
4206 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
4207 }
4208 }
4209 }
4210 xdr_setpos64(xdrs,start+size);
4211 }
4212 return this1;
4213}
4214
4215static s_FcalHits_t* unpack_s_FcalHits(XDR* xdrs, popNode* pop)
4216{
4217 s_FcalHits_t* this1 = (s_FcalHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4218 unsigned int size;
4219 if (! xdr_u_int(xdrs,&size))
4220 {
4221 return this1;
4222 }
4223 else if (size == 1)
4224 {
4225 fprintf(stderrstderr,"hddm error - "
4226 "compressed data found in input stream.\n"
4227 "Compression/decompression is not supported "
4228 "by the hddm c i/o interface.\n");
4229 fprintf(stderrstderr,"You must use the c++ "
4230 "interface to read this file.\n");
4231 exit(9);
4232 }
4233 else if (size > 0)
4234 {
4235 off_t start = xdr_getpos64(xdrs);
4236 int m;
4237 unsigned int mult;
4238 xdr_u_int(xdrs,&mult);
4239 this1 = make_s_FcalHits(mult);
4240 this1->mult = mult;
4241 for (m = 0; m < mult; m++ )
4242 {
4243 xdr_float(xdrs,&this1->in[m].E);
4244 xdr_float(xdrs,&this1->in[m].t);
4245 }
4246 xdr_setpos64(xdrs,start+size);
4247 }
4248 return this1;
4249}
4250
4251static s_FcalTruthHits_t* unpack_s_FcalTruthHits(XDR* xdrs, popNode* pop)
4252{
4253 s_FcalTruthHits_t* this1 = (s_FcalTruthHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4254 unsigned int size;
4255 if (! xdr_u_int(xdrs,&size))
4256 {
4257 return this1;
4258 }
4259 else if (size == 1)
4260 {
4261 fprintf(stderrstderr,"hddm error - "
4262 "compressed data found in input stream.\n"
4263 "Compression/decompression is not supported "
4264 "by the hddm c i/o interface.\n");
4265 fprintf(stderrstderr,"You must use the c++ "
4266 "interface to read this file.\n");
4267 exit(9);
4268 }
4269 else if (size > 0)
4270 {
4271 off_t start = xdr_getpos64(xdrs);
4272 int m;
4273 unsigned int mult;
4274 xdr_u_int(xdrs,&mult);
4275 this1 = make_s_FcalTruthHits(mult);
4276 this1->mult = mult;
4277 for (m = 0; m < mult; m++ )
4278 {
4279 xdr_float(xdrs,&this1->in[m].E);
4280 xdr_float(xdrs,&this1->in[m].t);
4281 }
4282 xdr_setpos64(xdrs,start+size);
4283 }
4284 return this1;
4285}
4286
4287static s_FcalTruthShowers_t* unpack_s_FcalTruthShowers(XDR* xdrs, popNode* pop)
4288{
4289 s_FcalTruthShowers_t* this1 = (s_FcalTruthShowers_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4290 unsigned int size;
4291 if (! xdr_u_int(xdrs,&size))
4292 {
4293 return this1;
4294 }
4295 else if (size == 1)
4296 {
4297 fprintf(stderrstderr,"hddm error - "
4298 "compressed data found in input stream.\n"
4299 "Compression/decompression is not supported "
4300 "by the hddm c i/o interface.\n");
4301 fprintf(stderrstderr,"You must use the c++ "
4302 "interface to read this file.\n");
4303 exit(9);
4304 }
4305 else if (size > 0)
4306 {
4307 off_t start = xdr_getpos64(xdrs);
4308 int m;
4309 unsigned int mult;
4310 xdr_u_int(xdrs,&mult);
4311 this1 = make_s_FcalTruthShowers(mult);
4312 this1->mult = mult;
4313 for (m = 0; m < mult; m++ )
4314 {
4315 xdr_float(xdrs,&this1->in[m].E);
4316 xdr_bool(xdrs,&this1->in[m].primary);
4317 xdr_int(xdrs,&this1->in[m].ptype);
4318 xdr_float(xdrs,&this1->in[m].px);
4319 xdr_float(xdrs,&this1->in[m].py);
4320 xdr_float(xdrs,&this1->in[m].pz);
4321 xdr_float(xdrs,&this1->in[m].t);
4322 xdr_int(xdrs,&this1->in[m].track);
4323 xdr_float(xdrs,&this1->in[m].x);
4324 xdr_float(xdrs,&this1->in[m].y);
4325 xdr_float(xdrs,&this1->in[m].z);
4326 }
4327 xdr_setpos64(xdrs,start+size);
4328 }
4329 return this1;
4330}
4331
4332static s_ComptonEMcal_t* unpack_s_ComptonEMcal(XDR* xdrs, popNode* pop)
4333{
4334 s_ComptonEMcal_t* this1 = (s_ComptonEMcal_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4335 unsigned int size;
4336 if (! xdr_u_int(xdrs,&size))
4337 {
4338 return this1;
4339 }
4340 else if (size == 1)
4341 {
4342 fprintf(stderrstderr,"hddm error - "
4343 "compressed data found in input stream.\n"
4344 "Compression/decompression is not supported "
4345 "by the hddm c i/o interface.\n");
4346 fprintf(stderrstderr,"You must use the c++ "
4347 "interface to read this file.\n");
4348 exit(9);
4349 }
4350 else if (size > 0)
4351 {
4352 off_t start = xdr_getpos64(xdrs);
4353 this1 = make_s_ComptonEMcal();
4354 {
4355 int p;
4356 void* (*ptr) = (void**) &this1->ccalBlocks;
4357 for (p = 0; p < pop->popListLength; p++)
4358 {
4359 popNode* pnode = pop->popList[p];
4360 if (pnode)
4361 {
4362 int kid = pnode->inParent;
4363 ptr[kid] = pnode->unpacker(xdrs,pnode);
4364 }
4365 else
4366 {
4367 unsigned int skip;
4368 xdr_u_int(xdrs,&skip);
4369 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
4370 }
4371 }
4372 }
4373 xdr_setpos64(xdrs,start+size);
4374 }
4375 return this1;
4376}
4377
4378static s_CcalBlocks_t* unpack_s_CcalBlocks(XDR* xdrs, popNode* pop)
4379{
4380 s_CcalBlocks_t* this1 = (s_CcalBlocks_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4381 unsigned int size;
4382 if (! xdr_u_int(xdrs,&size))
4383 {
4384 return this1;
4385 }
4386 else if (size == 1)
4387 {
4388 fprintf(stderrstderr,"hddm error - "
4389 "compressed data found in input stream.\n"
4390 "Compression/decompression is not supported "
4391 "by the hddm c i/o interface.\n");
4392 fprintf(stderrstderr,"You must use the c++ "
4393 "interface to read this file.\n");
4394 exit(9);
4395 }
4396 else if (size > 0)
4397 {
4398 off_t start = xdr_getpos64(xdrs);
4399 int m;
4400 unsigned int mult;
4401 xdr_u_int(xdrs,&mult);
4402 this1 = make_s_CcalBlocks(mult);
4403 this1->mult = mult;
4404 for (m = 0; m < mult; m++ )
4405 {
4406 int p;
4407 void* (*ptr) = (void**) &this1->in[m].ccalHits;
4408 xdr_int(xdrs,&this1->in[m].column);
4409 xdr_int(xdrs,&this1->in[m].row);
4410 for (p = 0; p < pop->popListLength; p++)
4411 {
4412 popNode* pnode = pop->popList[p];
4413 if (pnode)
4414 {
4415 int kid = pnode->inParent;
4416 ptr[kid] = pnode->unpacker(xdrs,pnode);
4417 }
4418 else
4419 {
4420 unsigned int skip;
4421 xdr_u_int(xdrs,&skip);
4422 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
4423 }
4424 }
4425 }
4426 xdr_setpos64(xdrs,start+size);
4427 }
4428 return this1;
4429}
4430
4431static s_CcalHits_t* unpack_s_CcalHits(XDR* xdrs, popNode* pop)
4432{
4433 s_CcalHits_t* this1 = (s_CcalHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4434 unsigned int size;
4435 if (! xdr_u_int(xdrs,&size))
4436 {
4437 return this1;
4438 }
4439 else if (size == 1)
4440 {
4441 fprintf(stderrstderr,"hddm error - "
4442 "compressed data found in input stream.\n"
4443 "Compression/decompression is not supported "
4444 "by the hddm c i/o interface.\n");
4445 fprintf(stderrstderr,"You must use the c++ "
4446 "interface to read this file.\n");
4447 exit(9);
4448 }
4449 else if (size > 0)
4450 {
4451 off_t start = xdr_getpos64(xdrs);
4452 int m;
4453 unsigned int mult;
4454 xdr_u_int(xdrs,&mult);
4455 this1 = make_s_CcalHits(mult);
4456 this1->mult = mult;
4457 for (m = 0; m < mult; m++ )
4458 {
4459 xdr_float(xdrs,&this1->in[m].E);
4460 xdr_float(xdrs,&this1->in[m].t);
4461 }
4462 xdr_setpos64(xdrs,start+size);
4463 }
4464 return this1;
4465}
4466
4467static s_CcalTruthHits_t* unpack_s_CcalTruthHits(XDR* xdrs, popNode* pop)
4468{
4469 s_CcalTruthHits_t* this1 = (s_CcalTruthHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4470 unsigned int size;
4471 if (! xdr_u_int(xdrs,&size))
4472 {
4473 return this1;
4474 }
4475 else if (size == 1)
4476 {
4477 fprintf(stderrstderr,"hddm error - "
4478 "compressed data found in input stream.\n"
4479 "Compression/decompression is not supported "
4480 "by the hddm c i/o interface.\n");
4481 fprintf(stderrstderr,"You must use the c++ "
4482 "interface to read this file.\n");
4483 exit(9);
4484 }
4485 else if (size > 0)
4486 {
4487 off_t start = xdr_getpos64(xdrs);
4488 int m;
4489 unsigned int mult;
4490 xdr_u_int(xdrs,&mult);
4491 this1 = make_s_CcalTruthHits(mult);
4492 this1->mult = mult;
4493 for (m = 0; m < mult; m++ )
4494 {
4495 xdr_float(xdrs,&this1->in[m].E);
4496 xdr_float(xdrs,&this1->in[m].t);
4497 }
4498 xdr_setpos64(xdrs,start+size);
4499 }
4500 return this1;
4501}
4502
4503static s_CcalTruthShowers_t* unpack_s_CcalTruthShowers(XDR* xdrs, popNode* pop)
4504{
4505 s_CcalTruthShowers_t* this1 = (s_CcalTruthShowers_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4506 unsigned int size;
4507 if (! xdr_u_int(xdrs,&size))
4508 {
4509 return this1;
4510 }
4511 else if (size == 1)
4512 {
4513 fprintf(stderrstderr,"hddm error - "
4514 "compressed data found in input stream.\n"
4515 "Compression/decompression is not supported "
4516 "by the hddm c i/o interface.\n");
4517 fprintf(stderrstderr,"You must use the c++ "
4518 "interface to read this file.\n");
4519 exit(9);
4520 }
4521 else if (size > 0)
4522 {
4523 off_t start = xdr_getpos64(xdrs);
4524 int m;
4525 unsigned int mult;
4526 xdr_u_int(xdrs,&mult);
4527 this1 = make_s_CcalTruthShowers(mult);
4528 this1->mult = mult;
4529 for (m = 0; m < mult; m++ )
4530 {
4531 xdr_float(xdrs,&this1->in[m].E);
4532 xdr_bool(xdrs,&this1->in[m].primary);
4533 xdr_int(xdrs,&this1->in[m].ptype);
4534 xdr_float(xdrs,&this1->in[m].px);
4535 xdr_float(xdrs,&this1->in[m].py);
4536 xdr_float(xdrs,&this1->in[m].pz);
4537 xdr_float(xdrs,&this1->in[m].t);
4538 xdr_int(xdrs,&this1->in[m].track);
4539 xdr_float(xdrs,&this1->in[m].x);
4540 xdr_float(xdrs,&this1->in[m].y);
4541 xdr_float(xdrs,&this1->in[m].z);
4542 }
4543 xdr_setpos64(xdrs,start+size);
4544 }
4545 return this1;
4546}
4547
4548static s_UpstreamEMveto_t* unpack_s_UpstreamEMveto(XDR* xdrs, popNode* pop)
4549{
4550 s_UpstreamEMveto_t* this1 = (s_UpstreamEMveto_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4551 unsigned int size;
4552 if (! xdr_u_int(xdrs,&size))
4553 {
4554 return this1;
4555 }
4556 else if (size == 1)
4557 {
4558 fprintf(stderrstderr,"hddm error - "
4559 "compressed data found in input stream.\n"
4560 "Compression/decompression is not supported "
4561 "by the hddm c i/o interface.\n");
4562 fprintf(stderrstderr,"You must use the c++ "
4563 "interface to read this file.\n");
4564 exit(9);
4565 }
4566 else if (size > 0)
4567 {
4568 off_t start = xdr_getpos64(xdrs);
4569 this1 = make_s_UpstreamEMveto();
4570 {
4571 int p;
4572 void* (*ptr) = (void**) &this1->upvPaddles;
4573 for (p = 0; p < pop->popListLength; p++)
4574 {
4575 popNode* pnode = pop->popList[p];
4576 if (pnode)
4577 {
4578 int kid = pnode->inParent;
4579 ptr[kid] = pnode->unpacker(xdrs,pnode);
4580 }
4581 else
4582 {
4583 unsigned int skip;
4584 xdr_u_int(xdrs,&skip);
4585 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
4586 }
4587 }
4588 }
4589 xdr_setpos64(xdrs,start+size);
4590 }
4591 return this1;
4592}
4593
4594static s_UpvPaddles_t* unpack_s_UpvPaddles(XDR* xdrs, popNode* pop)
4595{
4596 s_UpvPaddles_t* this1 = (s_UpvPaddles_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4597 unsigned int size;
4598 if (! xdr_u_int(xdrs,&size))
4599 {
4600 return this1;
4601 }
4602 else if (size == 1)
4603 {
4604 fprintf(stderrstderr,"hddm error - "
4605 "compressed data found in input stream.\n"
4606 "Compression/decompression is not supported "
4607 "by the hddm c i/o interface.\n");
4608 fprintf(stderrstderr,"You must use the c++ "
4609 "interface to read this file.\n");
4610 exit(9);
4611 }
4612 else if (size > 0)
4613 {
4614 off_t start = xdr_getpos64(xdrs);
4615 int m;
4616 unsigned int mult;
4617 xdr_u_int(xdrs,&mult);
4618 this1 = make_s_UpvPaddles(mult);
4619 this1->mult = mult;
4620 for (m = 0; m < mult; m++ )
4621 {
4622 int p;
4623 void* (*ptr) = (void**) &this1->in[m].upvLeftHits;
4624 xdr_int(xdrs,&this1->in[m].layer);
4625 xdr_int(xdrs,&this1->in[m].row);
4626 for (p = 0; p < pop->popListLength; p++)
4627 {
4628 popNode* pnode = pop->popList[p];
4629 if (pnode)
4630 {
4631 int kid = pnode->inParent;
4632 ptr[kid] = pnode->unpacker(xdrs,pnode);
4633 }
4634 else
4635 {
4636 unsigned int skip;
4637 xdr_u_int(xdrs,&skip);
4638 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
4639 }
4640 }
4641 }
4642 xdr_setpos64(xdrs,start+size);
4643 }
4644 return this1;
4645}
4646
4647static s_UpvLeftHits_t* unpack_s_UpvLeftHits(XDR* xdrs, popNode* pop)
4648{
4649 s_UpvLeftHits_t* this1 = (s_UpvLeftHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4650 unsigned int size;
4651 if (! xdr_u_int(xdrs,&size))
4652 {
4653 return this1;
4654 }
4655 else if (size == 1)
4656 {
4657 fprintf(stderrstderr,"hddm error - "
4658 "compressed data found in input stream.\n"
4659 "Compression/decompression is not supported "
4660 "by the hddm c i/o interface.\n");
4661 fprintf(stderrstderr,"You must use the c++ "
4662 "interface to read this file.\n");
4663 exit(9);
4664 }
4665 else if (size > 0)
4666 {
4667 off_t start = xdr_getpos64(xdrs);
4668 int m;
4669 unsigned int mult;
4670 xdr_u_int(xdrs,&mult);
4671 this1 = make_s_UpvLeftHits(mult);
4672 this1->mult = mult;
4673 for (m = 0; m < mult; m++ )
4674 {
4675 xdr_float(xdrs,&this1->in[m].E);
4676 xdr_float(xdrs,&this1->in[m].t);
4677 }
4678 xdr_setpos64(xdrs,start+size);
4679 }
4680 return this1;
4681}
4682
4683static s_UpvRightHits_t* unpack_s_UpvRightHits(XDR* xdrs, popNode* pop)
4684{
4685 s_UpvRightHits_t* this1 = (s_UpvRightHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4686 unsigned int size;
4687 if (! xdr_u_int(xdrs,&size))
4688 {
4689 return this1;
4690 }
4691 else if (size == 1)
4692 {
4693 fprintf(stderrstderr,"hddm error - "
4694 "compressed data found in input stream.\n"
4695 "Compression/decompression is not supported "
4696 "by the hddm c i/o interface.\n");
4697 fprintf(stderrstderr,"You must use the c++ "
4698 "interface to read this file.\n");
4699 exit(9);
4700 }
4701 else if (size > 0)
4702 {
4703 off_t start = xdr_getpos64(xdrs);
4704 int m;
4705 unsigned int mult;
4706 xdr_u_int(xdrs,&mult);
4707 this1 = make_s_UpvRightHits(mult);
4708 this1->mult = mult;
4709 for (m = 0; m < mult; m++ )
4710 {
4711 xdr_float(xdrs,&this1->in[m].E);
4712 xdr_float(xdrs,&this1->in[m].t);
4713 }
4714 xdr_setpos64(xdrs,start+size);
4715 }
4716 return this1;
4717}
4718
4719static s_UpvTruthShowers_t* unpack_s_UpvTruthShowers(XDR* xdrs, popNode* pop)
4720{
4721 s_UpvTruthShowers_t* this1 = (s_UpvTruthShowers_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4722 unsigned int size;
4723 if (! xdr_u_int(xdrs,&size))
4724 {
4725 return this1;
4726 }
4727 else if (size == 1)
4728 {
4729 fprintf(stderrstderr,"hddm error - "
4730 "compressed data found in input stream.\n"
4731 "Compression/decompression is not supported "
4732 "by the hddm c i/o interface.\n");
4733 fprintf(stderrstderr,"You must use the c++ "
4734 "interface to read this file.\n");
4735 exit(9);
4736 }
4737 else if (size > 0)
4738 {
4739 off_t start = xdr_getpos64(xdrs);
4740 int m;
4741 unsigned int mult;
4742 xdr_u_int(xdrs,&mult);
4743 this1 = make_s_UpvTruthShowers(mult);
4744 this1->mult = mult;
4745 for (m = 0; m < mult; m++ )
4746 {
4747 xdr_float(xdrs,&this1->in[m].E);
4748 xdr_bool(xdrs,&this1->in[m].primary);
4749 xdr_int(xdrs,&this1->in[m].ptype);
4750 xdr_float(xdrs,&this1->in[m].px);
4751 xdr_float(xdrs,&this1->in[m].py);
4752 xdr_float(xdrs,&this1->in[m].pz);
4753 xdr_float(xdrs,&this1->in[m].t);
4754 xdr_int(xdrs,&this1->in[m].track);
4755 xdr_float(xdrs,&this1->in[m].x);
4756 xdr_float(xdrs,&this1->in[m].y);
4757 xdr_float(xdrs,&this1->in[m].z);
4758 }
4759 xdr_setpos64(xdrs,start+size);
4760 }
4761 return this1;
4762}
4763
4764static s_Tagger_t* unpack_s_Tagger(XDR* xdrs, popNode* pop)
4765{
4766 s_Tagger_t* this1 = (s_Tagger_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4767 unsigned int size;
4768 if (! xdr_u_int(xdrs,&size))
4769 {
4770 return this1;
4771 }
4772 else if (size == 1)
4773 {
4774 fprintf(stderrstderr,"hddm error - "
4775 "compressed data found in input stream.\n"
4776 "Compression/decompression is not supported "
4777 "by the hddm c i/o interface.\n");
4778 fprintf(stderrstderr,"You must use the c++ "
4779 "interface to read this file.\n");
4780 exit(9);
4781 }
4782 else if (size > 0)
4783 {
4784 off_t start = xdr_getpos64(xdrs);
4785 this1 = make_s_Tagger();
4786 {
4787 int p;
4788 void* (*ptr) = (void**) &this1->microChannels;
4789 for (p = 0; p < pop->popListLength; p++)
4790 {
4791 popNode* pnode = pop->popList[p];
4792 if (pnode)
4793 {
4794 int kid = pnode->inParent;
4795 ptr[kid] = pnode->unpacker(xdrs,pnode);
4796 }
4797 else
4798 {
4799 unsigned int skip;
4800 xdr_u_int(xdrs,&skip);
4801 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
4802 }
4803 }
4804 }
4805 xdr_setpos64(xdrs,start+size);
4806 }
4807 return this1;
4808}
4809
4810static s_MicroChannels_t* unpack_s_MicroChannels(XDR* xdrs, popNode* pop)
4811{
4812 s_MicroChannels_t* this1 = (s_MicroChannels_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4813 unsigned int size;
4814 if (! xdr_u_int(xdrs,&size))
4815 {
4816 return this1;
4817 }
4818 else if (size == 1)
4819 {
4820 fprintf(stderrstderr,"hddm error - "
4821 "compressed data found in input stream.\n"
4822 "Compression/decompression is not supported "
4823 "by the hddm c i/o interface.\n");
4824 fprintf(stderrstderr,"You must use the c++ "
4825 "interface to read this file.\n");
4826 exit(9);
4827 }
4828 else if (size > 0)
4829 {
4830 off_t start = xdr_getpos64(xdrs);
4831 int m;
4832 unsigned int mult;
4833 xdr_u_int(xdrs,&mult);
4834 this1 = make_s_MicroChannels(mult);
4835 this1->mult = mult;
4836 for (m = 0; m < mult; m++ )
4837 {
4838 int p;
4839 void* (*ptr) = (void**) &this1->in[m].taggerHits;
4840 xdr_float(xdrs,&this1->in[m].E);
4841 xdr_int(xdrs,&this1->in[m].column);
4842 xdr_int(xdrs,&this1->in[m].row);
4843 for (p = 0; p < pop->popListLength; p++)
4844 {
4845 popNode* pnode = pop->popList[p];
4846 if (pnode)
4847 {
4848 int kid = pnode->inParent;
4849 ptr[kid] = pnode->unpacker(xdrs,pnode);
4850 }
4851 else
4852 {
4853 unsigned int skip;
4854 xdr_u_int(xdrs,&skip);
4855 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
4856 }
4857 }
4858 }
4859 xdr_setpos64(xdrs,start+size);
4860 }
4861 return this1;
4862}
4863
4864static s_TaggerHits_t* unpack_s_TaggerHits(XDR* xdrs, popNode* pop)
4865{
4866 s_TaggerHits_t* this1 = (s_TaggerHits_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4867 unsigned int size;
4868 if (! xdr_u_int(xdrs,&size))
4869 {
4870 return this1;
4871 }
4872 else if (size == 1)
4873 {
4874 fprintf(stderrstderr,"hddm error - "
4875 "compressed data found in input stream.\n"
4876 "Compression/decompression is not supported "
4877 "by the hddm c i/o interface.\n");
4878 fprintf(stderrstderr,"You must use the c++ "
4879 "interface to read this file.\n");
4880 exit(9);
4881 }
4882 else if (size > 0)
4883 {
4884 off_t start = xdr_getpos64(xdrs);
4885 int m;
4886 unsigned int mult;
4887 xdr_u_int(xdrs,&mult);
4888 this1 = make_s_TaggerHits(mult);
4889 this1->mult = mult;
4890 for (m = 0; m < mult; m++ )
4891 {
4892 xdr_float(xdrs,&this1->in[m].t);
4893 }
4894 xdr_setpos64(xdrs,start+size);
4895 }
4896 return this1;
4897}
4898
4899static s_McTrajectory_t* unpack_s_McTrajectory(XDR* xdrs, popNode* pop)
4900{
4901 s_McTrajectory_t* this1 = (s_McTrajectory_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4902 unsigned int size;
4903 if (! xdr_u_int(xdrs,&size))
4904 {
4905 return this1;
4906 }
4907 else if (size == 1)
4908 {
4909 fprintf(stderrstderr,"hddm error - "
4910 "compressed data found in input stream.\n"
4911 "Compression/decompression is not supported "
4912 "by the hddm c i/o interface.\n");
4913 fprintf(stderrstderr,"You must use the c++ "
4914 "interface to read this file.\n");
4915 exit(9);
4916 }
4917 else if (size > 0)
4918 {
4919 off_t start = xdr_getpos64(xdrs);
4920 this1 = make_s_McTrajectory();
4921 {
4922 int p;
4923 void* (*ptr) = (void**) &this1->mcTrajectoryPoints;
4924 for (p = 0; p < pop->popListLength; p++)
4925 {
4926 popNode* pnode = pop->popList[p];
4927 if (pnode)
4928 {
4929 int kid = pnode->inParent;
4930 ptr[kid] = pnode->unpacker(xdrs,pnode);
4931 }
4932 else
4933 {
4934 unsigned int skip;
4935 xdr_u_int(xdrs,&skip);
4936 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
4937 }
4938 }
4939 }
4940 xdr_setpos64(xdrs,start+size);
4941 }
4942 return this1;
4943}
4944
4945static s_McTrajectoryPoints_t* unpack_s_McTrajectoryPoints(XDR* xdrs, popNode* pop)
4946{
4947 s_McTrajectoryPoints_t* this1 = (s_McTrajectoryPoints_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4948 unsigned int size;
4949 if (! xdr_u_int(xdrs,&size))
4950 {
4951 return this1;
4952 }
4953 else if (size == 1)
4954 {
4955 fprintf(stderrstderr,"hddm error - "
4956 "compressed data found in input stream.\n"
4957 "Compression/decompression is not supported "
4958 "by the hddm c i/o interface.\n");
4959 fprintf(stderrstderr,"You must use the c++ "
4960 "interface to read this file.\n");
4961 exit(9);
4962 }
4963 else if (size > 0)
4964 {
4965 off_t start = xdr_getpos64(xdrs);
4966 int m;
4967 unsigned int mult;
4968 xdr_u_int(xdrs,&mult);
4969 this1 = make_s_McTrajectoryPoints(mult);
4970 this1->mult = mult;
4971 for (m = 0; m < mult; m++ )
4972 {
4973 xdr_float(xdrs,&this1->in[m].E);
4974 xdr_float(xdrs,&this1->in[m].dE);
4975 xdr_int(xdrs,&this1->in[m].mech);
4976 xdr_int(xdrs,&this1->in[m].part);
4977 xdr_int(xdrs,&this1->in[m].primary_track);
4978 xdr_float(xdrs,&this1->in[m].px);
4979 xdr_float(xdrs,&this1->in[m].py);
4980 xdr_float(xdrs,&this1->in[m].pz);
4981 xdr_float(xdrs,&this1->in[m].radlen);
4982 xdr_float(xdrs,&this1->in[m].step);
4983 xdr_float(xdrs,&this1->in[m].t);
4984 xdr_int(xdrs,&this1->in[m].track);
4985 xdr_float(xdrs,&this1->in[m].x);
4986 xdr_float(xdrs,&this1->in[m].y);
4987 xdr_float(xdrs,&this1->in[m].z);
4988 }
4989 xdr_setpos64(xdrs,start+size);
4990 }
4991 return this1;
4992}
4993
4994static s_ReconView_t* unpack_s_ReconView(XDR* xdrs, popNode* pop)
4995{
4996 s_ReconView_t* this1 = (s_ReconView_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
4997 unsigned int size;
4998 if (! xdr_u_int(xdrs,&size))
4999 {
5000 return this1;
5001 }
5002 else if (size == 1)
5003 {
5004 fprintf(stderrstderr,"hddm error - "
5005 "compressed data found in input stream.\n"
5006 "Compression/decompression is not supported "
5007 "by the hddm c i/o interface.\n");
5008 fprintf(stderrstderr,"You must use the c++ "
5009 "interface to read this file.\n");
5010 exit(9);
5011 }
5012 else if (size > 0)
5013 {
5014 off_t start = xdr_getpos64(xdrs);
5015 this1 = make_s_ReconView();
5016 {
5017 int p;
5018 void* (*ptr) = (void**) &this1->tracktimebaseds;
5019 for (p = 0; p < pop->popListLength; p++)
5020 {
5021 popNode* pnode = pop->popList[p];
5022 if (pnode)
5023 {
5024 int kid = pnode->inParent;
5025 ptr[kid] = pnode->unpacker(xdrs,pnode);
5026 }
5027 else
5028 {
5029 unsigned int skip;
5030 xdr_u_int(xdrs,&skip);
5031 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
5032 }
5033 }
5034 }
5035 xdr_setpos64(xdrs,start+size);
5036 }
5037 return this1;
5038}
5039
5040static s_Tracktimebaseds_t* unpack_s_Tracktimebaseds(XDR* xdrs, popNode* pop)
5041{
5042 s_Tracktimebaseds_t* this1 = (s_Tracktimebaseds_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
5043 unsigned int size;
5044 if (! xdr_u_int(xdrs,&size))
5045 {
5046 return this1;
5047 }
5048 else if (size == 1)
5049 {
5050 fprintf(stderrstderr,"hddm error - "
5051 "compressed data found in input stream.\n"
5052 "Compression/decompression is not supported "
5053 "by the hddm c i/o interface.\n");
5054 fprintf(stderrstderr,"You must use the c++ "
5055 "interface to read this file.\n");
5056 exit(9);
5057 }
5058 else if (size > 0)
5059 {
5060 off_t start = xdr_getpos64(xdrs);
5061 int m;
5062 unsigned int mult;
5063 xdr_u_int(xdrs,&mult);
5064 this1 = make_s_Tracktimebaseds(mult);
5065 this1->mult = mult;
5066 for (m = 0; m < mult; m++ )
5067 {
5068 int p;
5069 void* (*ptr) = (void**) &this1->in[m].momentum;
5070 xdr_float(xdrs,&this1->in[m].FOM);
5071 xdr_int(xdrs,&this1->in[m].Ndof);
5072 xdr_int(xdrs,&this1->in[m].candidateid);
5073 xdr_float(xdrs,&this1->in[m].chisq);
5074 xdr_int(xdrs,&this1->in[m].id);
5075 xdr_int(xdrs,&this1->in[m].trackid);
5076 for (p = 0; p < pop->popListLength; p++)
5077 {
5078 popNode* pnode = pop->popList[p];
5079 if (pnode)
5080 {
5081 int kid = pnode->inParent;
5082 ptr[kid] = pnode->unpacker(xdrs,pnode);
5083 }
5084 else
5085 {
5086 unsigned int skip;
5087 xdr_u_int(xdrs,&skip);
5088 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
5089 }
5090 }
5091 }
5092 xdr_setpos64(xdrs,start+size);
5093 }
5094 return this1;
5095}
5096
5097static s_ErrorMatrix_t* unpack_s_ErrorMatrix(XDR* xdrs, popNode* pop)
5098{
5099 s_ErrorMatrix_t* this1 = (s_ErrorMatrix_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
5100 unsigned int size;
5101 if (! xdr_u_int(xdrs,&size))
5102 {
5103 return this1;
5104 }
5105 else if (size == 1)
5106 {
5107 fprintf(stderrstderr,"hddm error - "
5108 "compressed data found in input stream.\n"
5109 "Compression/decompression is not supported "
5110 "by the hddm c i/o interface.\n");
5111 fprintf(stderrstderr,"You must use the c++ "
5112 "interface to read this file.\n");
5113 exit(9);
5114 }
5115 else if (size > 0)
5116 {
5117 off_t start = xdr_getpos64(xdrs);
5118 this1 = make_s_ErrorMatrix();
5119 {
5120 xdr_int(xdrs,&this1->Ncols);
5121 xdr_int(xdrs,&this1->Nrows);
5122 this1->type = 0;
5123 xdr_string(xdrs, &this1->type, 1000000);
5124 this1->vals = 0;
5125 xdr_string(xdrs, &this1->vals, 1000000);
5126 }
5127 xdr_setpos64(xdrs,start+size);
5128 }
5129 return this1;
5130}
5131
5132static s_TrackingErrorMatrix_t* unpack_s_TrackingErrorMatrix(XDR* xdrs, popNode* pop)
5133{
5134 s_TrackingErrorMatrix_t* this1 = (s_TrackingErrorMatrix_t*)HDDM_NULL(void*)&hddm_s_nullTarget;
5135 unsigned int size;
5136 if (! xdr_u_int(xdrs,&size))
5137 {
5138 return this1;
5139 }
5140 else if (size == 1)
5141 {
5142 fprintf(stderrstderr,"hddm error - "
5143 "compressed data found in input stream.\n"
5144 "Compression/decompression is not supported "
5145 "by the hddm c i/o interface.\n");
5146 fprintf(stderrstderr,"You must use the c++ "
5147 "interface to read this file.\n");
5148 exit(9);
5149 }
5150 else if (size > 0)
5151 {
5152 off_t start = xdr_getpos64(xdrs);
5153 this1 = make_s_TrackingErrorMatrix();
5154 {
5155 xdr_int(xdrs,&this1->Ncols);
5156 xdr_int(xdrs,&this1->Nrows);
5157 this1->type = 0;
5158 xdr_string(xdrs, &this1->type, 1000000);
5159 this1->vals = 0;
5160 xdr_string(xdrs, &this1->vals, 1000000);
5161 }
5162 xdr_setpos64(xdrs,start+size);
5163 }
5164 return this1;
5165}
5166
5167s_HDDM_t* read_s_HDDM(s_iostream_t* fp)
5168{
5169 s_HDDM_t* nextEvent = unpack_s_HDDM(fp->xdrs,fp->popTop);
5170 return (nextEvent == HDDM_NULL(void*)&hddm_s_nullTarget)? 0 : nextEvent;
5171}
5172
5173int skip_s_HDDM(s_iostream_t* fp, int nskip)
5174{
5175 int skipped;
5176 for (skipped=0; skipped < nskip; ++skipped)
5177 {
5178 unsigned int size;
5179 if (! xdr_u_int(fp->xdrs,&size))
5180 {
5181 return skipped;
5182 }
5183 else if (size == 1)
5184 {
5185 fprintf(stderrstderr,"hddm error - "
5186 "compressed data found in input stream.\n"
5187 "Compression/decompression is not supported "
5188 "by the hddm c i/o interface.\n");
5189 fprintf(stderrstderr,"You must use the c++ "
5190 "interface to read this file.\n");
5191 exit(9);
5192 }
5193 else if (size > 0)
5194 {
5195 off_t start = xdr_getpos64(fp->xdrs);
5196 if (xdr_setpos64(fp->xdrs,start+size) != 0) {
5197 fp->lerrno = errno(*__errno_location ());
5198 return skipped;
5199 }
5200 }
5201 }
5202 return skipped;
5203}
5204
5205static int pack_s_HDDM(XDR* xdrs, s_HDDM_t* this1);
5206static int pack_s_PhysicsEvents(XDR* xdrs, s_PhysicsEvents_t* this1);
5207static int pack_s_Reactions(XDR* xdrs, s_Reactions_t* this1);
5208static int pack_s_Beam(XDR* xdrs, s_Beam_t* this1);
5209static int pack_s_Momentum(XDR* xdrs, s_Momentum_t* this1);
5210static int pack_s_Properties(XDR* xdrs, s_Properties_t* this1);
5211static int pack_s_Target(XDR* xdrs, s_Target_t* this1);
5212static int pack_s_Vertices(XDR* xdrs, s_Vertices_t* this1);
5213static int pack_s_Products(XDR* xdrs, s_Products_t* this1);
5214static int pack_s_Origin(XDR* xdrs, s_Origin_t* this1);
5215static int pack_s_Random(XDR* xdrs, s_Random_t* this1);
5216static int pack_s_HitView(XDR* xdrs, s_HitView_t* this1);
5217static int pack_s_CentralDC(XDR* xdrs, s_CentralDC_t* this1);
5218static int pack_s_CdcStraws(XDR* xdrs, s_CdcStraws_t* this1);
5219static int pack_s_CdcStrawHits(XDR* xdrs, s_CdcStrawHits_t* this1);
5220static int pack_s_CdcStrawTruthHits(XDR* xdrs, s_CdcStrawTruthHits_t* this1);
5221static int pack_s_CdcTruthPoints(XDR* xdrs, s_CdcTruthPoints_t* this1);
5222static int pack_s_ForwardDC(XDR* xdrs, s_ForwardDC_t* this1);
5223static int pack_s_FdcChambers(XDR* xdrs, s_FdcChambers_t* this1);
5224static int pack_s_FdcAnodeWires(XDR* xdrs, s_FdcAnodeWires_t* this1);
5225static int pack_s_FdcAnodeHits(XDR* xdrs, s_FdcAnodeHits_t* this1);
5226static int pack_s_FdcAnodeTruthHits(XDR* xdrs, s_FdcAnodeTruthHits_t* this1);
5227static int pack_s_FdcCathodeStrips(XDR* xdrs, s_FdcCathodeStrips_t* this1);
5228static int pack_s_FdcCathodeHits(XDR* xdrs, s_FdcCathodeHits_t* this1);
5229static int pack_s_FdcCathodeTruthHits(XDR* xdrs, s_FdcCathodeTruthHits_t* this1);
5230static int pack_s_FdcTruthPoints(XDR* xdrs, s_FdcTruthPoints_t* this1);
5231static int pack_s_StartCntr(XDR* xdrs, s_StartCntr_t* this1);
5232static int pack_s_StcPaddles(XDR* xdrs, s_StcPaddles_t* this1);
5233static int pack_s_StcHits(XDR* xdrs, s_StcHits_t* this1);
5234static int pack_s_StcTruthHits(XDR* xdrs, s_StcTruthHits_t* this1);
5235static int pack_s_StcTruthPoints(XDR* xdrs, s_StcTruthPoints_t* this1);
5236static int pack_s_BarrelEMcal(XDR* xdrs, s_BarrelEMcal_t* this1);
5237static int pack_s_BcalCells(XDR* xdrs, s_BcalCells_t* this1);
5238static int pack_s_BcalSiPMUpHits(XDR* xdrs, s_BcalSiPMUpHits_t* this1);
5239static int pack_s_BcalSiPMDownHits(XDR* xdrs, s_BcalSiPMDownHits_t* this1);
5240static int pack_s_BcalHits(XDR* xdrs, s_BcalHits_t* this1);
5241static int pack_s_BcalIncidentParticles(XDR* xdrs, s_BcalIncidentParticles_t* this1);
5242static int pack_s_BcalSiPMSpectrums(XDR* xdrs, s_BcalSiPMSpectrums_t* this1);
5243static int pack_s_BcalfADCCells(XDR* xdrs, s_BcalfADCCells_t* this1);
5244static int pack_s_BcalfADCUpHits(XDR* xdrs, s_BcalfADCUpHits_t* this1);
5245static int pack_s_BcalfADCDownHits(XDR* xdrs, s_BcalfADCDownHits_t* this1);
5246static int pack_s_BcalTDCHits(XDR* xdrs, s_BcalTDCHits_t* this1);
5247static int pack_s_BcalTruthShowers(XDR* xdrs, s_BcalTruthShowers_t* this1);
5248static int pack_s_GapEMcal(XDR* xdrs, s_GapEMcal_t* this1);
5249static int pack_s_GcalCells(XDR* xdrs, s_GcalCells_t* this1);
5250static int pack_s_GcalHits(XDR* xdrs, s_GcalHits_t* this1);
5251static int pack_s_GcalTruthShowers(XDR* xdrs, s_GcalTruthShowers_t* this1);
5252static int pack_s_Cerenkov(XDR* xdrs, s_Cerenkov_t* this1);
5253static int pack_s_CereSections(XDR* xdrs, s_CereSections_t* this1);
5254static int pack_s_CereHits(XDR* xdrs, s_CereHits_t* this1);
5255static int pack_s_CereTruthPoints(XDR* xdrs, s_CereTruthPoints_t* this1);
5256static int pack_s_ForwardTOF(XDR* xdrs, s_ForwardTOF_t* this1);
5257static int pack_s_FtofCounters(XDR* xdrs, s_FtofCounters_t* this1);
5258static int pack_s_FtofNorthTruthHits(XDR* xdrs, s_FtofNorthTruthHits_t* this1);
5259static int pack_s_FtofMCHits(XDR* xdrs, s_FtofMCHits_t* this1);
5260static int pack_s_FtofSouthTruthHits(XDR* xdrs, s_FtofSouthTruthHits_t* this1);
5261static int pack_s_FtofNorthHits(XDR* xdrs, s_FtofNorthHits_t* this1);
5262static int pack_s_FtofSouthHits(XDR* xdrs, s_FtofSouthHits_t* this1);
5263static int pack_s_FtofTruthPoints(XDR* xdrs, s_FtofTruthPoints_t* this1);
5264static int pack_s_ForwardEMcal(XDR* xdrs, s_ForwardEMcal_t* this1);
5265static int pack_s_FcalBlocks(XDR* xdrs, s_FcalBlocks_t* this1);
5266static int pack_s_FcalHits(XDR* xdrs, s_FcalHits_t* this1);
5267static int pack_s_FcalTruthHits(XDR* xdrs, s_FcalTruthHits_t* this1);
5268static int pack_s_FcalTruthShowers(XDR* xdrs, s_FcalTruthShowers_t* this1);
5269static int pack_s_ComptonEMcal(XDR* xdrs, s_ComptonEMcal_t* this1);
5270static int pack_s_CcalBlocks(XDR* xdrs, s_CcalBlocks_t* this1);
5271static int pack_s_CcalHits(XDR* xdrs, s_CcalHits_t* this1);
5272static int pack_s_CcalTruthHits(XDR* xdrs, s_CcalTruthHits_t* this1);
5273static int pack_s_CcalTruthShowers(XDR* xdrs, s_CcalTruthShowers_t* this1);
5274static int pack_s_UpstreamEMveto(XDR* xdrs, s_UpstreamEMveto_t* this1);
5275static int pack_s_UpvPaddles(XDR* xdrs, s_UpvPaddles_t* this1);
5276static int pack_s_UpvLeftHits(XDR* xdrs, s_UpvLeftHits_t* this1);
5277static int pack_s_UpvRightHits(XDR* xdrs, s_UpvRightHits_t* this1);
5278static int pack_s_UpvTruthShowers(XDR* xdrs, s_UpvTruthShowers_t* this1);
5279static int pack_s_Tagger(XDR* xdrs, s_Tagger_t* this1);
5280static int pack_s_MicroChannels(XDR* xdrs, s_MicroChannels_t* this1);
5281static int pack_s_TaggerHits(XDR* xdrs, s_TaggerHits_t* this1);
5282static int pack_s_McTrajectory(XDR* xdrs, s_McTrajectory_t* this1);
5283static int pack_s_McTrajectoryPoints(XDR* xdrs, s_McTrajectoryPoints_t* this1);
5284static int pack_s_ReconView(XDR* xdrs, s_ReconView_t* this1);
5285static int pack_s_Tracktimebaseds(XDR* xdrs, s_Tracktimebaseds_t* this1);
5286static int pack_s_ErrorMatrix(XDR* xdrs, s_ErrorMatrix_t* this1);
5287static int pack_s_TrackingErrorMatrix(XDR* xdrs, s_TrackingErrorMatrix_t* this1);
5288
5289static int pack_s_HDDM(XDR* xdrs, s_HDDM_t* this1)
5290{
5291 int m=0;
5292 unsigned int size=0;
5293 off_t base,start,end;
5294 base = xdr_getpos64(xdrs);
5295 xdr_u_int(xdrs,&size);
5296 start = xdr_getpos64(xdrs);
5297
5298 {
5299 if (this1->physicsEvents != (s_PhysicsEvents_t*)&hddm_s_nullTarget)
5300 {
5301 if (pack_s_PhysicsEvents(xdrs,this1->physicsEvents) < 0) {
5302 return -1;
5303 }
5304 }
5305 else
5306 {
5307 int zero=0;
5308 xdr_int(xdrs,&zero);
5309 }
5310 }
5311 FREE(this1)free(this1);
5312 end = xdr_getpos64(xdrs);
5313 xdr_setpos64(xdrs,base);
5314 size = end-start;
5315 xdr_u_int(xdrs,&size);
5316 xdr_setpos64(xdrs,end);
5317 return size;
5318}
5319
5320static int pack_s_PhysicsEvents(XDR* xdrs, s_PhysicsEvents_t* this1)
5321{
5322 int m=0;
5323 unsigned int size=0;
5324 off_t base,start,end;
5325 base = xdr_getpos64(xdrs);
5326 xdr_u_int(xdrs,&size);
5327 start = xdr_getpos64(xdrs);
5328
5329 xdr_u_int(xdrs,&this1->mult);
5330 for (m = 0; m < this1->mult; m++)
5331 {
5332 xdr_int(xdrs,&this1->in[m].eventNo);
5333 xdr_int(xdrs,&this1->in[m].runNo);
5334 if (this1->in[m].reactions != (s_Reactions_t*)&hddm_s_nullTarget)
5335 {
5336 if (pack_s_Reactions(xdrs,this1->in[m].reactions) < 0) {
5337 return -1;
5338 }
5339 }
5340 else
5341 {
5342 int zero=0;
5343 xdr_int(xdrs,&zero);
5344 }
5345 if (this1->in[m].hitView != (s_HitView_t*)&hddm_s_nullTarget)
5346 {
5347 if (pack_s_HitView(xdrs,this1->in[m].hitView) < 0) {
5348 return -1;
5349 }
5350 }
5351 else
5352 {
5353 int zero=0;
5354 xdr_int(xdrs,&zero);
5355 }
5356 if (this1->in[m].reconView != (s_ReconView_t*)&hddm_s_nullTarget)
5357 {
5358 if (pack_s_ReconView(xdrs,this1->in[m].reconView) < 0) {
5359 return -1;
5360 }
5361 }
5362 else
5363 {
5364 int zero=0;
5365 xdr_int(xdrs,&zero);
5366 }
5367 }
5368 FREE(this1)free(this1);
5369 end = xdr_getpos64(xdrs);
5370 xdr_setpos64(xdrs,base);
5371 size = end-start;
5372 xdr_u_int(xdrs,&size);
5373 xdr_setpos64(xdrs,end);
5374 return size;
5375}
5376
5377static int pack_s_Reactions(XDR* xdrs, s_Reactions_t* this1)
5378{
5379 int m=0;
5380 unsigned int size=0;
5381 off_t base,start,end;
5382 base = xdr_getpos64(xdrs);
5383 xdr_u_int(xdrs,&size);
5384 start = xdr_getpos64(xdrs);
5385
5386 xdr_u_int(xdrs,&this1->mult);
5387 for (m = 0; m < this1->mult; m++)
5388 {
5389 xdr_int(xdrs,&this1->in[m].type);
5390 xdr_float(xdrs,&this1->in[m].weight);
5391 if (this1->in[m].beam != (s_Beam_t*)&hddm_s_nullTarget)
5392 {
5393 if (pack_s_Beam(xdrs,this1->in[m].beam) < 0) {
5394 return -1;
5395 }
5396 }
5397 else
5398 {
5399 int zero=0;
5400 xdr_int(xdrs,&zero);
5401 }
5402 if (this1->in[m].target != (s_Target_t*)&hddm_s_nullTarget)
5403 {
5404 if (pack_s_Target(xdrs,this1->in[m].target) < 0) {
5405 return -1;
5406 }
5407 }
5408 else
5409 {
5410 int zero=0;
5411 xdr_int(xdrs,&zero);
5412 }
5413 if (this1->in[m].vertices != (s_Vertices_t*)&hddm_s_nullTarget)
5414 {
5415 if (pack_s_Vertices(xdrs,this1->in[m].vertices) < 0) {
5416 return -1;
5417 }
5418 }
5419 else
5420 {
5421 int zero=0;
5422 xdr_int(xdrs,&zero);
5423 }
5424 if (this1->in[m].random != (s_Random_t*)&hddm_s_nullTarget)
5425 {
5426 if (pack_s_Random(xdrs,this1->in[m].random) < 0) {
5427 return -1;
5428 }
5429 }
5430 else
5431 {
5432 int zero=0;
5433 xdr_int(xdrs,&zero);
5434 }
5435 }
5436 FREE(this1)free(this1);
5437 end = xdr_getpos64(xdrs);
5438 xdr_setpos64(xdrs,base);
5439 size = end-start;
5440 xdr_u_int(xdrs,&size);
5441 xdr_setpos64(xdrs,end);
5442 return size;
5443}
5444
5445static int pack_s_Beam(XDR* xdrs, s_Beam_t* this1)
5446{
5447 int m=0;
5448 unsigned int size=0;
5449 off_t base,start,end;
5450 base = xdr_getpos64(xdrs);
5451 xdr_u_int(xdrs,&size);
5452 start = xdr_getpos64(xdrs);
5453
5454 {
5455 xdr_int(xdrs,(int*)&this1->type);
5456 if (this1->momentum != (s_Momentum_t*)&hddm_s_nullTarget)
5457 {
5458 if (pack_s_Momentum(xdrs,this1->momentum) < 0) {
5459 return -1;
5460 }
5461 }
5462 else
5463 {
5464 int zero=0;
5465 xdr_int(xdrs,&zero);
5466 }
5467 if (this1->properties != (s_Properties_t*)&hddm_s_nullTarget)
5468 {
5469 if (pack_s_Properties(xdrs,this1->properties) < 0) {
5470 return -1;
5471 }
5472 }
5473 else
5474 {
5475 int zero=0;
5476 xdr_int(xdrs,&zero);
5477 }
5478 }
5479 FREE(this1)free(this1);
5480 end = xdr_getpos64(xdrs);
5481 xdr_setpos64(xdrs,base);
5482 size = end-start;
5483 xdr_u_int(xdrs,&size);
5484 xdr_setpos64(xdrs,end);
5485 return size;
5486}
5487
5488static int pack_s_Momentum(XDR* xdrs, s_Momentum_t* this1)
5489{
5490 int m=0;
5491 unsigned int size=0;
5492 off_t base,start,end;
5493 base = xdr_getpos64(xdrs);
5494 xdr_u_int(xdrs,&size);
5495 start = xdr_getpos64(xdrs);
5496
5497 {
5498 xdr_float(xdrs,&this1->E);
5499 xdr_float(xdrs,&this1->px);
5500 xdr_float(xdrs,&this1->py);
5501 xdr_float(xdrs,&this1->pz);
5502 }
5503 FREE(this1)free(this1);
5504 end = xdr_getpos64(xdrs);
5505 xdr_setpos64(xdrs,base);
5506 size = end-start;
5507 xdr_u_int(xdrs,&size);
5508 xdr_setpos64(xdrs,end);
5509 return size;
5510}
5511
5512static int pack_s_Properties(XDR* xdrs, s_Properties_t* this1)
5513{
5514 int m=0;
5515 unsigned int size=0;
5516 off_t base,start,end;
5517 base = xdr_getpos64(xdrs);
5518 xdr_u_int(xdrs,&size);
5519 start = xdr_getpos64(xdrs);
5520
5521 {
5522 xdr_int(xdrs,&this1->charge);
5523 xdr_float(xdrs,&this1->mass);
5524 }
5525 FREE(this1)free(this1);
5526 end = xdr_getpos64(xdrs);
5527 xdr_setpos64(xdrs,base);
5528 size = end-start;
5529 xdr_u_int(xdrs,&size);
5530 xdr_setpos64(xdrs,end);
5531 return size;
5532}
5533
5534static int pack_s_Target(XDR* xdrs, s_Target_t* this1)
5535{
5536 int m=0;
5537 unsigned int size=0;
5538 off_t base,start,end;
5539 base = xdr_getpos64(xdrs);
5540 xdr_u_int(xdrs,&size);
5541 start = xdr_getpos64(xdrs);
5542
5543 {
5544 xdr_int(xdrs,(int*)&this1->type);
5545 if (this1->momentum != (s_Momentum_t*)&hddm_s_nullTarget)
5546 {
5547 if (pack_s_Momentum(xdrs,this1->momentum) < 0) {
5548 return -1;
5549 }
5550 }
5551 else
5552 {
5553 int zero=0;
5554 xdr_int(xdrs,&zero);
5555 }
5556 if (this1->properties != (s_Properties_t*)&hddm_s_nullTarget)
5557 {
5558 if (pack_s_Properties(xdrs,this1->properties) < 0) {
5559 return -1;
5560 }
5561 }
5562 else
5563 {
5564 int zero=0;
5565 xdr_int(xdrs,&zero);
5566 }
5567 }
5568 FREE(this1)free(this1);
5569 end = xdr_getpos64(xdrs);
5570 xdr_setpos64(xdrs,base);
5571 size = end-start;
5572 xdr_u_int(xdrs,&size);
5573 xdr_setpos64(xdrs,end);
5574 return size;
5575}
5576
5577static int pack_s_Vertices(XDR* xdrs, s_Vertices_t* this1)
5578{
5579 int m=0;
5580 unsigned int size=0;
5581 off_t base,start,end;
5582 base = xdr_getpos64(xdrs);
5583 xdr_u_int(xdrs,&size);
5584 start = xdr_getpos64(xdrs);
5585
5586 xdr_u_int(xdrs,&this1->mult);
5587 for (m = 0; m < this1->mult; m++)
5588 {
5589 if (this1->in[m].products != (s_Products_t*)&hddm_s_nullTarget)
5590 {
5591 if (pack_s_Products(xdrs,this1->in[m].products) < 0) {
5592 return -1;
5593 }
5594 }
5595 else
5596 {
5597 int zero=0;
5598 xdr_int(xdrs,&zero);
5599 }
5600 if (this1->in[m].origin != (s_Origin_t*)&hddm_s_nullTarget)
5601 {
5602 if (pack_s_Origin(xdrs,this1->in[m].origin) < 0) {
5603 return -1;
5604 }
5605 }
5606 else
5607 {
5608 int zero=0;
5609 xdr_int(xdrs,&zero);
5610 }
5611 }
5612 FREE(this1)free(this1);
5613 end = xdr_getpos64(xdrs);
5614 xdr_setpos64(xdrs,base);
5615 size = end-start;
5616 xdr_u_int(xdrs,&size);
5617 xdr_setpos64(xdrs,end);
5618 return size;
5619}
5620
5621static int pack_s_Products(XDR* xdrs, s_Products_t* this1)
5622{
5623 int m=0;
5624 unsigned int size=0;
5625 off_t base,start,end;
5626 base = xdr_getpos64(xdrs);
5627 xdr_u_int(xdrs,&size);
5628 start = xdr_getpos64(xdrs);
5629
5630 xdr_u_int(xdrs,&this1->mult);
5631 for (m = 0; m < this1->mult; m++)
5632 {
5633 xdr_int(xdrs,&this1->in[m].decayVertex);
5634 xdr_int(xdrs,&this1->in[m].id);
5635 xdr_int(xdrs,&this1->in[m].mech);
5636 xdr_int(xdrs,&this1->in[m].parentid);
5637 xdr_int(xdrs,&this1->in[m].pdgtype);
5638 xdr_int(xdrs,(int*)&this1->in[m].type);
5639 if (this1->in[m].momentum != (s_Momentum_t*)&hddm_s_nullTarget)
5640 {
5641 if (pack_s_Momentum(xdrs,this1->in[m].momentum) < 0) {
5642 return -1;
5643 }
5644 }
5645 else
5646 {
5647 int zero=0;
5648 xdr_int(xdrs,&zero);
5649 }
5650 if (this1->in[m].properties != (s_Properties_t*)&hddm_s_nullTarget)
5651 {
5652 if (pack_s_Properties(xdrs,this1->in[m].properties) < 0) {
5653 return -1;
5654 }
5655 }
5656 else
5657 {
5658 int zero=0;
5659 xdr_int(xdrs,&zero);
5660 }
5661 }
5662 FREE(this1)free(this1);
5663 end = xdr_getpos64(xdrs);
5664 xdr_setpos64(xdrs,base);
5665 size = end-start;
5666 xdr_u_int(xdrs,&size);
5667 xdr_setpos64(xdrs,end);
5668 return size;
5669}
5670
5671static int pack_s_Origin(XDR* xdrs, s_Origin_t* this1)
5672{
5673 int m=0;
5674 unsigned int size=0;
5675 off_t base,start,end;
5676 base = xdr_getpos64(xdrs);
5677 xdr_u_int(xdrs,&size);
5678 start = xdr_getpos64(xdrs);
5679
5680 {
5681 xdr_float(xdrs,&this1->t);
5682 xdr_float(xdrs,&this1->vx);
5683 xdr_float(xdrs,&this1->vy);
5684 xdr_float(xdrs,&this1->vz);
5685 }
5686 FREE(this1)free(this1);
5687 end = xdr_getpos64(xdrs);
5688 xdr_setpos64(xdrs,base);
5689 size = end-start;
5690 xdr_u_int(xdrs,&size);
5691 xdr_setpos64(xdrs,end);
5692 return size;
5693}
5694
5695static int pack_s_Random(XDR* xdrs, s_Random_t* this1)
5696{
5697 int m=0;
5698 unsigned int size=0;
5699 off_t base,start,end;
5700 base = xdr_getpos64(xdrs);
5701 xdr_u_int(xdrs,&size);
5702 start = xdr_getpos64(xdrs);
5703
5704 {
5705 xdr_int(xdrs,&this1->seed1);
5706 xdr_int(xdrs,&this1->seed2);
5707 xdr_int(xdrs,&this1->seed_mcsmear1);
5708 xdr_int(xdrs,&this1->seed_mcsmear2);
5709 xdr_int(xdrs,&this1->seed_mcsmear3);
5710 }
5711 FREE(this1)free(this1);
5712 end = xdr_getpos64(xdrs);
5713 xdr_setpos64(xdrs,base);
5714 size = end-start;
5715 xdr_u_int(xdrs,&size);
5716 xdr_setpos64(xdrs,end);
5717 return size;
5718}
5719
5720static int pack_s_HitView(XDR* xdrs, s_HitView_t* this1)
5721{
5722 int m=0;
5723 unsigned int size=0;
5724 off_t base,start,end;
5725 base = xdr_getpos64(xdrs);
5726 xdr_u_int(xdrs,&size);
5727 start = xdr_getpos64(xdrs);
5728
5729 {
5730 if (this1->centralDC != (s_CentralDC_t*)&hddm_s_nullTarget)
5731 {
5732 if (pack_s_CentralDC(xdrs,this1->centralDC) < 0) {
5733 return -1;
5734 }
5735 }
5736 else
5737 {
5738 int zero=0;
5739 xdr_int(xdrs,&zero);
5740 }
5741 if (this1->forwardDC != (s_ForwardDC_t*)&hddm_s_nullTarget)
5742 {
5743 if (pack_s_ForwardDC(xdrs,this1->forwardDC) < 0) {
5744 return -1;
5745 }
5746 }
5747 else
5748 {
5749 int zero=0;
5750 xdr_int(xdrs,&zero);
5751 }
5752 if (this1->startCntr != (s_StartCntr_t*)&hddm_s_nullTarget)
5753 {
5754 if (pack_s_StartCntr(xdrs,this1->startCntr) < 0) {
5755 return -1;
5756 }
5757 }
5758 else
5759 {
5760 int zero=0;
5761 xdr_int(xdrs,&zero);
5762 }
5763 if (this1->barrelEMcal != (s_BarrelEMcal_t*)&hddm_s_nullTarget)
5764 {
5765 if (pack_s_BarrelEMcal(xdrs,this1->barrelEMcal) < 0) {
5766 return -1;
5767 }
5768 }
5769 else
5770 {
5771 int zero=0;
5772 xdr_int(xdrs,&zero);
5773 }
5774 if (this1->gapEMcal != (s_GapEMcal_t*)&hddm_s_nullTarget)
5775 {
5776 if (pack_s_GapEMcal(xdrs,this1->gapEMcal) < 0) {
5777 return -1;
5778 }
5779 }
5780 else
5781 {
5782 int zero=0;
5783 xdr_int(xdrs,&zero);
5784 }
5785 if (this1->Cerenkov != (s_Cerenkov_t*)&hddm_s_nullTarget)
5786 {
5787 if (pack_s_Cerenkov(xdrs,this1->Cerenkov) < 0) {
5788 return -1;
5789 }
5790 }
5791 else
5792 {
5793 int zero=0;
5794 xdr_int(xdrs,&zero);
5795 }
5796 if (this1->forwardTOF != (s_ForwardTOF_t*)&hddm_s_nullTarget)
5797 {
5798 if (pack_s_ForwardTOF(xdrs,this1->forwardTOF) < 0) {
5799 return -1;
5800 }
5801 }
5802 else
5803 {
5804 int zero=0;
5805 xdr_int(xdrs,&zero);
5806 }
5807 if (this1->forwardEMcal != (s_ForwardEMcal_t*)&hddm_s_nullTarget)
5808 {
5809 if (pack_s_ForwardEMcal(xdrs,this1->forwardEMcal) < 0) {
5810 return -1;
5811 }
5812 }
5813 else
5814 {
5815 int zero=0;
5816 xdr_int(xdrs,&zero);
5817 }
5818 if (this1->ComptonEMcal != (s_ComptonEMcal_t*)&hddm_s_nullTarget)
5819 {
5820 if (pack_s_ComptonEMcal(xdrs,this1->ComptonEMcal) < 0) {
5821 return -1;
5822 }
5823 }
5824 else
5825 {
5826 int zero=0;
5827 xdr_int(xdrs,&zero);
5828 }
5829 if (this1->upstreamEMveto != (s_UpstreamEMveto_t*)&hddm_s_nullTarget)
5830 {
5831 if (pack_s_UpstreamEMveto(xdrs,this1->upstreamEMveto) < 0) {
5832 return -1;
5833 }
5834 }
5835 else
5836 {
5837 int zero=0;
5838 xdr_int(xdrs,&zero);
5839 }
5840 if (this1->tagger != (s_Tagger_t*)&hddm_s_nullTarget)
5841 {
5842 if (pack_s_Tagger(xdrs,this1->tagger) < 0) {
5843 return -1;
5844 }
5845 }
5846 else
5847 {
5848 int zero=0;
5849 xdr_int(xdrs,&zero);
5850 }
5851 if (this1->mcTrajectory != (s_McTrajectory_t*)&hddm_s_nullTarget)
5852 {
5853 if (pack_s_McTrajectory(xdrs,this1->mcTrajectory) < 0) {
5854 return -1;
5855 }
5856 }
5857 else
5858 {
5859 int zero=0;
5860 xdr_int(xdrs,&zero);
5861 }
5862 }
5863 FREE(this1)free(this1);
5864 end = xdr_getpos64(xdrs);
5865 xdr_setpos64(xdrs,base);
5866 size = end-start;
5867 xdr_u_int(xdrs,&size);
5868 xdr_setpos64(xdrs,end);
5869 return size;
5870}
5871
5872static int pack_s_CentralDC(XDR* xdrs, s_CentralDC_t* this1)
5873{
5874 int m=0;
5875 unsigned int size=0;
5876 off_t base,start,end;
5877 base = xdr_getpos64(xdrs);
5878 xdr_u_int(xdrs,&size);
5879 start = xdr_getpos64(xdrs);
5880
5881 {
5882 if (this1->cdcStraws != (s_CdcStraws_t*)&hddm_s_nullTarget)
5883 {
5884 if (pack_s_CdcStraws(xdrs,this1->cdcStraws) < 0) {
5885 return -1;
5886 }
5887 }
5888 else
5889 {
5890 int zero=0;
5891 xdr_int(xdrs,&zero);
5892 }
5893 if (this1->cdcTruthPoints != (s_CdcTruthPoints_t*)&hddm_s_nullTarget)
5894 {
5895 if (pack_s_CdcTruthPoints(xdrs,this1->cdcTruthPoints) < 0) {
5896 return -1;
5897 }
5898 }
5899 else
5900 {
5901 int zero=0;
5902 xdr_int(xdrs,&zero);
5903 }
5904 }
5905 FREE(this1)free(this1);
5906 end = xdr_getpos64(xdrs);
5907 xdr_setpos64(xdrs,base);
5908 size = end-start;
5909 xdr_u_int(xdrs,&size);
5910 xdr_setpos64(xdrs,end);
5911 return size;
5912}
5913
5914static int pack_s_CdcStraws(XDR* xdrs, s_CdcStraws_t* this1)
5915{
5916 int m=0;
5917 unsigned int size=0;
5918 off_t base,start,end;
5919 base = xdr_getpos64(xdrs);
5920 xdr_u_int(xdrs,&size);
5921 start = xdr_getpos64(xdrs);
5922
5923 xdr_u_int(xdrs,&this1->mult);
5924 for (m = 0; m < this1->mult; m++)
5925 {
5926 xdr_int(xdrs,&this1->in[m].ring);
5927 xdr_int(xdrs,&this1->in[m].straw);
5928 if (this1->in[m].cdcStrawHits != (s_CdcStrawHits_t*)&hddm_s_nullTarget)
5929 {
5930 if (pack_s_CdcStrawHits(xdrs,this1->in[m].cdcStrawHits) < 0) {
5931 return -1;
5932 }
5933 }
5934 else
5935 {
5936 int zero=0;
5937 xdr_int(xdrs,&zero);
5938 }
5939 if (this1->in[m].cdcStrawTruthHits != (s_CdcStrawTruthHits_t*)&hddm_s_nullTarget)
5940 {
5941 if (pack_s_CdcStrawTruthHits(xdrs,this1->in[m].cdcStrawTruthHits) < 0) {
5942 return -1;
5943 }
5944 }
5945 else
5946 {
5947 int zero=0;
5948 xdr_int(xdrs,&zero);
5949 }
5950 }
5951 FREE(this1)free(this1);
5952 end = xdr_getpos64(xdrs);
5953 xdr_setpos64(xdrs,base);
5954 size = end-start;
5955 xdr_u_int(xdrs,&size);
5956 xdr_setpos64(xdrs,end);
5957 return size;
5958}
5959
5960static int pack_s_CdcStrawHits(XDR* xdrs, s_CdcStrawHits_t* this1)
5961{
5962 int m=0;
5963 unsigned int size=0;
5964 off_t base,start,end;
5965 base = xdr_getpos64(xdrs);
5966 xdr_u_int(xdrs,&size);
5967 start = xdr_getpos64(xdrs);
5968
5969 xdr_u_int(xdrs,&this1->mult);
5970 for (m = 0; m < this1->mult; m++)
5971 {
5972 xdr_float(xdrs,&this1->in[m].d);
5973 xdr_float(xdrs,&this1->in[m].dE);
5974 xdr_int(xdrs,&this1->in[m].itrack);
5975 xdr_int(xdrs,&this1->in[m].ptype);
5976 xdr_float(xdrs,&this1->in[m].t);
5977 }
5978 FREE(this1)free(this1);
5979 end = xdr_getpos64(xdrs);
5980 xdr_setpos64(xdrs,base);
5981 size = end-start;
5982 xdr_u_int(xdrs,&size);
5983 xdr_setpos64(xdrs,end);
5984 return size;
5985}
5986
5987static int pack_s_CdcStrawTruthHits(XDR* xdrs, s_CdcStrawTruthHits_t* this1)
5988{
5989 int m=0;
5990 unsigned int size=0;
5991 off_t base,start,end;
5992 base = xdr_getpos64(xdrs);
5993 xdr_u_int(xdrs,&size);
5994 start = xdr_getpos64(xdrs);
5995
5996 xdr_u_int(xdrs,&this1->mult);
5997 for (m = 0; m < this1->mult; m++)
5998 {
5999 xdr_float(xdrs,&this1->in[m].d);
6000 xdr_float(xdrs,&this1->in[m].dE);
6001 xdr_int(xdrs,&this1->in[m].itrack);
6002 xdr_int(xdrs,&this1->in[m].ptype);
6003 xdr_float(xdrs,&this1->in[m].t);
6004 }
6005 FREE(this1)free(this1);
6006 end = xdr_getpos64(xdrs);
6007 xdr_setpos64(xdrs,base);
6008 size = end-start;
6009 xdr_u_int(xdrs,&size);
6010 xdr_setpos64(xdrs,end);
6011 return size;
6012}
6013
6014static int pack_s_CdcTruthPoints(XDR* xdrs, s_CdcTruthPoints_t* this1)
6015{
6016 int m=0;
6017 unsigned int size=0;
6018 off_t base,start,end;
6019 base = xdr_getpos64(xdrs);
6020 xdr_u_int(xdrs,&size);
6021 start = xdr_getpos64(xdrs);
6022
6023 xdr_u_int(xdrs,&this1->mult);
6024 for (m = 0; m < this1->mult; m++)
6025 {
6026 xdr_float(xdrs,&this1->in[m].dEdx);
6027 xdr_float(xdrs,&this1->in[m].dradius);
6028 xdr_float(xdrs,&this1->in[m].phi);
6029 xdr_bool(xdrs,&this1->in[m].primary);
6030 xdr_int(xdrs,&this1->in[m].ptype);
6031 xdr_float(xdrs,&this1->in[m].px);
6032 xdr_float(xdrs,&this1->in[m].py);
6033 xdr_float(xdrs,&this1->in[m].pz);
6034 xdr_float(xdrs,&this1->in[m].r);
6035 xdr_float(xdrs,&this1->in[m].t);
6036 xdr_int(xdrs,&this1->in[m].track);
6037 xdr_float(xdrs,&this1->in[m].z);
6038 }
6039 FREE(this1)free(this1);
6040 end = xdr_getpos64(xdrs);
6041 xdr_setpos64(xdrs,base);
6042 size = end-start;
6043 xdr_u_int(xdrs,&size);
6044 xdr_setpos64(xdrs,end);
6045 return size;
6046}
6047
6048static int pack_s_ForwardDC(XDR* xdrs, s_ForwardDC_t* this1)
6049{
6050 int m=0;
6051 unsigned int size=0;
6052 off_t base,start,end;
6053 base = xdr_getpos64(xdrs);
6054 xdr_u_int(xdrs,&size);
6055 start = xdr_getpos64(xdrs);
6056
6057 {
6058 if (this1->fdcChambers != (s_FdcChambers_t*)&hddm_s_nullTarget)
6059 {
6060 if (pack_s_FdcChambers(xdrs,this1->fdcChambers) < 0) {
6061 return -1;
6062 }
6063 }
6064 else
6065 {
6066 int zero=0;
6067 xdr_int(xdrs,&zero);
6068 }
6069 }
6070 FREE(this1)free(this1);
6071 end = xdr_getpos64(xdrs);
6072 xdr_setpos64(xdrs,base);
6073 size = end-start;
6074 xdr_u_int(xdrs,&size);
6075 xdr_setpos64(xdrs,end);
6076 return size;
6077}
6078
6079static int pack_s_FdcChambers(XDR* xdrs, s_FdcChambers_t* this1)
6080{
6081 int m=0;
6082 unsigned int size=0;
6083 off_t base,start,end;
6084 base = xdr_getpos64(xdrs);
6085 xdr_u_int(xdrs,&size);
6086 start = xdr_getpos64(xdrs);
6087
6088 xdr_u_int(xdrs,&this1->mult);
6089 for (m = 0; m < this1->mult; m++)
6090 {
6091 xdr_int(xdrs,&this1->in[m].layer);
6092 xdr_int(xdrs,&this1->in[m].module);
6093 if (this1->in[m].fdcAnodeWires != (s_FdcAnodeWires_t*)&hddm_s_nullTarget)
6094 {
6095 if (pack_s_FdcAnodeWires(xdrs,this1->in[m].fdcAnodeWires) < 0) {
6096 return -1;
6097 }
6098 }
6099 else
6100 {
6101 int zero=0;
6102 xdr_int(xdrs,&zero);
6103 }
6104 if (this1->in[m].fdcCathodeStrips != (s_FdcCathodeStrips_t*)&hddm_s_nullTarget)
6105 {
6106 if (pack_s_FdcCathodeStrips(xdrs,this1->in[m].fdcCathodeStrips) < 0) {
6107 return -1;
6108 }
6109 }
6110 else
6111 {
6112 int zero=0;
6113 xdr_int(xdrs,&zero);
6114 }
6115 if (this1->in[m].fdcTruthPoints != (s_FdcTruthPoints_t*)&hddm_s_nullTarget)
6116 {
6117 if (pack_s_FdcTruthPoints(xdrs,this1->in[m].fdcTruthPoints) < 0) {
6118 return -1;
6119 }
6120 }
6121 else
6122 {
6123 int zero=0;
6124 xdr_int(xdrs,&zero);
6125 }
6126 }
6127 FREE(this1)free(this1);
6128 end = xdr_getpos64(xdrs);
6129 xdr_setpos64(xdrs,base);
6130 size = end-start;
6131 xdr_u_int(xdrs,&size);
6132 xdr_setpos64(xdrs,end);
6133 return size;
6134}
6135
6136static int pack_s_FdcAnodeWires(XDR* xdrs, s_FdcAnodeWires_t* this1)
6137{
6138 int m=0;
6139 unsigned int size=0;
6140 off_t base,start,end;
6141 base = xdr_getpos64(xdrs);
6142 xdr_u_int(xdrs,&size);
6143 start = xdr_getpos64(xdrs);
6144
6145 xdr_u_int(xdrs,&this1->mult);
6146 for (m = 0; m < this1->mult; m++)
6147 {
6148 xdr_int(xdrs,&this1->in[m].wire);
6149 if (this1->in[m].fdcAnodeHits != (s_FdcAnodeHits_t*)&hddm_s_nullTarget)
6150 {
6151 if (pack_s_FdcAnodeHits(xdrs,this1->in[m].fdcAnodeHits) < 0) {
6152 return -1;
6153 }
6154 }
6155 else
6156 {
6157 int zero=0;
6158 xdr_int(xdrs,&zero);
6159 }
6160 if (this1->in[m].fdcAnodeTruthHits != (s_FdcAnodeTruthHits_t*)&hddm_s_nullTarget)
6161 {
6162 if (pack_s_FdcAnodeTruthHits(xdrs,this1->in[m].fdcAnodeTruthHits) < 0) {
6163 return -1;
6164 }
6165 }
6166 else
6167 {
6168 int zero=0;
6169 xdr_int(xdrs,&zero);
6170 }
6171 }
6172 FREE(this1)free(this1);
6173 end = xdr_getpos64(xdrs);
6174 xdr_setpos64(xdrs,base);
6175 size = end-start;
6176 xdr_u_int(xdrs,&size);
6177 xdr_setpos64(xdrs,end);
6178 return size;
6179}
6180
6181static int pack_s_FdcAnodeHits(XDR* xdrs, s_FdcAnodeHits_t* this1)
6182{
6183 int m=0;
6184 unsigned int size=0;
6185 off_t base,start,end;
6186 base = xdr_getpos64(xdrs);
6187 xdr_u_int(xdrs,&size);
6188 start = xdr_getpos64(xdrs);
6189
6190 xdr_u_int(xdrs,&this1->mult);
6191 for (m = 0; m < this1->mult; m++)
6192 {
6193 xdr_float(xdrs,&this1->in[m].d);
6194 xdr_float(xdrs,&this1->in[m].dE);
6195 xdr_int(xdrs,&this1->in[m].itrack);
6196 xdr_int(xdrs,&this1->in[m].ptype);
6197 xdr_float(xdrs,&this1->in[m].t);
6198 }
6199 FREE(this1)free(this1);
6200 end = xdr_getpos64(xdrs);
6201 xdr_setpos64(xdrs,base);
6202 size = end-start;
6203 xdr_u_int(xdrs,&size);
6204 xdr_setpos64(xdrs,end);
6205 return size;
6206}
6207
6208static int pack_s_FdcAnodeTruthHits(XDR* xdrs, s_FdcAnodeTruthHits_t* this1)
6209{
6210 int m=0;
6211 unsigned int size=0;
6212 off_t base,start,end;
6213 base = xdr_getpos64(xdrs);
6214 xdr_u_int(xdrs,&size);
6215 start = xdr_getpos64(xdrs);
6216
6217 xdr_u_int(xdrs,&this1->mult);
6218 for (m = 0; m < this1->mult; m++)
6219 {
6220 xdr_float(xdrs,&this1->in[m].d);
6221 xdr_float(xdrs,&this1->in[m].dE);
6222 xdr_int(xdrs,&this1->in[m].itrack);
6223 xdr_int(xdrs,&this1->in[m].ptype);
6224 xdr_float(xdrs,&this1->in[m].t);
6225 xdr_float(xdrs,&this1->in[m].t_unsmeared);
6226 }
6227 FREE(this1)free(this1);
6228 end = xdr_getpos64(xdrs);
6229 xdr_setpos64(xdrs,base);
6230 size = end-start;
6231 xdr_u_int(xdrs,&size);
6232 xdr_setpos64(xdrs,end);
6233 return size;
6234}
6235
6236static int pack_s_FdcCathodeStrips(XDR* xdrs, s_FdcCathodeStrips_t* this1)
6237{
6238 int m=0;
6239 unsigned int size=0;
6240 off_t base,start,end;
6241 base = xdr_getpos64(xdrs);
6242 xdr_u_int(xdrs,&size);
6243 start = xdr_getpos64(xdrs);
6244
6245 xdr_u_int(xdrs,&this1->mult);
6246 for (m = 0; m < this1->mult; m++)
6247 {
6248 xdr_int(xdrs,&this1->in[m].plane);
6249 xdr_int(xdrs,&this1->in[m].strip);
6250 if (this1->in[m].fdcCathodeHits != (s_FdcCathodeHits_t*)&hddm_s_nullTarget)
6251 {
6252 if (pack_s_FdcCathodeHits(xdrs,this1->in[m].fdcCathodeHits) < 0) {
6253 return -1;
6254 }
6255 }
6256 else
6257 {
6258 int zero=0;
6259 xdr_int(xdrs,&zero);
6260 }
6261 if (this1->in[m].fdcCathodeTruthHits != (s_FdcCathodeTruthHits_t*)&hddm_s_nullTarget)
6262 {
6263 if (pack_s_FdcCathodeTruthHits(xdrs,this1->in[m].fdcCathodeTruthHits) < 0) {
6264 return -1;
6265 }
6266 }
6267 else
6268 {
6269 int zero=0;
6270 xdr_int(xdrs,&zero);
6271 }
6272 }
6273 FREE(this1)free(this1);
6274 end = xdr_getpos64(xdrs);
6275 xdr_setpos64(xdrs,base);
6276 size = end-start;
6277 xdr_u_int(xdrs,&size);
6278 xdr_setpos64(xdrs,end);
6279 return size;
6280}
6281
6282static int pack_s_FdcCathodeHits(XDR* xdrs, s_FdcCathodeHits_t* this1)
6283{
6284 int m=0;
6285 unsigned int size=0;
6286 off_t base,start,end;
6287 base = xdr_getpos64(xdrs);
6288 xdr_u_int(xdrs,&size);
6289 start = xdr_getpos64(xdrs);
6290
6291 xdr_u_int(xdrs,&this1->mult);
6292 for (m = 0; m < this1->mult; m++)
6293 {
6294 xdr_int(xdrs,&this1->in[m].itrack);
6295 xdr_int(xdrs,&this1->in[m].ptype);
6296 xdr_float(xdrs,&this1->in[m].q);
6297 xdr_float(xdrs,&this1->in[m].t);
6298 }
6299 FREE(this1)free(this1);
6300 end = xdr_getpos64(xdrs);
6301 xdr_setpos64(xdrs,base);
6302 size = end-start;
6303 xdr_u_int(xdrs,&size);
6304 xdr_setpos64(xdrs,end);
6305 return size;
6306}
6307
6308static int pack_s_FdcCathodeTruthHits(XDR* xdrs, s_FdcCathodeTruthHits_t* this1)
6309{
6310 int m=0;
6311 unsigned int size=0;
6312 off_t base,start,end;
6313 base = xdr_getpos64(xdrs);
6314 xdr_u_int(xdrs,&size);
6315 start = xdr_getpos64(xdrs);
6316
6317 xdr_u_int(xdrs,&this1->mult);
6318 for (m = 0; m < this1->mult; m++)
6319 {
6320 xdr_int(xdrs,&this1->in[m].itrack);
6321 xdr_int(xdrs,&this1->in[m].ptype);
6322 xdr_float(xdrs,&this1->in[m].q);
6323 xdr_float(xdrs,&this1->in[m].t);
6324 }
6325 FREE(this1)free(this1);
6326 end = xdr_getpos64(xdrs);
6327 xdr_setpos64(xdrs,base);
6328 size = end-start;
6329 xdr_u_int(xdrs,&size);
6330 xdr_setpos64(xdrs,end);
6331 return size;
6332}
6333
6334static int pack_s_FdcTruthPoints(XDR* xdrs, s_FdcTruthPoints_t* this1)
6335{
6336 int m=0;
6337 unsigned int size=0;
6338 off_t base,start,end;
6339 base = xdr_getpos64(xdrs);
6340 xdr_u_int(xdrs,&size);
6341 start = xdr_getpos64(xdrs);
6342
6343 xdr_u_int(xdrs,&this1->mult);
6344 for (m = 0; m < this1->mult; m++)
6345 {
6346 xdr_float(xdrs,&this1->in[m].E);
6347 xdr_float(xdrs,&this1->in[m].dEdx);
6348 xdr_float(xdrs,&this1->in[m].dradius);
6349 xdr_bool(xdrs,&this1->in[m].primary);
6350 xdr_int(xdrs,&this1->in[m].ptype);
6351 xdr_float(xdrs,&this1->in[m].px);
6352 xdr_float(xdrs,&this1->in[m].py);
6353 xdr_float(xdrs,&this1->in[m].pz);
6354 xdr_float(xdrs,&this1->in[m].t);
6355 xdr_int(xdrs,&this1->in[m].track);
6356 xdr_float(xdrs,&this1->in[m].x);
6357 xdr_float(xdrs,&this1->in[m].y);
6358 xdr_float(xdrs,&this1->in[m].z);
6359 }
6360 FREE(this1)free(this1);
6361 end = xdr_getpos64(xdrs);
6362 xdr_setpos64(xdrs,base);
6363 size = end-start;
6364 xdr_u_int(xdrs,&size);
6365 xdr_setpos64(xdrs,end);
6366 return size;
6367}
6368
6369static int pack_s_StartCntr(XDR* xdrs, s_StartCntr_t* this1)
6370{
6371 int m=0;
6372 unsigned int size=0;
6373 off_t base,start,end;
6374 base = xdr_getpos64(xdrs);
6375 xdr_u_int(xdrs,&size);
6376 start = xdr_getpos64(xdrs);
6377
6378 {
6379 if (this1->stcPaddles != (s_StcPaddles_t*)&hddm_s_nullTarget)
6380 {
6381 if (pack_s_StcPaddles(xdrs,this1->stcPaddles) < 0) {
6382 return -1;
6383 }
6384 }
6385 else
6386 {
6387 int zero=0;
6388 xdr_int(xdrs,&zero);
6389 }
6390 if (this1->stcTruthPoints != (s_StcTruthPoints_t*)&hddm_s_nullTarget)
6391 {
6392 if (pack_s_StcTruthPoints(xdrs,this1->stcTruthPoints) < 0) {
6393 return -1;
6394 }
6395 }
6396 else
6397 {
6398 int zero=0;
6399 xdr_int(xdrs,&zero);
6400 }
6401 }
6402 FREE(this1)free(this1);
6403 end = xdr_getpos64(xdrs);
6404 xdr_setpos64(xdrs,base);
6405 size = end-start;
6406 xdr_u_int(xdrs,&size);
6407 xdr_setpos64(xdrs,end);
6408 return size;
6409}
6410
6411static int pack_s_StcPaddles(XDR* xdrs, s_StcPaddles_t* this1)
6412{
6413 int m=0;
6414 unsigned int size=0;
6415 off_t base,start,end;
6416 base = xdr_getpos64(xdrs);
6417 xdr_u_int(xdrs,&size);
6418 start = xdr_getpos64(xdrs);
6419
6420 xdr_u_int(xdrs,&this1->mult);
6421 for (m = 0; m < this1->mult; m++)
6422 {
6423 xdr_int(xdrs,&this1->in[m].sector);
6424 if (this1->in[m].stcHits != (s_StcHits_t*)&hddm_s_nullTarget)
6425 {
6426 if (pack_s_StcHits(xdrs,this1->in[m].stcHits) < 0) {
6427 return -1;
6428 }
6429 }
6430 else
6431 {
6432 int zero=0;
6433 xdr_int(xdrs,&zero);
6434 }
6435 if (this1->in[m].stcTruthHits != (s_StcTruthHits_t*)&hddm_s_nullTarget)
6436 {
6437 if (pack_s_StcTruthHits(xdrs,this1->in[m].stcTruthHits) < 0) {
6438 return -1;
6439 }
6440 }
6441 else
6442 {
6443 int zero=0;
6444 xdr_int(xdrs,&zero);
6445 }
6446 }
6447 FREE(this1)free(this1);
6448 end = xdr_getpos64(xdrs);
6449 xdr_setpos64(xdrs,base);
6450 size = end-start;
6451 xdr_u_int(xdrs,&size);
6452 xdr_setpos64(xdrs,end);
6453 return size;
6454}
6455
6456static int pack_s_StcHits(XDR* xdrs, s_StcHits_t* this1)
6457{
6458 int m=0;
6459 unsigned int size=0;
6460 off_t base,start,end;
6461 base = xdr_getpos64(xdrs);
6462 xdr_u_int(xdrs,&size);
6463 start = xdr_getpos64(xdrs);
6464
6465 xdr_u_int(xdrs,&this1->mult);
6466 for (m = 0; m < this1->mult; m++)
6467 {
6468 xdr_float(xdrs,&this1->in[m].dE);
6469 xdr_float(xdrs,&this1->in[m].t);
6470 }
6471 FREE(this1)free(this1);
6472 end = xdr_getpos64(xdrs);
6473 xdr_setpos64(xdrs,base);
6474 size = end-start;
6475 xdr_u_int(xdrs,&size);
6476 xdr_setpos64(xdrs,end);
6477 return size;
6478}
6479
6480static int pack_s_StcTruthHits(XDR* xdrs, s_StcTruthHits_t* this1)
6481{
6482 int m=0;
6483 unsigned int size=0;
6484 off_t base,start,end;
6485 base = xdr_getpos64(xdrs);
6486 xdr_u_int(xdrs,&size);
6487 start = xdr_getpos64(xdrs);
6488
6489 xdr_u_int(xdrs,&this1->mult);
6490 for (m = 0; m < this1->mult; m++)
6491 {
6492 xdr_float(xdrs,&this1->in[m].dE);
6493 xdr_float(xdrs,&this1->in[m].t);
6494 }
6495 FREE(this1)free(this1);
6496 end = xdr_getpos64(xdrs);
6497 xdr_setpos64(xdrs,base);
6498 size = end-start;
6499 xdr_u_int(xdrs,&size);
6500 xdr_setpos64(xdrs,end);
6501 return size;
6502}
6503
6504static int pack_s_StcTruthPoints(XDR* xdrs, s_StcTruthPoints_t* this1)
6505{
6506 int m=0;
6507 unsigned int size=0;
6508 off_t base,start,end;
6509 base = xdr_getpos64(xdrs);
6510 xdr_u_int(xdrs,&size);
6511 start = xdr_getpos64(xdrs);
6512
6513 xdr_u_int(xdrs,&this1->mult);
6514 for (m = 0; m < this1->mult; m++)
6515 {
6516 xdr_float(xdrs,&this1->in[m].E);
6517 xdr_float(xdrs,&this1->in[m].dEdx);
6518 xdr_float(xdrs,&this1->in[m].phi);
6519 xdr_bool(xdrs,&this1->in[m].primary);
6520 xdr_int(xdrs,&this1->in[m].ptype);
6521 xdr_float(xdrs,&this1->in[m].px);
6522 xdr_float(xdrs,&this1->in[m].py);
6523 xdr_float(xdrs,&this1->in[m].pz);
6524 xdr_float(xdrs,&this1->in[m].r);
6525 xdr_int(xdrs,&this1->in[m].sector);
6526 xdr_float(xdrs,&this1->in[m].t);
6527 xdr_int(xdrs,&this1->in[m].track);
6528 xdr_float(xdrs,&this1->in[m].z);
6529 }
6530 FREE(this1)free(this1);
6531 end = xdr_getpos64(xdrs);
6532 xdr_setpos64(xdrs,base);
6533 size = end-start;
6534 xdr_u_int(xdrs,&size);
6535 xdr_setpos64(xdrs,end);
6536 return size;
6537}
6538
6539static int pack_s_BarrelEMcal(XDR* xdrs, s_BarrelEMcal_t* this1)
6540{
6541 int m=0;
6542 unsigned int size=0;
6543 off_t base,start,end;
6544 base = xdr_getpos64(xdrs);
6545 xdr_u_int(xdrs,&size);
6546 start = xdr_getpos64(xdrs);
6547
6548 {
6549 if (this1->bcalCells != (s_BcalCells_t*)&hddm_s_nullTarget)
6550 {
6551 if (pack_s_BcalCells(xdrs,this1->bcalCells) < 0) {
6552 return -1;
6553 }
6554 }
6555 else
6556 {
6557 int zero=0;
6558 xdr_int(xdrs,&zero);
6559 }
6560 if (this1->bcalIncidentParticles != (s_BcalIncidentParticles_t*)&hddm_s_nullTarget)
6561 {
6562 if (pack_s_BcalIncidentParticles(xdrs,this1->bcalIncidentParticles) < 0) {
6563 return -1;
6564 }
6565 }
6566 else
6567 {
6568 int zero=0;
6569 xdr_int(xdrs,&zero);
6570 }
6571 if (this1->bcalSiPMSpectrums != (s_BcalSiPMSpectrums_t*)&hddm_s_nullTarget)
6572 {
6573 if (pack_s_BcalSiPMSpectrums(xdrs,this1->bcalSiPMSpectrums) < 0) {
6574 return -1;
6575 }
6576 }
6577 else
6578 {
6579 int zero=0;
6580 xdr_int(xdrs,&zero);
6581 }
6582 if (this1->bcalfADCCells != (s_BcalfADCCells_t*)&hddm_s_nullTarget)
6583 {
6584 if (pack_s_BcalfADCCells(xdrs,this1->bcalfADCCells) < 0) {
6585 return -1;
6586 }
6587 }
6588 else
6589 {
6590 int zero=0;
6591 xdr_int(xdrs,&zero);
6592 }
6593 if (this1->bcalTDCHits != (s_BcalTDCHits_t*)&hddm_s_nullTarget)
6594 {
6595 if (pack_s_BcalTDCHits(xdrs,this1->bcalTDCHits) < 0) {
6596 return -1;
6597 }
6598 }
6599 else
6600 {
6601 int zero=0;
6602 xdr_int(xdrs,&zero);
6603 }
6604 if (this1->bcalTruthShowers != (s_BcalTruthShowers_t*)&hddm_s_nullTarget)
6605 {
6606 if (pack_s_BcalTruthShowers(xdrs,this1->bcalTruthShowers) < 0) {
6607 return -1;
6608 }
6609 }
6610 else
6611 {
6612 int zero=0;
6613 xdr_int(xdrs,&zero);
6614 }
6615 }
6616 FREE(this1)free(this1);
6617 end = xdr_getpos64(xdrs);
6618 xdr_setpos64(xdrs,base);
6619 size = end-start;
6620 xdr_u_int(xdrs,&size);
6621 xdr_setpos64(xdrs,end);
6622 return size;
6623}
6624
6625static int pack_s_BcalCells(XDR* xdrs, s_BcalCells_t* this1)
6626{
6627 int m=0;
6628 unsigned int size=0;
6629 off_t base,start,end;
6630 base = xdr_getpos64(xdrs);
6631 xdr_u_int(xdrs,&size);
6632 start = xdr_getpos64(xdrs);
6633
6634 xdr_u_int(xdrs,&this1->mult);
6635 for (m = 0; m < this1->mult; m++)
6636 {
6637 xdr_int(xdrs,&this1->in[m].layer);
6638 xdr_int(xdrs,&this1->in[m].module);
6639 xdr_int(xdrs,&this1->in[m].sector);
6640 if (this1->in[m].bcalSiPMUpHits != (s_BcalSiPMUpHits_t*)&hddm_s_nullTarget)
6641 {
6642 if (pack_s_BcalSiPMUpHits(xdrs,this1->in[m].bcalSiPMUpHits) < 0) {
6643 return -1;
6644 }
6645 }
6646 else
6647 {
6648 int zero=0;
6649 xdr_int(xdrs,&zero);
6650 }
6651 if (this1->in[m].bcalSiPMDownHits != (s_BcalSiPMDownHits_t*)&hddm_s_nullTarget)
6652 {
6653 if (pack_s_BcalSiPMDownHits(xdrs,this1->in[m].bcalSiPMDownHits) < 0) {
6654 return -1;
6655 }
6656 }
6657 else
6658 {
6659 int zero=0;
6660 xdr_int(xdrs,&zero);
6661 }
6662 if (this1->in[m].bcalHits != (s_BcalHits_t*)&hddm_s_nullTarget)
6663 {
6664 if (pack_s_BcalHits(xdrs,this1->in[m].bcalHits) < 0) {
6665 return -1;
6666 }
6667 }
6668 else
6669 {
6670 int zero=0;
6671 xdr_int(xdrs,&zero);
6672 }
6673 }
6674 FREE(this1)free(this1);
6675 end = xdr_getpos64(xdrs);
6676 xdr_setpos64(xdrs,base);
6677 size = end-start;
6678 xdr_u_int(xdrs,&size);
6679 xdr_setpos64(xdrs,end);
6680 return size;
6681}
6682
6683static int pack_s_BcalSiPMUpHits(XDR* xdrs, s_BcalSiPMUpHits_t* this1)
6684{
6685 int m=0;
6686 unsigned int size=0;
6687 off_t base,start,end;
6688 base = xdr_getpos64(xdrs);
6689 xdr_u_int(xdrs,&size);
6690 start = xdr_getpos64(xdrs);
6691
6692 xdr_u_int(xdrs,&this1->mult);
6693 for (m = 0; m < this1->mult; m++)
6694 {
6695 xdr_float(xdrs,&this1->in[m].E);
6696 xdr_float(xdrs,&this1->in[m].t);
6697 }
6698 FREE(this1)free(this1);
6699 end = xdr_getpos64(xdrs);
6700 xdr_setpos64(xdrs,base);
6701 size = end-start;
6702 xdr_u_int(xdrs,&size);
6703 xdr_setpos64(xdrs,end);
6704 return size;
6705}
6706
6707static int pack_s_BcalSiPMDownHits(XDR* xdrs, s_BcalSiPMDownHits_t* this1)
6708{
6709 int m=0;
6710 unsigned int size=0;
6711 off_t base,start,end;
6712 base = xdr_getpos64(xdrs);
6713 xdr_u_int(xdrs,&size);
6714 start = xdr_getpos64(xdrs);
6715
6716 xdr_u_int(xdrs,&this1->mult);
6717 for (m = 0; m < this1->mult; m++)
6718 {
6719 xdr_float(xdrs,&this1->in[m].E);
6720 xdr_float(xdrs,&this1->in[m].t);
6721 }
6722 FREE(this1)free(this1);
6723 end = xdr_getpos64(xdrs);
6724 xdr_setpos64(xdrs,base);
6725 size = end-start;
6726 xdr_u_int(xdrs,&size);
6727 xdr_setpos64(xdrs,end);
6728 return size;
6729}
6730
6731static int pack_s_BcalHits(XDR* xdrs, s_BcalHits_t* this1)
6732{
6733 int m=0;
6734 unsigned int size=0;
6735 off_t base,start,end;
6736 base = xdr_getpos64(xdrs);
6737 xdr_u_int(xdrs,&size);
6738 start = xdr_getpos64(xdrs);
6739
6740 xdr_u_int(xdrs,&this1->mult);
6741 for (m = 0; m < this1->mult; m++)
6742 {
6743 xdr_float(xdrs,&this1->in[m].E);
6744 xdr_float(xdrs,&this1->in[m].t);
6745 xdr_float(xdrs,&this1->in[m].zLocal);
6746 }
6747 FREE(this1)free(this1);
6748 end = xdr_getpos64(xdrs);
6749 xdr_setpos64(xdrs,base);
6750 size = end-start;
6751 xdr_u_int(xdrs,&size);
6752 xdr_setpos64(xdrs,end);
6753 return size;
6754}
6755
6756static int pack_s_BcalIncidentParticles(XDR* xdrs, s_BcalIncidentParticles_t* this1)
6757{
6758 int m=0;
6759 unsigned int size=0;
6760 off_t base,start,end;
6761 base = xdr_getpos64(xdrs);
6762 xdr_u_int(xdrs,&size);
6763 start = xdr_getpos64(xdrs);
6764
6765 xdr_u_int(xdrs,&this1->mult);
6766 for (m = 0; m < this1->mult; m++)
6767 {
6768 xdr_int(xdrs,&this1->in[m].id);
6769 xdr_int(xdrs,&this1->in[m].ptype);
6770 xdr_float(xdrs,&this1->in[m].px);
6771 xdr_float(xdrs,&this1->in[m].py);
6772 xdr_float(xdrs,&this1->in[m].pz);
6773 xdr_float(xdrs,&this1->in[m].x);
6774 xdr_float(xdrs,&this1->in[m].y);
6775 xdr_float(xdrs,&this1->in[m].z);
6776 }
6777 FREE(this1)free(this1);
6778 end = xdr_getpos64(xdrs);
6779 xdr_setpos64(xdrs,base);
6780 size = end-start;
6781 xdr_u_int(xdrs,&size);
6782 xdr_setpos64(xdrs,end);
6783 return size;
6784}
6785
6786static int pack_s_BcalSiPMSpectrums(XDR* xdrs, s_BcalSiPMSpectrums_t* this1)
6787{
6788 int m=0;
6789 unsigned int size=0;
6790 off_t base,start,end;
6791 base = xdr_getpos64(xdrs);
6792 xdr_u_int(xdrs,&size);
6793 start = xdr_getpos64(xdrs);
6794
6795 xdr_u_int(xdrs,&this1->mult);
6796 for (m = 0; m < this1->mult; m++)
6797 {
6798 xdr_float(xdrs,&this1->in[m].Etruth);
6799 xdr_float(xdrs,&this1->in[m].bin_width);
6800 xdr_int(xdrs,&this1->in[m].end);
6801 xdr_int(xdrs,&this1->in[m].incident_id);
6802 xdr_int(xdrs,&this1->in[m].layer);
6803 xdr_int(xdrs,&this1->in[m].module);
6804 xdr_int(xdrs,&this1->in[m].sector);
6805 xdr_float(xdrs,&this1->in[m].tstart);
6806 xdr_string(xdrs,&this1->in[m].vals, 1000000);
6807 FREE(this1->in[m].vals)free(this1->in[m].vals);
6808 }
6809 FREE(this1)free(this1);
6810 end = xdr_getpos64(xdrs);
6811 xdr_setpos64(xdrs,base);
6812 size = end-start;
6813 xdr_u_int(xdrs,&size);
6814 xdr_setpos64(xdrs,end);
6815 return size;
6816}
6817
6818static int pack_s_BcalfADCCells(XDR* xdrs, s_BcalfADCCells_t* this1)
6819{
6820 int m=0;
6821 unsigned int size=0;
6822 off_t base,start,end;
6823 base = xdr_getpos64(xdrs);
6824 xdr_u_int(xdrs,&size);
6825 start = xdr_getpos64(xdrs);
6826
6827 xdr_u_int(xdrs,&this1->mult);
6828 for (m = 0; m < this1->mult; m++)
6829 {
6830 xdr_int(xdrs,&this1->in[m].layer);
6831 xdr_int(xdrs,&this1->in[m].module);
6832 xdr_int(xdrs,&this1->in[m].sector);
6833 if (this1->in[m].bcalfADCUpHits != (s_BcalfADCUpHits_t*)&hddm_s_nullTarget)
6834 {
6835 if (pack_s_BcalfADCUpHits(xdrs,this1->in[m].bcalfADCUpHits) < 0) {
6836 return -1;
6837 }
6838 }
6839 else
6840 {
6841 int zero=0;
6842 xdr_int(xdrs,&zero);
6843 }
6844 if (this1->in[m].bcalfADCDownHits != (s_BcalfADCDownHits_t*)&hddm_s_nullTarget)
6845 {
6846 if (pack_s_BcalfADCDownHits(xdrs,this1->in[m].bcalfADCDownHits) < 0) {
6847 return -1;
6848 }
6849 }
6850 else
6851 {
6852 int zero=0;
6853 xdr_int(xdrs,&zero);
6854 }
6855 }
6856 FREE(this1)free(this1);
6857 end = xdr_getpos64(xdrs);
6858 xdr_setpos64(xdrs,base);
6859 size = end-start;
6860 xdr_u_int(xdrs,&size);
6861 xdr_setpos64(xdrs,end);
6862 return size;
6863}
6864
6865static int pack_s_BcalfADCUpHits(XDR* xdrs, s_BcalfADCUpHits_t* this1)
6866{
6867 int m=0;
6868 unsigned int size=0;
6869 off_t base,start,end;
6870 base = xdr_getpos64(xdrs);
6871 xdr_u_int(xdrs,&size);
6872 start = xdr_getpos64(xdrs);
6873
6874 xdr_u_int(xdrs,&this1->mult);
6875 for (m = 0; m < this1->mult; m++)
6876 {
6877 xdr_float(xdrs,&this1->in[m].E);
6878 xdr_float(xdrs,&this1->in[m].t);
6879 }
6880 FREE(this1)free(this1);
6881 end = xdr_getpos64(xdrs);
6882 xdr_setpos64(xdrs,base);
6883 size = end-start;
6884 xdr_u_int(xdrs,&size);
6885 xdr_setpos64(xdrs,end);
6886 return size;
6887}
6888
6889static int pack_s_BcalfADCDownHits(XDR* xdrs, s_BcalfADCDownHits_t* this1)
6890{
6891 int m=0;
6892 unsigned int size=0;
6893 off_t base,start,end;
6894 base = xdr_getpos64(xdrs);
6895 xdr_u_int(xdrs,&size);
6896 start = xdr_getpos64(xdrs);
6897
6898 xdr_u_int(xdrs,&this1->mult);
6899 for (m = 0; m < this1->mult; m++)
6900 {
6901 xdr_float(xdrs,&this1->in[m].E);
6902 xdr_float(xdrs,&this1->in[m].t);
6903 }
6904 FREE(this1)free(this1);
6905 end = xdr_getpos64(xdrs);
6906 xdr_setpos64(xdrs,base);
6907 size = end-start;
6908 xdr_u_int(xdrs,&size);
6909 xdr_setpos64(xdrs,end);
6910 return size;
6911}
6912
6913static int pack_s_BcalTDCHits(XDR* xdrs, s_BcalTDCHits_t* this1)
6914{
6915 int m=0;
6916 unsigned int size=0;
6917 off_t base,start,end;
6918 base = xdr_getpos64(xdrs);
6919 xdr_u_int(xdrs,&size);
6920 start = xdr_getpos64(xdrs);
6921
6922 xdr_u_int(xdrs,&this1->mult);
6923 for (m = 0; m < this1->mult; m++)
6924 {
6925 xdr_int(xdrs,&this1->in[m].end);
6926 xdr_int(xdrs,&this1->in[m].layer);
6927 xdr_int(xdrs,&this1->in[m].module);
6928 xdr_int(xdrs,&this1->in[m].sector);
6929 xdr_float(xdrs,&this1->in[m].t);
6930 }
6931 FREE(this1)free(this1);
6932 end = xdr_getpos64(xdrs);
6933 xdr_setpos64(xdrs,base);
6934 size = end-start;
6935 xdr_u_int(xdrs,&size);
6936 xdr_setpos64(xdrs,end);
6937 return size;
6938}
6939
6940static int pack_s_BcalTruthShowers(XDR* xdrs, s_BcalTruthShowers_t* this1)
6941{
6942 int m=0;
6943 unsigned int size=0;
6944 off_t base,start,end;
6945 base = xdr_getpos64(xdrs);
6946 xdr_u_int(xdrs,&size);
6947 start = xdr_getpos64(xdrs);
6948
6949 xdr_u_int(xdrs,&this1->mult);
6950 for (m = 0; m < this1->mult; m++)
6951 {
6952 xdr_float(xdrs,&this1->in[m].E);
6953 xdr_float(xdrs,&this1->in[m].phi);
6954 xdr_bool(xdrs,&this1->in[m].primary);
6955 xdr_int(xdrs,&this1->in[m].ptype);
6956 xdr_float(xdrs,&this1->in[m].px);
6957 xdr_float(xdrs,&this1->in[m].py);
6958 xdr_float(xdrs,&this1->in[m].pz);
6959 xdr_float(xdrs,&this1->in[m].r);
6960 xdr_float(xdrs,&this1->in[m].t);
6961 xdr_int(xdrs,&this1->in[m].track);
6962 xdr_float(xdrs,&this1->in[m].z);
6963 }
6964 FREE(this1)free(this1);
6965 end = xdr_getpos64(xdrs);
6966 xdr_setpos64(xdrs,base);
6967 size = end-start;
6968 xdr_u_int(xdrs,&size);
6969 xdr_setpos64(xdrs,end);
6970 return size;
6971}
6972
6973static int pack_s_GapEMcal(XDR* xdrs, s_GapEMcal_t* this1)
6974{
6975 int m=0;
6976 unsigned int size=0;
6977 off_t base,start,end;
6978 base = xdr_getpos64(xdrs);
6979 xdr_u_int(xdrs,&size);
6980 start = xdr_getpos64(xdrs);
6981
6982 {
6983 if (this1->gcalCells != (s_GcalCells_t*)&hddm_s_nullTarget)
6984 {
6985 if (pack_s_GcalCells(xdrs,this1->gcalCells) < 0) {
6986 return -1;
6987 }
6988 }
6989 else
6990 {
6991 int zero=0;
6992 xdr_int(xdrs,&zero);
6993 }
6994 if (this1->gcalTruthShowers != (s_GcalTruthShowers_t*)&hddm_s_nullTarget)
6995 {
6996 if (pack_s_GcalTruthShowers(xdrs,this1->gcalTruthShowers) < 0) {
6997 return -1;
6998 }
6999 }
7000 else
7001 {
7002 int zero=0;
7003 xdr_int(xdrs,&zero);
7004 }
7005 }
7006 FREE(this1)free(this1);
7007 end = xdr_getpos64(xdrs);
7008 xdr_setpos64(xdrs,base);
7009 size = end-start;
7010 xdr_u_int(xdrs,&size);
7011 xdr_setpos64(xdrs,end);
7012 return size;
7013}
7014
7015static int pack_s_GcalCells(XDR* xdrs, s_GcalCells_t* this1)
7016{
7017 int m=0;
7018 unsigned int size=0;
7019 off_t base,start,end;
7020 base = xdr_getpos64(xdrs);
7021 xdr_u_int(xdrs,&size);
7022 start = xdr_getpos64(xdrs);
7023
7024 xdr_u_int(xdrs,&this1->mult);
7025 for (m = 0; m < this1->mult; m++)
7026 {
7027 xdr_int(xdrs,&this1->in[m].module);
7028 if (this1->in[m].gcalHits != (s_GcalHits_t*)&hddm_s_nullTarget)
7029 {
7030 if (pack_s_GcalHits(xdrs,this1->in[m].gcalHits) < 0) {
7031 return -1;
7032 }
7033 }
7034 else
7035 {
7036 int zero=0;
7037 xdr_int(xdrs,&zero);
7038 }
7039 }
7040 FREE(this1)free(this1);
7041 end = xdr_getpos64(xdrs);
7042 xdr_setpos64(xdrs,base);
7043 size = end-start;
7044 xdr_u_int(xdrs,&size);
7045 xdr_setpos64(xdrs,end);
7046 return size;
7047}
7048
7049static int pack_s_GcalHits(XDR* xdrs, s_GcalHits_t* this1)
7050{
7051 int m=0;
7052 unsigned int size=0;
7053 off_t base,start,end;
7054 base = xdr_getpos64(xdrs);
7055 xdr_u_int(xdrs,&size);
7056 start = xdr_getpos64(xdrs);
7057
7058 xdr_u_int(xdrs,&this1->mult);
7059 for (m = 0; m < this1->mult; m++)
7060 {
7061 xdr_float(xdrs,&this1->in[m].E);
7062 xdr_float(xdrs,&this1->in[m].t);
7063 xdr_float(xdrs,&this1->in[m].zLocal);
7064 }
7065 FREE(this1)free(this1);
7066 end = xdr_getpos64(xdrs);
7067 xdr_setpos64(xdrs,base);
7068 size = end-start;
7069 xdr_u_int(xdrs,&size);
7070 xdr_setpos64(xdrs,end);
7071 return size;
7072}
7073
7074static int pack_s_GcalTruthShowers(XDR* xdrs, s_GcalTruthShowers_t* this1)
7075{
7076 int m=0;
7077 unsigned int size=0;
7078 off_t base,start,end;
7079 base = xdr_getpos64(xdrs);
7080 xdr_u_int(xdrs,&size);
7081 start = xdr_getpos64(xdrs);
7082
7083 xdr_u_int(xdrs,&this1->mult);
7084 for (m = 0; m < this1->mult; m++)
7085 {
7086 xdr_float(xdrs,&this1->in[m].E);
7087 xdr_float(xdrs,&this1->in[m].phi);
7088 xdr_bool(xdrs,&this1->in[m].primary);
7089 xdr_int(xdrs,&this1->in[m].ptype);
7090 xdr_float(xdrs,&this1->in[m].px);
7091 xdr_float(xdrs,&this1->in[m].py);
7092 xdr_float(xdrs,&this1->in[m].pz);
7093 xdr_float(xdrs,&this1->in[m].r);
7094 xdr_float(xdrs,&this1->in[m].t);
7095 xdr_int(xdrs,&this1->in[m].track);
7096 xdr_float(xdrs,&this1->in[m].z);
7097 }
7098 FREE(this1)free(this1);
7099 end = xdr_getpos64(xdrs);
7100 xdr_setpos64(xdrs,base);
7101 size = end-start;
7102 xdr_u_int(xdrs,&size);
7103 xdr_setpos64(xdrs,end);
7104 return size;
7105}
7106
7107static int pack_s_Cerenkov(XDR* xdrs, s_Cerenkov_t* this1)
7108{
7109 int m=0;
7110 unsigned int size=0;
7111 off_t base,start,end;
7112 base = xdr_getpos64(xdrs);
7113 xdr_u_int(xdrs,&size);
7114 start = xdr_getpos64(xdrs);
7115
7116 {
7117 if (this1->cereSections != (s_CereSections_t*)&hddm_s_nullTarget)
7118 {
7119 if (pack_s_CereSections(xdrs,this1->cereSections) < 0) {
7120 return -1;
7121 }
7122 }
7123 else
7124 {
7125 int zero=0;
7126 xdr_int(xdrs,&zero);
7127 }
7128 if (this1->cereTruthPoints != (s_CereTruthPoints_t*)&hddm_s_nullTarget)
7129 {
7130 if (pack_s_CereTruthPoints(xdrs,this1->cereTruthPoints) < 0) {
7131 return -1;
7132 }
7133 }
7134 else
7135 {
7136 int zero=0;
7137 xdr_int(xdrs,&zero);
7138 }
7139 }
7140 FREE(this1)free(this1);
7141 end = xdr_getpos64(xdrs);
7142 xdr_setpos64(xdrs,base);
7143 size = end-start;
7144 xdr_u_int(xdrs,&size);
7145 xdr_setpos64(xdrs,end);
7146 return size;
7147}
7148
7149static int pack_s_CereSections(XDR* xdrs, s_CereSections_t* this1)
7150{
7151 int m=0;
7152 unsigned int size=0;
7153 off_t base,start,end;
7154 base = xdr_getpos64(xdrs);
7155 xdr_u_int(xdrs,&size);
7156 start = xdr_getpos64(xdrs);
7157
7158 xdr_u_int(xdrs,&this1->mult);
7159 for (m = 0; m < this1->mult; m++)
7160 {
7161 xdr_int(xdrs,&this1->in[m].sector);
7162 if (this1->in[m].cereHits != (s_CereHits_t*)&hddm_s_nullTarget)
7163 {
7164 if (pack_s_CereHits(xdrs,this1->in[m].cereHits) < 0) {
7165 return -1;
7166 }
7167 }
7168 else
7169 {
7170 int zero=0;
7171 xdr_int(xdrs,&zero);
7172 }
7173 }
7174 FREE(this1)free(this1);
7175 end = xdr_getpos64(xdrs);
7176 xdr_setpos64(xdrs,base);
7177 size = end-start;
7178 xdr_u_int(xdrs,&size);
7179 xdr_setpos64(xdrs,end);
7180 return size;
7181}
7182
7183static int pack_s_CereHits(XDR* xdrs, s_CereHits_t* this1)
7184{
7185 int m=0;
7186 unsigned int size=0;
7187 off_t base,start,end;
7188 base = xdr_getpos64(xdrs);
7189 xdr_u_int(xdrs,&size);
7190 start = xdr_getpos64(xdrs);
7191
7192 xdr_u_int(xdrs,&this1->mult);
7193 for (m = 0; m < this1->mult; m++)
7194 {
7195 xdr_float(xdrs,&this1->in[m].pe);
7196 xdr_float(xdrs,&this1->in[m].t);
7197 }
7198 FREE(this1)free(this1);
7199 end = xdr_getpos64(xdrs);
7200 xdr_setpos64(xdrs,base);
7201 size = end-start;
7202 xdr_u_int(xdrs,&size);
7203 xdr_setpos64(xdrs,end);
7204 return size;
7205}
7206
7207static int pack_s_CereTruthPoints(XDR* xdrs, s_CereTruthPoints_t* this1)
7208{
7209 int m=0;
7210 unsigned int size=0;
7211 off_t base,start,end;
7212 base = xdr_getpos64(xdrs);
7213 xdr_u_int(xdrs,&size);
7214 start = xdr_getpos64(xdrs);
7215
7216 xdr_u_int(xdrs,&this1->mult);
7217 for (m = 0; m < this1->mult; m++)
7218 {
7219 xdr_float(xdrs,&this1->in[m].E);
7220 xdr_bool(xdrs,&this1->in[m].primary);
7221 xdr_int(xdrs,&this1->in[m].ptype);
7222 xdr_float(xdrs,&this1->in[m].px);
7223 xdr_float(xdrs,&this1->in[m].py);
7224 xdr_float(xdrs,&this1->in[m].pz);
7225 xdr_float(xdrs,&this1->in[m].t);
7226 xdr_int(xdrs,&this1->in[m].track);
7227 xdr_float(xdrs,&this1->in[m].x);
7228 xdr_float(xdrs,&this1->in[m].y);
7229 xdr_float(xdrs,&this1->in[m].z);
7230 }
7231 FREE(this1)free(this1);
7232 end = xdr_getpos64(xdrs);
7233 xdr_setpos64(xdrs,base);
7234 size = end-start;
7235 xdr_u_int(xdrs,&size);
7236 xdr_setpos64(xdrs,end);
7237 return size;
7238}
7239
7240static int pack_s_ForwardTOF(XDR* xdrs, s_ForwardTOF_t* this1)
7241{
7242 int m=0;
7243 unsigned int size=0;
7244 off_t base,start,end;
7245 base = xdr_getpos64(xdrs);
7246 xdr_u_int(xdrs,&size);
7247 start = xdr_getpos64(xdrs);
7248
7249 {
7250 if (this1->ftofCounters != (s_FtofCounters_t*)&hddm_s_nullTarget)
7251 {
7252 if (pack_s_FtofCounters(xdrs,this1->ftofCounters) < 0) {
7253 return -1;
7254 }
7255 }
7256 else
7257 {
7258 int zero=0;
7259 xdr_int(xdrs,&zero);
7260 }
7261 if (this1->ftofTruthPoints != (s_FtofTruthPoints_t*)&hddm_s_nullTarget)
7262 {
7263 if (pack_s_FtofTruthPoints(xdrs,this1->ftofTruthPoints) < 0) {
7264 return -1;
7265 }
7266 }
7267 else
7268 {
7269 int zero=0;
7270 xdr_int(xdrs,&zero);
7271 }
7272 }
7273 FREE(this1)free(this1);
7274 end = xdr_getpos64(xdrs);
7275 xdr_setpos64(xdrs,base);
7276 size = end-start;
7277 xdr_u_int(xdrs,&size);
7278 xdr_setpos64(xdrs,end);
7279 return size;
7280}
7281
7282static int pack_s_FtofCounters(XDR* xdrs, s_FtofCounters_t* this1)
7283{
7284 int m=0;
7285 unsigned int size=0;
7286 off_t base,start,end;
7287 base = xdr_getpos64(xdrs);
7288 xdr_u_int(xdrs,&size);
7289 start = xdr_getpos64(xdrs);
7290
7291 xdr_u_int(xdrs,&this1->mult);
7292 for (m = 0; m < this1->mult; m++)
7293 {
7294 xdr_int(xdrs,&this1->in[m].bar);
7295 xdr_int(xdrs,&this1->in[m].plane);
7296 if (this1->in[m].ftofNorthTruthHits != (s_FtofNorthTruthHits_t*)&hddm_s_nullTarget)
7297 {
7298 if (pack_s_FtofNorthTruthHits(xdrs,this1->in[m].ftofNorthTruthHits) < 0) {
7299 return -1;
7300 }
7301 }
7302 else
7303 {
7304 int zero=0;
7305 xdr_int(xdrs,&zero);
7306 }
7307 if (this1->in[m].ftofSouthTruthHits != (s_FtofSouthTruthHits_t*)&hddm_s_nullTarget)
7308 {
7309 if (pack_s_FtofSouthTruthHits(xdrs,this1->in[m].ftofSouthTruthHits) < 0) {
7310 return -1;
7311 }
7312 }
7313 else
7314 {
7315 int zero=0;
7316 xdr_int(xdrs,&zero);
7317 }
7318 if (this1->in[m].ftofNorthHits != (s_FtofNorthHits_t*)&hddm_s_nullTarget)
7319 {
7320 if (pack_s_FtofNorthHits(xdrs,this1->in[m].ftofNorthHits) < 0) {
7321 return -1;
7322 }
7323 }
7324 else
7325 {
7326 int zero=0;
7327 xdr_int(xdrs,&zero);
7328 }
7329 if (this1->in[m].ftofSouthHits != (s_FtofSouthHits_t*)&hddm_s_nullTarget)
7330 {
7331 if (pack_s_FtofSouthHits(xdrs,this1->in[m].ftofSouthHits) < 0) {
7332 return -1;
7333 }
7334 }
7335 else
7336 {
7337 int zero=0;
7338 xdr_int(xdrs,&zero);
7339 }
7340 }
7341 FREE(this1)free(this1);
7342 end = xdr_getpos64(xdrs);
7343 xdr_setpos64(xdrs,base);
7344 size = end-start;
7345 xdr_u_int(xdrs,&size);
7346 xdr_setpos64(xdrs,end);
7347 return size;
7348}
7349
7350static int pack_s_FtofNorthTruthHits(XDR* xdrs, s_FtofNorthTruthHits_t* this1)
7351{
7352 int m=0;
7353 unsigned int size=0;
7354 off_t base,start,end;
7355 base = xdr_getpos64(xdrs);
7356 xdr_u_int(xdrs,&size);
7357 start = xdr_getpos64(xdrs);
7358
7359 xdr_u_int(xdrs,&this1->mult);
7360 for (m = 0; m < this1->mult; m++)
7361 {
7362 xdr_float(xdrs,&this1->in[m].dE);
7363 xdr_float(xdrs,&this1->in[m].t);
7364 if (this1->in[m].ftofMCHits != (s_FtofMCHits_t*)&hddm_s_nullTarget)
7365 {
7366 if (pack_s_FtofMCHits(xdrs,this1->in[m].ftofMCHits) < 0) {
7367 return -1;
7368 }
7369 }
7370 else
7371 {
7372 int zero=0;
7373 xdr_int(xdrs,&zero);
7374 }
7375 }
7376 FREE(this1)free(this1);
7377 end = xdr_getpos64(xdrs);
7378 xdr_setpos64(xdrs,base);
7379 size = end-start;
7380 xdr_u_int(xdrs,&size);
7381 xdr_setpos64(xdrs,end);
7382 return size;
7383}
7384
7385static int pack_s_FtofMCHits(XDR* xdrs, s_FtofMCHits_t* this1)
7386{
7387 int m=0;
7388 unsigned int size=0;
7389 off_t base,start,end;
7390 base = xdr_getpos64(xdrs);
7391 xdr_u_int(xdrs,&size);
7392 start = xdr_getpos64(xdrs);
7393
7394 xdr_u_int(xdrs,&this1->mult);
7395 for (m = 0; m < this1->mult; m++)
7396 {
7397 xdr_float(xdrs,&this1->in[m].E);
7398 xdr_float(xdrs,&this1->in[m].dist);
7399 xdr_int(xdrs,&this1->in[m].itrack);
7400 xdr_int(xdrs,&this1->in[m].ptype);
7401 xdr_float(xdrs,&this1->in[m].px);
7402 xdr_float(xdrs,&this1->in[m].py);
7403 xdr_float(xdrs,&this1->in[m].pz);
7404 xdr_float(xdrs,&this1->in[m].x);
7405 xdr_float(xdrs,&this1->in[m].y);
7406 xdr_float(xdrs,&this1->in[m].z);
7407 }
7408 FREE(this1)free(this1);
7409 end = xdr_getpos64(xdrs);
7410 xdr_setpos64(xdrs,base);
7411 size = end-start;
7412 xdr_u_int(xdrs,&size);
7413 xdr_setpos64(xdrs,end);
7414 return size;
7415}
7416
7417static int pack_s_FtofSouthTruthHits(XDR* xdrs, s_FtofSouthTruthHits_t* this1)
7418{
7419 int m=0;
7420 unsigned int size=0;
7421 off_t base,start,end;
7422 base = xdr_getpos64(xdrs);
7423 xdr_u_int(xdrs,&size);
7424 start = xdr_getpos64(xdrs);
7425
7426 xdr_u_int(xdrs,&this1->mult);
7427 for (m = 0; m < this1->mult; m++)
7428 {
7429 xdr_float(xdrs,&this1->in[m].dE);
7430 xdr_float(xdrs,&this1->in[m].t);
7431 if (this1->in[m].ftofMCHits != (s_FtofMCHits_t*)&hddm_s_nullTarget)
7432 {
7433 if (pack_s_FtofMCHits(xdrs,this1->in[m].ftofMCHits) < 0) {
7434 return -1;
7435 }
7436 }
7437 else
7438 {
7439 int zero=0;
7440 xdr_int(xdrs,&zero);
7441 }
7442 }
7443 FREE(this1)free(this1);
7444 end = xdr_getpos64(xdrs);
7445 xdr_setpos64(xdrs,base);
7446 size = end-start;
7447 xdr_u_int(xdrs,&size);
7448 xdr_setpos64(xdrs,end);
7449 return size;
7450}
7451
7452static int pack_s_FtofNorthHits(XDR* xdrs, s_FtofNorthHits_t* this1)
7453{
7454 int m=0;
7455 unsigned int size=0;
7456 off_t base,start,end;
7457 base = xdr_getpos64(xdrs);
7458 xdr_u_int(xdrs,&size);
7459 start = xdr_getpos64(xdrs);
7460
7461 xdr_u_int(xdrs,&this1->mult);
7462 for (m = 0; m < this1->mult; m++)
7463 {
7464 xdr_float(xdrs,&this1->in[m].dE);
7465 xdr_float(xdrs,&this1->in[m].t);
7466 }
7467 FREE(this1)free(this1);
7468 end = xdr_getpos64(xdrs);
7469 xdr_setpos64(xdrs,base);
7470 size = end-start;
7471 xdr_u_int(xdrs,&size);
7472 xdr_setpos64(xdrs,end);
7473 return size;
7474}
7475
7476static int pack_s_FtofSouthHits(XDR* xdrs, s_FtofSouthHits_t* this1)
7477{
7478 int m=0;
7479 unsigned int size=0;
7480 off_t base,start,end;
7481 base = xdr_getpos64(xdrs);
7482 xdr_u_int(xdrs,&size);
7483 start = xdr_getpos64(xdrs);
7484
7485 xdr_u_int(xdrs,&this1->mult);
7486 for (m = 0; m < this1->mult; m++)
7487 {
7488 xdr_float(xdrs,&this1->in[m].dE);
7489 xdr_float(xdrs,&this1->in[m].t);
7490 }
7491 FREE(this1)free(this1);
7492 end = xdr_getpos64(xdrs);
7493 xdr_setpos64(xdrs,base);
7494 size = end-start;
7495 xdr_u_int(xdrs,&size);
7496 xdr_setpos64(xdrs,end);
7497 return size;
7498}
7499
7500static int pack_s_FtofTruthPoints(XDR* xdrs, s_FtofTruthPoints_t* this1)
7501{
7502 int m=0;
7503 unsigned int size=0;
7504 off_t base,start,end;
7505 base = xdr_getpos64(xdrs);
7506 xdr_u_int(xdrs,&size);
7507 start = xdr_getpos64(xdrs);
7508
7509 xdr_u_int(xdrs,&this1->mult);
7510 for (m = 0; m < this1->mult; m++)
7511 {
7512 xdr_float(xdrs,&this1->in[m].E);
7513 xdr_bool(xdrs,&this1->in[m].primary);
7514 xdr_int(xdrs,&this1->in[m].ptype);
7515 xdr_float(xdrs,&this1->in[m].px);
7516 xdr_float(xdrs,&this1->in[m].py);
7517 xdr_float(xdrs,&this1->in[m].pz);
7518 xdr_float(xdrs,&this1->in[m].t);
7519 xdr_int(xdrs,&this1->in[m].track);
7520 xdr_float(xdrs,&this1->in[m].x);
7521 xdr_float(xdrs,&this1->in[m].y);
7522 xdr_float(xdrs,&this1->in[m].z);
7523 }
7524 FREE(this1)free(this1);
7525 end = xdr_getpos64(xdrs);
7526 xdr_setpos64(xdrs,base);
7527 size = end-start;
7528 xdr_u_int(xdrs,&size);
7529 xdr_setpos64(xdrs,end);
7530 return size;
7531}
7532
7533static int pack_s_ForwardEMcal(XDR* xdrs, s_ForwardEMcal_t* this1)
7534{
7535 int m=0;
7536 unsigned int size=0;
7537 off_t base,start,end;
7538 base = xdr_getpos64(xdrs);
7539 xdr_u_int(xdrs,&size);
7540 start = xdr_getpos64(xdrs);
7541
7542 {
7543 if (this1->fcalBlocks != (s_FcalBlocks_t*)&hddm_s_nullTarget)
7544 {
7545 if (pack_s_FcalBlocks(xdrs,this1->fcalBlocks) < 0) {
7546 return -1;
7547 }
7548 }
7549 else
7550 {
7551 int zero=0;
7552 xdr_int(xdrs,&zero);
7553 }
7554 if (this1->fcalTruthShowers != (s_FcalTruthShowers_t*)&hddm_s_nullTarget)
7555 {
7556 if (pack_s_FcalTruthShowers(xdrs,this1->fcalTruthShowers) < 0) {
7557 return -1;
7558 }
7559 }
7560 else
7561 {
7562 int zero=0;
7563 xdr_int(xdrs,&zero);
7564 }
7565 }
7566 FREE(this1)free(this1);
7567 end = xdr_getpos64(xdrs);
7568 xdr_setpos64(xdrs,base);
7569 size = end-start;
7570 xdr_u_int(xdrs,&size);
7571 xdr_setpos64(xdrs,end);
7572 return size;
7573}
7574
7575static int pack_s_FcalBlocks(XDR* xdrs, s_FcalBlocks_t* this1)
7576{
7577 int m=0;
7578 unsigned int size=0;
7579 off_t base,start,end;
7580 base = xdr_getpos64(xdrs);
7581 xdr_u_int(xdrs,&size);
7582 start = xdr_getpos64(xdrs);
7583
7584 xdr_u_int(xdrs,&this1->mult);
7585 for (m = 0; m < this1->mult; m++)
7586 {
7587 xdr_int(xdrs,&this1->in[m].column);
7588 xdr_int(xdrs,&this1->in[m].row);
7589 if (this1->in[m].fcalHits != (s_FcalHits_t*)&hddm_s_nullTarget)
7590 {
7591 if (pack_s_FcalHits(xdrs,this1->in[m].fcalHits) < 0) {
7592 return -1;
7593 }
7594 }
7595 else
7596 {
7597 int zero=0;
7598 xdr_int(xdrs,&zero);
7599 }
7600 if (this1->in[m].fcalTruthHits != (s_FcalTruthHits_t*)&hddm_s_nullTarget)
7601 {
7602 if (pack_s_FcalTruthHits(xdrs,this1->in[m].fcalTruthHits) < 0) {
7603 return -1;
7604 }
7605 }
7606 else
7607 {
7608 int zero=0;
7609 xdr_int(xdrs,&zero);
7610 }
7611 }
7612 FREE(this1)free(this1);
7613 end = xdr_getpos64(xdrs);
7614 xdr_setpos64(xdrs,base);
7615 size = end-start;
7616 xdr_u_int(xdrs,&size);
7617 xdr_setpos64(xdrs,end);
7618 return size;
7619}
7620
7621static int pack_s_FcalHits(XDR* xdrs, s_FcalHits_t* this1)
7622{
7623 int m=0;
7624 unsigned int size=0;
7625 off_t base,start,end;
7626 base = xdr_getpos64(xdrs);
7627 xdr_u_int(xdrs,&size);
7628 start = xdr_getpos64(xdrs);
7629
7630 xdr_u_int(xdrs,&this1->mult);
7631 for (m = 0; m < this1->mult; m++)
7632 {
7633 xdr_float(xdrs,&this1->in[m].E);
7634 xdr_float(xdrs,&this1->in[m].t);
7635 }
7636 FREE(this1)free(this1);
7637 end = xdr_getpos64(xdrs);
7638 xdr_setpos64(xdrs,base);
7639 size = end-start;
7640 xdr_u_int(xdrs,&size);
7641 xdr_setpos64(xdrs,end);
7642 return size;
7643}
7644
7645static int pack_s_FcalTruthHits(XDR* xdrs, s_FcalTruthHits_t* this1)
7646{
7647 int m=0;
7648 unsigned int size=0;
7649 off_t base,start,end;
7650 base = xdr_getpos64(xdrs);
7651 xdr_u_int(xdrs,&size);
7652 start = xdr_getpos64(xdrs);
7653
7654 xdr_u_int(xdrs,&this1->mult);
7655 for (m = 0; m < this1->mult; m++)
7656 {
7657 xdr_float(xdrs,&this1->in[m].E);
7658 xdr_float(xdrs,&this1->in[m].t);
7659 }
7660 FREE(this1)free(this1);
7661 end = xdr_getpos64(xdrs);
7662 xdr_setpos64(xdrs,base);
7663 size = end-start;
7664 xdr_u_int(xdrs,&size);
7665 xdr_setpos64(xdrs,end);
7666 return size;
7667}
7668
7669static int pack_s_FcalTruthShowers(XDR* xdrs, s_FcalTruthShowers_t* this1)
7670{
7671 int m=0;
7672 unsigned int size=0;
7673 off_t base,start,end;
7674 base = xdr_getpos64(xdrs);
7675 xdr_u_int(xdrs,&size);
7676 start = xdr_getpos64(xdrs);
7677
7678 xdr_u_int(xdrs,&this1->mult);
7679 for (m = 0; m < this1->mult; m++)
7680 {
7681 xdr_float(xdrs,&this1->in[m].E);
7682 xdr_bool(xdrs,&this1->in[m].primary);
7683 xdr_int(xdrs,&this1->in[m].ptype);
7684 xdr_float(xdrs,&this1->in[m].px);
7685 xdr_float(xdrs,&this1->in[m].py);
7686 xdr_float(xdrs,&this1->in[m].pz);
7687 xdr_float(xdrs,&this1->in[m].t);
7688 xdr_int(xdrs,&this1->in[m].track);
7689 xdr_float(xdrs,&this1->in[m].x);
7690 xdr_float(xdrs,&this1->in[m].y);
7691 xdr_float(xdrs,&this1->in[m].z);
7692 }
7693 FREE(this1)free(this1);
7694 end = xdr_getpos64(xdrs);
7695 xdr_setpos64(xdrs,base);
7696 size = end-start;
7697 xdr_u_int(xdrs,&size);
7698 xdr_setpos64(xdrs,end);
7699 return size;
7700}
7701
7702static int pack_s_ComptonEMcal(XDR* xdrs, s_ComptonEMcal_t* this1)
7703{
7704 int m=0;
7705 unsigned int size=0;
7706 off_t base,start,end;
7707 base = xdr_getpos64(xdrs);
7708 xdr_u_int(xdrs,&size);
7709 start = xdr_getpos64(xdrs);
7710
7711 {
7712 if (this1->ccalBlocks != (s_CcalBlocks_t*)&hddm_s_nullTarget)
7713 {
7714 if (pack_s_CcalBlocks(xdrs,this1->ccalBlocks) < 0) {
7715 return -1;
7716 }
7717 }
7718 else
7719 {
7720 int zero=0;
7721 xdr_int(xdrs,&zero);
7722 }
7723 if (this1->ccalTruthShowers != (s_CcalTruthShowers_t*)&hddm_s_nullTarget)
7724 {
7725 if (pack_s_CcalTruthShowers(xdrs,this1->ccalTruthShowers) < 0) {
7726 return -1;
7727 }
7728 }
7729 else
7730 {
7731 int zero=0;
7732 xdr_int(xdrs,&zero);
7733 }
7734 }
7735 FREE(this1)free(this1);
7736 end = xdr_getpos64(xdrs);
7737 xdr_setpos64(xdrs,base);
7738 size = end-start;
7739 xdr_u_int(xdrs,&size);
7740 xdr_setpos64(xdrs,end);
7741 return size;
7742}
7743
7744static int pack_s_CcalBlocks(XDR* xdrs, s_CcalBlocks_t* this1)
7745{
7746 int m=0;
7747 unsigned int size=0;
7748 off_t base,start,end;
7749 base = xdr_getpos64(xdrs);
7750 xdr_u_int(xdrs,&size);
7751 start = xdr_getpos64(xdrs);
7752
7753 xdr_u_int(xdrs,&this1->mult);
7754 for (m = 0; m < this1->mult; m++)
7755 {
7756 xdr_int(xdrs,&this1->in[m].column);
7757 xdr_int(xdrs,&this1->in[m].row);
7758 if (this1->in[m].ccalHits != (s_CcalHits_t*)&hddm_s_nullTarget)
7759 {
7760 if (pack_s_CcalHits(xdrs,this1->in[m].ccalHits) < 0) {
7761 return -1;
7762 }
7763 }
7764 else
7765 {
7766 int zero=0;
7767 xdr_int(xdrs,&zero);
7768 }
7769 if (this1->in[m].ccalTruthHits != (s_CcalTruthHits_t*)&hddm_s_nullTarget)
7770 {
7771 if (pack_s_CcalTruthHits(xdrs,this1->in[m].ccalTruthHits) < 0) {
7772 return -1;
7773 }
7774 }
7775 else
7776 {
7777 int zero=0;
7778 xdr_int(xdrs,&zero);
7779 }
7780 }
7781 FREE(this1)free(this1);
7782 end = xdr_getpos64(xdrs);
7783 xdr_setpos64(xdrs,base);
7784 size = end-start;
7785 xdr_u_int(xdrs,&size);
7786 xdr_setpos64(xdrs,end);
7787 return size;
7788}
7789
7790static int pack_s_CcalHits(XDR* xdrs, s_CcalHits_t* this1)
7791{
7792 int m=0;
7793 unsigned int size=0;
7794 off_t base,start,end;
7795 base = xdr_getpos64(xdrs);
7796 xdr_u_int(xdrs,&size);
7797 start = xdr_getpos64(xdrs);
7798
7799 xdr_u_int(xdrs,&this1->mult);
7800 for (m = 0; m < this1->mult; m++)
7801 {
7802 xdr_float(xdrs,&this1->in[m].E);
7803 xdr_float(xdrs,&this1->in[m].t);
7804 }
7805 FREE(this1)free(this1);
7806 end = xdr_getpos64(xdrs);
7807 xdr_setpos64(xdrs,base);
7808 size = end-start;
7809 xdr_u_int(xdrs,&size);
7810 xdr_setpos64(xdrs,end);
7811 return size;
7812}
7813
7814static int pack_s_CcalTruthHits(XDR* xdrs, s_CcalTruthHits_t* this1)
7815{
7816 int m=0;
7817 unsigned int size=0;
7818 off_t base,start,end;
7819 base = xdr_getpos64(xdrs);
7820 xdr_u_int(xdrs,&size);
7821 start = xdr_getpos64(xdrs);
7822
7823 xdr_u_int(xdrs,&this1->mult);
7824 for (m = 0; m < this1->mult; m++)
7825 {
7826 xdr_float(xdrs,&this1->in[m].E);
7827 xdr_float(xdrs,&this1->in[m].t);
7828 }
7829 FREE(this1)free(this1);
7830 end = xdr_getpos64(xdrs);
7831 xdr_setpos64(xdrs,base);
7832 size = end-start;
7833 xdr_u_int(xdrs,&size);
7834 xdr_setpos64(xdrs,end);
7835 return size;
7836}
7837
7838static int pack_s_CcalTruthShowers(XDR* xdrs, s_CcalTruthShowers_t* this1)
7839{
7840 int m=0;
7841 unsigned int size=0;
7842 off_t base,start,end;
7843 base = xdr_getpos64(xdrs);
7844 xdr_u_int(xdrs,&size);
7845 start = xdr_getpos64(xdrs);
7846
7847 xdr_u_int(xdrs,&this1->mult);
7848 for (m = 0; m < this1->mult; m++)
7849 {
7850 xdr_float(xdrs,&this1->in[m].E);
7851 xdr_bool(xdrs,&this1->in[m].primary);
7852 xdr_int(xdrs,&this1->in[m].ptype);
7853 xdr_float(xdrs,&this1->in[m].px);
7854 xdr_float(xdrs,&this1->in[m].py);
7855 xdr_float(xdrs,&this1->in[m].pz);
7856 xdr_float(xdrs,&this1->in[m].t);
7857 xdr_int(xdrs,&this1->in[m].track);
7858 xdr_float(xdrs,&this1->in[m].x);
7859 xdr_float(xdrs,&this1->in[m].y);
7860 xdr_float(xdrs,&this1->in[m].z);
7861 }
7862 FREE(this1)free(this1);
7863 end = xdr_getpos64(xdrs);
7864 xdr_setpos64(xdrs,base);
7865 size = end-start;
7866 xdr_u_int(xdrs,&size);
7867 xdr_setpos64(xdrs,end);
7868 return size;
7869}
7870
7871static int pack_s_UpstreamEMveto(XDR* xdrs, s_UpstreamEMveto_t* this1)
7872{
7873 int m=0;
7874 unsigned int size=0;
7875 off_t base,start,end;
7876 base = xdr_getpos64(xdrs);
7877 xdr_u_int(xdrs,&size);
7878 start = xdr_getpos64(xdrs);
7879
7880 {
7881 if (this1->upvPaddles != (s_UpvPaddles_t*)&hddm_s_nullTarget)
7882 {
7883 if (pack_s_UpvPaddles(xdrs,this1->upvPaddles) < 0) {
7884 return -1;
7885 }
7886 }
7887 else
7888 {
7889 int zero=0;
7890 xdr_int(xdrs,&zero);
7891 }
7892 if (this1->upvTruthShowers != (s_UpvTruthShowers_t*)&hddm_s_nullTarget)
7893 {
7894 if (pack_s_UpvTruthShowers(xdrs,this1->upvTruthShowers) < 0) {
7895 return -1;
7896 }
7897 }
7898 else
7899 {
7900 int zero=0;
7901 xdr_int(xdrs,&zero);
7902 }
7903 }
7904 FREE(this1)free(this1);
7905 end = xdr_getpos64(xdrs);
7906 xdr_setpos64(xdrs,base);
7907 size = end-start;
7908 xdr_u_int(xdrs,&size);
7909 xdr_setpos64(xdrs,end);
7910 return size;
7911}
7912
7913static int pack_s_UpvPaddles(XDR* xdrs, s_UpvPaddles_t* this1)
7914{
7915 int m=0;
7916 unsigned int size=0;
7917 off_t base,start,end;
7918 base = xdr_getpos64(xdrs);
7919 xdr_u_int(xdrs,&size);
7920 start = xdr_getpos64(xdrs);
7921
7922 xdr_u_int(xdrs,&this1->mult);
7923 for (m = 0; m < this1->mult; m++)
7924 {
7925 xdr_int(xdrs,&this1->in[m].layer);
7926 xdr_int(xdrs,&this1->in[m].row);
7927 if (this1->in[m].upvLeftHits != (s_UpvLeftHits_t*)&hddm_s_nullTarget)
7928 {
7929 if (pack_s_UpvLeftHits(xdrs,this1->in[m].upvLeftHits) < 0) {
7930 return -1;
7931 }
7932 }
7933 else
7934 {
7935 int zero=0;
7936 xdr_int(xdrs,&zero);
7937 }
7938 if (this1->in[m].upvRightHits != (s_UpvRightHits_t*)&hddm_s_nullTarget)
7939 {
7940 if (pack_s_UpvRightHits(xdrs,this1->in[m].upvRightHits) < 0) {
7941 return -1;
7942 }
7943 }
7944 else
7945 {
7946 int zero=0;
7947 xdr_int(xdrs,&zero);
7948 }
7949 }
7950 FREE(this1)free(this1);
7951 end = xdr_getpos64(xdrs);
7952 xdr_setpos64(xdrs,base);
7953 size = end-start;
7954 xdr_u_int(xdrs,&size);
7955 xdr_setpos64(xdrs,end);
7956 return size;
7957}
7958
7959static int pack_s_UpvLeftHits(XDR* xdrs, s_UpvLeftHits_t* this1)
7960{
7961 int m=0;
7962 unsigned int size=0;
7963 off_t base,start,end;
7964 base = xdr_getpos64(xdrs);
7965 xdr_u_int(xdrs,&size);
7966 start = xdr_getpos64(xdrs);
7967
7968 xdr_u_int(xdrs,&this1->mult);
7969 for (m = 0; m < this1->mult; m++)
7970 {
7971 xdr_float(xdrs,&this1->in[m].E);
7972 xdr_float(xdrs,&this1->in[m].t);
7973 }
7974 FREE(this1)free(this1);
7975 end = xdr_getpos64(xdrs);
7976 xdr_setpos64(xdrs,base);
7977 size = end-start;
7978 xdr_u_int(xdrs,&size);
7979 xdr_setpos64(xdrs,end);
7980 return size;
7981}
7982
7983static int pack_s_UpvRightHits(XDR* xdrs, s_UpvRightHits_t* this1)
7984{
7985 int m=0;
7986 unsigned int size=0;
7987 off_t base,start,end;
7988 base = xdr_getpos64(xdrs);
7989 xdr_u_int(xdrs,&size);
7990 start = xdr_getpos64(xdrs);
7991
7992 xdr_u_int(xdrs,&this1->mult);
7993 for (m = 0; m < this1->mult; m++)
7994 {
7995 xdr_float(xdrs,&this1->in[m].E);
7996 xdr_float(xdrs,&this1->in[m].t);
7997 }
7998 FREE(this1)free(this1);
7999 end = xdr_getpos64(xdrs);
8000 xdr_setpos64(xdrs,base);
8001 size = end-start;
8002 xdr_u_int(xdrs,&size);
8003 xdr_setpos64(xdrs,end);
8004 return size;
8005}
8006
8007static int pack_s_UpvTruthShowers(XDR* xdrs, s_UpvTruthShowers_t* this1)
8008{
8009 int m=0;
8010 unsigned int size=0;
8011 off_t base,start,end;
8012 base = xdr_getpos64(xdrs);
8013 xdr_u_int(xdrs,&size);
8014 start = xdr_getpos64(xdrs);
8015
8016 xdr_u_int(xdrs,&this1->mult);
8017 for (m = 0; m < this1->mult; m++)
8018 {
8019 xdr_float(xdrs,&this1->in[m].E);
8020 xdr_bool(xdrs,&this1->in[m].primary);
8021 xdr_int(xdrs,&this1->in[m].ptype);
8022 xdr_float(xdrs,&this1->in[m].px);
8023 xdr_float(xdrs,&this1->in[m].py);
8024 xdr_float(xdrs,&this1->in[m].pz);
8025 xdr_float(xdrs,&this1->in[m].t);
8026 xdr_int(xdrs,&this1->in[m].track);
8027 xdr_float(xdrs,&this1->in[m].x);
8028 xdr_float(xdrs,&this1->in[m].y);
8029 xdr_float(xdrs,&this1->in[m].z);
8030 }
8031 FREE(this1)free(this1);
8032 end = xdr_getpos64(xdrs);
8033 xdr_setpos64(xdrs,base);
8034 size = end-start;
8035 xdr_u_int(xdrs,&size);
8036 xdr_setpos64(xdrs,end);
8037 return size;
8038}
8039
8040static int pack_s_Tagger(XDR* xdrs, s_Tagger_t* this1)
8041{
8042 int m=0;
8043 unsigned int size=0;
8044 off_t base,start,end;
8045 base = xdr_getpos64(xdrs);
8046 xdr_u_int(xdrs,&size);
8047 start = xdr_getpos64(xdrs);
8048
8049 {
8050 if (this1->microChannels != (s_MicroChannels_t*)&hddm_s_nullTarget)
8051 {
8052 if (pack_s_MicroChannels(xdrs,this1->microChannels) < 0) {
8053 return -1;
8054 }
8055 }
8056 else
8057 {
8058 int zero=0;
8059 xdr_int(xdrs,&zero);
8060 }
8061 }
8062 FREE(this1)free(this1);
8063 end = xdr_getpos64(xdrs);
8064 xdr_setpos64(xdrs,base);
8065 size = end-start;
8066 xdr_u_int(xdrs,&size);
8067 xdr_setpos64(xdrs,end);
8068 return size;
8069}
8070
8071static int pack_s_MicroChannels(XDR* xdrs, s_MicroChannels_t* this1)
8072{
8073 int m=0;
8074 unsigned int size=0;
8075 off_t base,start,end;
8076 base = xdr_getpos64(xdrs);
8077 xdr_u_int(xdrs,&size);
8078 start = xdr_getpos64(xdrs);
8079
8080 xdr_u_int(xdrs,&this1->mult);
8081 for (m = 0; m < this1->mult; m++)
8082 {
8083 xdr_float(xdrs,&this1->in[m].E);
8084 xdr_int(xdrs,&this1->in[m].column);
8085 xdr_int(xdrs,&this1->in[m].row);
8086 if (this1->in[m].taggerHits != (s_TaggerHits_t*)&hddm_s_nullTarget)
8087 {
8088 if (pack_s_TaggerHits(xdrs,this1->in[m].taggerHits) < 0) {
8089 return -1;
8090 }
8091 }
8092 else
8093 {
8094 int zero=0;
8095 xdr_int(xdrs,&zero);
8096 }
8097 }
8098 FREE(this1)free(this1);
8099 end = xdr_getpos64(xdrs);
8100 xdr_setpos64(xdrs,base);
8101 size = end-start;
8102 xdr_u_int(xdrs,&size);
8103 xdr_setpos64(xdrs,end);
8104 return size;
8105}
8106
8107static int pack_s_TaggerHits(XDR* xdrs, s_TaggerHits_t* this1)
8108{
8109 int m=0;
8110 unsigned int size=0;
8111 off_t base,start,end;
8112 base = xdr_getpos64(xdrs);
8113 xdr_u_int(xdrs,&size);
8114 start = xdr_getpos64(xdrs);
8115
8116 xdr_u_int(xdrs,&this1->mult);
8117 for (m = 0; m < this1->mult; m++)
8118 {
8119 xdr_float(xdrs,&this1->in[m].t);
8120 }
8121 FREE(this1)free(this1);
8122 end = xdr_getpos64(xdrs);
8123 xdr_setpos64(xdrs,base);
8124 size = end-start;
8125 xdr_u_int(xdrs,&size);
8126 xdr_setpos64(xdrs,end);
8127 return size;
8128}
8129
8130static int pack_s_McTrajectory(XDR* xdrs, s_McTrajectory_t* this1)
8131{
8132 int m=0;
8133 unsigned int size=0;
8134 off_t base,start,end;
8135 base = xdr_getpos64(xdrs);
8136 xdr_u_int(xdrs,&size);
8137 start = xdr_getpos64(xdrs);
8138
8139 {
8140 if (this1->mcTrajectoryPoints != (s_McTrajectoryPoints_t*)&hddm_s_nullTarget)
8141 {
8142 if (pack_s_McTrajectoryPoints(xdrs,this1->mcTrajectoryPoints) < 0) {
8143 return -1;
8144 }
8145 }
8146 else
8147 {
8148 int zero=0;
8149 xdr_int(xdrs,&zero);
8150 }
8151 }
8152 FREE(this1)free(this1);
8153 end = xdr_getpos64(xdrs);
8154 xdr_setpos64(xdrs,base);
8155 size = end-start;
8156 xdr_u_int(xdrs,&size);
8157 xdr_setpos64(xdrs,end);
8158 return size;
8159}
8160
8161static int pack_s_McTrajectoryPoints(XDR* xdrs, s_McTrajectoryPoints_t* this1)
8162{
8163 int m=0;
8164 unsigned int size=0;
8165 off_t base,start,end;
8166 base = xdr_getpos64(xdrs);
8167 xdr_u_int(xdrs,&size);
8168 start = xdr_getpos64(xdrs);
8169
8170 xdr_u_int(xdrs,&this1->mult);
8171 for (m = 0; m < this1->mult; m++)
8172 {
8173 xdr_float(xdrs,&this1->in[m].E);
8174 xdr_float(xdrs,&this1->in[m].dE);
8175 xdr_int(xdrs,&this1->in[m].mech);
8176 xdr_int(xdrs,&this1->in[m].part);
8177 xdr_int(xdrs,&this1->in[m].primary_track);
8178 xdr_float(xdrs,&this1->in[m].px);
8179 xdr_float(xdrs,&this1->in[m].py);
8180 xdr_float(xdrs,&this1->in[m].pz);
8181 xdr_float(xdrs,&this1->in[m].radlen);
8182 xdr_float(xdrs,&this1->in[m].step);
8183 xdr_float(xdrs,&this1->in[m].t);
8184 xdr_int(xdrs,&this1->in[m].track);
8185 xdr_float(xdrs,&this1->in[m].x);
8186 xdr_float(xdrs,&this1->in[m].y);
8187 xdr_float(xdrs,&this1->in[m].z);
8188 }
8189 FREE(this1)free(this1);
8190 end = xdr_getpos64(xdrs);
8191 xdr_setpos64(xdrs,base);
8192 size = end-start;
8193 xdr_u_int(xdrs,&size);
8194 xdr_setpos64(xdrs,end);
8195 return size;
8196}
8197
8198static int pack_s_ReconView(XDR* xdrs, s_ReconView_t* this1)
8199{
8200 int m=0;
8201 unsigned int size=0;
8202 off_t base,start,end;
8203 base = xdr_getpos64(xdrs);
8204 xdr_u_int(xdrs,&size);
8205 start = xdr_getpos64(xdrs);
8206
8207 {
8208 if (this1->tracktimebaseds != (s_Tracktimebaseds_t*)&hddm_s_nullTarget)
8209 {
8210 if (pack_s_Tracktimebaseds(xdrs,this1->tracktimebaseds) < 0) {
8211 return -1;
8212 }
8213 }
8214 else
8215 {
8216 int zero=0;
8217 xdr_int(xdrs,&zero);
8218 }
8219 }
8220 FREE(this1)free(this1);
8221 end = xdr_getpos64(xdrs);
8222 xdr_setpos64(xdrs,base);
8223 size = end-start;
8224 xdr_u_int(xdrs,&size);
8225 xdr_setpos64(xdrs,end);
8226 return size;
8227}
8228
8229static int pack_s_Tracktimebaseds(XDR* xdrs, s_Tracktimebaseds_t* this1)
8230{
8231 int m=0;
8232 unsigned int size=0;
8233 off_t base,start,end;
8234 base = xdr_getpos64(xdrs);
8235 xdr_u_int(xdrs,&size);
8236 start = xdr_getpos64(xdrs);
8237
8238 xdr_u_int(xdrs,&this1->mult);
8239 for (m = 0; m < this1->mult; m++)
8240 {
8241 xdr_float(xdrs,&this1->in[m].FOM);
8242 xdr_int(xdrs,&this1->in[m].Ndof);
8243 xdr_int(xdrs,&this1->in[m].candidateid);
8244 xdr_float(xdrs,&this1->in[m].chisq);
8245 xdr_int(xdrs,&this1->in[m].id);
8246 xdr_int(xdrs,&this1->in[m].trackid);
8247 if (this1->in[m].momentum != (s_Momentum_t*)&hddm_s_nullTarget)
8248 {
8249 if (pack_s_Momentum(xdrs,this1->in[m].momentum) < 0) {
8250 return -1;
8251 }
8252 }
8253 else
8254 {
8255 int zero=0;
8256 xdr_int(xdrs,&zero);
8257 }
8258 if (this1->in[m].properties != (s_Properties_t*)&hddm_s_nullTarget)
8259 {
8260 if (pack_s_Properties(xdrs,this1->in[m].properties) < 0) {
8261 return -1;
8262 }
8263 }
8264 else
8265 {
8266 int zero=0;
8267 xdr_int(xdrs,&zero);
8268 }
8269 if (this1->in[m].origin != (s_Origin_t*)&hddm_s_nullTarget)
8270 {
8271 if (pack_s_Origin(xdrs,this1->in[m].origin) < 0) {
8272 return -1;
8273 }
8274 }
8275 else
8276 {
8277 int zero=0;
8278 xdr_int(xdrs,&zero);
8279 }
8280 if (this1->in[m].errorMatrix != (s_ErrorMatrix_t*)&hddm_s_nullTarget)
8281 {
8282 if (pack_s_ErrorMatrix(xdrs,this1->in[m].errorMatrix) < 0) {
8283 return -1;
8284 }
8285 }
8286 else
8287 {
8288 int zero=0;
8289 xdr_int(xdrs,&zero);
8290 }
8291 if (this1->in[m].TrackingErrorMatrix != (s_TrackingErrorMatrix_t*)&hddm_s_nullTarget)
8292 {
8293 if (pack_s_TrackingErrorMatrix(xdrs,this1->in[m].TrackingErrorMatrix) < 0) {
8294 return -1;
8295 }
8296 }
8297 else
8298 {
8299 int zero=0;
8300 xdr_int(xdrs,&zero);
8301 }
8302 }
8303 FREE(this1)free(this1);
8304 end = xdr_getpos64(xdrs);
8305 xdr_setpos64(xdrs,base);
8306 size = end-start;
8307 xdr_u_int(xdrs,&size);
8308 xdr_setpos64(xdrs,end);
8309 return size;
8310}
8311
8312static int pack_s_ErrorMatrix(XDR* xdrs, s_ErrorMatrix_t* this1)
8313{
8314 int m=0;
8315 unsigned int size=0;
8316 off_t base,start,end;
8317 base = xdr_getpos64(xdrs);
8318 xdr_u_int(xdrs,&size);
8319 start = xdr_getpos64(xdrs);
8320
8321 {
8322 xdr_int(xdrs,&this1->Ncols);
8323 xdr_int(xdrs,&this1->Nrows);
8324 xdr_string(xdrs,&this1->type, 1000000);
8325 FREE(this1->type)free(this1->type);
8326 xdr_string(xdrs,&this1->vals, 1000000);
8327 FREE(this1->vals)free(this1->vals);
8328 }
8329 FREE(this1)free(this1);
8330 end = xdr_getpos64(xdrs);
8331 xdr_setpos64(xdrs,base);
8332 size = end-start;
8333 xdr_u_int(xdrs,&size);
8334 xdr_setpos64(xdrs,end);
8335 return size;
8336}
8337
8338static int pack_s_TrackingErrorMatrix(XDR* xdrs, s_TrackingErrorMatrix_t* this1)
8339{
8340 int m=0;
8341 unsigned int size=0;
8342 off_t base,start,end;
8343 base = xdr_getpos64(xdrs);
8344 xdr_u_int(xdrs,&size);
8345 start = xdr_getpos64(xdrs);
8346
8347 {
8348 xdr_int(xdrs,&this1->Ncols);
8349 xdr_int(xdrs,&this1->Nrows);
8350 xdr_string(xdrs,&this1->type, 1000000);
8351 FREE(this1->type)free(this1->type);
8352 xdr_string(xdrs,&this1->vals, 1000000);
8353 FREE(this1->vals)free(this1->vals);
8354 }
8355 FREE(this1)free(this1);
8356 end = xdr_getpos64(xdrs);
8357 xdr_setpos64(xdrs,base);
8358 size = end-start;
8359 xdr_u_int(xdrs,&size);
8360 xdr_setpos64(xdrs,end);
8361 return size;
8362}
8363
8364int flush_s_HDDM(s_HDDM_t* this1,s_iostream_t* fp)
8365{
8366 if (this1 == 0)
8367 {
8368 return 0;
8369 }
8370 else if (fp == 0)
8371 {
8372 XDR* xdrs = (XDR*)malloc(sizeof(XDR));
8373 int max_buffer_size = 1000000;
8374 char* dump = (char*)malloc(max_buffer_size);
8375 xdrmem_create(xdrs,dump,max_buffer_size,XDR_ENCODE);
8376 pack_s_HDDM(xdrs,this1);
8377 xdr_destroy(xdrs)do { if ((xdrs)->x_ops->x_destroy) (*(xdrs)->x_ops->
x_destroy)(xdrs); } while (0);
8378 free(xdrs);
8379 free(dump);
8380 }
8381 else if (fp->iomode == HDDM_STREAM_OUTPUT-92)
8382 {
8383 if (pack_s_HDDM(fp->xdrs,this1) < 0) {
8384 fp->lerrno = errno(*__errno_location ());
8385 return -1;
8386 }
8387 }
8388 return 0;
8389}
8390
8391static int getTag(char* d, char* tag)
8392{
8393 int level;
8394 char* token;
8395 char line[500];
8396 strncpy(line,d,500);
8397 line[499] = 0;
8398 level = index(line,'<')-line;
8399 if (level < 500 &&
8400 (token = strtok(line+level+1," >")))
8401 {
8402 strncpy(tag,token,500);
8403 return level/2;
8404 }
8405 return -1;
8406}
8407
8408static char* getEndTag(char* d, char* tag)
8409{
8410 char line[500];
8411 char endTag[510];
8412 strncpy(line,d,500);
8413 line[499] = 0;
8414 if (strstr(strtok(line,"\n"),"/>") == 0)
8415 {
8416 sprintf(endTag,"</%s>",tag);
8417 }
8418 else
8419 {
8420 strcpy(endTag,"/>");
8421 }
8422 return strstr(d,endTag);
8423}
8424
8425static void collide(char* b, char* c)
8426{
8427 char btag[500];
8428 getTag(b,btag);
8429 b = index(b,'<');
8430 c = index(c,'<');
8431 *(index(b,'\n')) = 0;
8432 *(index(c,'\n')) = 0;
8433 fprintf(stderrstderr,"HDDM warning: ");
8434 fprintf(stderrstderr,"tag %s in input file ", btag);
8435 fprintf(stderrstderr,"does not match c header hddm_s.h\n");
8436 fprintf(stderrstderr," input file: %s\n", b);
8437 fprintf(stderrstderr," c header: %s\n", c);
8438 fprintf(stderrstderr," === Tag %s will be ignored,", btag);
8439 fprintf(stderrstderr," rebuild to cure the problem ===\n");
8440 *(index(b,0)) = '\n';
8441 *(index(c,0)) = '\n';
8442}
8443
8444static popNode* matches(char* b, char* c)
8445{
8446 char btag[500];
8447 char ctag[500];
8448 int blevel, clevel;
8449 int ptrSeqNo = 0;
8450 blevel = getTag(b,btag);
8451 while ((clevel = getTag(c,ctag)) == blevel)
8452 {
8453 if ((clevel == blevel) && (strcmp(ctag,btag) == 0))
8454 {
8455 popNode* this1 = (popNode*)malloc(sizeof(popNode));
8456 int len = index(c+1,'\n') - c;
8457 if (strncmp(c,b,len) != 0)
8458 {
8459 collide(b,c);
8460 return 0;
8461 }
8462 else if (strcmp(btag,"HDDM") == 0)
8463 {
8464 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_HDDM;
8465 }
8466 else if (strcmp(btag,"physicsEvent") == 0)
8467 {
8468 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_PhysicsEvents;
8469 }
8470 else if (strcmp(btag,"reaction") == 0)
8471 {
8472 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Reactions;
8473 }
8474 else if (strcmp(btag,"beam") == 0)
8475 {
8476 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Beam;
8477 }
8478 else if (strcmp(btag,"momentum") == 0)
8479 {
8480 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Momentum;
8481 }
8482 else if (strcmp(btag,"properties") == 0)
8483 {
8484 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Properties;
8485 }
8486 else if (strcmp(btag,"target") == 0)
8487 {
8488 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Target;
8489 }
8490 else if (strcmp(btag,"vertex") == 0)
8491 {
8492 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Vertices;
8493 }
8494 else if (strcmp(btag,"product") == 0)
8495 {
8496 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Products;
8497 }
8498 else if (strcmp(btag,"origin") == 0)
8499 {
8500 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Origin;
8501 }
8502 else if (strcmp(btag,"random") == 0)
8503 {
8504 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Random;
8505 }
8506 else if (strcmp(btag,"hitView") == 0)
8507 {
8508 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_HitView;
8509 }
8510 else if (strcmp(btag,"centralDC") == 0)
8511 {
8512 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CentralDC;
8513 }
8514 else if (strcmp(btag,"cdcStraw") == 0)
8515 {
8516 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CdcStraws;
8517 }
8518 else if (strcmp(btag,"cdcStrawHit") == 0)
8519 {
8520 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CdcStrawHits;
8521 }
8522 else if (strcmp(btag,"cdcStrawTruthHit") == 0)
8523 {
8524 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CdcStrawTruthHits;
8525 }
8526 else if (strcmp(btag,"cdcTruthPoint") == 0)
8527 {
8528 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CdcTruthPoints;
8529 }
8530 else if (strcmp(btag,"forwardDC") == 0)
8531 {
8532 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_ForwardDC;
8533 }
8534 else if (strcmp(btag,"fdcChamber") == 0)
8535 {
8536 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FdcChambers;
8537 }
8538 else if (strcmp(btag,"fdcAnodeWire") == 0)
8539 {
8540 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FdcAnodeWires;
8541 }
8542 else if (strcmp(btag,"fdcAnodeHit") == 0)
8543 {
8544 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FdcAnodeHits;
8545 }
8546 else if (strcmp(btag,"fdcAnodeTruthHit") == 0)
8547 {
8548 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FdcAnodeTruthHits;
8549 }
8550 else if (strcmp(btag,"fdcCathodeStrip") == 0)
8551 {
8552 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FdcCathodeStrips;
8553 }
8554 else if (strcmp(btag,"fdcCathodeHit") == 0)
8555 {
8556 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FdcCathodeHits;
8557 }
8558 else if (strcmp(btag,"fdcCathodeTruthHit") == 0)
8559 {
8560 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FdcCathodeTruthHits;
8561 }
8562 else if (strcmp(btag,"fdcTruthPoint") == 0)
8563 {
8564 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FdcTruthPoints;
8565 }
8566 else if (strcmp(btag,"startCntr") == 0)
8567 {
8568 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_StartCntr;
8569 }
8570 else if (strcmp(btag,"stcPaddle") == 0)
8571 {
8572 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_StcPaddles;
8573 }
8574 else if (strcmp(btag,"stcHit") == 0)
8575 {
8576 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_StcHits;
8577 }
8578 else if (strcmp(btag,"stcTruthHit") == 0)
8579 {
8580 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_StcTruthHits;
8581 }
8582 else if (strcmp(btag,"stcTruthPoint") == 0)
8583 {
8584 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_StcTruthPoints;
8585 }
8586 else if (strcmp(btag,"barrelEMcal") == 0)
8587 {
8588 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BarrelEMcal;
8589 }
8590 else if (strcmp(btag,"bcalCell") == 0)
8591 {
8592 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalCells;
8593 }
8594 else if (strcmp(btag,"bcalSiPMUpHit") == 0)
8595 {
8596 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalSiPMUpHits;
8597 }
8598 else if (strcmp(btag,"bcalSiPMDownHit") == 0)
8599 {
8600 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalSiPMDownHits;
8601 }
8602 else if (strcmp(btag,"bcalHit") == 0)
8603 {
8604 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalHits;
8605 }
8606 else if (strcmp(btag,"bcalIncidentParticle") == 0)
8607 {
8608 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalIncidentParticles;
8609 }
8610 else if (strcmp(btag,"bcalSiPMSpectrum") == 0)
8611 {
8612 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalSiPMSpectrums;
8613 }
8614 else if (strcmp(btag,"bcalfADCCell") == 0)
8615 {
8616 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalfADCCells;
8617 }
8618 else if (strcmp(btag,"bcalfADCUpHit") == 0)
8619 {
8620 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalfADCUpHits;
8621 }
8622 else if (strcmp(btag,"bcalfADCDownHit") == 0)
8623 {
8624 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalfADCDownHits;
8625 }
8626 else if (strcmp(btag,"bcalTDCHit") == 0)
8627 {
8628 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalTDCHits;
8629 }
8630 else if (strcmp(btag,"bcalTruthShower") == 0)
8631 {
8632 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalTruthShowers;
8633 }
8634 else if (strcmp(btag,"gapEMcal") == 0)
8635 {
8636 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_GapEMcal;
8637 }
8638 else if (strcmp(btag,"gcalCell") == 0)
8639 {
8640 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_GcalCells;
8641 }
8642 else if (strcmp(btag,"gcalHit") == 0)
8643 {
8644 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_GcalHits;
8645 }
8646 else if (strcmp(btag,"gcalTruthShower") == 0)
8647 {
8648 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_GcalTruthShowers;
8649 }
8650 else if (strcmp(btag,"Cerenkov") == 0)
8651 {
8652 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Cerenkov;
8653 }
8654 else if (strcmp(btag,"cereSection") == 0)
8655 {
8656 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CereSections;
8657 }
8658 else if (strcmp(btag,"cereHit") == 0)
8659 {
8660 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CereHits;
8661 }
8662 else if (strcmp(btag,"cereTruthPoint") == 0)
8663 {
8664 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CereTruthPoints;
8665 }
8666 else if (strcmp(btag,"forwardTOF") == 0)
8667 {
8668 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_ForwardTOF;
8669 }
8670 else if (strcmp(btag,"ftofCounter") == 0)
8671 {
8672 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FtofCounters;
8673 }
8674 else if (strcmp(btag,"ftofNorthTruthHit") == 0)
8675 {
8676 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FtofNorthTruthHits;
8677 }
8678 else if (strcmp(btag,"ftofMCHit") == 0)
8679 {
8680 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FtofMCHits;
8681 }
8682 else if (strcmp(btag,"ftofSouthTruthHit") == 0)
8683 {
8684 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FtofSouthTruthHits;
8685 }
8686 else if (strcmp(btag,"ftofNorthHit") == 0)
8687 {
8688 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FtofNorthHits;
8689 }
8690 else if (strcmp(btag,"ftofSouthHit") == 0)
8691 {
8692 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FtofSouthHits;
8693 }
8694 else if (strcmp(btag,"ftofTruthPoint") == 0)
8695 {
8696 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FtofTruthPoints;
8697 }
8698 else if (strcmp(btag,"forwardEMcal") == 0)
8699 {
8700 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_ForwardEMcal;
8701 }
8702 else if (strcmp(btag,"fcalBlock") == 0)
8703 {
8704 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FcalBlocks;
8705 }
8706 else if (strcmp(btag,"fcalHit") == 0)
8707 {
8708 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FcalHits;
8709 }
8710 else if (strcmp(btag,"fcalTruthHit") == 0)
8711 {
8712 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FcalTruthHits;
8713 }
8714 else if (strcmp(btag,"fcalTruthShower") == 0)
8715 {
8716 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FcalTruthShowers;
8717 }
8718 else if (strcmp(btag,"ComptonEMcal") == 0)
8719 {
8720 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_ComptonEMcal;
8721 }
8722 else if (strcmp(btag,"ccalBlock") == 0)
8723 {
8724 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CcalBlocks;
8725 }
8726 else if (strcmp(btag,"ccalHit") == 0)
8727 {
8728 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CcalHits;
8729 }
8730 else if (strcmp(btag,"ccalTruthHit") == 0)
8731 {
8732 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CcalTruthHits;
8733 }
8734 else if (strcmp(btag,"ccalTruthShower") == 0)
8735 {
8736 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CcalTruthShowers;
8737 }
8738 else if (strcmp(btag,"upstreamEMveto") == 0)
8739 {
8740 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_UpstreamEMveto;
8741 }
8742 else if (strcmp(btag,"upvPaddle") == 0)
8743 {
8744 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_UpvPaddles;
8745 }
8746 else if (strcmp(btag,"upvLeftHit") == 0)
8747 {
8748 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_UpvLeftHits;
8749 }
8750 else if (strcmp(btag,"upvRightHit") == 0)
8751 {
8752 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_UpvRightHits;
8753 }
8754 else if (strcmp(btag,"upvTruthShower") == 0)
8755 {
8756 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_UpvTruthShowers;
8757 }
8758 else if (strcmp(btag,"tagger") == 0)
8759 {
8760 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Tagger;
8761 }
8762 else if (strcmp(btag,"microChannel") == 0)
8763 {
8764 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_MicroChannels;
8765 }
8766 else if (strcmp(btag,"taggerHit") == 0)
8767 {
8768 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_TaggerHits;
8769 }
8770 else if (strcmp(btag,"mcTrajectory") == 0)
8771 {
8772 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_McTrajectory;
8773 }
8774 else if (strcmp(btag,"mcTrajectoryPoint") == 0)
8775 {
8776 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_McTrajectoryPoints;
8777 }
8778 else if (strcmp(btag,"reconView") == 0)
8779 {
8780 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_ReconView;
8781 }
8782 else if (strcmp(btag,"tracktimebased") == 0)
8783 {
8784 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Tracktimebaseds;
8785 }
8786 else if (strcmp(btag,"errorMatrix") == 0)
8787 {
8788 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_ErrorMatrix;
8789 }
8790 else if (strcmp(btag,"TrackingErrorMatrix") == 0)
8791 {
8792 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_TrackingErrorMatrix;
8793 }
8794 this1->inParent = ptrSeqNo;
8795 this1->popListLength = 0;
8796 c = index(c+1,'\n');
8797 b = index(b+1,'\n');
8798 while (getTag(b,btag) > blevel)
8799 {
8800 this1->popList[this1->popListLength++] = matches(b,c);
8801 if (this1->popListLength > 99)
8802 {
8803 fprintf(stderrstderr,"hddm error - popList overflow.\n");
8804 fprintf(stderrstderr,"Increase MAX_POPLIST_LENGTH and recompile.\n");
8805 exit(9);
8806 }
8807 b = getEndTag(b,btag);
8808 b = index(b+1,'\n');
8809 }
8810 return this1;
8811 }
8812 else
8813 {
8814 c = getEndTag(c,ctag);
8815 c = index(c+1,'\n');
8816 ++ptrSeqNo;
8817 }
8818 }
8819 return 0;
8820}
8821
8822s_iostream_t* open_s_HDDM(char* filename)
8823{
8824 s_iostream_t* fp = (s_iostream_t*)malloc(sizeof(s_iostream_t));
8825 char* p;
8826 char* head;
8827 if (filename)
8828 {
8829 fp->fd = fopen(filename,"r");
8830 }
8831 else
8832 {
8833 fp->fd = fdopen(0,"r");
8834 }
8835 if (fp->fd == 0)
8836 {
8837 free(fp);
8838 return 0;
8839 }
8840 fp->iomode = HDDM_STREAM_INPUT-91;
8841 head = (char*)malloc(1000000);
8842 *head = 0;
8843 for (p = head;
8844 strstr(head,"</HDDM>") == 0;
8845 p += strlen(p))
8846 {
8847 if (p-head < 999000)
8848 {
8849 char *pbuf;
8850 pbuf = fgets(p,1000,fp->fd);
Value stored to 'pbuf' is never read
8851 }
8852 else
8853 {
8854 break;
8855 }
8856 }
8857 fp->popTop = matches(head,HDDM_s_DocumentString);
8858 free(head);
8859 if (fp->popTop->popListLength == 0)
8860 {
8861 fprintf(stderrstderr,"HDDM Error: ");
8862 fprintf(stderrstderr,"input template model ");
8863 fprintf(stderrstderr,"does not match c header.");
8864 fprintf(stderrstderr," Please recompile.\n");
8865 exit(9);
8866 }
8867 fp->filename = (char*)malloc(strlen(filename) + 1);
8868 strcpy(fp->filename,filename);
8869 fp->xdrs = (XDR*)malloc(sizeof(XDR));
8870 xdrstdio_create(fp->xdrs,fp->fd,XDR_DECODE);
8871 return fp;
8872}
8873
8874s_iostream_t* init_s_HDDM(char* filename)
8875{
8876 int len;
8877 char* head;
8878 s_iostream_t* fp = (s_iostream_t*)malloc(sizeof(s_iostream_t));
8879 if (filename)
8880 {
8881 fp->fd = fopen(filename,"w");
8882 }
8883 else
8884 {
8885 fp->fd = fdopen(1,"w");
8886 }
8887 if (fp->fd == 0)
8888 {
8889 free(fp);
8890 return 0;
8891 }
8892 fp->iomode = HDDM_STREAM_OUTPUT-92;
8893 len = strlen(HDDM_s_DocumentString);
8894 head = (char*)malloc(len+1);
8895 strcpy(head,HDDM_s_DocumentString);
8896 if (fwrite(head,1,len,fp->fd) != len)
8897 {
8898 fprintf(stderrstderr,"HDDM Error: ");
8899 fprintf(stderrstderr,"error writing to ");
8900 fprintf(stderrstderr,"output file %s\n",filename);
8901 exit(9);
8902 }
8903 fp->filename = (char*)malloc(strlen(filename) + 1);
8904 strcpy(fp->filename,filename);
8905 fp->popTop = 0;
8906 fp->xdrs = (XDR*)malloc(sizeof(XDR));
8907 xdrstdio_create(fp->xdrs,fp->fd,XDR_ENCODE);
8908 free(head);
8909 return fp;
8910}
8911
8912static void popaway(popNode* p)
8913{
8914 if (p)
8915 {
8916 int n;
8917 for (n = 0; n < p->popListLength; n++)
8918 {
8919 popaway(p->popList[n]);
8920 }
8921 free(p);
8922 }
8923}
8924
8925void close_s_HDDM(s_iostream_t* fp)
8926{
8927 xdr_destroy(fp->xdrs)do { if ((fp->xdrs)->x_ops->x_destroy) (*(fp->xdrs
)->x_ops->x_destroy)(fp->xdrs); } while (0);
8928 free(fp->xdrs);
8929 fclose(fp->fd);
8930 free(fp->filename);
8931 popaway(fp->popTop);
8932 free(fp);
8933}