Line data Source code
1 : /*
2 : dateStream.c
3 : ============
4 :
5 : Utility to simulate a DATE raw data stream using a given set of raw
6 : data files and a configuration file.
7 :
8 : Revision history:
9 :
10 : V01.00 4/05/2004 RD Created
11 : V01.01 25/10/2005 RD Support added for timestamp
12 : V01.02 4/04/2006 RD Support for CDH
13 : V01.03 24/05/2006 RD Added "Direct disk access" option
14 : V01.04 15/10/2010 RD Added possibility to set the run number
15 : */
16 : #define VID "1.04"
17 :
18 : #include <stdio.h>
19 : #include <stdlib.h>
20 : #include <errno.h>
21 : #include <assert.h>
22 : #include <ctype.h>
23 : #include <time.h>
24 : #include <cassert>
25 : #include "event.h"
26 :
27 : #define DESCRIPTION "DATE raw data stream simulator"
28 : #ifdef AIX
29 : static
30 : #endif
31 : char fileHandlerIdent[]= "@(#)""" __FILE__ """: """ DESCRIPTION \
32 : """ """ VID """ """ \
33 : """ compiled """ __DATE__ """ """ __TIME__;
34 :
35 : #define DBG_BASE if ( debug > 0 )
36 : #define DBG_DETAILED if ( debug > 1 )
37 : #define DBG_VERBOSE if ( debug > 2 )
38 :
39 : #ifndef TRUE
40 : # define TRUE (0 == 0)
41 : #endif
42 : #ifndef FALSE
43 : # define FALSE (0 == 1)
44 : #endif
45 :
46 : const char *myName;
47 : int debug;
48 : FILE *outF;
49 : typedef enum { unknown, ldc, gdc } workingAsType;
50 : typedef enum { collider, fixedTarget } workingModeType;
51 : workingAsType workingAs;
52 : workingModeType workingMode;
53 : struct ldcDescriptorStruct {
54 : eventLdcIdType id;
55 : struct ldcDescriptorStruct *next;
56 : } *ldcsHead, *ldcsTail;
57 : void *eventsHead, *eventsTail;
58 : struct gdcEventDescriptorStruct {
59 : struct ldcEventDescriptorStruct *head;
60 : struct ldcEventDescriptorStruct *tail;
61 : struct gdcEventDescriptorStruct *next;
62 : struct eventHeaderStruct header;
63 : int loaded;
64 : unsigned long32 detPattern;
65 : eventTimestampSecType timestamp;
66 : } *currGdc;
67 : struct ldcEventDescriptorStruct {
68 : struct equipmentEventDescriptorStruct *head;
69 : struct equipmentEventDescriptorStruct *tail;
70 : struct ldcEventDescriptorStruct *next;
71 : eventLdcIdType id;
72 : struct eventHeaderStruct header;
73 : int loaded;
74 : unsigned long32 detPattern;
75 : eventTimestampSecType timestamp;
76 : } *currLdc;
77 : struct equipmentEventDescriptorStruct {
78 : struct equipmentEventDescriptorStruct *next;
79 : equipmentIdType id;
80 : struct payloadDescriptorStruct *payload;
81 : struct equipmentHeaderStruct header;
82 : } *currEvent;
83 : struct payloadDescriptorStruct {
84 : struct payloadDescriptorStruct *next;
85 : char *fileName;
86 : int fileSize;
87 : int size;
88 : void *data;
89 : } *payloadsHead, *payloadsTail;
90 : int lineNmb;
91 : eventGdcIdType currGdcId;
92 : unsigned long32 currDetPattern;
93 : eventTimestampSecType currTimestamp;
94 : eventLdcIdType currLdcId;
95 : equipmentIdType currEquipmentId;
96 : int currRunNb;
97 : int numOfLdcs;
98 : int numOfEvents;
99 : int createSorEor;
100 : int handleCDH;
101 : eventIdType oneEventDelta;
102 : eventIdType currEventId;
103 : int gotAliceTrigger;
104 : int bufferData;
105 :
106 : struct commonDataHeaderStruct *cdhRef = NULL;
107 :
108 : void dumpPayload( const struct payloadDescriptorStruct *p ) {
109 : char *c;
110 : int i;
111 : int printable;
112 :
113 0 : if ( p->data != NULL ) {
114 0 : for ( i = 0, c = (char *)p->data, printable = TRUE;
115 0 : printable && i != p->size;
116 0 : c++, i++ )
117 0 : printable = isascii( *c );
118 0 : if ( printable ) {
119 0 : printf( " \"" );
120 0 : for ( i = 0, c = (char *)p->data; i != p->size; c++, i++ ) {
121 0 : if ( *c == '\n' )
122 0 : printf( "\"\n \"" );
123 : else
124 0 : putchar( *c );
125 : }
126 0 : if ( *c != '\n' ) printf( "\"\n" );
127 : } else {
128 : long32 *v;
129 0 : for ( i = 0, v = (long32 *)p->data;
130 0 : i+4 <= p->size;
131 0 : v++, i += 4 ) {
132 0 : if ( i % (4*8) == 0 ) {
133 0 : if ( i != 0 ) printf( "\n" );
134 0 : printf( " " );
135 0 : }
136 0 : printf( "%08x ", *v );
137 : }
138 0 : if ( i < p->size ) {
139 : int j = 0;
140 :
141 0 : printf( "\n " );
142 0 : while ( i != p->size ) {
143 0 : printf( "%02x ", *((char *)p->data + p->size - j - 1) & 0xff );
144 0 : j++;
145 0 : i++;
146 : }
147 0 : }
148 : }
149 0 : printf( "\n" );
150 0 : }
151 0 : } /* End of dumpPayload */
152 :
153 : void dumpEvents() {
154 0 : assert( workingAs == ldc || workingAs == gdc );
155 0 : if ( eventsHead != NULL ) {
156 0 : printf( "Events:\n" );
157 0 : if ( workingAs == gdc ) {
158 : struct gdcEventDescriptorStruct *gdc;
159 :
160 0 : for ( gdc = (struct gdcEventDescriptorStruct *)eventsHead;
161 0 : gdc != NULL;
162 0 : gdc = gdc->next ) {
163 : struct ldcEventDescriptorStruct *ldc;
164 :
165 0 : printf( " GDC (%p)\n", (void*)gdc );
166 0 : for ( ldc = gdc->head; ldc != NULL; ldc = ldc->next ) {
167 : struct equipmentEventDescriptorStruct *eq;
168 :
169 0 : printf( " LDC (%p): %d\n", (void*)ldc, ldc->id );
170 0 : for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
171 0 : printf( " EQUIPMENT (%p): %d PAYLOAD (%p):",
172 0 : (void*)eq,
173 0 : eq->id,
174 0 : (void*)eq->payload );
175 0 : fflush( stdout );
176 0 : printf( "\"%s\" (%d bytes)\n",
177 0 : eq->payload->fileName,
178 0 : eq->payload->size );
179 0 : dumpPayload( eq->payload );
180 : }
181 : }
182 : }
183 0 : }
184 0 : if ( workingAs == ldc ) {
185 : struct ldcEventDescriptorStruct *ldc;
186 :
187 0 : for ( ldc = (struct ldcEventDescriptorStruct *)eventsHead;
188 0 : ldc != NULL;
189 0 : ldc = ldc->next ) {
190 : struct equipmentEventDescriptorStruct *eq;
191 :
192 0 : printf( " LDC\n" );
193 0 : for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
194 0 : printf( " EQUIPMENT (%p): %d PAYLOAD (%p):",
195 0 : (void*)eq,
196 0 : eq->id,
197 0 : (void*)eq->payload );
198 0 : fflush( stdout );
199 0 : printf( "\"%s\" (%d bytes)\n",
200 0 : eq->payload->fileName,
201 0 : eq->payload->size );
202 0 : dumpPayload( eq->payload );
203 : }
204 : }
205 0 : }
206 : } else {
207 0 : printf( "Events: EMPTY\n" );
208 : }
209 0 : } /* End of dumpEvents */
210 :
211 : void getLine( char *line, const int maxSize ) {
212 : int read;
213 : int c;
214 :
215 317966 : for ( read = 0; !feof( stdin ) && !ferror( stdin ) && read != maxSize; read++ ) {
216 78966 : if ( (line[read] = getchar()) == '\n' ) break;
217 : }
218 2100 : if ( ferror( stdin ) ) {
219 0 : fprintf( stderr,
220 : "%s: failed to read configuration input errno:%d ",
221 0 : myName, errno );
222 0 : perror( "" );
223 0 : exit( 1 );
224 : }
225 2101 : if ( feof( stdin ) ) read--;
226 2100 : if ( read == maxSize && line[read] != '\n' ) {
227 0 : fprintf( stderr,
228 : "%s: Input line # %d too long (%d chars max)\n",
229 0 : myName, lineNmb, maxSize-1 );
230 0 : exit( 1 );
231 : }
232 2100 : line[ read ] = 0;
233 2100 : DBG_VERBOSE {
234 0 : if ( !( read == 0 && feof( stdin ) ) ) {
235 0 : printf( "%d) [%3d] \"%s\"", lineNmb, read, line );
236 0 : }
237 : }
238 157932 : for ( c = 0; c != read; c++ ) {
239 76866 : if ( line[c] == '#' ) {
240 0 : line[c] = 0;
241 0 : break;
242 : }
243 : }
244 2100 : DBG_VERBOSE {
245 0 : if ( read != c ) {
246 0 : printf( " => \"%s\"", line );
247 0 : }
248 0 : if ( feof( stdin ) ) printf( "<<< EOF >>>" );
249 0 : if ( ferror( stdin ) ) printf( "<<< FERROR >>>" );
250 0 : printf( "\n" );
251 0 : }
252 2100 : } /* End of getLine */
253 :
254 : void handleLdc( eventLdcIdType ldcId ) {
255 : struct ldcDescriptorStruct *ldc;
256 :
257 948 : if ( ldcsHead != NULL ) {
258 56682 : for ( ldc = ldcsHead; ldc != NULL; ldc = ldc->next ) {
259 28219 : if ( ldc->id == ldcId ) {
260 351 : return;
261 : }
262 : }
263 : }
264 123 : if ( (ldc = (struct ldcDescriptorStruct *)malloc( sizeof( *ldc ) )) == NULL ) {
265 0 : fprintf( stderr,
266 : "%s: Failed to malloc for %d bytes (struct ldcDescriptorStruct)\n",
267 0 : myName, (int)sizeof( *ldc ) );
268 0 : exit( 1 );
269 : }
270 123 : ldc->id = ldcId;
271 123 : ldc->next = NULL;
272 123 : if ( ldcsHead == NULL ) {
273 1 : ldcsHead = ldcsTail = ldc;
274 1 : } else {
275 122 : ldcsTail->next = ldc;
276 122 : ldcsTail = ldc;
277 : }
278 123 : numOfLdcs++;
279 597 : } /* End of handleLdc */
280 :
281 : void createNewEvent() {
282 8 : assert( workingAs == ldc || workingAs == gdc );
283 4 : if ( workingAs == ldc ) {
284 : struct ldcEventDescriptorStruct *p;
285 :
286 0 : if ( (p = (struct ldcEventDescriptorStruct *)malloc( sizeof( *p ) ))
287 0 : == NULL ) {
288 0 : fprintf( stderr,
289 : "%s: failed to malloc for %d bytes (createNewEvent: struct ldcEventDescriptorStruct)",
290 0 : myName, (int)sizeof( *p ) );
291 0 : perror( "" );
292 0 : exit( 1 );
293 : }
294 0 : p->loaded = FALSE;
295 0 : p->head = p->tail = NULL;
296 0 : p->next = NULL;
297 0 : currLdc = p;
298 0 : if ( eventsHead == NULL ) {
299 0 : eventsHead = eventsTail = p;
300 0 : } else {
301 : struct ldcEventDescriptorStruct *q =
302 0 : (struct ldcEventDescriptorStruct *)eventsTail;
303 :
304 0 : q->next = p;
305 0 : eventsTail = p;
306 : }
307 0 : p->id = currLdcId;
308 0 : p->detPattern = currDetPattern;
309 0 : p->timestamp = currTimestamp;
310 4 : } else if ( workingAs == gdc ) {
311 : struct gdcEventDescriptorStruct *p;
312 :
313 8 : if ( (p = (struct gdcEventDescriptorStruct *)malloc( sizeof( *p ) ))
314 4 : == NULL ) {
315 0 : fprintf( stderr,
316 : "%s: failed to malloc for %d bytes (createNewEvent: struct gdcEventDescriptorStruct)",
317 0 : myName, (int)sizeof( *p ) );
318 0 : perror( "" );
319 0 : exit( 1 );
320 : }
321 4 : p->loaded = FALSE;
322 4 : p->next = NULL;
323 4 : p->head = p->tail = NULL;
324 4 : currGdc = p;
325 4 : if ( eventsHead == NULL ) {
326 1 : eventsHead = eventsTail = p;
327 1 : } else {
328 : struct gdcEventDescriptorStruct *q =
329 3 : (struct gdcEventDescriptorStruct *)eventsTail;
330 :
331 3 : q->next = p;
332 3 : eventsTail = p;
333 : }
334 4 : p->detPattern = currDetPattern;
335 4 : p->timestamp = currTimestamp;
336 4 : }
337 4 : } /* End of createNewEvent */
338 :
339 : void createNewLdcEvent() {
340 : struct gdcEventDescriptorStruct *gdcDesc;
341 : struct ldcEventDescriptorStruct *p;
342 :
343 1422 : if ( (p = (struct ldcEventDescriptorStruct *)malloc( sizeof( *p ) ))
344 474 : == NULL ) {
345 0 : fprintf( stderr,
346 : "%s: failed to malloc for %d bytes (createNewLdcEvent: struct ldcEventDescriptorStruct)",
347 0 : myName, (int)sizeof( *p ) );
348 0 : perror( "" );
349 0 : exit( 1 );
350 : }
351 474 : p->id = currLdcId;
352 474 : p->detPattern = currDetPattern;
353 474 : p->timestamp = currTimestamp;
354 474 : p->head = p->tail = NULL;
355 474 : p->next = NULL;
356 474 : gdcDesc = (struct gdcEventDescriptorStruct *)eventsTail;
357 948 : if ( gdcDesc->head == NULL ) {
358 478 : gdcDesc->head = gdcDesc->tail = p;
359 4 : } else {
360 470 : gdcDesc->tail->next = p;
361 470 : gdcDesc->tail = p;
362 : }
363 474 : currLdc = p;
364 474 : } /* End of createNewLdcEvent */
365 :
366 : void loadBuffer( struct payloadDescriptorStruct * const payload ) {
367 : FILE *f;
368 : int bytesRead;
369 :
370 3242 : if ( (f = fopen( payload->fileName, "r" )) == NULL ) {
371 0 : fprintf( stderr,
372 : "%s: line:%d payload file \"%s\" not found or not readable, errno:%d. ",
373 0 : myName,
374 0 : lineNmb,
375 0 : payload->fileName,
376 0 : errno );
377 0 : perror( "System-dependent error " );
378 0 : exit( 1 );
379 : }
380 1621 : if ( (payload->data = malloc( payload->size )) == NULL ) {
381 0 : fprintf( stderr,
382 : "%s: line:%d Failed to malloc for payload file \"%s\" size:%d errno:%d ",
383 0 : myName,
384 0 : lineNmb,
385 0 : payload->fileName,
386 0 : payload->size,
387 0 : errno );
388 0 : perror( "System-dependent status " );
389 0 : exit( 1 );
390 : }
391 1621 : if ( (bytesRead = fread( payload->data, payload->fileSize, 1, f )) != 1 ) {
392 0 : fprintf( stderr,
393 : "%s: line:%d Failed to read payload file \"%s\" size:%d requested:1 got:%d feof:%s ferror:%s errno:%d ",
394 0 : myName,
395 0 : lineNmb,
396 0 : payload->fileName,
397 0 : payload->size,
398 : bytesRead,
399 0 : feof(f) ? "TRUE" : "false",
400 0 : ferror(f) ? "TRUE" : "false",
401 0 : errno );
402 0 : perror( "System-dependent status " );
403 0 : exit( 1 );
404 : }
405 1621 : fclose(f);
406 1621 : if ( payload->size != payload->fileSize ) {
407 0 : memset( (char *)payload->data + payload->fileSize,
408 : 0,
409 0 : payload->size - payload->fileSize );
410 0 : }
411 1621 : } /* End of loadBuffer */
412 :
413 : void unloadBuffer( struct payloadDescriptorStruct * const payload ) {
414 3242 : if ( payload->data != NULL ) {
415 1621 : free( payload->data );
416 1621 : payload->data = NULL;
417 1621 : }
418 1621 : } /* End of unloadBuffer */
419 :
420 : void unloadAllBuffers() {
421 : struct payloadDescriptorStruct *payload;
422 :
423 0 : for ( payload = payloadsHead; payload != NULL; payload = payload->next ) {
424 0 : unloadBuffer( payload );
425 : }
426 0 : } /* End of unloadAllBuffers */
427 :
428 : void loadPayload( const char *fileName ) {
429 : struct payloadDescriptorStruct *payload;
430 :
431 2630883 : for ( payload = payloadsHead; payload != NULL; payload = payload->next ) {
432 1313010 : if ( strcmp( fileName, payload->fileName ) == 0 )
433 : break;
434 : }
435 1621 : if ( payload == NULL ) {
436 : FILE *f;
437 :
438 3242 : if ( (payload = (struct payloadDescriptorStruct *)malloc( sizeof( *payload ) ))
439 1621 : == NULL ) {
440 0 : fprintf( stderr,
441 : "%s: failed to malloc for %d bytes (loadPayload/payloadDescriptorStruct)\n",
442 0 : myName,
443 : (int)sizeof( *payload ) );
444 0 : exit( 1 );
445 : }
446 1621 : if ( (payload->fileName = strdup( fileName )) == NULL ) {
447 0 : fprintf( stderr,
448 : "%s: failed to duplicate string \"%s\" (loadPaload/fileName)\n",
449 0 : myName,
450 : fileName );
451 0 : exit( 1 );
452 : }
453 1621 : if ( (f = fopen( fileName, "r" )) == NULL ) {
454 0 : fprintf( stderr,
455 : "%s: line:%d payload file \"%s\" not found or not readable, errno:%d. ",
456 0 : myName,
457 0 : lineNmb,
458 : fileName,
459 0 : errno );
460 0 : perror( "System-dependent error " );
461 0 : exit( 1 );
462 : }
463 1621 : if ( fseek( f, 0L, SEEK_END ) != 0 ) {
464 0 : fprintf( stderr,
465 : "%s: line:%d Failed to seek payload file \"%s\" errno:%d ",
466 0 : myName,
467 0 : lineNmb,
468 : fileName,
469 0 : errno );
470 0 : perror( "System-dependent error " );
471 0 : exit( 1 );
472 : }
473 1621 : if ( (payload->size = ftell( f )) <= 0 ) {
474 0 : fprintf( stderr,
475 : "%s: line:%d Failed to get file \"%s\" size size:%d errno:%d ",
476 0 : myName,
477 0 : lineNmb,
478 : fileName,
479 : payload->size,
480 0 : errno );
481 0 : perror( "System-dependent status " );
482 0 : exit( 1 );
483 : }
484 1621 : payload->fileSize = payload->size;
485 3242 : while ( (payload->size & 3) != 0 ) payload->size++;
486 1621 : fclose( f );
487 :
488 1621 : if ( bufferData ) {
489 0 : loadBuffer( payload );
490 0 : } else {
491 1621 : payload->data = NULL;
492 : }
493 :
494 1621 : payload->next = NULL;
495 1621 : if ( payloadsHead == NULL ) {
496 1 : payloadsHead = payloadsTail = payload;
497 1 : } else {
498 1620 : payloadsTail->next = payload;
499 1620 : payloadsTail = payload;
500 : }
501 1621 : DBG_VERBOSE {
502 : int b, n;
503 :
504 0 : printf( "%d) Payload \"%s\" loaded at %p\n",
505 0 : lineNmb,
506 : fileName,
507 0 : (void*)payload );
508 0 : if ( bufferData ) {
509 0 : if ( handleCDH &&
510 0 : strncmp(fileName,"TRG_",4) != 0 ) {
511 : struct commonDataHeaderStruct *cdh =
512 0 : (struct commonDataHeaderStruct *)payload->data;
513 :
514 0 : printf( " CDH: blockLenght:%d=0x%08x ",
515 0 : cdh->cdhBlockLength, cdh->cdhBlockLength );
516 0 : if ( cdh->cdhBlockLength < sizeof( *cdh ) ) {
517 0 : printf( "TOO SMALL (minimum:%ld=0x%08lx)\n",
518 : (unsigned long)sizeof( *cdh ),
519 : (unsigned long)sizeof( *cdh ) );
520 0 : } else {
521 0 : printf( "version:%d=0x%x ", cdh->cdhVersion, cdh->cdhVersion );
522 0 : if ( cdh->cdhVersion != CDH_VERSION ) {
523 0 : printf( "EXPECTED:%d=%x (decoding may be inaccurate) ",
524 : CDH_VERSION, CDH_VERSION );
525 0 : }
526 : }
527 0 : printf( "L1TriggerMessage:0x%x", cdh->cdhL1TriggerMessage );
528 0 : if ( cdh->cdhL1TriggerMessage != 0 ) {
529 0 : for ( b = 0, n = 0; b != 10; b++ ) {
530 0 : if ( (cdh->cdhL1TriggerMessage & (1<<b)) != 0 ) {
531 0 : if ( n++ != 0 )printf( "+" );
532 0 : switch (b) {
533 0 : case 0: printf( "L1SwC" ); break;
534 0 : case 1: printf( "ESR" ); break;
535 0 : case 2: printf( "RoC1" ); break;
536 0 : case 3: printf( "RoC2" ); break;
537 0 : case 4: printf( "RoC3" ); break;
538 0 : case 5: printf( "RoC4" ); break;
539 0 : case 6: printf( "ClT" ); break;
540 0 : default: printf( "spare %d", b+14 );
541 0 : }
542 : }
543 : }
544 0 : printf( ">" );
545 0 : }
546 0 : printf( " " );
547 0 : if ( cdh->cdhMBZ0 != 0 )
548 0 : printf( "MBZ0:0x%x ",
549 : cdh->cdhMBZ0 );
550 0 : printf( "\n" );
551 :
552 0 : printf( " " );
553 0 : printf( "EventId2(orbit):%d=0x%x ",
554 0 : cdh->cdhEventId2, cdh->cdhEventId2 );
555 0 : printf( "EventId1(bunchCrossing):%d=0x%x ",
556 0 : cdh->cdhEventId1, cdh->cdhEventId1 );
557 0 : printf( "\n" );
558 :
559 0 : printf( " " );
560 0 : if ( cdh->cdhMBZ1 != 0 )
561 0 : printf( "MBZ1:0x%x ",
562 : cdh->cdhMBZ1 );
563 0 : printf( "BlockAttributes:0x%x",
564 0 : cdh->cdhBlockAttributes );
565 0 : if ( cdh->cdhBlockAttributes != 0 ) {
566 0 : printf( "=<" );
567 0 : for ( b = 0, n = 0; b != 8; b++ ) {
568 0 : if ( (cdh->cdhBlockAttributes & (1<<b)) != 0 ) {
569 0 : if ( n++ != 0 )
570 0 : printf( "+" );
571 0 : printf( "%d", b );
572 0 : }
573 : }
574 0 : printf( ">" );
575 0 : }
576 0 : printf( " " );
577 0 : printf( "ParticipatingSubDetectors:0x%x ",
578 0 : cdh->cdhParticipatingSubDetectors );
579 0 : printf( "\n" );
580 0 : printf( " " );
581 :
582 0 : printf( "Status/Error:0x%x", cdh->cdhStatusErrorBits );
583 0 : if ( cdh->cdhStatusErrorBits != 0 ) {
584 0 : printf( "=<" );
585 0 : for ( b = 0,n = 0; b != 16; b++ ) {
586 0 : if ( (cdh->cdhStatusErrorBits & (1<<b)) != 0 ) {
587 0 : if ( n++ != 0 ) printf( "+" );
588 0 : switch (b) {
589 0 : case 0: printf( "TriggerOverLapError" ); break;
590 0 : case 1: printf( "TriggerMissingError" ); break;
591 0 : case 2: printf( "DataParityError" ); break;
592 0 : case 3: printf( "ControlParityError" ); break;
593 0 : case 4: printf( "TriggerInformationUnavailable" ); break;
594 0 : case 5: printf( "FEEError" ); break;
595 0 : case 6: printf( "HLTDecision" ); break;
596 0 : case 7: printf( "HLTPayload" ); break;
597 0 : case 8: printf( "DDGPayload" ); break;
598 0 : default: printf( "spare %d", b );
599 0 : }
600 : }
601 : }
602 0 : printf( ">" );
603 0 : }
604 0 : printf( " " );
605 0 : printf( "MiniEventId(bunchCrossing):%d=0x%x ",
606 0 : cdh->cdhMiniEventId, cdh->cdhMiniEventId );
607 0 : printf( "\n" );
608 :
609 0 : printf( " " );
610 0 : printf( "Trigger classes: 0x(%05x-%08x)",
611 0 : cdh->cdhTriggerClassesHigh,
612 0 : cdh->cdhTriggerClassesLow );
613 0 : if ( cdh->cdhTriggerClassesHigh != 0
614 0 : || cdh->cdhTriggerClassesLow != 0 ) {
615 0 : printf( "=<" );
616 0 : for ( b=0, n=0; b != 32; b++ ) {
617 0 : if ( (cdh->cdhTriggerClassesLow & (1<<b)) != 0 ) {
618 0 : if ( n++ != 0 ) printf( "+" );
619 0 : printf( "%d", b );
620 0 : }
621 : }
622 0 : for ( b=0; b != 18; b++ ) {
623 0 : if ( (cdh->cdhTriggerClassesHigh & (1<<b)) != 0 ) {
624 0 : if ( n++ != 0 ) printf( "+" );
625 0 : printf( "%d", b+32 );
626 0 : }
627 : }
628 0 : printf( ">" );
629 0 : }
630 0 : printf( "\n" );
631 :
632 0 : printf( " " );
633 0 : printf( "ROI:0x(%08x-%01x)", cdh->cdhRoiHigh, cdh->cdhRoiLow );
634 0 : if ( cdh->cdhRoiHigh != 0
635 0 : || cdh->cdhRoiLow != 0 ) {
636 0 : printf( "=<" );
637 0 : for ( b=0, n=0; b != 5; b++ ) {
638 0 : if ( (cdh->cdhRoiLow & (1<<b)) != 0 ) {
639 0 : if ( n++ != 0 ) printf( "+" );
640 0 : printf( "%d", b );
641 0 : }
642 : }
643 0 : for ( b=0; b != 32; b++ ) {
644 0 : if ( (cdh->cdhRoiHigh & (1<<b)) != 0 ) {
645 0 : if ( n++ != 0 ) printf( "+" );
646 0 : printf( "%d", b+4 );
647 0 : }
648 : }
649 0 : printf( ">" );
650 0 : }
651 0 : printf( "\n" );
652 0 : }
653 : }
654 0 : }
655 1621 : } else {
656 0 : DBG_VERBOSE
657 0 : printf( "%d) Payload \"%s\" already loaded at %p\n",
658 0 : lineNmb,
659 : fileName,
660 0 : (void*)payload );
661 : }
662 :
663 1621 : currEvent->payload = payload;
664 1621 : } /* End of loadPayload */
665 :
666 : void parseEquipment( char * const line ) {
667 : struct equipmentEventDescriptorStruct *equipment;
668 : int payloadFound = FALSE;
669 3242 : char *p;
670 : char *keyword;
671 :
672 1621 : if ( (equipment =
673 1621 : (struct equipmentEventDescriptorStruct *)malloc( sizeof( *equipment ) )) == NULL ) {
674 0 : fprintf( stderr,
675 : "%s: filed to malloc for %d bytes (parseEquipment/equipmentEventDescriptorStruct) errno:%d ",
676 0 : myName,
677 : (int)sizeof( *equipment ),
678 0 : errno );
679 0 : perror( "" );
680 0 : exit( 1 );
681 : }
682 1621 : currEvent = equipment;
683 :
684 1621 : p = line;
685 6484 : while ( (keyword = strtok_r( p, " \t", &p )) != NULL ) {
686 3242 : DBG_VERBOSE printf( "%d) Equipment - Keyword:\"%s\"\n",
687 0 : lineNmb,
688 : keyword );
689 3242 : if ( strcasecmp( "id", keyword ) == 0 ) {
690 : char *idNum;
691 :
692 1621 : if ( (idNum = strtok_r( p, " \t", &p )) == NULL ) {
693 0 : fprintf( stderr,
694 : "%s: line:%d EQUIPMENT declaration, ID needed",
695 0 : myName,
696 0 : lineNmb );
697 0 : exit( 1 );
698 : }
699 1621 : if ( sscanf( idNum, "%d", &currEquipmentId ) != 1 ) {
700 0 : fprintf( stderr,
701 : "%s: line:%d EQUIPMENT declaration, numeric ID needed (%s)",
702 0 : myName,
703 0 : lineNmb,
704 : idNum );
705 0 : exit( 1 );
706 : }
707 1621 : DBG_VERBOSE printf( "%d) EQUIPMENT - ID:%d\n",
708 0 : lineNmb,
709 0 : currEquipmentId );
710 3242 : } else if ( strncasecmp( "pay", keyword, 3 ) == 0 ) {
711 : char *fileName;
712 :
713 1621 : if ( (fileName = strtok_r( p, " \t", &p )) == NULL ) {
714 0 : fprintf( stderr,
715 : "%s line:%d Payload without filename found\n",
716 0 : myName,
717 0 : lineNmb );
718 0 : exit( 1 );
719 : }
720 1621 : DBG_VERBOSE printf( "%d) Equipment - Payload:\"%s\"\n",
721 0 : lineNmb,
722 : fileName );
723 1621 : if ( payloadFound ) {
724 0 : fprintf( stderr,
725 : "%s line:%d Payload with multiple filenames found\n",
726 0 : myName,
727 0 : lineNmb );
728 0 : exit( 1 );
729 : }
730 1621 : loadPayload( fileName );
731 : payloadFound = TRUE;
732 : } else {
733 0 : fprintf( stderr,
734 : "%s: line:%d Equipment declaration, unknown keyword \"%s\"\n",
735 0 : myName,
736 0 : lineNmb,
737 : keyword );
738 0 : exit( 1 );
739 : }
740 : }
741 1621 : if ( !payloadFound ) {
742 0 : fprintf( stderr,
743 : "%s: line:%d Equipment without payload found\n",
744 0 : myName,
745 0 : lineNmb );
746 0 : exit( 1 );
747 : }
748 :
749 1621 : equipment->id = currEquipmentId;
750 1621 : equipment->next = NULL;
751 3242 : if ( currLdc->head == NULL ) {
752 2095 : currLdc->head = currLdc->tail = equipment;
753 474 : } else {
754 1147 : currLdc->tail->next = equipment;
755 1147 : currLdc->tail = equipment;
756 : }
757 1621 : } /* End of parseEquipment */
758 :
759 : void parseGdc( char * const line ) {
760 8 : char *p;
761 : char *keyword;
762 :
763 4 : p = line;
764 16 : while ( (keyword = strtok_r( p, " \t", &p )) != NULL ) {
765 8 : if ( strcasecmp( "id", keyword ) == 0 ) {
766 : char *idNum;
767 :
768 0 : if ( (idNum = strtok_r( p, " \t", &p )) == NULL ) {
769 0 : fprintf( stderr,
770 : "%s: line:%d GDC declaration, ID needed",
771 0 : myName,
772 0 : lineNmb );
773 0 : exit( 1 );
774 : }
775 0 : int inCurrGdcId;
776 0 : if ( sscanf( idNum, "%d", &inCurrGdcId ) != 1 ) {
777 0 : fprintf( stderr,
778 : "%s: line:%d GDC declaration, numeric ID needed (%s)",
779 0 : myName,
780 0 : lineNmb,
781 : idNum );
782 0 : exit( 1 );
783 : }
784 0 : currGdcId = (eventGdcIdType)inCurrGdcId;
785 0 : DBG_VERBOSE printf( "%d) GDC - ID:%d\n",
786 0 : lineNmb,
787 : currGdcId );
788 8 : } else if ( strcasecmp( "DetectorPattern", keyword ) == 0 ) {
789 : char *detPattern;
790 :
791 4 : if ( (detPattern = strtok_r( p, " \t", &p )) == NULL ) {
792 0 : fprintf( stderr,
793 : "%s: line:%d GDC declaration, DetectorPattern needed",
794 0 : myName,
795 0 : lineNmb );
796 0 : exit( 1 );
797 : }
798 4 : if ( sscanf( detPattern, "%u", &currDetPattern ) != 1 ) {
799 0 : fprintf( stderr,
800 : "%s: line:%d GDC declaration, numeric DetectorPattern needed (%s)",
801 0 : myName,
802 0 : lineNmb,
803 : detPattern );
804 0 : exit( 1 );
805 : }
806 4 : DBG_VERBOSE printf( "%d) GDC - DetectorPattern:%u\n",
807 0 : lineNmb,
808 0 : currDetPattern );
809 8 : } else if ( strcasecmp( "Timestamp", keyword ) == 0 ) {
810 : char *timestamp;
811 :
812 4 : if ( (timestamp = strtok_r( p, " \t", &p )) == NULL ) {
813 0 : fprintf( stderr,
814 : "%s: line:%d GDC declaration, Timestamp needed",
815 0 : myName,
816 0 : lineNmb );
817 0 : exit( 1 );
818 : }
819 4 : if ( sscanf( timestamp, "%u", &currTimestamp ) != 1 ) {
820 0 : fprintf( stderr,
821 : "%s: line:%d GDC declaration, numeric Timestamp needed (%s)",
822 0 : myName,
823 0 : lineNmb,
824 : timestamp );
825 0 : exit( 1 );
826 : }
827 4 : DBG_VERBOSE printf( "%d) GDC - Timestamp:%u\n",
828 0 : lineNmb,
829 0 : currTimestamp );
830 : } else {
831 0 : fprintf( stderr,
832 : "%s: line:%d GDC declaration, unknown keyword \"%s\"\n",
833 0 : myName,
834 0 : lineNmb,
835 : keyword );
836 0 : exit( 1 );
837 : }
838 : }
839 4 : } /* End of parseGdc */
840 :
841 : void parseLdc( char * const line ) {
842 948 : char *p;
843 : char *keyword;
844 :
845 474 : p = line;
846 1896 : while ( (keyword = strtok_r( p, " \t", &p )) != NULL ) {
847 474 : if ( strcasecmp( "id", keyword ) == 0 ) {
848 : char *idNum;
849 :
850 474 : if ( (idNum = strtok_r( p, " \t", &p )) == NULL ) {
851 0 : fprintf( stderr,
852 : "%s: line:%d LDC declaration, ID needed",
853 0 : myName,
854 0 : lineNmb );
855 0 : exit( 1 );
856 : }
857 474 : int inCurrLdcId;
858 474 : if ( sscanf( idNum, "%d", &inCurrLdcId ) != 1 ) {
859 0 : fprintf( stderr,
860 : "%s: line:%d LDC declaration, numeric ID needed (%s)",
861 0 : myName,
862 0 : lineNmb,
863 : idNum );
864 0 : exit( 1 );
865 : }
866 474 : currLdcId = (eventLdcIdType)inCurrLdcId;
867 474 : DBG_VERBOSE printf( "%d) LDC - ID:%d\n",
868 0 : lineNmb,
869 : currLdcId );
870 474 : } else {
871 0 : fprintf( stderr,
872 : "%s: line:%d LDC declaration, unknown keyword \"%s\"\n",
873 0 : myName,
874 0 : lineNmb,
875 : keyword );
876 0 : exit( 1 );
877 : }
878 : }
879 474 : } /* End of parseLdc */
880 :
881 : void parseRules() {
882 2 : char line[ 1025 ];
883 :
884 1 : currLdcId = HOST_ID_MIN;
885 1 : currGdcId = HOST_ID_MIN;
886 1 : currDetPattern = 0;
887 1 : currTimestamp = 0;
888 :
889 4202 : for ( lineNmb = 1; !feof( stdin ); lineNmb++ ) {
890 2100 : getLine( line, sizeof(line) );
891 2100 : if ( strlen(line) != 0 ) {
892 2099 : char *p;
893 : char *keyword;
894 :
895 2099 : if ( (keyword = strtok_r( line, " \t", &p )) != NULL ) {
896 2099 : DBG_VERBOSE printf( "%d) Keyword:\"%s\"\n", lineNmb, keyword );
897 2099 : if ( strcasecmp( "gdc", keyword ) == 0 ) {
898 4 : if ( workingAs != gdc && workingAs != unknown ) {
899 0 : fprintf( stderr,
900 : "%s: line:%d GDC found when working in non-GDC mode (e.g. as a LDC)\n",
901 0 : myName, lineNmb );
902 0 : exit( 1 );
903 : }
904 4 : workingAs = gdc;
905 4 : parseGdc( p );
906 4 : createNewEvent();
907 4 : currLdcId = HOST_ID_MIN;
908 4 : currLdc = NULL;
909 4 : currEquipmentId = 0;
910 2099 : } else if ( strcasecmp( "ldc", keyword ) == 0 ) {
911 474 : if ( workingAs != gdc && workingAs != ldc && workingAs != unknown ) {
912 0 : fprintf( stderr,
913 : "%s: line:%d LDC found when working in non-LDC/GDC mode\n",
914 0 : myName, lineNmb );
915 0 : exit( 1 );
916 : }
917 474 : if ( workingAs == unknown ) workingAs = ldc;
918 474 : parseLdc( p );
919 474 : if ( workingAs == ldc ) {
920 0 : createNewEvent();
921 0 : currEquipmentId = 0;
922 0 : } else {
923 474 : createNewLdcEvent();
924 474 : handleLdc( currLdcId );
925 474 : currLdcId++;
926 : }
927 474 : currEvent = NULL;
928 2095 : } else if ( strncasecmp( "equ", keyword, 3 ) == 0 ) {
929 1621 : if ( workingAs == unknown
930 3242 : || (workingAs == ldc && currLdc == NULL )
931 1621 : || (workingAs == gdc && currGdc == NULL ) ) {
932 0 : fprintf( stderr,
933 : "%s: line:%d Unexpected EQUIPMENT declaration (LDC or GDC needed first)\n",
934 0 : myName,
935 0 : lineNmb );
936 0 : exit( 1 );
937 : }
938 1621 : parseEquipment( p );
939 1621 : currEquipmentId++;
940 : } else {
941 0 : fprintf( stderr,
942 : "%s: line:%d Parse error in \"%s\" unknown keyword\n",
943 0 : myName,
944 0 : lineNmb,
945 : keyword );
946 0 : exit( 1 );
947 : }
948 : }
949 2099 : }
950 1 : } while ( !feof( stdin ) ) {}
951 1 : lineNmb -= 2;
952 :
953 1 : DBG_VERBOSE {
954 0 : printf( "End of parse: %d line%s found\n",
955 : lineNmb,
956 0 : lineNmb != 1 ? "s" : "" );
957 0 : printf( "Working as %s\n",
958 0 : workingAs == gdc ? "GDC" :
959 0 : workingAs == ldc ? "LDC" :
960 : "UNKNOWN" );
961 0 : if ( workingAs == gdc ) {
962 : struct ldcDescriptorStruct *ldc;
963 :
964 0 : printf( "LDCs (%d):", numOfLdcs );
965 0 : for ( ldc = ldcsHead; ldc != NULL; ldc = ldc->next ) {
966 0 : printf( " %d", ldc->id );
967 : }
968 0 : printf( "\n" );
969 0 : }
970 0 : dumpEvents();
971 0 : }
972 :
973 1 : if ( workingAs == ldc ) {
974 0 : assert( ldcsHead == ldcsTail );
975 0 : assert( ldcsTail == NULL );
976 : }
977 :
978 1 : if ( workingAs == gdc ) {
979 : struct ldcDescriptorStruct *ldc;
980 :
981 1 : assert( ldcsHead != NULL );
982 1 : assert( ldcsTail != NULL );
983 1 : assert( ldcsTail->next == NULL );
984 246 : for ( ldc = ldcsHead; ldc->next != NULL; ldc = ldc->next ) {}
985 1 : assert ( ldc == ldcsTail );
986 1 : }
987 :
988 1 : if ( workingAs == unknown ) {
989 0 : DBG_VERBOSE printf( "Empty configuration: nothing to do!\n" );
990 0 : exit( 0 );
991 : }
992 :
993 3 : assert( (eventsHead == NULL && eventsTail == NULL)
994 : || (eventsHead != NULL && eventsTail != NULL) );
995 1 : } /* End of parseRules */
996 :
997 : void initEvent( struct eventHeaderStruct * const ev ) {
998 956 : memset( ev, 0, sizeof( *ev ) );
999 :
1000 478 : ev->eventMagic = EVENT_MAGIC_NUMBER;
1001 478 : ev->eventHeadSize = EVENT_HEAD_BASE_SIZE;
1002 478 : ev->eventVersion = EVENT_CURRENT_VERSION;
1003 478 : ev->eventRunNb = currRunNb;
1004 478 : ZERO_EVENT_ID( ev->eventId );
1005 478 : ZERO_TRIGGER_PATTERN( ev->eventTriggerPattern );
1006 478 : ZERO_DETECTOR_PATTERN( ev->eventDetectorPattern );
1007 478 : RESET_ATTRIBUTES( ev->eventTypeAttribute );
1008 478 : if ( workingMode == collider )
1009 478 : SET_SYSTEM_ATTRIBUTE( ev->eventTypeAttribute, ATTR_ORBIT_BC );
1010 478 : ev->eventLdcId = VOID_ID;
1011 478 : ev->eventGdcId = VOID_ID;
1012 478 : } /* End of initEvent */
1013 :
1014 : int Swap(int x)
1015 : {
1016 : // Swap the endianess of the integer value 'x'
1017 :
1018 0 : return (((x & 0x000000ffU) << 24) | ((x & 0x0000ff00U) << 8) |
1019 0 : ((x & 0x00ff0000U) >> 8) | ((x & 0xff000000U) >> 24));
1020 : }
1021 :
1022 : void outputEvent( const void * const ev,
1023 : const int size ) {
1024 : int done;
1025 :
1026 7440 : DBG_VERBOSE {
1027 0 : const long32 * const v = (long32 *)ev;
1028 0 : printf( "Writing %d bytes @ %p (%d)\n", size, ev, *v );
1029 0 : }
1030 :
1031 : // .............................Test endianess..............................
1032 : int temp = 1;
1033 : char* ptemp = (char*) &temp;
1034 :
1035 3720 : if (ptemp[0]!=1) { // Mac platform: ptemp != 1..............................................................................
1036 0 : int bufSize= size; if (bufSize > (int) sizeof(eventHeaderStruct)) { bufSize = sizeof(eventHeaderStruct); }
1037 0 : char* evTemp = (char*) malloc (bufSize);
1038 0 : memcpy(evTemp, ev, bufSize);
1039 :
1040 0 : if ((bufSize % sizeof(int)) != 0) {
1041 0 : fprintf( stderr, "%s: size of the input buffer ev is not multiple of 4 (size = %d)\n", myName, bufSize);
1042 0 : exit( 1 );
1043 : }
1044 : else {
1045 : // Invert header to evTemp.....................................................
1046 0 : int* buf = (int*) evTemp;
1047 0 : for (int i=0; i < (int) (bufSize / sizeof(int)); i++, buf++) {
1048 0 : int value = Swap(*buf);
1049 0 : memcpy(evTemp + (i * sizeof(int)), &value, sizeof(int));
1050 : }
1051 :
1052 : // Write inverted header to file...............................................
1053 0 : if ((done = fwrite( evTemp, bufSize, 1, outF )) != 1 ) {
1054 0 : fprintf( stderr, "%s: failed to write inverted header. event size:%d bytes, errno:%d (%s)\n", myName, size, errno, strerror( errno ) );
1055 0 : exit( 1 );
1056 : }
1057 :
1058 0 : if (size > bufSize) { // Still theraw-data payload to write (but not inverted, since it is inverted eariler).............
1059 0 : if ((done = fwrite( (char*)ev + bufSize, size - bufSize, 1, outF )) != 1 ) {
1060 0 : fprintf( stderr, "%s: failed to write additional event size:%d bytes, errno:%d (%s)\n", myName, size, errno, strerror( errno ) );
1061 0 : exit( 1 );
1062 : }
1063 : }
1064 : }
1065 0 : free(evTemp);
1066 0 : }
1067 : else { // Intel platform: ptemp == 1............................................................................
1068 3720 : if ((done = fwrite( ev, size, 1, outF )) != 1 ) {
1069 0 : fprintf( stderr, "%s: failed to write event size:%d bytes, errno:%d (%s)\n", myName, size, errno, strerror( errno ) );
1070 0 : exit( 1 );
1071 : }
1072 : }
1073 3720 : } /* End of outputEvent */
1074 :
1075 : void createSorAndEor( const int sor ) {
1076 4 : unsigned char event[ 1000 ];
1077 : struct eventHeaderStruct *ev;
1078 2 : struct eventHeaderStruct sev;
1079 :
1080 2 : assert( workingAs == ldc || workingAs == gdc );
1081 :
1082 4 : if ( !createSorEor ) return;
1083 0 : ev = (struct eventHeaderStruct *)event;
1084 0 : initEvent( ev );
1085 0 : ev->eventSize = sizeof( event );
1086 0 : ev->eventType = sor ? START_OF_RUN : END_OF_RUN;
1087 0 : if ( workingMode == fixedTarget )
1088 0 : LOAD_RAW_EVENT_ID( ev->eventId, 0, 0, 0 );
1089 : else
1090 0 : LOAD_EVENT_ID( ev->eventId, 0, 0, 0 );
1091 0 : SET_SYSTEM_ATTRIBUTE( ev->eventTypeAttribute, ATTR_P_START );
1092 :
1093 0 : if ( workingAs == ldc ) {
1094 0 : currLdc = (struct ldcEventDescriptorStruct *)eventsHead;
1095 0 : }
1096 0 : if ( workingAs == gdc ) {
1097 0 : initEvent( &sev );
1098 0 : sev.eventGdcId = currGdcId;
1099 0 : ev->eventGdcId = currGdcId;
1100 0 : currGdc = (struct gdcEventDescriptorStruct *)eventsHead;
1101 0 : currLdc = currGdc->head;
1102 0 : }
1103 0 : ev->eventLdcId = currLdc->id;
1104 :
1105 0 : if ( workingAs == ldc ) {
1106 0 : outputEvent( ev, ev->eventSize );
1107 0 : }
1108 0 : if ( workingAs == gdc ) {
1109 : struct ldcDescriptorStruct *ldc;
1110 :
1111 0 : sev.eventSize = sizeof( sev ) + numOfLdcs * ev->eventSize;
1112 0 : sev.eventType = sor ? START_OF_RUN : END_OF_RUN ;
1113 0 : COPY_EVENT_ID( ev->eventId, sev.eventId );
1114 0 : COPY_SYSTEM_ATTRIBUTES( ev->eventTypeAttribute, sev.eventTypeAttribute );
1115 0 : SET_SYSTEM_ATTRIBUTE( sev.eventTypeAttribute, ATTR_SUPER_EVENT );
1116 0 : outputEvent( &sev, sizeof( sev ) );
1117 :
1118 0 : ev->eventGdcId = currGdcId;
1119 0 : for ( ldc = ldcsHead; ldc != NULL; ldc = ldc->next ) {
1120 0 : ev->eventLdcId = ldc->id;
1121 0 : outputEvent( ev, ev->eventSize );
1122 : }
1123 0 : }
1124 :
1125 0 : ADD_EVENT_ID( ev->eventId, oneEventDelta );
1126 0 : ev->eventSize = ev->eventSize / 2;
1127 0 : ev->eventType = sor ? START_OF_RUN_FILES : END_OF_RUN_FILES;
1128 0 : CLEAR_SYSTEM_ATTRIBUTE( ev->eventTypeAttribute, ATTR_P_START );
1129 0 : if ( workingAs == ldc ) {
1130 0 : outputEvent( ev, ev->eventSize );
1131 0 : }
1132 0 : if ( workingAs == gdc ) {
1133 : struct ldcDescriptorStruct *ldc;
1134 :
1135 0 : sev.eventSize = ev->eventSize;
1136 0 : sev.eventType = sor ? START_OF_RUN_FILES : END_OF_RUN_FILES;
1137 0 : COPY_EVENT_ID( ev->eventId, sev.eventId );
1138 0 : COPY_SYSTEM_ATTRIBUTES( ev->eventTypeAttribute, sev.eventTypeAttribute );
1139 0 : CLEAR_SYSTEM_ATTRIBUTE( sev.eventTypeAttribute, ATTR_SUPER_EVENT );
1140 0 : outputEvent( &sev, sizeof( sev ) );
1141 0 : outputEvent( ev, ev->eventSize - sizeof( sev ) );
1142 :
1143 0 : sev.eventSize = sizeof( sev ) + ev->eventSize;
1144 0 : sev.eventType = sor ? START_OF_RUN_FILES : END_OF_RUN_FILES;
1145 0 : COPY_EVENT_ID( ev->eventId, sev.eventId );
1146 0 : COPY_SYSTEM_ATTRIBUTES( ev->eventTypeAttribute, sev.eventTypeAttribute );
1147 0 : SET_SYSTEM_ATTRIBUTE( sev.eventTypeAttribute, ATTR_SUPER_EVENT );
1148 :
1149 0 : ev->eventGdcId = currGdcId;
1150 0 : for ( ldc = ldcsHead; ldc != NULL; ldc = ldc->next ) {
1151 0 : outputEvent( &sev, sizeof( sev ) );
1152 0 : ev->eventLdcId = ldc->id;
1153 0 : outputEvent( ev, ev->eventSize );
1154 : }
1155 0 : }
1156 :
1157 0 : ADD_EVENT_ID( ev->eventId, oneEventDelta );
1158 0 : ev->eventSize = sizeof( *ev );
1159 0 : ev->eventType = sor ? START_OF_RUN : END_OF_RUN;
1160 0 : SET_SYSTEM_ATTRIBUTE( ev->eventTypeAttribute, ATTR_P_END );
1161 0 : if ( workingAs == ldc ) {
1162 0 : outputEvent( ev, ev->eventSize );
1163 0 : }
1164 0 : if ( workingAs == gdc ) {
1165 : struct ldcDescriptorStruct *ldc;
1166 :
1167 0 : sev.eventSize = sizeof( sev ) + numOfLdcs * ev->eventSize;
1168 0 : sev.eventType = sor ? START_OF_RUN : END_OF_RUN;
1169 0 : COPY_EVENT_ID( ev->eventId, sev.eventId );
1170 0 : COPY_SYSTEM_ATTRIBUTES( ev->eventTypeAttribute, sev.eventTypeAttribute );
1171 0 : SET_SYSTEM_ATTRIBUTE( sev.eventTypeAttribute, ATTR_SUPER_EVENT );
1172 :
1173 0 : outputEvent( &sev, sizeof( sev ) );
1174 :
1175 0 : for ( ldc = ldcsHead; ldc != NULL; ldc = ldc->next ) {
1176 0 : ev->eventLdcId = ldc->id;
1177 0 : outputEvent( ev, ev->eventSize );
1178 : }
1179 0 : }
1180 2 : } /* End of createSorEor */
1181 :
1182 : void createSor() {
1183 2 : createSorAndEor( TRUE );
1184 1 : } /* End of createSor */
1185 :
1186 : void createEor() {
1187 2 : createSorAndEor( FALSE );
1188 1 : } /* End of createEor */
1189 :
1190 : void loadCdh( struct commonDataHeaderStruct * const cdh,
1191 : eventIdType * const eventId,
1192 : equipmentIdType id ) {
1193 4863 : if ( !handleCDH ) return;
1194 :
1195 : // CTP raw-data does not contain CDH
1196 1621 : if ( id == 4352) return;
1197 :
1198 1617 : if ( gotAliceTrigger ) {
1199 0 : cdh->cdhEventId1 = EVENT_ID_GET_BUNCH_CROSSING( *eventId );
1200 0 : cdh->cdhEventId2 = EVENT_ID_GET_ORBIT( *eventId );
1201 0 : } else {
1202 1617 : cdh->cdhEventId1 = 0;
1203 1617 : cdh->cdhEventId2 = EVENT_ID_GET_NB_IN_RUN( *eventId );
1204 : }
1205 1617 : cdh->cdhMiniEventId = cdh->cdhEventId1;
1206 3238 : }
1207 : void decodeCDH( struct ldcEventDescriptorStruct * const ldc,
1208 : const struct payloadDescriptorStruct * const payloadDesc,
1209 : equipmentIdType id );
1210 :
1211 : void createEvent( void ) {
1212 8 : assert( workingAs == ldc || workingAs == gdc );
1213 :
1214 : /* Step 1: load all buffers (if needed) and compose the GDC/LDC headers */
1215 4 : if ( workingAs == gdc ) {
1216 : struct ldcEventDescriptorStruct *ldc;
1217 :
1218 956 : for( ldc = currGdc->head; ldc != NULL; ldc = ldc->next ) {
1219 474 : COPY_EVENT_ID( currEventId, ldc->header.eventId );
1220 : }
1221 4 : COPY_EVENT_ID( currEventId, currGdc->header.eventId );
1222 :
1223 956 : for( ldc = currGdc->head; ldc != NULL; ldc = ldc->next ) {
1224 : struct equipmentEventDescriptorStruct *eq;
1225 : int n;
1226 :
1227 4190 : for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
1228 1621 : if ( !bufferData ) {
1229 1621 : loadBuffer( eq->payload );
1230 1621 : decodeCDH( ldc, eq->payload, eq->id );
1231 1621 : }
1232 3242 : loadCdh( (struct commonDataHeaderStruct*)eq->payload->data,
1233 : &currEventId,
1234 1621 : eq->id);
1235 : }
1236 :
1237 474 : if ( !currGdc->loaded ) {
1238 40 : for ( n = 0; n != EVENT_TRIGGER_PATTERN_WORDS; n++ )
1239 16 : currGdc->header.eventTriggerPattern[n] |= ldc->header.eventTriggerPattern[n];
1240 16 : for ( n = 0; n != EVENT_DETECTOR_PATTERN_WORDS; n++ )
1241 4 : currGdc->header.eventDetectorPattern[n] |= ldc->header.eventDetectorPattern[n];
1242 32 : for ( n = 0; n != ALL_ATTRIBUTE_WORDS; n++ )
1243 12 : currGdc->header.eventTypeAttribute[n] |= ldc->header.eventTypeAttribute[n];
1244 4 : currGdc->loaded = TRUE;
1245 4 : }
1246 : }
1247 4 : cdhRef = NULL;
1248 4 : } else if ( workingAs == ldc ) {
1249 : struct equipmentEventDescriptorStruct *eq;
1250 :
1251 0 : COPY_EVENT_ID( currEventId, currLdc->header.eventId );
1252 :
1253 0 : for ( eq = currLdc->head; eq != NULL; eq = eq->next ) {
1254 0 : if ( !bufferData ) {
1255 0 : loadBuffer( eq->payload );
1256 0 : decodeCDH( currLdc, eq->payload, eq->id );
1257 0 : }
1258 0 : loadCdh( (struct commonDataHeaderStruct*)eq->payload->data,
1259 : &currEventId,
1260 0 : eq->id);
1261 0 : currLdc->loaded = TRUE;
1262 : }
1263 0 : cdhRef = NULL;
1264 0 : }
1265 4 : ADD_EVENT_ID( currEventId, oneEventDelta );
1266 :
1267 : /* Step 2: output the event */
1268 4 : if ( workingAs == gdc ) {
1269 : struct ldcEventDescriptorStruct *ldc;
1270 :
1271 4 : outputEvent( &currGdc->header, sizeof( currGdc->header ) );
1272 :
1273 956 : for( ldc = currGdc->head; ldc != NULL; ldc = ldc->next ) {
1274 : struct equipmentEventDescriptorStruct *eq;
1275 :
1276 474 : outputEvent( &ldc->header, sizeof( ldc->header ) );
1277 :
1278 4190 : for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
1279 1621 : outputEvent( &eq->header, sizeof( eq->header ) );
1280 1621 : outputEvent( eq->payload->data, eq->payload->size );
1281 3242 : if ( !bufferData ) unloadBuffer( eq->payload );
1282 : }
1283 : }
1284 4 : if ( (currGdc = currGdc->next) == NULL )
1285 1 : currGdc = (struct gdcEventDescriptorStruct *)eventsHead;
1286 4 : } else if ( workingAs == ldc ) {
1287 : struct equipmentEventDescriptorStruct *eq;
1288 :
1289 0 : outputEvent( &currLdc->header, sizeof( currLdc->header ) );
1290 :
1291 0 : for ( eq = currLdc->head; eq != NULL; eq = eq->next ) {
1292 0 : outputEvent( &eq->header, sizeof( eq->header ) );
1293 0 : outputEvent( eq->payload->data, eq->payload->size );
1294 0 : if ( !bufferData ) unloadBuffer( eq->payload );
1295 : }
1296 0 : if ( (currLdc = currLdc->next) == NULL )
1297 0 : currLdc = (struct ldcEventDescriptorStruct *)eventsHead;
1298 0 : }
1299 4 : } /* End of createEvent */
1300 :
1301 : void createEvents() {
1302 : int eventNum = 0;
1303 :
1304 2 : currGdc = (struct gdcEventDescriptorStruct *)eventsHead;
1305 1 : currLdc = (struct ldcEventDescriptorStruct *)eventsHead;
1306 1 : currEvent = NULL;
1307 :
1308 1 : createSor();
1309 10 : for ( eventNum = 0;
1310 5 : eventNum != numOfEvents && numOfEvents != 0;
1311 4 : eventNum++ ) {
1312 4 : createEvent();
1313 : }
1314 1 : createEor();
1315 1 : } /* End of createEvents */
1316 :
1317 : int usage() {
1318 0 : fprintf( stderr,
1319 : "Usage: %s [-?][-d][-i definitionFile][-o outputFile][-# numOfEvents][-s][-F|-C]\n\
1320 : -? This text\n\
1321 : -v Print version ID and exit\n\
1322 : -d Enable debug (repeat for more verbosity)\n\
1323 : -i definitionFile File with the description of the events to create (default: stdin)\n\
1324 : -o outputFile File used to store events (default: stdout)\n\
1325 : -# numOfEvents Number of events to generate (default: 1 event)\n\
1326 : -s Do not generate SOR/EOR files (valid only for GDCs)\n\
1327 : -F/-C Working in Fixed Target (F) or Collider (C) mode\n\
1328 : -c Handles CDH\n\
1329 : -D Direct disc access (no buffering)\n",
1330 0 : myName );
1331 0 : return 1;
1332 : } /* End of usage */
1333 :
1334 : void parseArgs( int argc, char **argv ) {
1335 : int arg = 1;
1336 : int inFileName = -1;
1337 : int outFileName = -1;
1338 :
1339 2 : myName = argv[0] ;
1340 16 : while ( arg < argc ) {
1341 7 : if ( strcmp( "-?", argv[ arg ] ) == 0 ) {
1342 0 : usage();
1343 0 : exit( 0 );
1344 : }
1345 7 : if ( strcmp( "-i", argv[ arg ] ) == 0 ) {
1346 0 : if ( ++arg == argc ) exit( usage() );
1347 : inFileName = arg;
1348 0 : if ( freopen( argv[arg], "r", stdin ) == NULL ){
1349 0 : fprintf( stderr,
1350 : "%s: failed to open input definition \"%s\" errno:%d ",
1351 0 : myName, argv[arg], errno );
1352 0 : perror( "" );
1353 0 : exit( 1 );
1354 : }
1355 7 : } else if ( strcmp( "-v", argv[ arg ] ) == 0 ) {
1356 0 : printf( "%s\n", fileHandlerIdent );
1357 0 : exit( 0 );
1358 7 : } else if ( strcmp( "-o", argv[ arg ] ) == 0 ) {
1359 1 : if ( ++arg == argc ) exit( usage() );
1360 : outFileName = arg;
1361 7 : } else if ( strcmp( "-#", argv[ arg ] ) == 0 ) {
1362 1 : int n;
1363 :
1364 1 : if ( ++arg == argc ) exit( usage() );
1365 1 : if ( sscanf( argv[ arg ], "%d", &n ) != 1 ) exit( usage() );
1366 1 : if ( n < 0 ) exit( usage() );
1367 1 : numOfEvents = n;
1368 6 : } else if ( strcmp( "-s", argv[ arg ] ) == 0 ) {
1369 1 : createSorEor = FALSE;
1370 5 : } else if ( strcmp( "-F", argv[ arg ] ) == 0 ) {
1371 0 : workingMode = fixedTarget;
1372 4 : } else if ( strcmp( "-C", argv[ arg ] ) == 0 ) {
1373 1 : workingMode = collider;
1374 4 : } else if ( strcmp( "-d", argv[ arg ] ) == 0 ) {
1375 0 : debug++;
1376 3 : } else if ( strcmp( "-c", argv[ arg ] ) == 0 ) {
1377 1 : handleCDH = TRUE;
1378 3 : } else if ( strcmp( "-D", argv[ arg ] ) == 0 ) {
1379 1 : bufferData = FALSE;
1380 2 : } else if ( strcmp( "-run", argv[ arg ] ) == 0 ) {
1381 1 : int runnumber;
1382 1 : if ( ++arg == argc ) exit( usage() );
1383 1 : if ( sscanf( argv[ arg ], "%d", &runnumber ) != 1 ) exit( usage() );
1384 1 : if ( runnumber < 0 ) exit( usage() );
1385 1 : currRunNb = runnumber;
1386 1 : } else {
1387 0 : fprintf( stderr, "%s: Unknown switch \"%s\"\n", myName, argv[argc] );
1388 0 : exit( usage() );
1389 : }
1390 7 : arg++;
1391 : }
1392 :
1393 1 : if ( workingMode == fixedTarget )
1394 0 : LOAD_RAW_EVENT_ID( oneEventDelta, 1, 0, 1 );
1395 : else
1396 1 : LOAD_EVENT_ID( oneEventDelta, 0, 0, 1 );
1397 1 : ZERO_EVENT_ID( currEventId );
1398 :
1399 1 : DBG_VERBOSE {
1400 0 : printf( "Configuration:\n" );
1401 0 : printf( " Debug level: %d\n", debug );
1402 0 : printf( " Configuration: %s\n",
1403 0 : inFileName == -1 ? "stdin" : argv[ inFileName ] );
1404 0 : printf( " Output: %s\n",
1405 0 : outFileName == -1 ? "stdout" : argv[ outFileName ] );
1406 0 : printf( " Working mode: %s\n",
1407 0 : workingMode == fixedTarget ? "fixed target" : "collider" );
1408 0 : printf( " Number of events: %d\n", numOfEvents );
1409 0 : printf( " %s SOR/EOR files\n",
1410 0 : createSorEor ? "Create" : "Do not create" );
1411 0 : printf( " CDH handling: %s\n",
1412 0 : handleCDH ? "enabled" : "disabled" );
1413 0 : printf( " data buffering: %s\n",
1414 0 : bufferData ? "enabled" : "DISABLED" );
1415 0 : }
1416 :
1417 1 : if ( outFileName == -1 ) {
1418 0 : DBG_BASE
1419 0 : printf( "No more trace information from this point...\n" );
1420 0 : debug = 0;
1421 0 : outF = stdout;
1422 0 : } else {
1423 1 : if ( ( outF = fopen( argv[ outFileName ], "w" ) ) == NULL ) {
1424 0 : fprintf( stderr,
1425 : "%s: failed to open output file \"%s\" for writing, errno:%d (%s)\n",
1426 0 : myName,
1427 0 : argv[ outFileName ],
1428 0 : errno,
1429 0 : strerror( errno ) );
1430 0 : exit( 1 );
1431 : }
1432 1 : DBG_DETAILED
1433 0 : printf( "Output file \"%s\" opened OK for writing\n",
1434 0 : argv[ outFileName ] );
1435 : }
1436 1 : } /* End of parseArgs */
1437 : void initEquipment( struct equipmentHeaderStruct * const eq ) {
1438 3242 : memset( eq, 0, sizeof( *eq ) );
1439 1621 : RESET_ATTRIBUTES( eq->equipmentTypeAttribute );
1440 1621 : eq->equipmentBasicElementSize = 4;
1441 1621 : } /* End of initEquipment */
1442 :
1443 : void decodeCDH( struct ldcEventDescriptorStruct * const ldc,
1444 : const struct payloadDescriptorStruct * const payloadDesc,
1445 : equipmentIdType id ) {
1446 9726 : if ( handleCDH &&
1447 3242 : id != 4352 ) {
1448 : struct commonDataHeaderStruct *cdh;
1449 : static int softwareTriggerIndicator = FALSE;
1450 : int attr;
1451 : int trig;
1452 :
1453 3234 : if ( payloadDesc->size < CDH_SIZE ) {
1454 0 : fprintf( stderr,
1455 : "%s: payload too small got:%d CDH:%d\n",
1456 0 : myName,
1457 : payloadDesc->size,
1458 : CDH_SIZE );
1459 0 : exit( 1 );
1460 : }
1461 3234 : if ( (cdh = (struct commonDataHeaderStruct *)payloadDesc->data) != NULL ) {
1462 1617 : if ( cdh->cdhVersion != CDH_VERSION ) {
1463 0 : fprintf( stderr,
1464 : "%s: CDH version mismatch expected:%d got:%d\n",
1465 0 : myName,
1466 : CDH_VERSION,
1467 : cdh->cdhVersion );
1468 0 : exit( 1 );
1469 : }
1470 1617 : if ( cdhRef == NULL ) {
1471 4 : cdhRef = cdh;
1472 : #define CDH_TRIGGER_INFORMATION_UNAVAILABLE_MASK (1<<CDH_TRIGGER_INFORMATION_UNAVAILABLE_BIT)
1473 4 : gotAliceTrigger = (cdhRef->cdhStatusErrorBits & CDH_TRIGGER_INFORMATION_UNAVAILABLE_MASK) == 0;
1474 4 : if ( gotAliceTrigger && workingMode == fixedTarget ) {
1475 0 : fprintf( stderr,
1476 : "%s: ALICE trigger and fixed target mode are not compatible.\n\
1477 : Either work in Collider mode or set the trigger unavailable status bit in the CDH.\n",
1478 0 : myName );
1479 0 : exit( 1 );
1480 : }
1481 4 : if ( gotAliceTrigger ) {
1482 0 : if ( (cdh->cdhL1TriggerMessage & 0x40) != 0 ) {
1483 0 : fprintf( stderr,
1484 : "%s: CDH is a calibration trigger (unsupported) L1TriggerMessage:0x%x\n",
1485 0 : myName, cdh->cdhL1TriggerMessage );
1486 0 : exit( 1 );
1487 : }
1488 0 : if ( (cdh->cdhL1TriggerMessage & 0x01) != 0 ) {
1489 0 : softwareTriggerIndicator = TRUE;
1490 0 : }
1491 0 : if ( softwareTriggerIndicator ) {
1492 0 : switch ((cdh->cdhL1TriggerMessage >> 2) & 0xF) {
1493 : case 0xC:
1494 : case 0xB:
1495 : case 0xA:
1496 : case 0x9:
1497 : break;
1498 : case 0xD:
1499 : /* L1SwC bit = on, Clt bit = off, RoC[4..1] = 0xD --> SYNC */
1500 : case 0xF:
1501 : /* L1SwC bit = on, Clt bit = off, RoC[4..1] = 0xF --> END_OF_DATA */
1502 : case 0xE:
1503 : /* L1SwC bit = on, Clt bit = off, RoC[4..1] = 0xE0 --> START_OF_DATA */
1504 : case 0x8:
1505 : /* L1SwC bit = on, Clt bit = off, RoC[4] = 1, but not 0xE or 0xF
1506 : --> SYSTEM_SOFTWARE_TRIGGER_EVENT */
1507 : default:
1508 : /* L1SwC bit = on, Clt bit = off, RoC[4] = 0
1509 : --> DETECTOR_SOFTWARE_TRIGGER_EVENT */
1510 0 : fprintf( stderr,
1511 : "%s: CDH trigger SOD/EOD/SST/DST/SYNC (unsupported) \
1512 : L1TriggerMessage:0x%x ALICETrigger:%s\n",
1513 0 : myName,
1514 : cdh->cdhL1TriggerMessage,
1515 0 : gotAliceTrigger ? "yes" : "no" );
1516 0 : exit( 1 );
1517 : }
1518 : }
1519 : }
1520 : } else {
1521 3226 : if ( (cdh->cdhStatusErrorBits & CDH_TRIGGER_INFORMATION_UNAVAILABLE_MASK) !=
1522 1613 : (cdhRef->cdhStatusErrorBits & CDH_TRIGGER_INFORMATION_UNAVAILABLE_MASK) ) {
1523 0 : fprintf( stderr,
1524 : "%s: CDH coherency check failed. \
1525 : Trigger information reference:%savailable current:%savailable\n",
1526 0 : myName,
1527 0 : (cdhRef->cdhStatusErrorBits & CDH_TRIGGER_INFORMATION_UNAVAILABLE_MASK) == 0 ? "UN" : "",
1528 0 : (cdh->cdhStatusErrorBits & CDH_TRIGGER_INFORMATION_UNAVAILABLE_MASK) == 0 ? "UN" : "" );
1529 0 : exit( 1 );
1530 : }
1531 1613 : if ( gotAliceTrigger ) {
1532 0 : if ( cdhRef->cdhL1TriggerMessage != cdh->cdhL1TriggerMessage ) {
1533 0 : fprintf( stderr,
1534 : "%s: CDH coherency check failed. \
1535 : L1 trigger message reference:0x%x current:0x%x\n",
1536 0 : myName,
1537 : cdhRef->cdhL1TriggerMessage,
1538 : cdh->cdhL1TriggerMessage );
1539 0 : exit( 1 );
1540 : }
1541 0 : if ( cdh->cdhParticipatingSubDetectors != cdhRef->cdhParticipatingSubDetectors ) {
1542 0 : fprintf( stderr,
1543 : "%s: CDH coherency check failed. \
1544 : ParticipatingSubDetectors reference:0x%x current:0x%x\n",
1545 0 : myName,
1546 : cdhRef->cdhParticipatingSubDetectors,
1547 : cdh->cdhParticipatingSubDetectors );
1548 0 : exit( 1 );
1549 : }
1550 0 : if ( cdh->cdhTriggerClassesLow != cdhRef->cdhTriggerClassesLow
1551 0 : || cdh->cdhTriggerClassesHigh != cdhRef->cdhTriggerClassesHigh ) {
1552 0 : fprintf( stderr,
1553 : "%s: CDH coherency check failed. \
1554 : TriggerClassesHigh/Low reference:0x%x-%x current:0x%x-%x\n",
1555 0 : myName,
1556 0 : cdhRef->cdhTriggerClassesHigh, cdhRef->cdhTriggerClassesLow,
1557 0 : cdh ->cdhTriggerClassesHigh, cdh ->cdhTriggerClassesLow );
1558 0 : exit( 1 );
1559 : }
1560 0 : if ( cdh->cdhBlockLength != 0xffffffff ) {
1561 0 : if ( (unsigned)payloadDesc->size != cdh->cdhBlockLength ) {
1562 0 : fprintf( stderr,
1563 : "%s: CDH coherency check failed. \
1564 : Payload size:%d (0x%08x) CDH block length:%d (0x%08x)\n",
1565 0 : myName,
1566 : payloadDesc->size, payloadDesc->size,
1567 : cdh->cdhBlockLength, cdh->cdhBlockLength );
1568 0 : exit( 1 );
1569 : }
1570 : }
1571 0 : if ( cdh->cdhRoiLow != cdhRef->cdhRoiLow
1572 0 : || cdh->cdhRoiHigh != cdhRef->cdhRoiHigh ) {
1573 0 : fprintf( stderr,
1574 : "%s: CDH coherency check failed. \
1575 : RoiHigh/Low reference:0x%x-%x current:0x%x-%x\n",
1576 0 : myName,
1577 0 : cdhRef->cdhRoiHigh, cdhRef->cdhRoiLow,
1578 0 : cdh ->cdhRoiHigh, cdh ->cdhRoiLow );
1579 0 : exit( 1 );
1580 : }
1581 : }
1582 3226 : if ( cdh->cdhMBZ0 != 0
1583 3226 : || cdh->cdhMBZ1 != 0
1584 3226 : || cdh->cdhMBZ4 != 0 ) {
1585 0 : fprintf( stderr,
1586 : "%s: CDH check failed. MBZ0:0x%x MBZ1:0x%x MBZ4:0x%x\n",
1587 0 : myName,
1588 0 : cdh->cdhMBZ0, cdh->cdhMBZ1, cdh->cdhMBZ4 );
1589 0 : exit( 1 );
1590 : }
1591 : }
1592 29106 : for ( attr = 0; attr != 8; attr++ ) {
1593 12936 : if ( (cdh->cdhBlockAttributes & (1<<attr)) != 0 ) {
1594 4148 : SET_USER_ATTRIBUTE( ldc->header.eventTypeAttribute, attr );
1595 2074 : }
1596 : }
1597 106722 : for ( trig = 0; trig != 32; trig++ ) {
1598 51744 : if ( (cdh->cdhTriggerClassesLow & (1<<trig)) != 0 ) {
1599 27474 : SET_TRIGGER_IN_PATTERN( ldc->header.eventTriggerPattern,
1600 : trig );
1601 13737 : }
1602 : }
1603 61446 : for ( trig = 0; trig != 18; trig++ ) {
1604 29106 : if ( (cdh->cdhTriggerClassesMiddleLow & (1<<trig)) != 0 ) {
1605 0 : SET_TRIGGER_IN_PATTERN( ldc->header.eventTriggerPattern,
1606 : 32+trig );
1607 0 : }
1608 : }
1609 106722 : for ( trig = 0; trig != 32; trig++ ) {
1610 51744 : if ( (cdh->cdhTriggerClassesMiddleHigh & (1<<trig)) != 0 ) {
1611 0 : SET_TRIGGER_IN_PATTERN( ldc->header.eventTriggerPattern,
1612 : 18+32+trig );
1613 0 : }
1614 : }
1615 61446 : for ( trig = 0; trig != 18; trig++ ) {
1616 29106 : if ( (cdh->cdhTriggerClassesHigh & (1<<trig)) != 0 ) {
1617 0 : SET_TRIGGER_IN_PATTERN( ldc->header.eventTriggerPattern,
1618 : 32+18+32+trig );
1619 0 : }
1620 : }
1621 1617 : if ( gotAliceTrigger )
1622 0 : VALIDATE_TRIGGER_PATTERN( ldc->header.eventTriggerPattern );
1623 : }
1624 3234 : }
1625 3242 : } /* End of decodeCDH */
1626 :
1627 : void initEvents() {
1628 2 : assert( workingAs == ldc || workingAs == gdc );
1629 :
1630 1 : if ( workingAs == gdc ) {
1631 : struct gdcEventDescriptorStruct *gdc;
1632 :
1633 10 : for ( gdc = (struct gdcEventDescriptorStruct *)eventsHead;
1634 5 : gdc != NULL;
1635 4 : gdc = gdc->next ) {
1636 : struct ldcEventDescriptorStruct *ldc;
1637 :
1638 4 : initEvent( &gdc->header );
1639 4 : gdc->header.eventSize = gdc->header.eventHeadSize;
1640 4 : gdc->header.eventType = PHYSICS_EVENT;
1641 4 : SET_SYSTEM_ATTRIBUTE( gdc->header.eventTypeAttribute, ATTR_SUPER_EVENT );
1642 4 : gdc->header.eventGdcId = currGdcId;
1643 4 : COPY_DETECTOR_PATTERN(&gdc->detPattern, gdc->header.eventDetectorPattern);
1644 4 : gdc->header.eventTimestamp = gdc->timestamp;
1645 956 : for ( ldc = gdc->head; ldc != NULL; ldc = ldc->next ) {
1646 : struct equipmentEventDescriptorStruct *eq;
1647 :
1648 474 : initEvent( &ldc->header );
1649 474 : ldc->header.eventSize = ldc->header.eventHeadSize;
1650 474 : ldc->header.eventType = PHYSICS_EVENT;
1651 474 : ldc->header.eventGdcId = currGdcId;
1652 474 : COPY_DETECTOR_PATTERN(&ldc->detPattern, ldc->header.eventDetectorPattern);
1653 474 : ldc->header.eventTimestamp = ldc->timestamp;
1654 474 : ldc->header.eventLdcId = ldc->id;
1655 4190 : for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
1656 1621 : initEquipment( &eq->header );
1657 1621 : eq->header.equipmentId = eq->id;
1658 1621 : if ( workingMode == collider )
1659 1621 : SET_SYSTEM_ATTRIBUTE( eq->header.equipmentTypeAttribute,
1660 : ATTR_ORBIT_BC );
1661 1621 : eq->header.equipmentSize = eq->payload->size + sizeof( eq->header );
1662 1621 : ldc->header.eventSize += eq->header.equipmentSize;
1663 1621 : decodeCDH( ldc, eq->payload, eq->id );
1664 1621 : OR_ALL_ATTRIBUTES( eq->header.equipmentTypeAttribute,
1665 : ldc->header.eventTypeAttribute );
1666 1621 : OR_ALL_ATTRIBUTES( eq->header.equipmentTypeAttribute,
1667 : gdc->header.eventTypeAttribute );
1668 : }
1669 474 : gdc->header.eventSize += ldc->header.eventSize;
1670 : }
1671 4 : cdhRef = NULL;
1672 : }
1673 :
1674 1 : DBG_VERBOSE {
1675 0 : printf( "Headers:\n" );
1676 0 : for ( gdc = (struct gdcEventDescriptorStruct *)eventsHead;
1677 0 : gdc != NULL;
1678 0 : gdc = gdc->next ) {
1679 : struct ldcEventDescriptorStruct *ldc;
1680 :
1681 0 : printf( " GDC:%d size:%d vers:%08x\n",
1682 0 : currGdcId,
1683 0 : gdc->header.eventSize,
1684 0 : gdc->header.eventVersion);
1685 0 : for ( ldc = gdc->head; ldc != NULL; ldc = ldc->next ) {
1686 : struct equipmentEventDescriptorStruct *eq;
1687 :
1688 0 : printf( " LDC:%d size:%d vers:%08x\n",
1689 0 : ldc->id,
1690 0 : ldc->header.eventSize,
1691 0 : ldc->header.eventVersion );
1692 0 : for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
1693 0 : printf( " EQ:%d size:%d %spayload:%d\n",
1694 0 : eq->id,
1695 0 : eq->header.equipmentSize,
1696 0 : eq->header.equipmentSize - sizeof( struct equipmentHeaderStruct ) == (unsigned)eq->payload->size ? "" : "-ERROR",
1697 : eq->payload->size );
1698 : }
1699 : }
1700 : }
1701 : }
1702 1 : } else if ( workingAs == ldc ) {
1703 : struct ldcEventDescriptorStruct *ldc;
1704 :
1705 0 : for ( ldc = (struct ldcEventDescriptorStruct *)eventsHead;
1706 0 : ldc != NULL;
1707 0 : ldc = ldc->next ) {
1708 : struct equipmentEventDescriptorStruct *eq;
1709 :
1710 0 : initEvent( &ldc->header );
1711 0 : ldc->header.eventSize = ldc->header.eventHeadSize;
1712 0 : ldc->header.eventType = PHYSICS_EVENT;
1713 0 : ldc->header.eventGdcId = VOID_ID;
1714 0 : ldc->header.eventLdcId = ldc->id;
1715 0 : for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
1716 0 : initEquipment( &eq->header );
1717 0 : eq->header.equipmentId = eq->id;
1718 0 : if ( workingMode == collider )
1719 0 : SET_SYSTEM_ATTRIBUTE( eq->header.equipmentTypeAttribute,
1720 : ATTR_ORBIT_BC );
1721 0 : eq->header.equipmentSize = eq->payload->size + sizeof( eq->header );
1722 0 : ldc->header.eventSize += eq->header.equipmentSize;
1723 0 : decodeCDH( ldc, eq->payload, eq->id );
1724 0 : OR_ALL_ATTRIBUTES( eq->header.equipmentTypeAttribute,
1725 : ldc->header.eventTypeAttribute );
1726 : }
1727 0 : cdhRef = NULL;
1728 : }
1729 0 : DBG_VERBOSE {
1730 0 : printf( "Headers:\n" );
1731 0 : for ( ldc = (struct ldcEventDescriptorStruct *)eventsHead;
1732 0 : ldc != NULL;
1733 0 : ldc = ldc->next ) {
1734 : struct equipmentEventDescriptorStruct *eq;
1735 :
1736 0 : printf( " LDC:%d size:%d vers:%08x\n",
1737 0 : ldc->id,
1738 0 : ldc->header.eventSize,
1739 0 : ldc->header.eventVersion );
1740 0 : for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
1741 0 : printf( " EQ:%d size:%d %spayload:%d\n",
1742 0 : eq->id,
1743 0 : eq->header.equipmentSize,
1744 0 : eq->header.equipmentSize - sizeof( struct equipmentHeaderStruct ) == (unsigned)eq->payload->size ? "" : "-ERROR",
1745 : eq->payload->size );
1746 : }
1747 : }
1748 : }
1749 0 : }
1750 1 : } /* End of initEvents */
1751 :
1752 : void initVars() {
1753 2 : debug = 0;
1754 1 : workingAs = unknown;
1755 1 : workingMode = fixedTarget;
1756 1 : ldcsHead = ldcsTail = NULL;
1757 1 : eventsHead = eventsTail = NULL;
1758 1 : currGdc = NULL;
1759 1 : currLdc = NULL;
1760 1 : currEvent = NULL;
1761 1 : payloadsHead = payloadsTail = NULL;
1762 1 : currRunNb = -1;
1763 1 : numOfLdcs = 0;
1764 1 : numOfEvents = 1;
1765 1 : createSorEor = TRUE;
1766 1 : handleCDH = FALSE;
1767 1 : gotAliceTrigger = TRUE;
1768 1 : bufferData=TRUE;
1769 1 : } /* End of initVars */
1770 :
1771 : int main( int argc, char **argv ) {
1772 2 : initVars();
1773 1 : parseArgs( argc, argv );
1774 1 : parseRules();
1775 1 : initEvents();
1776 1 : createEvents();
1777 1 : return 0;
1778 : } /* End of main */
|
