1 | |
2 | |
3 | |
4 | |
5 | |
6 | |
7 | |
8 | |
9 | |
10 | |
11 | |
12 | |
13 | |
14 | |
15 | |
16 | |
17 | |
18 | int hddm_r_nullTarget=0; |
19 | #define HDDM_NULL(void*)&hddm_r_nullTarget (void*)&hddm_r_nullTarget |
20 | |
21 | #include "hddm_r.h" |
22 | |
23 | |
24 | r_HDDM_t* make_r_HDDM() |
25 | { |
26 | int size = sizeof(r_HDDM_t); |
27 | r_HDDM_t* p = (r_HDDM_t*)MALLOC(size,"r_HDDM_t")malloc(size); |
28 | p->reconstructedPhysicsEvent = (r_ReconstructedPhysicsEvent_t*)&hddm_r_nullTarget; |
29 | return p; |
30 | } |
31 | |
32 | r_ReconstructedPhysicsEvent_t* make_r_ReconstructedPhysicsEvent() |
33 | { |
34 | int size = sizeof(r_ReconstructedPhysicsEvent_t); |
35 | r_ReconstructedPhysicsEvent_t* p = (r_ReconstructedPhysicsEvent_t*)MALLOC(size,"r_ReconstructedPhysicsEvent_t")malloc(size); |
36 | p->eventNo = 0; |
37 | p->runNo = 0; |
38 | p->comments = (r_Comments_t*)&hddm_r_nullTarget; |
39 | p->reactions = (r_Reactions_t*)&hddm_r_nullTarget; |
40 | p->taggerHits = (r_TaggerHits_t*)&hddm_r_nullTarget; |
41 | p->calorimeterClusters = (r_CalorimeterClusters_t*)&hddm_r_nullTarget; |
42 | p->chargedTracks = (r_ChargedTracks_t*)&hddm_r_nullTarget; |
43 | p->startHits = (r_StartHits_t*)&hddm_r_nullTarget; |
44 | p->tofPoints = (r_TofPoints_t*)&hddm_r_nullTarget; |
45 | p->RFtime = (r_RFtime_t*)&hddm_r_nullTarget; |
46 | return p; |
47 | } |
48 | |
49 | r_Comments_t* make_r_Comments(int n) |
50 | { |
51 | int i; |
52 | int rep = (n > 1) ? n-1 : 0; |
53 | int size = sizeof(r_Comments_t) + rep * sizeof(r_Comment_t); |
54 | r_Comments_t* p = (r_Comments_t*)MALLOC(size,"r_Comments_t")malloc(size); |
55 | p->mult = 0; |
56 | for (i=0; i<n; i++) { |
57 | r_Comment_t* pp = &p->in[i]; |
58 | pp->text = (string_t)&hddm_r_nullTarget; |
59 | } |
60 | return p; |
61 | } |
62 | |
63 | r_Reactions_t* make_r_Reactions(int n) |
64 | { |
65 | int i; |
66 | int rep = (n > 1) ? n-1 : 0; |
67 | int size = sizeof(r_Reactions_t) + rep * sizeof(r_Reaction_t); |
68 | r_Reactions_t* p = (r_Reactions_t*)MALLOC(size,"r_Reactions_t")malloc(size); |
69 | p->mult = 0; |
70 | for (i=0; i<n; i++) { |
71 | r_Reaction_t* pp = &p->in[i]; |
72 | pp->Ebeam = 0; |
73 | pp->jtag = (string_t)&hddm_r_nullTarget; |
74 | pp->targetType = (Particle_t)0; |
75 | pp->type = 0; |
76 | pp->weight = 0; |
77 | pp->vertices = (r_Vertices_t*)&hddm_r_nullTarget; |
78 | } |
79 | return p; |
80 | } |
81 | |
82 | r_Vertices_t* make_r_Vertices(int n) |
83 | { |
84 | int i; |
85 | int rep = (n > 1) ? n-1 : 0; |
86 | int size = sizeof(r_Vertices_t) + rep * sizeof(r_Vertex_t); |
87 | r_Vertices_t* p = (r_Vertices_t*)MALLOC(size,"r_Vertices_t")malloc(size); |
88 | p->mult = 0; |
89 | for (i=0; i<n; i++) { |
90 | r_Vertex_t* pp = &p->in[i]; |
91 | pp->origin = (r_Origin_t*)&hddm_r_nullTarget; |
92 | pp->products = (r_Products_t*)&hddm_r_nullTarget; |
93 | } |
94 | return p; |
95 | } |
96 | |
97 | r_Origin_t* make_r_Origin() |
98 | { |
99 | int size = sizeof(r_Origin_t); |
100 | r_Origin_t* p = (r_Origin_t*)MALLOC(size,"r_Origin_t")malloc(size); |
101 | p->t = 0; |
102 | p->vx = 0; |
103 | p->vy = 0; |
104 | p->vz = 0; |
105 | return p; |
106 | } |
107 | |
108 | r_Products_t* make_r_Products(int n) |
109 | { |
110 | int i; |
111 | int rep = (n > 1) ? n-1 : 0; |
112 | int size = sizeof(r_Products_t) + rep * sizeof(r_Product_t); |
113 | r_Products_t* p = (r_Products_t*)MALLOC(size,"r_Products_t")malloc(size); |
114 | p->mult = 0; |
115 | for (i=0; i<n; i++) { |
116 | r_Product_t* pp = &p->in[i]; |
117 | pp->id = 0; |
118 | pp->parentId = 0; |
119 | pp->pdgtype = 0; |
120 | pp->momentum = (r_Momentum_t*)&hddm_r_nullTarget; |
121 | } |
122 | return p; |
123 | } |
124 | |
125 | r_Momentum_t* make_r_Momentum() |
126 | { |
127 | int size = sizeof(r_Momentum_t); |
128 | r_Momentum_t* p = (r_Momentum_t*)MALLOC(size,"r_Momentum_t")malloc(size); |
129 | p->E = 0; |
130 | p->px = 0; |
131 | p->py = 0; |
132 | p->pz = 0; |
133 | return p; |
134 | } |
135 | |
136 | r_TaggerHits_t* make_r_TaggerHits(int n) |
137 | { |
138 | int i; |
139 | int rep = (n > 1) ? n-1 : 0; |
140 | int size = sizeof(r_TaggerHits_t) + rep * sizeof(r_TaggerHit_t); |
141 | r_TaggerHits_t* p = (r_TaggerHits_t*)MALLOC(size,"r_TaggerHits_t")malloc(size); |
142 | p->mult = 0; |
143 | for (i=0; i<n; i++) { |
144 | r_TaggerHit_t* pp = &p->in[i]; |
145 | pp->E = 0; |
146 | pp->jtag = (string_t)&hddm_r_nullTarget; |
147 | pp->t = 0; |
148 | } |
149 | return p; |
150 | } |
151 | |
152 | r_CalorimeterClusters_t* make_r_CalorimeterClusters(int n) |
153 | { |
154 | int i; |
155 | int rep = (n > 1) ? n-1 : 0; |
156 | int size = sizeof(r_CalorimeterClusters_t) + rep * sizeof(r_CalorimeterCluster_t); |
157 | r_CalorimeterClusters_t* p = (r_CalorimeterClusters_t*)MALLOC(size,"r_CalorimeterClusters_t")malloc(size); |
158 | p->mult = 0; |
159 | for (i=0; i<n; i++) { |
160 | r_CalorimeterCluster_t* pp = &p->in[i]; |
161 | pp->E = 0; |
162 | pp->Eerr = 0; |
163 | pp->Ezcorr = 0; |
164 | pp->jtag = (string_t)&hddm_r_nullTarget; |
165 | pp->t = 0; |
166 | pp->terr = 0; |
167 | pp->tzcorr = 0; |
168 | pp->x = 0; |
169 | pp->xerr = 0; |
170 | pp->xycorr = 0; |
171 | pp->xzcorr = 0; |
172 | pp->y = 0; |
173 | pp->yerr = 0; |
174 | pp->yzcorr = 0; |
175 | pp->z = 0; |
176 | pp->zerr = 0; |
177 | } |
178 | return p; |
179 | } |
180 | |
181 | r_ChargedTracks_t* make_r_ChargedTracks(int n) |
182 | { |
183 | int i; |
184 | int rep = (n > 1) ? n-1 : 0; |
185 | int size = sizeof(r_ChargedTracks_t) + rep * sizeof(r_ChargedTrack_t); |
186 | r_ChargedTracks_t* p = (r_ChargedTracks_t*)MALLOC(size,"r_ChargedTracks_t")malloc(size); |
187 | p->mult = 0; |
188 | for (i=0; i<n; i++) { |
189 | r_ChargedTrack_t* pp = &p->in[i]; |
190 | pp->candidateId = 0; |
191 | pp->jtag = (string_t)&hddm_r_nullTarget; |
192 | pp->ptype = (Particle_t)0; |
193 | pp->trackFit = (r_TrackFit_t*)&hddm_r_nullTarget; |
194 | pp->dEdxDC = (r_DEdxDC_t*)&hddm_r_nullTarget; |
195 | } |
196 | return p; |
197 | } |
198 | |
199 | r_TrackFit_t* make_r_TrackFit() |
200 | { |
201 | int size = sizeof(r_TrackFit_t); |
202 | r_TrackFit_t* p = (r_TrackFit_t*)MALLOC(size,"r_TrackFit_t")malloc(size); |
203 | p->Ndof = 0; |
204 | p->chisq = 0; |
205 | p->e11 = 0; |
206 | p->e12 = 0; |
207 | p->e13 = 0; |
208 | p->e14 = 0; |
209 | p->e15 = 0; |
210 | p->e22 = 0; |
211 | p->e23 = 0; |
212 | p->e24 = 0; |
213 | p->e25 = 0; |
214 | p->e33 = 0; |
215 | p->e34 = 0; |
216 | p->e35 = 0; |
217 | p->e44 = 0; |
218 | p->e45 = 0; |
219 | p->e55 = 0; |
220 | p->px = 0; |
221 | p->py = 0; |
222 | p->pz = 0; |
223 | p->t0 = 0; |
224 | p->t0det = 0; |
225 | p->t0err = 0; |
226 | p->x0 = 0; |
227 | p->y0 = 0; |
228 | p->z0 = 0; |
229 | return p; |
230 | } |
231 | |
232 | r_DEdxDC_t* make_r_DEdxDC() |
233 | { |
234 | int size = sizeof(r_DEdxDC_t); |
235 | r_DEdxDC_t* p = (r_DEdxDC_t*)MALLOC(size,"r_DEdxDC_t")malloc(size); |
236 | p->NsampleCDC = 0; |
237 | p->NsampleFDC = 0; |
238 | p->dEdxCDC = 0; |
239 | p->dEdxFDC = 0; |
240 | p->dxCDC = 0; |
241 | p->dxFDC = 0; |
242 | return p; |
243 | } |
244 | |
245 | r_StartHits_t* make_r_StartHits(int n) |
246 | { |
247 | int i; |
248 | int rep = (n > 1) ? n-1 : 0; |
249 | int size = sizeof(r_StartHits_t) + rep * sizeof(r_StartHit_t); |
250 | r_StartHits_t* p = (r_StartHits_t*)MALLOC(size,"r_StartHits_t")malloc(size); |
251 | p->mult = 0; |
252 | for (i=0; i<n; i++) { |
253 | r_StartHit_t* pp = &p->in[i]; |
254 | pp->dE = 0; |
255 | pp->jtag = (string_t)&hddm_r_nullTarget; |
256 | pp->sector = 0; |
257 | pp->t = 0; |
258 | } |
259 | return p; |
260 | } |
261 | |
262 | r_TofPoints_t* make_r_TofPoints(int n) |
263 | { |
264 | int i; |
265 | int rep = (n > 1) ? n-1 : 0; |
266 | int size = sizeof(r_TofPoints_t) + rep * sizeof(r_TofPoint_t); |
267 | r_TofPoints_t* p = (r_TofPoints_t*)MALLOC(size,"r_TofPoints_t")malloc(size); |
268 | p->mult = 0; |
269 | for (i=0; i<n; i++) { |
270 | r_TofPoint_t* pp = &p->in[i]; |
271 | pp->dE = 0; |
272 | pp->jtag = (string_t)&hddm_r_nullTarget; |
273 | pp->t = 0; |
274 | pp->x = 0; |
275 | pp->y = 0; |
276 | pp->z = 0; |
277 | } |
278 | return p; |
279 | } |
280 | |
281 | r_RFtime_t* make_r_RFtime() |
282 | { |
283 | int size = sizeof(r_RFtime_t); |
284 | r_RFtime_t* p = (r_RFtime_t*)MALLOC(size,"r_RFtime_t")malloc(size); |
285 | p->jtag = (string_t)&hddm_r_nullTarget; |
286 | p->tsync = 0; |
287 | p->tsyncerr = 0; |
288 | return p; |
289 | } |
290 | |
291 | char HDDM_r_DocumentString[] = |
292 | "<HDDM class=\"r\" version=\"1.0.1\" xmlns=\"http://www.gluex.org/hddm\">\n" |
293 | " <reconstructedPhysicsEvent eventNo=\"int\" runNo=\"int\">\n" |
294 | " <comment maxOccurs=\"unbounded\" minOccurs=\"0\" text=\"string\" />\n" |
295 | " <reaction Ebeam=\"float\" Eunit=\"GeV\" jtag=\"string\" maxOccurs=\"unbounded\" minOccurs=\"0\" targetType=\"Particle_t\" type=\"int\" weight=\"float\">\n" |
296 | " <vertex maxOccurs=\"unbounded\">\n" |
297 | " <origin lunit=\"cm\" t=\"float\" vx=\"float\" vy=\"float\" vz=\"float\" />\n" |
298 | " <product id=\"int\" maxOccurs=\"unbounded\" parentId=\"int\" pdgtype=\"int\">\n" |
299 | " <momentum E=\"float\" Eunit=\"GeV\" punit=\"GeV/c\" px=\"float\" py=\"float\" pz=\"float\" />\n" |
300 | " </product>\n" |
301 | " </vertex>\n" |
302 | " </reaction>\n" |
303 | " <taggerHit E=\"float\" Eunit=\"GeV\" jtag=\"string\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" tunit=\"ns\" />\n" |
304 | " <calorimeterCluster E=\"float\" Eerr=\"float\" Eunit=\"GeV\" Ezcorr=\"float\" jtag=\"string\" lunit=\"cm\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" terr=\"float\" tunit=\"ns\" tzcorr=\"float\" x=\"float\" xerr=\"float\" xycorr=\"float\" xzcorr=\"float\" y=\"float\" yerr=\"float\" yzcorr=\"float\" z=\"float\" zerr=\"float\" />\n" |
305 | " <chargedTrack candidateId=\"int\" jtag=\"string\" maxOccurs=\"unbounded\" minOccurs=\"0\" ptype=\"Particle_t\">\n" |
306 | " <trackFit Ndof=\"int\" chisq=\"float\" e11=\"float\" e12=\"float\" e13=\"float\" e14=\"float\" e15=\"float\" e22=\"float\" e23=\"float\" e24=\"float\" e25=\"float\" e33=\"float\" e34=\"float\" e35=\"float\" e44=\"float\" e45=\"float\" e55=\"float\" lunit=\"cm\" punit=\"GeV/c\" px=\"float\" py=\"float\" pz=\"float\" t0=\"float\" t0det=\"int\" t0err=\"float\" tunit=\"ns\" x0=\"float\" y0=\"float\" z0=\"float\" />\n" |
307 | " <dEdxDC NsampleCDC=\"int\" NsampleFDC=\"int\" dEdxCDC=\"float\" dEdxFDC=\"float\" dEdx_unit=\"GeV/cm\" dxCDC=\"float\" dxFDC=\"float\" lunit=\"cm\" minOccurs=\"0\" />\n" |
308 | " </chargedTrack>\n" |
309 | " <startHit dE=\"float\" jtag=\"string\" maxOccurs=\"unbounded\" minOccurs=\"0\" sector=\"int\" t=\"float\" />\n" |
310 | " <tofPoint dE=\"float\" jtag=\"string\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" x=\"float\" y=\"float\" z=\"float\" />\n" |
311 | " <RFtime jtag=\"string\" minOccurs=\"0\" tsync=\"float\" tsyncerr=\"float\" tunit=\"ns\" />\n" |
312 | " </reconstructedPhysicsEvent>\n" |
313 | "</HDDM>\n" |
314 | ; |
315 | |
316 | #ifndef _FILE_OFFSET_BITS64 |
317 | # define _FILE_OFFSET_BITS64 64 |
318 | #endif |
319 | |
320 | static off_t xdr_getpos64(XDR *xdrs) |
321 | { |
322 | if (xdrs->x_base == 0) { |
323 | return ftello((FILE *)xdrs->x_private); |
324 | } |
325 | off_t pos = xdr_getpos(xdrs)(*(xdrs)->x_ops->x_getpostn)(xdrs); |
326 | return pos; |
327 | } |
328 | |
329 | static bool_t xdr_setpos64(XDR *xdrs, off_t pos) |
330 | { |
331 | if (xdrs->x_base == 0) { |
332 | return ((fseeko((FILE *)xdrs->x_private, pos, 0) < 0)? FALSE(0) : TRUE(1)); |
333 | } |
334 | return xdr_setpos(xdrs,pos)(*(xdrs)->x_ops->x_setpostn)(xdrs, pos); |
335 | } |
336 | |
337 | |
338 | static r_HDDM_t* unpack_r_HDDM(XDR* xdrs, popNode* pop) |
339 | { |
340 | r_HDDM_t* this1 = (r_HDDM_t*)HDDM_NULL(void*)&hddm_r_nullTarget; |
341 | unsigned int size; |
342 | if (! xdr_u_int(xdrs,&size)) |
343 | { |
344 | return this1; |
345 | } |
346 | else if (size == 1) |
347 | { |
348 | fprintf(stderrstderr,"hddm error - " |
349 | "compressed data found in input stream.\n" |
350 | "Compression/decompression is not supported " |
351 | "by the hddm c i/o interface.\n"); |
352 | fprintf(stderrstderr,"You must use the c++ " |
353 | "interface to read this file.\n"); |
354 | exit(9); |
355 | } |
356 | else if (size > 0) |
357 | { |
358 | off_t start = xdr_getpos64(xdrs); |
359 | this1 = make_r_HDDM(); |
360 | { |
361 | int p; |
362 | void* (*ptr) = (void**) &this1->reconstructedPhysicsEvent; |
363 | for (p = 0; p < pop->popListLength; p++) |
364 | { |
365 | popNode* pnode = pop->popList[p]; |
366 | if (pnode) |
367 | { |
368 | int kid = pnode->inParent; |
369 | ptr[kid] = pnode->unpacker(xdrs,pnode); |
370 | } |
371 | else |
372 | { |
373 | unsigned int skip; |
374 | xdr_u_int(xdrs,&skip); |
375 | xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip); |
376 | } |
377 | } |
378 | } |
379 | xdr_setpos64(xdrs,start+size); |
380 | } |
381 | return this1; |
382 | } |
383 | |
384 | static r_ReconstructedPhysicsEvent_t* unpack_r_ReconstructedPhysicsEvent(XDR* xdrs, popNode* pop) |
385 | { |
386 | r_ReconstructedPhysicsEvent_t* this1 = (r_ReconstructedPhysicsEvent_t*)HDDM_NULL(void*)&hddm_r_nullTarget; |
387 | unsigned int size; |
388 | if (! xdr_u_int(xdrs,&size)) |
389 | { |
390 | return this1; |
391 | } |
392 | else if (size == 1) |
393 | { |
394 | fprintf(stderrstderr,"hddm error - " |
395 | "compressed data found in input stream.\n" |
396 | "Compression/decompression is not supported " |
397 | "by the hddm c i/o interface.\n"); |
398 | fprintf(stderrstderr,"You must use the c++ " |
399 | "interface to read this file.\n"); |
400 | exit(9); |
401 | } |
402 | else if (size > 0) |
403 | { |
404 | off_t start = xdr_getpos64(xdrs); |
405 | this1 = make_r_ReconstructedPhysicsEvent(); |
406 | { |
407 | int p; |
408 | void* (*ptr) = (void**) &this1->comments; |
409 | xdr_int(xdrs,&this1->eventNo); |
410 | xdr_int(xdrs,&this1->runNo); |
411 | for (p = 0; p < pop->popListLength; p++) |
412 | { |
413 | popNode* pnode = pop->popList[p]; |
414 | if (pnode) |
415 | { |
416 | int kid = pnode->inParent; |
417 | ptr[kid] = pnode->unpacker(xdrs,pnode); |
418 | } |
419 | else |
420 | { |
421 | unsigned int skip; |
422 | xdr_u_int(xdrs,&skip); |
423 | xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip); |
424 | } |
425 | } |
426 | } |
427 | xdr_setpos64(xdrs,start+size); |
428 | } |
429 | return this1; |
430 | } |
431 | |
432 | static r_Comments_t* unpack_r_Comments(XDR* xdrs, popNode* pop) |
433 | { |
434 | r_Comments_t* this1 = (r_Comments_t*)HDDM_NULL(void*)&hddm_r_nullTarget; |
435 | unsigned int size; |
436 | if (! xdr_u_int(xdrs,&size)) |
437 | { |
438 | return this1; |
439 | } |
440 | else if (size == 1) |
441 | { |
442 | fprintf(stderrstderr,"hddm error - " |
443 | "compressed data found in input stream.\n" |
444 | "Compression/decompression is not supported " |
445 | "by the hddm c i/o interface.\n"); |
446 | fprintf(stderrstderr,"You must use the c++ " |
447 | "interface to read this file.\n"); |
448 | exit(9); |
449 | } |
450 | else if (size > 0) |
451 | { |
452 | off_t start = xdr_getpos64(xdrs); |
453 | int m; |
454 | unsigned int mult; |
455 | xdr_u_int(xdrs,&mult); |
456 | this1 = make_r_Comments(mult); |
457 | this1->mult = mult; |
458 | for (m = 0; m < mult; m++ ) |
459 | { |
460 | this1->in[m].text = 0; |
461 | xdr_string(xdrs, &this1->in[m].text, 1000000); |
462 | } |
463 | xdr_setpos64(xdrs,start+size); |
464 | } |
465 | return this1; |
466 | } |
467 | |
468 | static r_Reactions_t* unpack_r_Reactions(XDR* xdrs, popNode* pop) |
469 | { |
470 | r_Reactions_t* this1 = (r_Reactions_t*)HDDM_NULL(void*)&hddm_r_nullTarget; |
471 | unsigned int size; |
472 | if (! xdr_u_int(xdrs,&size)) |
473 | { |
474 | return this1; |
475 | } |
476 | else if (size == 1) |
477 | { |
478 | fprintf(stderrstderr,"hddm error - " |
479 | "compressed data found in input stream.\n" |
480 | "Compression/decompression is not supported " |
481 | "by the hddm c i/o interface.\n"); |
482 | fprintf(stderrstderr,"You must use the c++ " |
483 | "interface to read this file.\n"); |
484 | exit(9); |
485 | } |
486 | else if (size > 0) |
487 | { |
488 | off_t start = xdr_getpos64(xdrs); |
489 | int m; |
490 | unsigned int mult; |
491 | xdr_u_int(xdrs,&mult); |
492 | this1 = make_r_Reactions(mult); |
493 | this1->mult = mult; |
494 | for (m = 0; m < mult; m++ ) |
495 | { |
496 | int p; |
497 | void* (*ptr) = (void**) &this1->in[m].vertices; |
498 | xdr_float(xdrs,&this1->in[m].Ebeam); |
499 | this1->in[m].jtag = 0; |
500 | xdr_string(xdrs, &this1->in[m].jtag, 1000000); |
501 | xdr_int(xdrs,(int*)&this1->in[m].targetType); |
502 | xdr_int(xdrs,&this1->in[m].type); |
503 | xdr_float(xdrs,&this1->in[m].weight); |
504 | for (p = 0; p < pop->popListLength; p++) |
505 | { |
506 | popNode* pnode = pop->popList[p]; |
507 | if (pnode) |
508 | { |
509 | int kid = pnode->inParent; |
510 | ptr[kid] = pnode->unpacker(xdrs,pnode); |
511 | } |
512 | else |
513 | { |
514 | unsigned int skip; |
515 | xdr_u_int(xdrs,&skip); |
516 | xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip); |
517 | } |
518 | } |
519 | } |
520 | xdr_setpos64(xdrs,start+size); |
521 | } |
522 | return this1; |
523 | } |
524 | |
525 | static r_Vertices_t* unpack_r_Vertices(XDR* xdrs, popNode* pop) |
526 | { |
527 | r_Vertices_t* this1 = (r_Vertices_t*)HDDM_NULL(void*)&hddm_r_nullTarget; |
528 | unsigned int size; |
529 | if (! xdr_u_int(xdrs,&size)) |
530 | { |
531 | return this1; |
532 | } |
533 | else if (size == 1) |
534 | { |
535 | fprintf(stderrstderr,"hddm error - " |
536 | "compressed data found in input stream.\n" |
537 | "Compression/decompression is not supported " |
538 | "by the hddm c i/o interface.\n"); |
539 | fprintf(stderrstderr,"You must use the c++ " |
540 | "interface to read this file.\n"); |
541 | exit(9); |
542 | } |
543 | else if (size > 0) |
544 | { |
545 | off_t start = xdr_getpos64(xdrs); |
546 | int m; |
547 | unsigned int mult; |
548 | xdr_u_int(xdrs,&mult); |
549 | this1 = make_r_Vertices(mult); |
550 | this1->mult = mult; |
551 | for (m = 0; m < mult; m++ ) |
552 | { |
553 | int p; |
554 | void* (*ptr) = (void**) &this1->in[m].origin; |
555 | for (p = 0; p < pop->popListLength; p++) |
556 | { |
557 | popNode* pnode = pop->popList[p]; |
558 | if (pnode) |
559 | { |
560 | int kid = pnode->inParent; |
561 | ptr[kid] = pnode->unpacker(xdrs,pnode); |
562 | } |
563 | else |
564 | { |
565 | unsigned int skip; |
566 | xdr_u_int(xdrs,&skip); |
567 | xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip); |
568 | } |
569 | } |
570 | } |
571 | xdr_setpos64(xdrs,start+size); |
572 | } |
573 | return this1; |
574 | } |
575 | |
576 | static r_Origin_t* unpack_r_Origin(XDR* xdrs, popNode* pop) |
577 | { |
578 | r_Origin_t* this1 = (r_Origin_t*)HDDM_NULL(void*)&hddm_r_nullTarget; |
579 | unsigned int size; |
580 | if (! xdr_u_int(xdrs,&size)) |
581 | { |
582 | return this1; |
583 | } |
584 | else if (size == 1) |
585 | { |
586 | fprintf(stderrstderr,"hddm error - " |
587 | "compressed data found in input stream.\n" |
588 | "Compression/decompression is not supported " |
589 | "by the hddm c i/o interface.\n"); |
590 | fprintf(stderrstderr,"You must use the c++ " |
591 | "interface to read this file.\n"); |
592 | exit(9); |
593 | } |
594 | else if (size > 0) |
595 | { |
596 | off_t start = xdr_getpos64(xdrs); |
597 | this1 = make_r_Origin(); |
598 | { |
599 | xdr_float(xdrs,&this1->t); |
600 | xdr_float(xdrs,&this1->vx); |
601 | xdr_float(xdrs,&this1->vy); |
602 | xdr_float(xdrs,&this1->vz); |
603 | } |
604 | xdr_setpos64(xdrs,start+size); |
605 | } |
606 | return this1; |
607 | } |
608 | |
609 | static r_Products_t* unpack_r_Products(XDR* xdrs, popNode* pop) |
610 | { |
611 | r_Products_t* this1 = (r_Products_t*)HDDM_NULL(void*)&hddm_r_nullTarget; |
612 | unsigned int size; |
613 | if (! xdr_u_int(xdrs,&size)) |
614 | { |
615 | return this1; |
616 | } |
617 | else if (size == 1) |
618 | { |
619 | fprintf(stderrstderr,"hddm error - " |
620 | "compressed data found in input stream.\n" |
621 | "Compression/decompression is not supported " |
622 | "by the hddm c i/o interface.\n"); |
623 | fprintf(stderrstderr,"You must use the c++ " |
624 | "interface to read this file.\n"); |
625 | exit(9); |
626 | } |
627 | else if (size > 0) |
628 | { |
629 | off_t start = xdr_getpos64(xdrs); |
630 | int m; |
631 | unsigned int mult; |
632 | xdr_u_int(xdrs,&mult); |
633 | this1 = make_r_Products(mult); |
634 | this1->mult = mult; |
635 | for (m = 0; m < mult; m++ ) |
636 | { |
637 | int p; |
638 | void* (*ptr) = (void**) &this1->in[m].momentum; |
639 | xdr_int(xdrs,&this1->in[m].id); |
640 | xdr_int(xdrs,&this1->in[m].parentId); |
641 | xdr_int(xdrs,&this1->in[m].pdgtype); |
642 | for (p = 0; p < pop->popListLength; p++) |
643 | { |
644 | popNode* pnode = pop->popList[p]; |
645 | if (pnode) |
646 | { |
647 | int kid = pnode->inParent; |
648 | ptr[kid] = pnode->unpacker(xdrs,pnode); |
649 | } |
650 | else |
651 | { |
652 | unsigned int skip; |
653 | xdr_u_int(xdrs,&skip); |
654 | xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip); |
655 | } |
656 | } |
657 | } |
658 | xdr_setpos64(xdrs,start+size); |
659 | } |
660 | return this1; |
661 | } |
662 | |
663 | static r_Momentum_t* unpack_r_Momentum(XDR* xdrs, popNode* pop) |
664 | { |
665 | r_Momentum_t* this1 = (r_Momentum_t*)HDDM_NULL(void*)&hddm_r_nullTarget; |
666 | unsigned int size; |
667 | if (! xdr_u_int(xdrs,&size)) |
668 | { |
669 | return this1; |
670 | } |
671 | else if (size == 1) |
672 | { |
673 | fprintf(stderrstderr,"hddm error - " |
674 | "compressed data found in input stream.\n" |
675 | "Compression/decompression is not supported " |
676 | "by the hddm c i/o interface.\n"); |
677 | fprintf(stderrstderr,"You must use the c++ " |
678 | "interface to read this file.\n"); |
679 | exit(9); |
680 | } |
681 | else if (size > 0) |
682 | { |
683 | off_t start = xdr_getpos64(xdrs); |
684 | this1 = make_r_Momentum(); |
685 | { |
686 | xdr_float(xdrs,&this1->E); |
687 | xdr_float(xdrs,&this1->px); |
688 | xdr_float(xdrs,&this1->py); |
689 | xdr_float(xdrs,&this1->pz); |
690 | } |
691 | xdr_setpos64(xdrs,start+size); |
692 | } |
693 | return this1; |
694 | } |
695 | |
696 | static r_TaggerHits_t* unpack_r_TaggerHits(XDR* xdrs, popNode* pop) |
697 | { |
698 | r_TaggerHits_t* this1 = (r_TaggerHits_t*)HDDM_NULL(void*)&hddm_r_nullTarget; |
699 | unsigned int size; |
700 | if (! xdr_u_int(xdrs,&size)) |
701 | { |
702 | return this1; |
703 | } |
704 | else if (size == 1) |
705 | { |
706 | fprintf(stderrstderr,"hddm error - " |
707 | "compressed data found in input stream.\n" |
708 | "Compression/decompression is not supported " |
709 | "by the hddm c i/o interface.\n"); |
710 | fprintf(stderrstderr,"You must use the c++ " |
711 | "interface to read this file.\n"); |
712 | exit(9); |
713 | } |
714 | else if (size > 0) |
715 | { |
716 | off_t start = xdr_getpos64(xdrs); |
717 | int m; |
718 | unsigned int mult; |
719 | xdr_u_int(xdrs,&mult); |
720 | this1 = make_r_TaggerHits(mult); |
721 | this1->mult = mult; |
722 | for (m = 0; m < mult; m++ ) |
723 | { |
724 | xdr_float(xdrs,&this1->in[m].E); |
725 | this1->in[m].jtag = 0; |
726 | xdr_string(xdrs, &this1->in[m].jtag, 1000000); |
727 | xdr_float(xdrs,&this1->in[m].t); |
728 | } |
729 | xdr_setpos64(xdrs,start+size); |
730 | } |
731 | return this1; |
732 | } |
733 | |
734 | static r_CalorimeterClusters_t* unpack_r_CalorimeterClusters(XDR* xdrs, popNode* pop) |
735 | { |
736 | r_CalorimeterClusters_t* this1 = (r_CalorimeterClusters_t*)HDDM_NULL(void*)&hddm_r_nullTarget; |
737 | unsigned int size; |
738 | if (! xdr_u_int(xdrs,&size)) |
739 | { |
740 | return this1; |
741 | } |
742 | else if (size == 1) |
743 | { |
744 | fprintf(stderrstderr,"hddm error - " |
745 | "compressed data found in input stream.\n" |
746 | "Compression/decompression is not supported " |
747 | "by the hddm c i/o interface.\n"); |
748 | fprintf(stderrstderr,"You must use the c++ " |
749 | "interface to read this file.\n"); |
750 | exit(9); |
751 | } |
752 | else if (size > 0) |
753 | { |
754 | off_t start = xdr_getpos64(xdrs); |
755 | int m; |
756 | unsigned int mult; |
757 | xdr_u_int(xdrs,&mult); |
758 | this1 = make_r_CalorimeterClusters(mult); |
759 | this1->mult = mult; |
760 | for (m = 0; m < mult; m++ ) |
761 | { |
762 | xdr_float(xdrs,&this1->in[m].E); |
763 | xdr_float(xdrs,&this1->in[m].Eerr); |
764 | xdr_float(xdrs,&this1->in[m].Ezcorr); |
765 | this1->in[m].jtag = 0; |
766 | xdr_string(xdrs, &this1->in[m].jtag, 1000000); |
767 | xdr_float(xdrs,&this1->in[m].t); |
768 | xdr_float(xdrs,&this1->in[m].terr); |
769 | xdr_float(xdrs,&this1->in[m].tzcorr); |
770 | xdr_float(xdrs,&this1->in[m].x); |
771 | xdr_float(xdrs,&this1->in[m].xerr); |
772 | xdr_float(xdrs,&this1->in[m].xycorr); |
773 | xdr_float(xdrs,&this1->in[m].xzcorr); |
774 | xdr_float(xdrs,&this1->in[m].y); |
775 | xdr_float(xdrs,&this1->in[m].yerr); |
776 | xdr_float(xdrs,&this1->in[m].yzcorr); |
777 | xdr_float(xdrs,&this1->in[m].z); |
778 | xdr_float(xdrs,&this1->in[m].zerr); |
779 | } |
780 | xdr_setpos64(xdrs,start+size); |
781 | } |
782 | return this1; |
783 | } |
784 | |
785 | static r_ChargedTracks_t* unpack_r_ChargedTracks(XDR* xdrs, popNode* pop) |
786 | { |
787 | r_ChargedTracks_t* this1 = (r_ChargedTracks_t*)HDDM_NULL(void*)&hddm_r_nullTarget; |
788 | unsigned int size; |
789 | if (! xdr_u_int(xdrs,&size)) |
790 | { |
791 | return this1; |
792 | } |
793 | else if (size == 1) |
794 | { |
795 | fprintf(stderrstderr,"hddm error - " |
796 | "compressed data found in input stream.\n" |
797 | "Compression/decompression is not supported " |
798 | "by the hddm c i/o interface.\n"); |
799 | fprintf(stderrstderr,"You must use the c++ " |
800 | "interface to read this file.\n"); |
801 | exit(9); |
802 | } |
803 | else if (size > 0) |
804 | { |
805 | off_t start = xdr_getpos64(xdrs); |
806 | int m; |
807 | unsigned int mult; |
808 | xdr_u_int(xdrs,&mult); |
809 | this1 = make_r_ChargedTracks(mult); |
810 | this1->mult = mult; |
811 | for (m = 0; m < mult; m++ ) |
812 | { |
813 | int p; |
814 | void* (*ptr) = (void**) &this1->in[m].trackFit; |
815 | xdr_int(xdrs,&this1->in[m].candidateId); |
816 | this1->in[m].jtag = 0; |
817 | xdr_string(xdrs, &this1->in[m].jtag, 1000000); |
818 | xdr_int(xdrs,(int*)&this1->in[m].ptype); |
819 | for (p = 0; p < pop->popListLength; p++) |
820 | { |
821 | popNode* pnode = pop->popList[p]; |
822 | if (pnode) |
823 | { |
824 | int kid = pnode->inParent; |
825 | ptr[kid] = pnode->unpacker(xdrs,pnode); |
826 | } |
827 | else |
828 | { |
829 | unsigned int skip; |
830 | xdr_u_int(xdrs,&skip); |
831 | xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip); |
832 | } |
833 | } |
834 | } |
835 | xdr_setpos64(xdrs,start+size); |
836 | } |
837 | return this1; |
838 | } |
839 | |
840 | static r_TrackFit_t* unpack_r_TrackFit(XDR* xdrs, popNode* pop) |
841 | { |
842 | r_TrackFit_t* this1 = (r_TrackFit_t*)HDDM_NULL(void*)&hddm_r_nullTarget; |
843 | unsigned int size; |
844 | if (! xdr_u_int(xdrs,&size)) |
845 | { |
846 | return this1; |
847 | } |
848 | else if (size == 1) |
849 | { |
850 | fprintf(stderrstderr,"hddm error - " |
851 | "compressed data found in input stream.\n" |
852 | "Compression/decompression is not supported " |
853 | "by the hddm c i/o interface.\n"); |
854 | fprintf(stderrstderr,"You must use the c++ " |
855 | "interface to read this file.\n"); |
856 | exit(9); |
857 | } |
858 | else if (size > 0) |
859 | { |
860 | off_t start = xdr_getpos64(xdrs); |
861 | this1 = make_r_TrackFit(); |
862 | { |
863 | xdr_int(xdrs,&this1->Ndof); |
864 | xdr_float(xdrs,&this1->chisq); |
865 | xdr_float(xdrs,&this1->e11); |
866 | xdr_float(xdrs,&this1->e12); |
867 | xdr_float(xdrs,&this1->e13); |
868 | xdr_float(xdrs,&this1->e14); |
869 | xdr_float(xdrs,&this1->e15); |
870 | xdr_float(xdrs,&this1->e22); |
871 | xdr_float(xdrs,&this1->e23); |
872 | xdr_float(xdrs,&this1->e24); |
873 | xdr_float(xdrs,&this1->e25); |
874 | xdr_float(xdrs,&this1->e33); |
875 | xdr_float(xdrs,&this1->e34); |
876 | xdr_float(xdrs,&this1->e35); |
877 | xdr_float(xdrs,&this1->e44); |
878 | xdr_float(xdrs,&this1->e45); |
879 | xdr_float(xdrs,&this1->e55); |
880 | xdr_float(xdrs,&this1->px); |
881 | xdr_float(xdrs,&this1->py); |
882 | xdr_float(xdrs,&this1->pz); |
883 | xdr_float(xdrs,&this1->t0); |
884 | xdr_int(xdrs,&this1->t0det); |
885 | xdr_float(xdrs,&this1->t0err); |
886 | xdr_float(xdrs,&this1->x0); |
887 | xdr_float(xdrs,&this1->y0); |
888 | xdr_float(xdrs,&this1->z0); |
889 | } |
890 | xdr_setpos64(xdrs,start+size); |
891 | } |
892 | return this1; |
893 | } |
894 | |
895 | static r_DEdxDC_t* unpack_r_DEdxDC(XDR* xdrs, popNode* pop) |
896 | { |
897 | r_DEdxDC_t* this1 = (r_DEdxDC_t*)HDDM_NULL(void*)&hddm_r_nullTarget; |
898 | unsigned int size; |
899 | if (! xdr_u_int(xdrs,&size)) |
900 | { |
901 | return this1; |
902 | } |
903 | else if (size == 1) |
904 | { |
905 | fprintf(stderrstderr,"hddm error - " |
906 | "compressed data found in input stream.\n" |
907 | "Compression/decompression is not supported " |
908 | "by the hddm c i/o interface.\n"); |
909 | fprintf(stderrstderr,"You must use the c++ " |
910 | "interface to read this file.\n"); |
911 | exit(9); |
912 | } |
913 | else if (size > 0) |
914 | { |
915 | off_t start = xdr_getpos64(xdrs); |
916 | this1 = make_r_DEdxDC(); |
917 | { |
918 | xdr_int(xdrs,&this1->NsampleCDC); |
919 | xdr_int(xdrs,&this1->NsampleFDC); |
920 | xdr_float(xdrs,&this1->dEdxCDC); |
921 | xdr_float(xdrs,&this1->dEdxFDC); |
922 | xdr_float(xdrs,&this1->dxCDC); |
923 | xdr_float(xdrs,&this1->dxFDC); |
924 | } |
925 | xdr_setpos64(xdrs,start+size); |
926 | } |
927 | return this1; |
928 | } |
929 | |
930 | static r_StartHits_t* unpack_r_StartHits(XDR* xdrs, popNode* pop) |
931 | { |
932 | r_StartHits_t* this1 = (r_StartHits_t*)HDDM_NULL(void*)&hddm_r_nullTarget; |
933 | unsigned int size; |
934 | if (! xdr_u_int(xdrs,&size)) |
935 | { |
936 | return this1; |
937 | } |
938 | else if (size == 1) |
939 | { |
940 | fprintf(stderrstderr,"hddm error - " |
941 | "compressed data found in input stream.\n" |
942 | "Compression/decompression is not supported " |
943 | "by the hddm c i/o interface.\n"); |
944 | fprintf(stderrstderr,"You must use the c++ " |
945 | "interface to read this file.\n"); |
946 | exit(9); |
947 | } |
948 | else if (size > 0) |
949 | { |
950 | off_t start = xdr_getpos64(xdrs); |
951 | int m; |
952 | unsigned int mult; |
953 | xdr_u_int(xdrs,&mult); |
954 | this1 = make_r_StartHits(mult); |
955 | this1->mult = mult; |
956 | for (m = 0; m < mult; m++ ) |
957 | { |
958 | xdr_float(xdrs,&this1->in[m].dE); |
959 | this1->in[m].jtag = 0; |
960 | xdr_string(xdrs, &this1->in[m].jtag, 1000000); |
961 | xdr_int(xdrs,&this1->in[m].sector); |
962 | xdr_float(xdrs,&this1->in[m].t); |
963 | } |
964 | xdr_setpos64(xdrs,start+size); |
965 | } |
966 | return this1; |
967 | } |
968 | |
969 | static r_TofPoints_t* unpack_r_TofPoints(XDR* xdrs, popNode* pop) |
970 | { |
971 | r_TofPoints_t* this1 = (r_TofPoints_t*)HDDM_NULL(void*)&hddm_r_nullTarget; |
972 | unsigned int size; |
973 | if (! xdr_u_int(xdrs,&size)) |
974 | { |
975 | return this1; |
976 | } |
977 | else if (size == 1) |
978 | { |
979 | fprintf(stderrstderr,"hddm error - " |
980 | "compressed data found in input stream.\n" |
981 | "Compression/decompression is not supported " |
982 | "by the hddm c i/o interface.\n"); |
983 | fprintf(stderrstderr,"You must use the c++ " |
984 | "interface to read this file.\n"); |
985 | exit(9); |
986 | } |
987 | else if (size > 0) |
988 | { |
989 | off_t start = xdr_getpos64(xdrs); |
990 | int m; |
991 | unsigned int mult; |
992 | xdr_u_int(xdrs,&mult); |
993 | this1 = make_r_TofPoints(mult); |
994 | this1->mult = mult; |
995 | for (m = 0; m < mult; m++ ) |
996 | { |
997 | xdr_float(xdrs,&this1->in[m].dE); |
998 | this1->in[m].jtag = 0; |
999 | xdr_string(xdrs, &this1->in[m].jtag, 1000000); |
1000 | xdr_float(xdrs,&this1->in[m].t); |
1001 | xdr_float(xdrs,&this1->in[m].x); |
1002 | xdr_float(xdrs,&this1->in[m].y); |
1003 | xdr_float(xdrs,&this1->in[m].z); |
1004 | } |
1005 | xdr_setpos64(xdrs,start+size); |
1006 | } |
1007 | return this1; |
1008 | } |
1009 | |
1010 | static r_RFtime_t* unpack_r_RFtime(XDR* xdrs, popNode* pop) |
1011 | { |
1012 | r_RFtime_t* this1 = (r_RFtime_t*)HDDM_NULL(void*)&hddm_r_nullTarget; |
1013 | unsigned int size; |
1014 | if (! xdr_u_int(xdrs,&size)) |
1015 | { |
1016 | return this1; |
1017 | } |
1018 | else if (size == 1) |
1019 | { |
1020 | fprintf(stderrstderr,"hddm error - " |
1021 | "compressed data found in input stream.\n" |
1022 | "Compression/decompression is not supported " |
1023 | "by the hddm c i/o interface.\n"); |
1024 | fprintf(stderrstderr,"You must use the c++ " |
1025 | "interface to read this file.\n"); |
1026 | exit(9); |
1027 | } |
1028 | else if (size > 0) |
1029 | { |
1030 | off_t start = xdr_getpos64(xdrs); |
1031 | this1 = make_r_RFtime(); |
1032 | { |
1033 | this1->jtag = 0; |
1034 | xdr_string(xdrs, &this1->jtag, 1000000); |
1035 | xdr_float(xdrs,&this1->tsync); |
1036 | xdr_float(xdrs,&this1->tsyncerr); |
1037 | } |
1038 | xdr_setpos64(xdrs,start+size); |
1039 | } |
1040 | return this1; |
1041 | } |
1042 | |
1043 | r_HDDM_t* read_r_HDDM(r_iostream_t* fp) |
1044 | { |
1045 | r_HDDM_t* nextEvent = unpack_r_HDDM(fp->xdrs,fp->popTop); |
1046 | return (nextEvent == HDDM_NULL(void*)&hddm_r_nullTarget)? 0 : nextEvent; |
1047 | } |
1048 | |
1049 | int skip_r_HDDM(r_iostream_t* fp, int nskip) |
1050 | { |
1051 | int skipped; |
1052 | for (skipped=0; skipped < nskip; ++skipped) |
1053 | { |
1054 | unsigned int size; |
1055 | if (! xdr_u_int(fp->xdrs,&size)) |
1056 | { |
1057 | return skipped; |
1058 | } |
1059 | else if (size == 1) |
1060 | { |
1061 | fprintf(stderrstderr,"hddm error - " |
1062 | "compressed data found in input stream.\n" |
1063 | "Compression/decompression is not supported " |
1064 | "by the hddm c i/o interface.\n"); |
1065 | fprintf(stderrstderr,"You must use the c++ " |
1066 | "interface to read this file.\n"); |
1067 | exit(9); |
1068 | } |
1069 | else if (size > 0) |
1070 | { |
1071 | off_t start = xdr_getpos64(fp->xdrs); |
1072 | if (xdr_setpos64(fp->xdrs,start+size) != 0) { |
1073 | fp->lerrno = errno(*__errno_location ()); |
1074 | return skipped; |
1075 | } |
1076 | } |
1077 | } |
1078 | return skipped; |
1079 | } |
1080 | |
1081 | static int pack_r_HDDM(XDR* xdrs, r_HDDM_t* this1); |
1082 | static int pack_r_ReconstructedPhysicsEvent(XDR* xdrs, r_ReconstructedPhysicsEvent_t* this1); |
1083 | static int pack_r_Comments(XDR* xdrs, r_Comments_t* this1); |
1084 | static int pack_r_Reactions(XDR* xdrs, r_Reactions_t* this1); |
1085 | static int pack_r_Vertices(XDR* xdrs, r_Vertices_t* this1); |
1086 | static int pack_r_Origin(XDR* xdrs, r_Origin_t* this1); |
1087 | static int pack_r_Products(XDR* xdrs, r_Products_t* this1); |
1088 | static int pack_r_Momentum(XDR* xdrs, r_Momentum_t* this1); |
1089 | static int pack_r_TaggerHits(XDR* xdrs, r_TaggerHits_t* this1); |
1090 | static int pack_r_CalorimeterClusters(XDR* xdrs, r_CalorimeterClusters_t* this1); |
1091 | static int pack_r_ChargedTracks(XDR* xdrs, r_ChargedTracks_t* this1); |
1092 | static int pack_r_TrackFit(XDR* xdrs, r_TrackFit_t* this1); |
1093 | static int pack_r_DEdxDC(XDR* xdrs, r_DEdxDC_t* this1); |
1094 | static int pack_r_StartHits(XDR* xdrs, r_StartHits_t* this1); |
1095 | static int pack_r_TofPoints(XDR* xdrs, r_TofPoints_t* this1); |
1096 | static int pack_r_RFtime(XDR* xdrs, r_RFtime_t* this1); |
1097 | |
1098 | static int pack_r_HDDM(XDR* xdrs, r_HDDM_t* this1) |
1099 | { |
1100 | int m=0; |
1101 | unsigned int size=0; |
1102 | off_t base,start,end; |
1103 | base = xdr_getpos64(xdrs); |
1104 | xdr_u_int(xdrs,&size); |
1105 | start = xdr_getpos64(xdrs); |
1106 | |
1107 | { |
1108 | if (this1->reconstructedPhysicsEvent != (r_ReconstructedPhysicsEvent_t*)&hddm_r_nullTarget) |
1109 | { |
1110 | if (pack_r_ReconstructedPhysicsEvent(xdrs,this1->reconstructedPhysicsEvent) < 0) { |
1111 | return -1; |
1112 | } |
1113 | } |
1114 | else |
1115 | { |
1116 | int zero=0; |
1117 | xdr_int(xdrs,&zero); |
1118 | } |
1119 | } |
1120 | FREE(this1)free(this1); |
1121 | end = xdr_getpos64(xdrs); |
1122 | xdr_setpos64(xdrs,base); |
1123 | size = end-start; |
1124 | xdr_u_int(xdrs,&size); |
1125 | xdr_setpos64(xdrs,end); |
1126 | return size; |
1127 | } |
1128 | |
1129 | static int pack_r_ReconstructedPhysicsEvent(XDR* xdrs, r_ReconstructedPhysicsEvent_t* this1) |
1130 | { |
1131 | int m=0; |
1132 | unsigned int size=0; |
1133 | off_t base,start,end; |
1134 | base = xdr_getpos64(xdrs); |
1135 | xdr_u_int(xdrs,&size); |
1136 | start = xdr_getpos64(xdrs); |
1137 | |
1138 | { |
1139 | xdr_int(xdrs,&this1->eventNo); |
1140 | xdr_int(xdrs,&this1->runNo); |
1141 | if (this1->comments != (r_Comments_t*)&hddm_r_nullTarget) |
1142 | { |
1143 | if (pack_r_Comments(xdrs,this1->comments) < 0) { |
1144 | return -1; |
1145 | } |
1146 | } |
1147 | else |
1148 | { |
1149 | int zero=0; |
1150 | xdr_int(xdrs,&zero); |
1151 | } |
1152 | if (this1->reactions != (r_Reactions_t*)&hddm_r_nullTarget) |
1153 | { |
1154 | if (pack_r_Reactions(xdrs,this1->reactions) < 0) { |
1155 | return -1; |
1156 | } |
1157 | } |
1158 | else |
1159 | { |
1160 | int zero=0; |
1161 | xdr_int(xdrs,&zero); |
1162 | } |
1163 | if (this1->taggerHits != (r_TaggerHits_t*)&hddm_r_nullTarget) |
1164 | { |
1165 | if (pack_r_TaggerHits(xdrs,this1->taggerHits) < 0) { |
1166 | return -1; |
1167 | } |
1168 | } |
1169 | else |
1170 | { |
1171 | int zero=0; |
1172 | xdr_int(xdrs,&zero); |
1173 | } |
1174 | if (this1->calorimeterClusters != (r_CalorimeterClusters_t*)&hddm_r_nullTarget) |
1175 | { |
1176 | if (pack_r_CalorimeterClusters(xdrs,this1->calorimeterClusters) < 0) { |
1177 | return -1; |
1178 | } |
1179 | } |
1180 | else |
1181 | { |
1182 | int zero=0; |
1183 | xdr_int(xdrs,&zero); |
1184 | } |
1185 | if (this1->chargedTracks != (r_ChargedTracks_t*)&hddm_r_nullTarget) |
1186 | { |
1187 | if (pack_r_ChargedTracks(xdrs,this1->chargedTracks) < 0) { |
1188 | return -1; |
1189 | } |
1190 | } |
1191 | else |
1192 | { |
1193 | int zero=0; |
1194 | xdr_int(xdrs,&zero); |
1195 | } |
1196 | if (this1->startHits != (r_StartHits_t*)&hddm_r_nullTarget) |
1197 | { |
1198 | if (pack_r_StartHits(xdrs,this1->startHits) < 0) { |
1199 | return -1; |
1200 | } |
1201 | } |
1202 | else |
1203 | { |
1204 | int zero=0; |
1205 | xdr_int(xdrs,&zero); |
1206 | } |
1207 | if (this1->tofPoints != (r_TofPoints_t*)&hddm_r_nullTarget) |
1208 | { |
1209 | if (pack_r_TofPoints(xdrs,this1->tofPoints) < 0) { |
1210 | return -1; |
1211 | } |
1212 | } |
1213 | else |
1214 | { |
1215 | int zero=0; |
1216 | xdr_int(xdrs,&zero); |
1217 | } |
1218 | if (this1->RFtime != (r_RFtime_t*)&hddm_r_nullTarget) |
1219 | { |
1220 | if (pack_r_RFtime(xdrs,this1->RFtime) < 0) { |
1221 | return -1; |
1222 | } |
1223 | } |
1224 | else |
1225 | { |
1226 | int zero=0; |
1227 | xdr_int(xdrs,&zero); |
1228 | } |
1229 | } |
1230 | FREE(this1)free(this1); |
1231 | end = xdr_getpos64(xdrs); |
1232 | xdr_setpos64(xdrs,base); |
1233 | size = end-start; |
1234 | xdr_u_int(xdrs,&size); |
1235 | xdr_setpos64(xdrs,end); |
1236 | return size; |
1237 | } |
1238 | |
1239 | static int pack_r_Comments(XDR* xdrs, r_Comments_t* this1) |
1240 | { |
1241 | int m=0; |
1242 | unsigned int size=0; |
1243 | off_t base,start,end; |
1244 | base = xdr_getpos64(xdrs); |
1245 | xdr_u_int(xdrs,&size); |
1246 | start = xdr_getpos64(xdrs); |
1247 | |
1248 | xdr_u_int(xdrs,&this1->mult); |
1249 | for (m = 0; m < this1->mult; m++) |
1250 | { |
1251 | xdr_string(xdrs,&this1->in[m].text, 1000000); |
1252 | FREE(this1->in[m].text)free(this1->in[m].text); |
1253 | } |
1254 | FREE(this1)free(this1); |
1255 | end = xdr_getpos64(xdrs); |
1256 | xdr_setpos64(xdrs,base); |
1257 | size = end-start; |
1258 | xdr_u_int(xdrs,&size); |
1259 | xdr_setpos64(xdrs,end); |
1260 | return size; |
1261 | } |
1262 | |
1263 | static int pack_r_Reactions(XDR* xdrs, r_Reactions_t* this1) |
1264 | { |
1265 | int m=0; |
1266 | unsigned int size=0; |
1267 | off_t base,start,end; |
1268 | base = xdr_getpos64(xdrs); |
1269 | xdr_u_int(xdrs,&size); |
1270 | start = xdr_getpos64(xdrs); |
1271 | |
1272 | xdr_u_int(xdrs,&this1->mult); |
1273 | for (m = 0; m < this1->mult; m++) |
1274 | { |
1275 | xdr_float(xdrs,&this1->in[m].Ebeam); |
1276 | xdr_string(xdrs,&this1->in[m].jtag, 1000000); |
1277 | FREE(this1->in[m].jtag)free(this1->in[m].jtag); |
1278 | xdr_int(xdrs,(int*)&this1->in[m].targetType); |
1279 | xdr_int(xdrs,&this1->in[m].type); |
1280 | xdr_float(xdrs,&this1->in[m].weight); |
1281 | if (this1->in[m].vertices != (r_Vertices_t*)&hddm_r_nullTarget) |
1282 | { |
1283 | if (pack_r_Vertices(xdrs,this1->in[m].vertices) < 0) { |
1284 | return -1; |
1285 | } |
1286 | } |
1287 | else |
1288 | { |
1289 | int zero=0; |
1290 | xdr_int(xdrs,&zero); |
1291 | } |
1292 | } |
1293 | FREE(this1)free(this1); |
1294 | end = xdr_getpos64(xdrs); |
1295 | xdr_setpos64(xdrs,base); |
1296 | size = end-start; |
1297 | xdr_u_int(xdrs,&size); |
1298 | xdr_setpos64(xdrs,end); |
1299 | return size; |
1300 | } |
1301 | |
1302 | static int pack_r_Vertices(XDR* xdrs, r_Vertices_t* this1) |
1303 | { |
1304 | int m=0; |
1305 | unsigned int size=0; |
1306 | off_t base,start,end; |
1307 | base = xdr_getpos64(xdrs); |
1308 | xdr_u_int(xdrs,&size); |
1309 | start = xdr_getpos64(xdrs); |
1310 | |
1311 | xdr_u_int(xdrs,&this1->mult); |
1312 | for (m = 0; m < this1->mult; m++) |
1313 | { |
1314 | if (this1->in[m].origin != (r_Origin_t*)&hddm_r_nullTarget) |
1315 | { |
1316 | if (pack_r_Origin(xdrs,this1->in[m].origin) < 0) { |
1317 | return -1; |
1318 | } |
1319 | } |
1320 | else |
1321 | { |
1322 | int zero=0; |
1323 | xdr_int(xdrs,&zero); |
1324 | } |
1325 | if (this1->in[m].products != (r_Products_t*)&hddm_r_nullTarget) |
1326 | { |
1327 | if (pack_r_Products(xdrs,this1->in[m].products) < 0) { |
1328 | return -1; |
1329 | } |
1330 | } |
1331 | else |
1332 | { |
1333 | int zero=0; |
1334 | xdr_int(xdrs,&zero); |
1335 | } |
1336 | } |
1337 | FREE(this1)free(this1); |
1338 | end = xdr_getpos64(xdrs); |
1339 | xdr_setpos64(xdrs,base); |
1340 | size = end-start; |
1341 | xdr_u_int(xdrs,&size); |
1342 | xdr_setpos64(xdrs,end); |
1343 | return size; |
1344 | } |
1345 | |
1346 | static int pack_r_Origin(XDR* xdrs, r_Origin_t* this1) |
1347 | { |
1348 | int m=0; |
1349 | unsigned int size=0; |
1350 | off_t base,start,end; |
1351 | base = xdr_getpos64(xdrs); |
1352 | xdr_u_int(xdrs,&size); |
1353 | start = xdr_getpos64(xdrs); |
1354 | |
1355 | { |
1356 | xdr_float(xdrs,&this1->t); |
1357 | xdr_float(xdrs,&this1->vx); |
1358 | xdr_float(xdrs,&this1->vy); |
1359 | xdr_float(xdrs,&this1->vz); |
1360 | } |
1361 | FREE(this1)free(this1); |
1362 | end = xdr_getpos64(xdrs); |
1363 | xdr_setpos64(xdrs,base); |
1364 | size = end-start; |
1365 | xdr_u_int(xdrs,&size); |
1366 | xdr_setpos64(xdrs,end); |
1367 | return size; |
1368 | } |
1369 | |
1370 | static int pack_r_Products(XDR* xdrs, r_Products_t* this1) |
1371 | { |
1372 | int m=0; |
1373 | unsigned int size=0; |
1374 | off_t base,start,end; |
1375 | base = xdr_getpos64(xdrs); |
1376 | xdr_u_int(xdrs,&size); |
1377 | start = xdr_getpos64(xdrs); |
1378 | |
1379 | xdr_u_int(xdrs,&this1->mult); |
1380 | for (m = 0; m < this1->mult; m++) |
1381 | { |
1382 | xdr_int(xdrs,&this1->in[m].id); |
1383 | xdr_int(xdrs,&this1->in[m].parentId); |
1384 | xdr_int(xdrs,&this1->in[m].pdgtype); |
1385 | if (this1->in[m].momentum != (r_Momentum_t*)&hddm_r_nullTarget) |
1386 | { |
1387 | if (pack_r_Momentum(xdrs,this1->in[m].momentum) < 0) { |
1388 | return -1; |
1389 | } |
1390 | } |
1391 | else |
1392 | { |
1393 | int zero=0; |
1394 | xdr_int(xdrs,&zero); |
1395 | } |
1396 | } |
1397 | FREE(this1)free(this1); |
1398 | end = xdr_getpos64(xdrs); |
1399 | xdr_setpos64(xdrs,base); |
1400 | size = end-start; |
1401 | xdr_u_int(xdrs,&size); |
1402 | xdr_setpos64(xdrs,end); |
1403 | return size; |
1404 | } |
1405 | |
1406 | static int pack_r_Momentum(XDR* xdrs, r_Momentum_t* this1) |
1407 | { |
1408 | int m=0; |
1409 | unsigned int size=0; |
1410 | off_t base,start,end; |
1411 | base = xdr_getpos64(xdrs); |
1412 | xdr_u_int(xdrs,&size); |
1413 | start = xdr_getpos64(xdrs); |
1414 | |
1415 | { |
1416 | xdr_float(xdrs,&this1->E); |
1417 | xdr_float(xdrs,&this1->px); |
1418 | xdr_float(xdrs,&this1->py); |
1419 | xdr_float(xdrs,&this1->pz); |
1420 | } |
1421 | FREE(this1)free(this1); |
1422 | end = xdr_getpos64(xdrs); |
1423 | xdr_setpos64(xdrs,base); |
1424 | size = end-start; |
1425 | xdr_u_int(xdrs,&size); |
1426 | xdr_setpos64(xdrs,end); |
1427 | return size; |
1428 | } |
1429 | |
1430 | static int pack_r_TaggerHits(XDR* xdrs, r_TaggerHits_t* this1) |
1431 | { |
1432 | int m=0; |
1433 | unsigned int size=0; |
1434 | off_t base,start,end; |
1435 | base = xdr_getpos64(xdrs); |
1436 | xdr_u_int(xdrs,&size); |
1437 | start = xdr_getpos64(xdrs); |
1438 | |
1439 | xdr_u_int(xdrs,&this1->mult); |
1440 | for (m = 0; m < this1->mult; m++) |
1441 | { |
1442 | xdr_float(xdrs,&this1->in[m].E); |
1443 | xdr_string(xdrs,&this1->in[m].jtag, 1000000); |
1444 | FREE(this1->in[m].jtag)free(this1->in[m].jtag); |
1445 | xdr_float(xdrs,&this1->in[m].t); |
1446 | } |
1447 | FREE(this1)free(this1); |
1448 | end = xdr_getpos64(xdrs); |
1449 | xdr_setpos64(xdrs,base); |
1450 | size = end-start; |
1451 | xdr_u_int(xdrs,&size); |
1452 | xdr_setpos64(xdrs,end); |
1453 | return size; |
1454 | } |
1455 | |
1456 | static int pack_r_CalorimeterClusters(XDR* xdrs, r_CalorimeterClusters_t* this1) |
1457 | { |
1458 | int m=0; |
1459 | unsigned int size=0; |
1460 | off_t base,start,end; |
1461 | base = xdr_getpos64(xdrs); |
1462 | xdr_u_int(xdrs,&size); |
1463 | start = xdr_getpos64(xdrs); |
1464 | |
1465 | xdr_u_int(xdrs,&this1->mult); |
1466 | for (m = 0; m < this1->mult; m++) |
1467 | { |
1468 | xdr_float(xdrs,&this1->in[m].E); |
1469 | xdr_float(xdrs,&this1->in[m].Eerr); |
1470 | xdr_float(xdrs,&this1->in[m].Ezcorr); |
1471 | xdr_string(xdrs,&this1->in[m].jtag, 1000000); |
1472 | FREE(this1->in[m].jtag)free(this1->in[m].jtag); |
1473 | xdr_float(xdrs,&this1->in[m].t); |
1474 | xdr_float(xdrs,&this1->in[m].terr); |
1475 | xdr_float(xdrs,&this1->in[m].tzcorr); |
1476 | xdr_float(xdrs,&this1->in[m].x); |
1477 | xdr_float(xdrs,&this1->in[m].xerr); |
1478 | xdr_float(xdrs,&this1->in[m].xycorr); |
1479 | xdr_float(xdrs,&this1->in[m].xzcorr); |
1480 | xdr_float(xdrs,&this1->in[m].y); |
1481 | xdr_float(xdrs,&this1->in[m].yerr); |
1482 | xdr_float(xdrs,&this1->in[m].yzcorr); |
1483 | xdr_float(xdrs,&this1->in[m].z); |
1484 | xdr_float(xdrs,&this1->in[m].zerr); |
1485 | } |
1486 | FREE(this1)free(this1); |
1487 | end = xdr_getpos64(xdrs); |
1488 | xdr_setpos64(xdrs,base); |
1489 | size = end-start; |
1490 | xdr_u_int(xdrs,&size); |
1491 | xdr_setpos64(xdrs,end); |
1492 | return size; |
1493 | } |
1494 | |
1495 | static int pack_r_ChargedTracks(XDR* xdrs, r_ChargedTracks_t* this1) |
1496 | { |
1497 | int m=0; |
1498 | unsigned int size=0; |
1499 | off_t base,start,end; |
1500 | base = xdr_getpos64(xdrs); |
1501 | xdr_u_int(xdrs,&size); |
1502 | start = xdr_getpos64(xdrs); |
1503 | |
1504 | xdr_u_int(xdrs,&this1->mult); |
1505 | for (m = 0; m < this1->mult; m++) |
1506 | { |
1507 | xdr_int(xdrs,&this1->in[m].candidateId); |
1508 | xdr_string(xdrs,&this1->in[m].jtag, 1000000); |
1509 | FREE(this1->in[m].jtag)free(this1->in[m].jtag); |
1510 | xdr_int(xdrs,(int*)&this1->in[m].ptype); |
1511 | if (this1->in[m].trackFit != (r_TrackFit_t*)&hddm_r_nullTarget) |
1512 | { |
1513 | if (pack_r_TrackFit(xdrs,this1->in[m].trackFit) < 0) { |
1514 | return -1; |
1515 | } |
1516 | } |
1517 | else |
1518 | { |
1519 | int zero=0; |
1520 | xdr_int(xdrs,&zero); |
1521 | } |
1522 | if (this1->in[m].dEdxDC != (r_DEdxDC_t*)&hddm_r_nullTarget) |
1523 | { |
1524 | if (pack_r_DEdxDC(xdrs,this1->in[m].dEdxDC) < 0) { |
1525 | return -1; |
1526 | } |
1527 | } |
1528 | else |
1529 | { |
1530 | int zero=0; |
1531 | xdr_int(xdrs,&zero); |
1532 | } |
1533 | } |
1534 | FREE(this1)free(this1); |
1535 | end = xdr_getpos64(xdrs); |
1536 | xdr_setpos64(xdrs,base); |
1537 | size = end-start; |
1538 | xdr_u_int(xdrs,&size); |
1539 | xdr_setpos64(xdrs,end); |
1540 | return size; |
1541 | } |
1542 | |
1543 | static int pack_r_TrackFit(XDR* xdrs, r_TrackFit_t* this1) |
1544 | { |
1545 | int m=0; |
1546 | unsigned int size=0; |
1547 | off_t base,start,end; |
1548 | base = xdr_getpos64(xdrs); |
1549 | xdr_u_int(xdrs,&size); |
1550 | start = xdr_getpos64(xdrs); |
1551 | |
1552 | { |
1553 | xdr_int(xdrs,&this1->Ndof); |
1554 | xdr_float(xdrs,&this1->chisq); |
1555 | xdr_float(xdrs,&this1->e11); |
1556 | xdr_float(xdrs,&this1->e12); |
1557 | xdr_float(xdrs,&this1->e13); |
1558 | xdr_float(xdrs,&this1->e14); |
1559 | xdr_float(xdrs,&this1->e15); |
1560 | xdr_float(xdrs,&this1->e22); |
1561 | xdr_float(xdrs,&this1->e23); |
1562 | xdr_float(xdrs,&this1->e24); |
1563 | xdr_float(xdrs,&this1->e25); |
1564 | xdr_float(xdrs,&this1->e33); |
1565 | xdr_float(xdrs,&this1->e34); |
1566 | xdr_float(xdrs,&this1->e35); |
1567 | xdr_float(xdrs,&this1->e44); |
1568 | xdr_float(xdrs,&this1->e45); |
1569 | xdr_float(xdrs,&this1->e55); |
1570 | xdr_float(xdrs,&this1->px); |
1571 | xdr_float(xdrs,&this1->py); |
1572 | xdr_float(xdrs,&this1->pz); |
1573 | xdr_float(xdrs,&this1->t0); |
1574 | xdr_int(xdrs,&this1->t0det); |
1575 | xdr_float(xdrs,&this1->t0err); |
1576 | xdr_float(xdrs,&this1->x0); |
1577 | xdr_float(xdrs,&this1->y0); |
1578 | xdr_float(xdrs,&this1->z0); |
1579 | } |
1580 | FREE(this1)free(this1); |
1581 | end = xdr_getpos64(xdrs); |
1582 | xdr_setpos64(xdrs,base); |
1583 | size = end-start; |
1584 | xdr_u_int(xdrs,&size); |
1585 | xdr_setpos64(xdrs,end); |
1586 | return size; |
1587 | } |
1588 | |
1589 | static int pack_r_DEdxDC(XDR* xdrs, r_DEdxDC_t* this1) |
1590 | { |
1591 | int m=0; |
1592 | unsigned int size=0; |
1593 | off_t base,start,end; |
1594 | base = xdr_getpos64(xdrs); |
1595 | xdr_u_int(xdrs,&size); |
1596 | start = xdr_getpos64(xdrs); |
1597 | |
1598 | { |
1599 | xdr_int(xdrs,&this1->NsampleCDC); |
1600 | xdr_int(xdrs,&this1->NsampleFDC); |
1601 | xdr_float(xdrs,&this1->dEdxCDC); |
1602 | xdr_float(xdrs,&this1->dEdxFDC); |
1603 | xdr_float(xdrs,&this1->dxCDC); |
1604 | xdr_float(xdrs,&this1->dxFDC); |
1605 | } |
1606 | FREE(this1)free(this1); |
1607 | end = xdr_getpos64(xdrs); |
1608 | xdr_setpos64(xdrs,base); |
1609 | size = end-start; |
1610 | xdr_u_int(xdrs,&size); |
1611 | xdr_setpos64(xdrs,end); |
1612 | return size; |
1613 | } |
1614 | |
1615 | static int pack_r_StartHits(XDR* xdrs, r_StartHits_t* this1) |
1616 | { |
1617 | int m=0; |
1618 | unsigned int size=0; |
1619 | off_t base,start,end; |
1620 | base = xdr_getpos64(xdrs); |
1621 | xdr_u_int(xdrs,&size); |
1622 | start = xdr_getpos64(xdrs); |
1623 | |
1624 | xdr_u_int(xdrs,&this1->mult); |
1625 | for (m = 0; m < this1->mult; m++) |
1626 | { |
1627 | xdr_float(xdrs,&this1->in[m].dE); |
1628 | xdr_string(xdrs,&this1->in[m].jtag, 1000000); |
1629 | FREE(this1->in[m].jtag)free(this1->in[m].jtag); |
1630 | xdr_int(xdrs,&this1->in[m].sector); |
1631 | xdr_float(xdrs,&this1->in[m].t); |
1632 | } |
1633 | FREE(this1)free(this1); |
1634 | end = xdr_getpos64(xdrs); |
1635 | xdr_setpos64(xdrs,base); |
1636 | size = end-start; |
1637 | xdr_u_int(xdrs,&size); |
1638 | xdr_setpos64(xdrs,end); |
1639 | return size; |
1640 | } |
1641 | |
1642 | static int pack_r_TofPoints(XDR* xdrs, r_TofPoints_t* this1) |
1643 | { |
1644 | int m=0; |
1645 | unsigned int size=0; |
1646 | off_t base,start,end; |
1647 | base = xdr_getpos64(xdrs); |
1648 | xdr_u_int(xdrs,&size); |
1649 | start = xdr_getpos64(xdrs); |
1650 | |
1651 | xdr_u_int(xdrs,&this1->mult); |
1652 | for (m = 0; m < this1->mult; m++) |
1653 | { |
1654 | xdr_float(xdrs,&this1->in[m].dE); |
1655 | xdr_string(xdrs,&this1->in[m].jtag, 1000000); |
1656 | FREE(this1->in[m].jtag)free(this1->in[m].jtag); |
1657 | xdr_float(xdrs,&this1->in[m].t); |
1658 | xdr_float(xdrs,&this1->in[m].x); |
1659 | xdr_float(xdrs,&this1->in[m].y); |
1660 | xdr_float(xdrs,&this1->in[m].z); |
1661 | } |
1662 | FREE(this1)free(this1); |
1663 | end = xdr_getpos64(xdrs); |
1664 | xdr_setpos64(xdrs,base); |
1665 | size = end-start; |
1666 | xdr_u_int(xdrs,&size); |
1667 | xdr_setpos64(xdrs,end); |
1668 | return size; |
1669 | } |
1670 | |
1671 | static int pack_r_RFtime(XDR* xdrs, r_RFtime_t* this1) |
1672 | { |
1673 | int m=0; |
1674 | unsigned int size=0; |
1675 | off_t base,start,end; |
1676 | base = xdr_getpos64(xdrs); |
1677 | xdr_u_int(xdrs,&size); |
1678 | start = xdr_getpos64(xdrs); |
1679 | |
1680 | { |
1681 | xdr_string(xdrs,&this1->jtag, 1000000); |
1682 | FREE(this1->jtag)free(this1->jtag); |
1683 | xdr_float(xdrs,&this1->tsync); |
1684 | xdr_float(xdrs,&this1->tsyncerr); |
1685 | } |
1686 | FREE(this1)free(this1); |
1687 | end = xdr_getpos64(xdrs); |
1688 | xdr_setpos64(xdrs,base); |
1689 | size = end-start; |
1690 | xdr_u_int(xdrs,&size); |
1691 | xdr_setpos64(xdrs,end); |
1692 | return size; |
1693 | } |
1694 | |
1695 | int flush_r_HDDM(r_HDDM_t* this1,r_iostream_t* fp) |
1696 | { |
1697 | if (this1 == 0) |
1698 | { |
1699 | return 0; |
1700 | } |
1701 | else if (fp == 0) |
1702 | { |
1703 | XDR* xdrs = (XDR*)malloc(sizeof(XDR)); |
1704 | int max_buffer_size = 1000000; |
1705 | char* dump = (char*)malloc(max_buffer_size); |
1706 | xdrmem_create(xdrs,dump,max_buffer_size,XDR_ENCODE); |
1707 | pack_r_HDDM(xdrs,this1); |
1708 | xdr_destroy(xdrs)do { if ((xdrs)->x_ops->x_destroy) (*(xdrs)->x_ops-> x_destroy)(xdrs); } while (0); |
1709 | free(xdrs); |
1710 | free(dump); |
1711 | } |
1712 | else if (fp->iomode == HDDM_STREAM_OUTPUT-92) |
1713 | { |
1714 | if (pack_r_HDDM(fp->xdrs,this1) < 0) { |
1715 | fp->lerrno = errno(*__errno_location ()); |
1716 | return -1; |
1717 | } |
1718 | } |
1719 | return 0; |
1720 | } |
1721 | |
1722 | static int getTag(char* d, char* tag) |
1723 | { |
1724 | int level; |
1725 | char* token; |
1726 | char line[500]; |
1727 | strncpy(line,d,500); |
1728 | line[499] = 0; |
1729 | level = index(line,'<')-line; |
1730 | if (level < 500 && |
1731 | (token = strtok(line+level+1," >"))) |
1732 | { |
1733 | strncpy(tag,token,500); |
1734 | return level/2; |
1735 | } |
1736 | return -1; |
1737 | } |
1738 | |
1739 | static char* getEndTag(char* d, char* tag) |
1740 | { |
1741 | char line[500]; |
1742 | char endTag[510]; |
1743 | strncpy(line,d,500); |
1744 | line[499] = 0; |
1745 | if (strstr(strtok(line,"\n"),"/>") == 0) |
1746 | { |
1747 | sprintf(endTag,"</%s>",tag); |
1748 | } |
1749 | else |
1750 | { |
1751 | strcpy(endTag,"/>"); |
1752 | } |
1753 | return strstr(d,endTag); |
1754 | } |
1755 | |
1756 | static void collide(char* b, char* c) |
1757 | { |
1758 | char btag[500]; |
1759 | getTag(b,btag); |
1760 | b = index(b,'<'); |
1761 | c = index(c,'<'); |
1762 | *(index(b,'\n')) = 0; |
1763 | *(index(c,'\n')) = 0; |
1764 | fprintf(stderrstderr,"HDDM warning: "); |
1765 | fprintf(stderrstderr,"tag %s in input file ", btag); |
1766 | fprintf(stderrstderr,"does not match c header hddm_r.h\n"); |
1767 | fprintf(stderrstderr," input file: %s\n", b); |
1768 | fprintf(stderrstderr," c header: %s\n", c); |
1769 | fprintf(stderrstderr," === Tag %s will be ignored,", btag); |
1770 | fprintf(stderrstderr," rebuild to cure the problem ===\n"); |
1771 | *(index(b,0)) = '\n'; |
1772 | *(index(c,0)) = '\n'; |
1773 | } |
1774 | |
1775 | static popNode* matches(char* b, char* c) |
1776 | { |
1777 | char btag[500]; |
1778 | char ctag[500]; |
1779 | int blevel, clevel; |
1780 | int ptrSeqNo = 0; |
1781 | blevel = getTag(b,btag); |
1782 | while ((clevel = getTag(c,ctag)) == blevel) |
1783 | { |
1784 | if ((clevel == blevel) && (strcmp(ctag,btag) == 0)) |
1785 | { |
1786 | popNode* this1 = (popNode*)malloc(sizeof(popNode)); |
1787 | int len = index(c+1,'\n') - c; |
1788 | if (strncmp(c,b,len) != 0) |
1789 | { |
1790 | collide(b,c); |
1791 | return 0; |
1792 | } |
1793 | else if (strcmp(btag,"HDDM") == 0) |
1794 | { |
1795 | this1->unpacker = (void*(*)(XDR*,popNode*))unpack_r_HDDM; |
1796 | } |
1797 | else if (strcmp(btag,"reconstructedPhysicsEvent") == 0) |
1798 | { |
1799 | this1->unpacker = (void*(*)(XDR*,popNode*))unpack_r_ReconstructedPhysicsEvent; |
1800 | } |
1801 | else if (strcmp(btag,"comment") == 0) |
1802 | { |
1803 | this1->unpacker = (void*(*)(XDR*,popNode*))unpack_r_Comments; |
1804 | } |
1805 | else if (strcmp(btag,"reaction") == 0) |
1806 | { |
1807 | this1->unpacker = (void*(*)(XDR*,popNode*))unpack_r_Reactions; |
1808 | } |
1809 | else if (strcmp(btag,"vertex") == 0) |
1810 | { |
1811 | this1->unpacker = (void*(*)(XDR*,popNode*))unpack_r_Vertices; |
1812 | } |
1813 | else if (strcmp(btag,"origin") == 0) |
1814 | { |
1815 | this1->unpacker = (void*(*)(XDR*,popNode*))unpack_r_Origin; |
1816 | } |
1817 | else if (strcmp(btag,"product") == 0) |
1818 | { |
1819 | this1->unpacker = (void*(*)(XDR*,popNode*))unpack_r_Products; |
1820 | } |
1821 | else if (strcmp(btag,"momentum") == 0) |
1822 | { |
1823 | this1->unpacker = (void*(*)(XDR*,popNode*))unpack_r_Momentum; |
1824 | } |
1825 | else if (strcmp(btag,"taggerHit") == 0) |
1826 | { |
1827 | this1->unpacker = (void*(*)(XDR*,popNode*))unpack_r_TaggerHits; |
1828 | } |
1829 | else if (strcmp(btag,"calorimeterCluster") == 0) |
1830 | { |
1831 | this1->unpacker = (void*(*)(XDR*,popNode*))unpack_r_CalorimeterClusters; |
1832 | } |
1833 | else if (strcmp(btag,"chargedTrack") == 0) |
1834 | { |
1835 | this1->unpacker = (void*(*)(XDR*,popNode*))unpack_r_ChargedTracks; |
1836 | } |
1837 | else if (strcmp(btag,"trackFit") == 0) |
1838 | { |
1839 | this1->unpacker = (void*(*)(XDR*,popNode*))unpack_r_TrackFit; |
1840 | } |
1841 | else if (strcmp(btag,"dEdxDC") == 0) |
1842 | { |
1843 | this1->unpacker = (void*(*)(XDR*,popNode*))unpack_r_DEdxDC; |
1844 | } |
1845 | else if (strcmp(btag,"startHit") == 0) |
1846 | { |
1847 | this1->unpacker = (void*(*)(XDR*,popNode*))unpack_r_StartHits; |
1848 | } |
1849 | else if (strcmp(btag,"tofPoint") == 0) |
1850 | { |
1851 | this1->unpacker = (void*(*)(XDR*,popNode*))unpack_r_TofPoints; |
1852 | } |
1853 | else if (strcmp(btag,"RFtime") == 0) |
1854 | { |
1855 | this1->unpacker = (void*(*)(XDR*,popNode*))unpack_r_RFtime; |
1856 | } |
1857 | this1->inParent = ptrSeqNo; |
1858 | this1->popListLength = 0; |
1859 | c = index(c+1,'\n'); |
1860 | b = index(b+1,'\n'); |
1861 | while (getTag(b,btag) > blevel) |
1862 | { |
1863 | this1->popList[this1->popListLength++] = matches(b,c); |
1864 | if (this1->popListLength > 99) |
1865 | { |
1866 | fprintf(stderrstderr,"hddm error - popList overflow.\n"); |
1867 | fprintf(stderrstderr,"Increase MAX_POPLIST_LENGTH and recompile.\n"); |
1868 | exit(9); |
1869 | } |
1870 | b = getEndTag(b,btag); |
1871 | b = index(b+1,'\n'); |
1872 | } |
1873 | return this1; |
1874 | } |
1875 | else |
1876 | { |
1877 | c = getEndTag(c,ctag); |
1878 | c = index(c+1,'\n'); |
1879 | ++ptrSeqNo; |
1880 | } |
1881 | } |
1882 | return 0; |
1883 | } |
1884 | |
1885 | r_iostream_t* open_r_HDDM(char* filename) |
1886 | { |
1887 | r_iostream_t* fp = (r_iostream_t*)malloc(sizeof(r_iostream_t)); |
1888 | char* p; |
1889 | char* head; |
1890 | if (filename) |
| 1 | Assuming 'filename' is null | |
|
| 2 | | Assuming pointer value is null | |
|
| |
1891 | { |
1892 | fp->fd = fopen(filename,"r"); |
1893 | } |
1894 | else |
1895 | { |
1896 | fp->fd = fdopen(0,"r"); |
1897 | } |
1898 | if (fp->fd == 0) |
| |
1899 | { |
1900 | free(fp); |
1901 | return 0; |
1902 | } |
1903 | fp->iomode = HDDM_STREAM_INPUT-91; |
1904 | head = (char*)malloc(1000000); |
1905 | *head = 0; |
1906 | for (p = head; |
| 5 | | Loop condition is false. Execution continues on line 1920 | |
|
1907 | strstr(head,"</HDDM>") == 0; |
1908 | p += strlen(p)) |
1909 | { |
1910 | if (p-head < 999000) |
1911 | { |
1912 | char *pbuf; |
1913 | pbuf = fgets(p,1000,fp->fd); |
1914 | } |
1915 | else |
1916 | { |
1917 | break; |
1918 | } |
1919 | } |
1920 | fp->popTop = matches(head,HDDM_r_DocumentString); |
1921 | free(head); |
1922 | if (fp->popTop->popListLength == 0) |
| |
1923 | { |
1924 | fprintf(stderrstderr,"HDDM Error: "); |
1925 | fprintf(stderrstderr,"input template model "); |
1926 | fprintf(stderrstderr,"does not match c header."); |
1927 | fprintf(stderrstderr," Please recompile.\n"); |
1928 | exit(9); |
1929 | } |
1930 | fp->filename = (char*)malloc(strlen(filename) + 1); |
| 7 | | Null pointer passed as an argument to a 'nonnull' parameter |
|
1931 | strcpy(fp->filename,filename); |
1932 | fp->xdrs = (XDR*)malloc(sizeof(XDR)); |
1933 | xdrstdio_create(fp->xdrs,fp->fd,XDR_DECODE); |
1934 | return fp; |
1935 | } |
1936 | |
1937 | r_iostream_t* init_r_HDDM(char* filename) |
1938 | { |
1939 | int len; |
1940 | char* head; |
1941 | r_iostream_t* fp = (r_iostream_t*)malloc(sizeof(r_iostream_t)); |
1942 | if (filename) |
1943 | { |
1944 | fp->fd = fopen(filename,"w"); |
1945 | } |
1946 | else |
1947 | { |
1948 | fp->fd = fdopen(1,"w"); |
1949 | } |
1950 | if (fp->fd == 0) |
1951 | { |
1952 | free(fp); |
1953 | return 0; |
1954 | } |
1955 | fp->iomode = HDDM_STREAM_OUTPUT-92; |
1956 | len = strlen(HDDM_r_DocumentString); |
1957 | head = (char*)malloc(len+1); |
1958 | strcpy(head,HDDM_r_DocumentString); |
1959 | if (fwrite(head,1,len,fp->fd) != len) |
1960 | { |
1961 | fprintf(stderrstderr,"HDDM Error: "); |
1962 | fprintf(stderrstderr,"error writing to "); |
1963 | fprintf(stderrstderr,"output file %s\n",filename); |
1964 | exit(9); |
1965 | } |
1966 | fp->filename = (char*)malloc(strlen(filename) + 1); |
1967 | strcpy(fp->filename,filename); |
1968 | fp->popTop = 0; |
1969 | fp->xdrs = (XDR*)malloc(sizeof(XDR)); |
1970 | xdrstdio_create(fp->xdrs,fp->fd,XDR_ENCODE); |
1971 | free(head); |
1972 | return fp; |
1973 | } |
1974 | |
1975 | static void popaway(popNode* p) |
1976 | { |
1977 | if (p) |
1978 | { |
1979 | int n; |
1980 | for (n = 0; n < p->popListLength; n++) |
1981 | { |
1982 | popaway(p->popList[n]); |
1983 | } |
1984 | free(p); |
1985 | } |
1986 | } |
1987 | |
1988 | void close_r_HDDM(r_iostream_t* fp) |
1989 | { |
1990 | xdr_destroy(fp->xdrs)do { if ((fp->xdrs)->x_ops->x_destroy) (*(fp->xdrs )->x_ops->x_destroy)(fp->xdrs); } while (0); |
1991 | free(fp->xdrs); |
1992 | fclose(fp->fd); |
1993 | free(fp->filename); |
1994 | popaway(fp->popTop); |
1995 | free(fp); |
1996 | } |