5 Utility to simulate a DATE raw data stream using a given set of raw
6 data files and a configuration file.
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
26 #define DESCRIPTION "DATE raw data stream simulator"
30 char fileHandlerIdent[]= "@(#)""" __FILE__ """: """ DESCRIPTION \
32 """ compiled """ __DATE__ """ """ __TIME__;
34 #define DBG_BASE if ( debug > 0 )
35 #define DBG_DETAILED if ( debug > 1 )
36 #define DBG_VERBOSE if ( debug > 2 )
39 # define TRUE (0 == 0)
42 # define FALSE (0 == 1)
48 typedef enum { unknown, ldc, gdc } workingAsType;
49 typedef enum { collider, fixedTarget } workingModeType;
50 workingAsType workingAs;
51 workingModeType workingMode;
52 struct ldcDescriptorStruct {
54 struct ldcDescriptorStruct *next;
55 } *ldcsHead, *ldcsTail;
56 void *eventsHead, *eventsTail;
57 struct gdcEventDescriptorStruct {
58 struct ldcEventDescriptorStruct *head;
59 struct ldcEventDescriptorStruct *tail;
60 struct gdcEventDescriptorStruct *next;
61 struct eventHeaderStruct header;
64 struct ldcEventDescriptorStruct {
65 struct equipmentEventDescriptorStruct *head;
66 struct equipmentEventDescriptorStruct *tail;
67 struct ldcEventDescriptorStruct *next;
69 struct eventHeaderStruct header;
72 struct equipmentEventDescriptorStruct {
73 struct equipmentEventDescriptorStruct *next;
75 struct payloadDescriptorStruct *payload;
76 struct equipmentHeaderStruct header;
78 struct payloadDescriptorStruct {
79 struct payloadDescriptorStruct *next;
84 } *payloadsHead, *payloadsTail;
86 eventGdcIdType currGdcId;
87 eventLdcIdType currLdcId;
88 equipmentIdType currEquipmentId;
94 eventIdType oneEventDelta;
95 eventIdType currEventId;
99 void dumpPayload( const struct payloadDescriptorStruct *p ) {
104 if ( p->data != NULL ) {
105 for ( i = 0, c = (char *)p->data, printable = TRUE;
106 printable && i != p->size;
108 printable = isascii( *c );
111 for ( i = 0, c = (char *)p->data; i != p->size; c++, i++ ) {
117 if ( *c != '\n' ) printf( "\"\n" );
120 for ( i = 0, v = (long32 *)p->data;
123 if ( i % (4*8) == 0 ) {
124 if ( i != 0 ) printf( "\n" );
127 printf( "%08x ", *v );
133 while ( i != p->size ) {
134 printf( "%02x ", *((char *)p->data + p->size - j - 1) & 0xff );
142 } /* End of dumpPayload */
145 assert( workingAs == ldc || workingAs == gdc );
146 if ( eventsHead != NULL ) {
147 printf( "Events:\n" );
148 if ( workingAs == gdc ) {
149 struct gdcEventDescriptorStruct *gdc;
151 for ( gdc = (struct gdcEventDescriptorStruct *)eventsHead;
154 struct ldcEventDescriptorStruct *ldc;
156 printf( " GDC (%p)\n", gdc );
157 for ( ldc = gdc->head; ldc != NULL; ldc = ldc->next ) {
158 struct equipmentEventDescriptorStruct *eq;
160 printf( " LDC (%p): %d\n", ldc, ldc->id );
161 for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
162 printf( " EQUIPMENT (%p): %d PAYLOAD (%p):",
167 printf( "\"%s\" (%d bytes)\n",
168 eq->payload->fileName,
170 dumpPayload( eq->payload );
175 if ( workingAs == ldc ) {
176 struct ldcEventDescriptorStruct *ldc;
178 for ( ldc = (struct ldcEventDescriptorStruct *)eventsHead;
181 struct equipmentEventDescriptorStruct *eq;
184 for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
185 printf( " EQUIPMENT (%p): %d PAYLOAD (%p):",
190 printf( "\"%s\" (%d bytes)\n",
191 eq->payload->fileName,
193 dumpPayload( eq->payload );
198 printf( "Events: EMPTY\n" );
200 } /* End of dumpEvents */
202 void getLine( char *line, const int maxSize ) {
206 for ( read = 0; !feof( stdin ) && !ferror( stdin ) && read != maxSize; read++ ) {
207 if ( (line[read] = getchar()) == '\n' ) break;
209 if ( ferror( stdin ) ) {
211 "%s: failed to read configuration input errno:%d ",
216 if ( feof( stdin ) ) read--;
217 if ( read == maxSize && line[read] != '\n' ) {
219 "%s: Input line # %d too long (%d chars max)\n",
220 myName, lineNo, maxSize-1 );
225 if ( !( read == 0 && feof( stdin ) ) ) {
226 printf( "%d) [%3d] \"%s\"", lineNo, read, line );
229 for ( c = 0; c != read; c++ ) {
230 if ( line[c] == '#' ) {
237 printf( " => \"%s\"", line );
239 if ( feof( stdin ) ) printf( "<<< EOF >>>" );
240 if ( ferror( stdin ) ) printf( "<<< FERROR >>>" );
243 } /* End of getLine */
245 void handleLdc( eventLdcIdType ldcId ) {
246 struct ldcDescriptorStruct *ldc;
248 if ( ldcsHead != NULL ) {
249 for ( ldc = ldcsHead; ldc != NULL; ldc = ldc->next ) {
250 if ( ldc->id == ldcId ) {
255 if ( (ldc = (struct ldcDescriptorStruct *)malloc( sizeof( *ldc ) )) == NULL ) {
257 "%s: Failed to malloc for %d bytes (struct ldcDescriptorStruct)\n",
258 myName, (int)sizeof( *ldc ) );
263 if ( ldcsHead == NULL ) {
264 ldcsHead = ldcsTail = ldc;
266 ldcsTail->next = ldc;
270 } /* End of handleLdc */
272 void createNewEvent() {
273 assert( workingAs == ldc || workingAs == gdc );
274 if ( workingAs == ldc ) {
275 struct ldcEventDescriptorStruct *p;
277 if ( (p = (struct ldcEventDescriptorStruct *)malloc( sizeof( *p ) ))
280 "%s: failed to malloc for %d bytes (createNewEvent: struct ldcEventDescriptorStruct)",
281 myName, (int)sizeof( *p ) );
286 p->head = p->tail = NULL;
289 if ( eventsHead == NULL ) {
290 eventsHead = eventsTail = p;
292 struct ldcEventDescriptorStruct *q =
293 (struct ldcEventDescriptorStruct *)eventsTail;
299 } else if ( workingAs == gdc ) {
300 struct gdcEventDescriptorStruct *p;
302 if ( (p = (struct gdcEventDescriptorStruct *)malloc( sizeof( *p ) ))
305 "%s: failed to malloc for %d bytes (createNewEvent: struct gdcEventDescriptorStruct)",
306 myName, (int)sizeof( *p ) );
312 p->head = p->tail = NULL;
314 if ( eventsHead == NULL ) {
315 eventsHead = eventsTail = p;
317 struct gdcEventDescriptorStruct *q =
318 (struct gdcEventDescriptorStruct *)eventsTail;
324 } /* End of createNewEvent */
326 void createNewLdcEvent() {
327 struct gdcEventDescriptorStruct *gdcDesc;
328 struct ldcEventDescriptorStruct *p;
330 if ( (p = (struct ldcEventDescriptorStruct *)malloc( sizeof( *p ) ))
333 "%s: failed to malloc for %d bytes (createNewLdcEvent: struct ldcEventDescriptorStruct)",
334 myName, (int)sizeof( *p ) );
339 p->head = p->tail = NULL;
341 gdcDesc = (struct gdcEventDescriptorStruct *)eventsTail;
342 if ( gdcDesc->head == NULL ) {
343 gdcDesc->head = gdcDesc->tail = p;
345 gdcDesc->tail->next = p;
349 } /* End of createNewLdcEvent */
351 void loadBuffer( struct payloadDescriptorStruct * const payload ) {
355 if ( (f = fopen( payload->fileName, "r" )) == NULL ) {
357 "%s: line:%d payload file \"%s\" not found or not readable, errno:%d. ",
362 perror( "System-dependent error " );
365 if ( (payload->data = malloc( payload->size )) == NULL ) {
367 "%s: line:%d Failed to malloc for payload file \"%s\" size:%d errno:%d ",
373 perror( "System-dependent status " );
376 if ( (bytesRead = fread( payload->data, payload->fileSize, 1, f )) != 1 ) {
378 "%s: line:%d Failed to read payload file \"%s\" size:%d requested:1 got:%d feof:%s ferror:%s errno:%d ",
384 feof(f) ? "TRUE" : "false",
385 ferror(f) ? "TRUE" : "false",
387 perror( "System-dependent status " );
391 if ( payload->size != payload->fileSize ) {
392 memset( (char *)payload->data + payload->fileSize,
394 payload->size - payload->fileSize );
396 } /* End of loadBuffer */
398 void unloadBuffer( struct payloadDescriptorStruct * const payload ) {
399 if ( payload->data != NULL ) {
400 free( payload->data );
401 payload->data = NULL;
403 } /* End of unloadBuffer */
405 void unloadAllBuffers() {
406 struct payloadDescriptorStruct *payload;
408 for ( payload = payloadsHead; payload != NULL; payload = payload->next ) {
409 unloadBuffer( payload );
411 } /* End of unloadAllBuffers */
413 void loadPayload( const char *fileName ) {
414 struct payloadDescriptorStruct *payload;
416 for ( payload = payloadsHead; payload != NULL; payload = payload->next ) {
417 if ( strcmp( fileName, payload->fileName ) == 0 )
420 if ( payload == NULL ) {
423 if ( (payload = (struct payloadDescriptorStruct *)malloc( sizeof( *payload ) ))
426 "%s: failed to malloc for %d bytes (loadPayload/payloadDescriptorStruct)\n",
428 (int)sizeof( *payload ) );
431 if ( (payload->fileName = strdup( fileName )) == NULL ) {
433 "%s: failed to duplicate string \"%s\" (loadPaload/fileName)\n",
438 if ( (f = fopen( fileName, "r" )) == NULL ) {
440 "%s: line:%d payload file \"%s\" not found or not readable, errno:%d. ",
445 perror( "System-dependent error " );
448 if ( fseek( f, 0L, SEEK_END ) != 0 ) {
450 "%s: line:%d Failed to seek payload file \"%s\" errno:%d ",
455 perror( "System-dependent error " );
458 if ( (payload->size = ftell( f )) <= 0 ) {
460 "%s: line:%d Failed to get file \"%s\" size size:%d errno:%d ",
466 perror( "System-dependent status " );
469 payload->fileSize = payload->size;
470 while ( (payload->size & 3) != 0 ) payload->size++;
474 loadBuffer( payload );
476 payload->data = NULL;
479 payload->next = NULL;
480 if ( payloadsHead == NULL ) {
481 payloadsHead = payloadsTail = payload;
483 payloadsTail->next = payload;
484 payloadsTail = payload;
489 printf( "%d) Payload \"%s\" loaded at %p\n",
495 struct commonDataHeaderStruct *cdh =
496 (struct commonDataHeaderStruct *)payload->data;
498 printf( " CDH: blockLenght:%d=0x%08x ",
499 cdh->cdhBlockLength, cdh->cdhBlockLength );
500 if ( cdh->cdhBlockLength < sizeof( *cdh ) ) {
501 printf( "TOO SMALL (minimum:%ld=0x%08lx)\n",
502 (unsigned long)sizeof( *cdh ),
503 (unsigned long)sizeof( *cdh ) );
505 printf( "version:%d=0x%x ", cdh->cdhVersion, cdh->cdhVersion );
506 if ( cdh->cdhVersion != CDH_VERSION ) {
507 printf( "EXPECTED:%d=%x (decoding may be inaccurate) ",
508 CDH_VERSION, CDH_VERSION );
511 printf( "L1TriggerMessage:0x%x", cdh->cdhL1TriggerMessage );
512 if ( cdh->cdhL1TriggerMessage != 0 ) {
513 for ( b = 0, n = 0; b != 10; b++ ) {
514 if ( (cdh->cdhL1TriggerMessage & (1<<b)) != 0 ) {
515 if ( n++ != 0 )printf( "+" );
517 case 0: printf( "L1SwC" ); break;
518 case 1: printf( "ESR" ); break;
519 case 2: printf( "RoC1" ); break;
520 case 3: printf( "RoC2" ); break;
521 case 4: printf( "RoC3" ); break;
522 case 5: printf( "RoC4" ); break;
523 case 6: printf( "ClT" ); break;
524 default: printf( "spare %d", b+14 );
531 if ( cdh->cdhMBZ0 != 0 )
532 printf( "MBZ0:0x%x ",
537 printf( "EventId2(orbit):%d=0x%x ",
538 cdh->cdhEventId2, cdh->cdhEventId2 );
539 printf( "EventId1(bunchCrossing):%d=0x%x ",
540 cdh->cdhEventId1, cdh->cdhEventId1 );
544 if ( cdh->cdhMBZ1 != 0 )
545 printf( "MBZ1:0x%x ",
547 printf( "BlockAttributes:0x%x",
548 cdh->cdhBlockAttributes );
549 if ( cdh->cdhBlockAttributes != 0 ) {
551 for ( b = 0, n = 0; b != 8; b++ ) {
552 if ( (cdh->cdhBlockAttributes & (1<<b)) != 0 ) {
561 printf( "ParticipatingSubDetectors:0x%x ",
562 cdh->cdhParticipatingSubDetectors );
566 if ( cdh->cdhMBZ2 != 0 )
567 printf( "MBZ2:0x%x ",
569 printf( "Status/Error:0x%x", cdh->cdhStatusErrorBits );
570 if ( cdh->cdhStatusErrorBits != 0 ) {
572 for ( b = 0,n = 0; b != 16; b++ ) {
573 if ( (cdh->cdhStatusErrorBits & (1<<b)) != 0 ) {
574 if ( n++ != 0 ) printf( "+" );
576 case 0: printf( "TriggerOverLapError" ); break;
577 case 1: printf( "TriggerMissingError" ); break;
578 case 2: printf( "DataParityError" ); break;
579 case 3: printf( "ControlParityError" ); break;
580 case 4: printf( "TriggerInformationUnavailable" ); break;
581 case 5: printf( "FEEError" ); break;
582 case 6: printf( "HLTDecision" ); break;
583 case 7: printf( "HLTPayload" ); break;
584 case 8: printf( "DDGPayload" ); break;
585 default: printf( "spare %d", b );
592 printf( "MiniEventId(bunchCrossing):%d=0x%x ",
593 cdh->cdhMiniEventId, cdh->cdhMiniEventId );
597 printf( "Trigger classes: 0x(%05x-%08x)",
598 cdh->cdhTriggerClassesHigh,
599 cdh->cdhTriggerClassesLow );
600 if ( cdh->cdhTriggerClassesHigh != 0
601 || cdh->cdhTriggerClassesLow != 0 ) {
603 for ( b=0, n=0; b != 32; b++ ) {
604 if ( (cdh->cdhTriggerClassesLow & (1<<b)) != 0 ) {
605 if ( n++ != 0 ) printf( "+" );
609 for ( b=0; b != 18; b++ ) {
610 if ( (cdh->cdhTriggerClassesHigh & (1<<b)) != 0 ) {
611 if ( n++ != 0 ) printf( "+" );
612 printf( "%d", b+32 );
620 if ( cdh->cdhMBZ3 != 0 ) {
621 printf( "MBZ3:0x%x ",
624 printf( "ROI:0x(%08x-%01x)", cdh->cdhRoiHigh, cdh->cdhRoiLow );
625 if ( cdh->cdhRoiHigh != 0
626 || cdh->cdhRoiLow != 0 ) {
628 for ( b=0, n=0; b != 5; b++ ) {
629 if ( (cdh->cdhRoiLow & (1<<b)) != 0 ) {
630 if ( n++ != 0 ) printf( "+" );
634 for ( b=0; b != 32; b++ ) {
635 if ( (cdh->cdhRoiHigh & (1<<b)) != 0 ) {
636 if ( n++ != 0 ) printf( "+" );
648 printf( "%d) Payload \"%s\" already loaded at %p\n",
654 currEvent->payload = payload;
655 } /* End of loadPayload */
657 void parseEquipment( char * const line ) {
658 struct equipmentEventDescriptorStruct *equipment;
659 int payloadFound = FALSE;
664 (struct equipmentEventDescriptorStruct *)malloc( sizeof( *equipment ) )) == NULL ) {
666 "%s: filed to malloc for %d bytes (parseEquipment/equipmentEventDescriptorStruct) errno:%d ",
668 (int)sizeof( *equipment ),
673 currEvent = equipment;
676 while ( (keyword = strtok_r( p, " \t", &p )) != NULL ) {
677 DBG_VERBOSE printf( "%d) Equipment - Keyword:\"%s\"\n",
680 if ( strcasecmp( "id", keyword ) == 0 ) {
683 if ( (idNum = strtok_r( p, " \t", &p )) == NULL ) {
685 "%s: line:%d EQUIPMENT declaration, ID needed",
690 if ( sscanf( idNum, "%d", &currEquipmentId ) != 1 ) {
692 "%s: line:%d EQUIPMENT declaration, numeric ID needed (%s)",
698 DBG_VERBOSE printf( "%d) EQUIPMENT - ID:%d\n",
701 } else if ( strncasecmp( "pay", keyword, 3 ) == 0 ) {
704 if ( (fileName = strtok_r( p, " \t", &p )) == NULL ) {
706 "%s line:%d Payload without filename found\n",
711 DBG_VERBOSE printf( "%d) Equipment - Payload:\"%s\"\n",
714 if ( payloadFound ) {
716 "%s line:%d Payload with multiple filenames found\n",
721 loadPayload( fileName );
725 "%s: line:%d Equipment declaration, unknown keyword \"%s\"\n",
732 if ( !payloadFound ) {
734 "%s: line:%d Equipment without payload found\n",
740 equipment->id = currEquipmentId;
741 equipment->next = NULL;
742 if ( currLdc->head == NULL ) {
743 currLdc->head = currLdc->tail = equipment;
745 currLdc->tail->next = equipment;
746 currLdc->tail = equipment;
748 } /* End of parseEquipment */
750 void parseGdc( char * const line ) {
755 while ( (keyword = strtok_r( p, " \t", &p )) != NULL ) {
756 if ( strcasecmp( "id", keyword ) == 0 ) {
759 if ( (idNum = strtok_r( p, " \t", &p )) == NULL ) {
761 "%s: line:%d GDC declaration, ID needed",
766 if ( sscanf( idNum, "%d", &currGdcId ) != 1 ) {
768 "%s: line:%d GDC declaration, numeric ID needed (%s)",
774 DBG_VERBOSE printf( "%d) GDC - ID:%d\n",
779 "%s: line:%d GDC declaration, unknown keyword \"%s\"\n",
786 } /* End of parseGdc */
788 void parseLdc( char * const line ) {
793 while ( (keyword = strtok_r( p, " \t", &p )) != NULL ) {
794 if ( strcasecmp( "id", keyword ) == 0 ) {
797 if ( (idNum = strtok_r( p, " \t", &p )) == NULL ) {
799 "%s: line:%d LDC declaration, ID needed",
804 if ( sscanf( idNum, "%d", &currLdcId ) != 1 ) {
806 "%s: line:%d LDC declaration, numeric ID needed (%s)",
812 DBG_VERBOSE printf( "%d) LDC - ID:%d\n",
817 "%s: line:%d LDC declaration, unknown keyword \"%s\"\n",
824 } /* End of parseLdc */
829 currLdcId = HOST_ID_MIN;
830 currGdcId = HOST_ID_MIN;
832 for ( lineNo = 1; !feof( stdin ); lineNo++ ) {
833 getLine( line, sizeof(line) );
834 if ( strlen(line) != 0 ) {
838 if ( (keyword = strtok_r( line, " \t", &p )) != NULL ) {
839 DBG_VERBOSE printf( "%d) Keyword:\"%s\"\n", lineNo, keyword );
840 if ( strcasecmp( "gdc", keyword ) == 0 ) {
841 if ( workingAs != gdc && workingAs != unknown ) {
843 "%s: line:%d GDC found when working in non-GDC mode (e.g. as a LDC)\n",
850 currLdcId = HOST_ID_MIN;
853 } else if ( strcasecmp( "ldc", keyword ) == 0 ) {
854 if ( workingAs != gdc && workingAs != ldc && workingAs != unknown ) {
856 "%s: line:%d LDC found when working in non-LDC/GDC mode\n",
860 if ( workingAs == unknown ) workingAs = ldc;
862 if ( workingAs == ldc ) {
867 handleLdc( currLdcId );
871 } else if ( strncasecmp( "equ", keyword, 3 ) == 0 ) {
872 if ( workingAs == unknown
873 || (workingAs == ldc && currLdc == NULL )
874 || (workingAs == gdc && currGdc == NULL ) ) {
876 "%s: line:%d Unexpected EQUIPMENT declaration (LDC or GDC needed first)\n",
885 "%s: line:%d Parse error in \"%s\" unknown keyword\n",
893 } while ( !feof( stdin ) );
897 printf( "End of parse: %d line%s found\n",
899 lineNo != 1 ? "s" : "" );
900 printf( "Working as %s\n",
901 workingAs == gdc ? "GDC" :
902 workingAs == ldc ? "LDC" :
904 if ( workingAs == gdc ) {
905 struct ldcDescriptorStruct *ldc;
907 printf( "LDCs (%d):", numOfLdcs );
908 for ( ldc = ldcsHead; ldc != NULL; ldc = ldc->next ) {
909 printf( " %d", ldc->id );
916 if ( workingAs == ldc ) {
917 assert( ldcsHead == ldcsTail );
918 assert( ldcsTail == NULL );
921 if ( workingAs == gdc ) {
922 struct ldcDescriptorStruct *ldc;
924 assert( ldcsHead != NULL );
925 assert( ldcsTail != NULL );
926 assert( ldcsTail->next == NULL );
927 for ( ldc = ldcsHead; ldc->next != NULL; ldc = ldc->next );
928 assert ( ldc == ldcsTail );
931 if ( workingAs == unknown ) {
932 DBG_VERBOSE printf( "Empty configuration: nothing to do!\n" );
936 assert( (eventsHead == NULL && eventsTail == NULL)
937 || (eventsHead != NULL && eventsTail != NULL) );
938 } /* End of parseRules */
940 void loadTimestamp( struct eventHeaderStruct * const ev ) {
943 if ( time( &t ) == (time_t)-1 ) {
945 "%s: failed to get system time errno:%d (%s)\n",
946 myName, errno, strerror( errno ) );
949 ev->eventTimestamp = (eventTimestampType)t;
950 } /* End of loadTimestamp */
952 void initEvent( struct eventHeaderStruct * const ev ) {
953 memset( ev, 0, sizeof( *ev ) );
955 ev->eventMagic = EVENT_MAGIC_NUMBER;
956 ev->eventHeadSize = EVENT_HEAD_BASE_SIZE;
957 ev->eventVersion = EVENT_CURRENT_VERSION;
958 ev->eventRunNb = currRunNb;
959 ZERO_EVENT_ID( ev->eventId );
960 ZERO_TRIGGER_PATTERN( ev->eventTriggerPattern );
961 ZERO_DETECTOR_PATTERN( ev->eventDetectorPattern );
962 RESET_ATTRIBUTES( ev->eventTypeAttribute );
963 if ( workingMode == collider )
964 SET_SYSTEM_ATTRIBUTE( ev->eventTypeAttribute, ATTR_ORBIT_BC );
965 ev->eventLdcId = VOID_ID;
966 ev->eventGdcId = VOID_ID;
968 } /* End of initEvent */
970 void outputEvent( const void * const ev,
975 const long32 * const v = (long32 *)ev;
976 printf( "Writing %d bytes @ %p (%d)\n", size, ev, *v );
979 if ( (done = fwrite( ev, size, 1, outF )) != 1 ) {
981 "%s: failed to write event size:%d bytes, errno:%d (%s)\n",
982 myName, size, errno, strerror( errno ) );
985 } /* End of outputEvent */
987 void createSorAndEor( const int sor ) {
988 unsigned char event[ 1000 ];
989 struct eventHeaderStruct *ev;
990 struct eventHeaderStruct sev;
992 assert( workingAs == ldc || workingAs == gdc );
994 if ( !createSorEor ) return;
995 ev = (struct eventHeaderStruct *)event;
997 ev->eventSize = sizeof( event );
998 ev->eventType = sor ? START_OF_RUN : END_OF_RUN;
999 if ( workingMode == fixedTarget )
1000 LOAD_RAW_EVENT_ID( ev->eventId, 0, 0, 0 );
1002 LOAD_EVENT_ID( ev->eventId, 0, 0, 0 );
1003 SET_SYSTEM_ATTRIBUTE( ev->eventTypeAttribute, ATTR_P_START );
1005 if ( workingAs == ldc ) {
1006 currLdc = (struct ldcEventDescriptorStruct *)eventsHead;
1008 if ( workingAs == gdc ) {
1010 sev.eventGdcId = currGdcId;
1011 ev->eventGdcId = currGdcId;
1012 currGdc = (struct gdcEventDescriptorStruct *)eventsHead;
1013 currLdc = currGdc->head;
1015 ev->eventLdcId = currLdc->id;
1017 if ( workingAs == ldc ) {
1018 loadTimestamp( ev );
1019 outputEvent( ev, ev->eventSize );
1021 if ( workingAs == gdc ) {
1022 struct ldcDescriptorStruct *ldc;
1024 loadTimestamp( ev );
1026 sev.eventSize = sizeof( sev ) + numOfLdcs * ev->eventSize;
1027 sev.eventType = sor ? START_OF_RUN : END_OF_RUN ;
1028 COPY_EVENT_ID( ev->eventId, sev.eventId );
1029 COPY_SYSTEM_ATTRIBUTES( ev->eventTypeAttribute, sev.eventTypeAttribute );
1030 SET_SYSTEM_ATTRIBUTE( sev.eventTypeAttribute, ATTR_SUPER_EVENT );
1031 loadTimestamp( &sev );
1032 outputEvent( &sev, sizeof( sev ) );
1034 ev->eventGdcId = currGdcId;
1035 for ( ldc = ldcsHead; ldc != NULL; ldc = ldc->next ) {
1036 ev->eventLdcId = ldc->id;
1037 outputEvent( ev, ev->eventSize );
1041 ADD_EVENT_ID( ev->eventId, oneEventDelta );
1042 ev->eventSize = ev->eventSize / 2;
1043 ev->eventType = sor ? START_OF_RUN_FILES : END_OF_RUN_FILES;
1044 CLEAR_SYSTEM_ATTRIBUTE( ev->eventTypeAttribute, ATTR_P_START );
1045 if ( workingAs == ldc ) {
1046 loadTimestamp( ev );
1047 outputEvent( ev, ev->eventSize );
1049 if ( workingAs == gdc ) {
1050 struct ldcDescriptorStruct *ldc;
1052 loadTimestamp( ev );
1054 sev.eventSize = ev->eventSize;
1055 sev.eventType = sor ? START_OF_RUN_FILES : END_OF_RUN_FILES;
1056 COPY_EVENT_ID( ev->eventId, sev.eventId );
1057 COPY_SYSTEM_ATTRIBUTES( ev->eventTypeAttribute, sev.eventTypeAttribute );
1058 CLEAR_SYSTEM_ATTRIBUTE( sev.eventTypeAttribute, ATTR_SUPER_EVENT );
1059 outputEvent( &sev, sizeof( sev ) );
1060 outputEvent( ev, ev->eventSize - sizeof( sev ) );
1062 sev.eventSize = sizeof( sev ) + ev->eventSize;
1063 sev.eventType = sor ? START_OF_RUN_FILES : END_OF_RUN_FILES;
1064 COPY_EVENT_ID( ev->eventId, sev.eventId );
1065 COPY_SYSTEM_ATTRIBUTES( ev->eventTypeAttribute, sev.eventTypeAttribute );
1066 SET_SYSTEM_ATTRIBUTE( sev.eventTypeAttribute, ATTR_SUPER_EVENT );
1068 loadTimestamp( &sev );
1070 ev->eventGdcId = currGdcId;
1071 for ( ldc = ldcsHead; ldc != NULL; ldc = ldc->next ) {
1072 loadTimestamp( &sev );
1073 outputEvent( &sev, sizeof( sev ) );
1074 ev->eventLdcId = ldc->id;
1075 outputEvent( ev, ev->eventSize );
1079 ADD_EVENT_ID( ev->eventId, oneEventDelta );
1080 ev->eventSize = sizeof( *ev );
1081 ev->eventType = sor ? START_OF_RUN : END_OF_RUN;
1082 SET_SYSTEM_ATTRIBUTE( ev->eventTypeAttribute, ATTR_P_END );
1083 if ( workingAs == ldc ) {
1084 loadTimestamp( ev );
1085 outputEvent( ev, ev->eventSize );
1087 if ( workingAs == gdc ) {
1088 struct ldcDescriptorStruct *ldc;
1090 loadTimestamp( ev );
1092 sev.eventSize = sizeof( sev ) + numOfLdcs * ev->eventSize;
1093 sev.eventType = sor ? START_OF_RUN : END_OF_RUN;
1094 COPY_EVENT_ID( ev->eventId, sev.eventId );
1095 COPY_SYSTEM_ATTRIBUTES( ev->eventTypeAttribute, sev.eventTypeAttribute );
1096 SET_SYSTEM_ATTRIBUTE( sev.eventTypeAttribute, ATTR_SUPER_EVENT );
1097 loadTimestamp( &sev );
1099 outputEvent( &sev, sizeof( sev ) );
1101 for ( ldc = ldcsHead; ldc != NULL; ldc = ldc->next ) {
1102 ev->eventLdcId = ldc->id;
1103 outputEvent( ev, ev->eventSize );
1106 } /* End of createSorEor */
1109 createSorAndEor( TRUE );
1110 } /* End of createSor */
1113 createSorAndEor( FALSE );
1114 } /* End of createEor */
1116 void loadCdh( struct commonDataHeaderStruct * const cdh,
1117 eventIdType * const eventId ) {
1118 if ( !handleCDH ) return;
1120 if ( gotAliceTrigger ) {
1121 cdh->cdhEventId1 = EVENT_ID_GET_BUNCH_CROSSING( *eventId );
1122 cdh->cdhEventId2 = EVENT_ID_GET_ORBIT( *eventId );
1124 cdh->cdhEventId1 = 0;
1125 cdh->cdhEventId2 = EVENT_ID_GET_NB_IN_RUN( *eventId );
1127 cdh->cdhMiniEventId = cdh->cdhEventId1;
1129 void decodeCDH( struct ldcEventDescriptorStruct * const ldc,
1130 const struct payloadDescriptorStruct * const payloadDesc );
1132 void createEvent( void ) {
1133 assert( workingAs == ldc || workingAs == gdc );
1135 /* Step 1: load all buffers (if needed) and compose the GDC/LDC headers */
1136 if ( workingAs == gdc ) {
1137 struct ldcEventDescriptorStruct *ldc;
1139 for( ldc = currGdc->head; ldc != NULL; ldc = ldc->next ) {
1140 COPY_EVENT_ID( currEventId, ldc->header.eventId );
1141 loadTimestamp( &ldc->header );
1143 COPY_EVENT_ID( currEventId, currGdc->header.eventId );
1144 loadTimestamp( &currGdc->header );
1146 for( ldc = currGdc->head; ldc != NULL; ldc = ldc->next ) {
1147 struct equipmentEventDescriptorStruct *eq;
1150 for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
1151 if ( !bufferData ) {
1152 loadBuffer( eq->payload );
1153 if ( !currGdc->loaded ) decodeCDH( ldc, eq->payload );
1155 loadCdh( (struct commonDataHeaderStruct*)eq->payload->data,
1159 if ( !currGdc->loaded ) {
1160 for ( n = 0; n != EVENT_TRIGGER_PATTERN_WORDS; n++ )
1161 currGdc->header.eventTriggerPattern[n] |= ldc->header.eventTriggerPattern[n];
1162 for ( n = 0; n != EVENT_DETECTOR_PATTERN_WORDS; n++ )
1163 currGdc->header.eventDetectorPattern[n] |= ldc->header.eventDetectorPattern[n];
1164 for ( n = 0; n != ALL_ATTRIBUTE_WORDS; n++ )
1165 currGdc->header.eventTypeAttribute[n] |= ldc->header.eventTypeAttribute[n];
1166 currGdc->loaded = TRUE;
1169 } else if ( workingAs == ldc ) {
1170 struct equipmentEventDescriptorStruct *eq;
1172 COPY_EVENT_ID( currEventId, currLdc->header.eventId );
1173 loadTimestamp( &currLdc->header );
1175 for ( eq = currLdc->head; eq != NULL; eq = eq->next ) {
1176 if ( !bufferData ) {
1177 loadBuffer( eq->payload );
1178 if ( !currLdc->loaded ) decodeCDH( currLdc, eq->payload );
1180 loadCdh( (struct commonDataHeaderStruct*)eq->payload->data,
1182 currLdc->loaded = TRUE;
1185 ADD_EVENT_ID( currEventId, oneEventDelta );
1187 /* Step 2: output the event */
1188 if ( workingAs == gdc ) {
1189 struct ldcEventDescriptorStruct *ldc;
1191 outputEvent( &currGdc->header, sizeof( currGdc->header ) );
1193 for( ldc = currGdc->head; ldc != NULL; ldc = ldc->next ) {
1194 struct equipmentEventDescriptorStruct *eq;
1196 outputEvent( &ldc->header, sizeof( ldc->header ) );
1198 for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
1199 outputEvent( &eq->header, sizeof( eq->header ) );
1200 outputEvent( eq->payload->data, eq->payload->size );
1201 if ( !bufferData ) unloadBuffer( eq->payload );
1204 if ( (currGdc = currGdc->next) == NULL )
1205 currGdc = (struct gdcEventDescriptorStruct *)eventsHead;
1206 } else if ( workingAs == ldc ) {
1207 struct equipmentEventDescriptorStruct *eq;
1209 outputEvent( &currLdc->header, sizeof( currLdc->header ) );
1211 for ( eq = currLdc->head; eq != NULL; eq = eq->next ) {
1212 outputEvent( &eq->header, sizeof( eq->header ) );
1213 outputEvent( eq->payload->data, eq->payload->size );
1214 if ( !bufferData ) unloadBuffer( eq->payload );
1216 if ( (currLdc = currLdc->next) == NULL )
1217 currLdc = (struct ldcEventDescriptorStruct *)eventsHead;
1219 } /* End of createEvent */
1221 void createEvents() {
1224 currGdc = (struct gdcEventDescriptorStruct *)eventsHead;
1225 currLdc = (struct ldcEventDescriptorStruct *)eventsHead;
1230 eventNum != numOfEvents && numOfEvents != 0;
1235 } /* End of createEvents */
1239 "Usage: %s [-?][-d][-i definitionFile][-o outputFile][-# numOfEvents][-s][-F|-C]\n\
1241 -v Print version ID and exit\n\
1242 -d Enable debug (repeat for more verbosity)\n\
1243 -i definitionFile File with the description of the events to create (default: stdin)\n\
1244 -o outputFile File used to store events (default: stdout)\n\
1245 -# numOfEvents Number of events to generate (default: 1 event)\n\
1246 -s Do not generate SOR/EOR files (valid only for GDCs)\n\
1247 -F/-C Working in Fixed Target (F) or Collider (C) mode\n\
1249 -D Direct disc access (no buffering)\n",
1252 } /* End of usage */
1254 void parseArgs( int argc, char **argv ) {
1256 int inFileName = -1;
1257 int outFileName = -1;
1260 while ( arg < argc ) {
1261 if ( strcmp( "-?", argv[ arg ] ) == 0 ) {
1265 if ( strcmp( "-i", argv[ arg ] ) == 0 ) {
1266 if ( ++arg == argc ) exit( usage() );
1268 if ( freopen( argv[arg], "r", stdin ) == NULL ){
1270 "%s: failed to open input definition \"%s\" errno:%d ",
1271 myName, argv[arg], errno );
1275 } else if ( strcmp( "-v", argv[ arg ] ) == 0 ) {
1276 printf( "%s\n", fileHandlerIdent );
1278 } else if ( strcmp( "-o", argv[ arg ] ) == 0 ) {
1279 if ( ++arg == argc ) exit( usage() );
1281 } else if ( strcmp( "-#", argv[ arg ] ) == 0 ) {
1284 if ( ++arg == argc ) exit( usage() );
1285 if ( sscanf( argv[ arg ], "%d", &n ) != 1 ) exit( usage() );
1286 if ( n < 0 ) exit( usage() );
1288 } else if ( strcmp( "-s", argv[ arg ] ) == 0 ) {
1289 createSorEor = FALSE;
1290 } else if ( strcmp( "-F", argv[ arg ] ) == 0 ) {
1291 workingMode = fixedTarget;
1292 } else if ( strcmp( "-C", argv[ arg ] ) == 0 ) {
1293 workingMode = collider;
1294 } else if ( strcmp( "-d", argv[ arg ] ) == 0 ) {
1296 } else if ( strcmp( "-c", argv[ arg ] ) == 0 ) {
1298 } else if ( strcmp( "-D", argv[ arg ] ) == 0 ) {
1301 fprintf( stderr, "%s: Unknown switch \"%s\"\n", myName, argv[argc] );
1307 if ( workingMode == fixedTarget )
1308 LOAD_RAW_EVENT_ID( oneEventDelta, 1, 0, 1 );
1310 LOAD_EVENT_ID( oneEventDelta, 0, 0, 1 );
1311 ZERO_EVENT_ID( currEventId );
1314 printf( "Configuration:\n" );
1315 printf( " Debug level: %d\n", debug );
1316 printf( " Configuration: %s\n",
1317 inFileName == -1 ? "stdin" : argv[ inFileName ] );
1318 printf( " Output: %s\n",
1319 outFileName == -1 ? "stdout" : argv[ outFileName ] );
1320 printf( " Working mode: %s\n",
1321 workingMode == fixedTarget ? "fixed target" : "collider" );
1322 printf( " Number of events: %d\n", numOfEvents );
1323 printf( " %s SOR/EOR files\n",
1324 createSorEor ? "Create" : "Do not create" );
1325 printf( " CDH handling: %s\n",
1326 handleCDH ? "enabled" : "disabled" );
1327 printf( " data buffering: %s\n",
1328 bufferData ? "enabled" : "DISABLED" );
1331 if ( outFileName == -1 ) {
1333 printf( "No more trace information from this point...\n" );
1337 if ( ( outF = fopen( argv[ outFileName ], "w" ) ) == NULL ) {
1339 "%s: failed to open output file \"%s\" for writing, errno:%d (%s)\n",
1341 argv[ outFileName ],
1343 strerror( errno ) );
1347 printf( "Output file \"%s\" opened OK for writing\n",
1348 argv[ outFileName ] );
1350 } /* End of parseArgs */
1351 void initEquipment( struct equipmentHeaderStruct * const eq ) {
1352 memset( eq, 0, sizeof( *eq ) );
1353 RESET_ATTRIBUTES( eq->equipmentTypeAttribute );
1354 eq->equipmentBasicElementSize = 4;
1355 } /* End of initEquipment */
1357 void decodeCDH( struct ldcEventDescriptorStruct * const ldc,
1358 const struct payloadDescriptorStruct * const payloadDesc ) {
1360 static struct commonDataHeaderStruct *cdhRef = NULL;
1361 struct commonDataHeaderStruct *cdh;
1362 static int softwareTriggerIndicator = FALSE;
1366 if ( payloadDesc->size < CDH_SIZE ) {
1368 "%s: payload too small got:%d CDH:%d\n",
1374 if ( (cdh = (struct commonDataHeaderStruct *)payloadDesc->data) != NULL ) {
1375 if ( cdh->cdhVersion != CDH_VERSION ) {
1377 "%s: CDH version mismatch expected:%d got:%d\n",
1383 if ( cdhRef == NULL ) {
1385 #define CDH_TRIGGER_INFORMATION_UNAVAILABLE_MASK (1<<CDH_TRIGGER_INFORMATION_UNAVAILABLE_BIT)
1386 gotAliceTrigger = (cdhRef->cdhStatusErrorBits & CDH_TRIGGER_INFORMATION_UNAVAILABLE_MASK) == 0;
1387 if ( gotAliceTrigger && workingMode == fixedTarget ) {
1389 "%s: ALICE trigger and fixed target mode are not compatible.\n\
1390 Either work in Collider mode or set the trigger unavailable status bit in the CDH.\n",
1394 if ( gotAliceTrigger ) {
1395 if ( (cdh->cdhL1TriggerMessage & 0x40) != 0 ) {
1397 "%s: CDH is a calibration trigger (unsupported) L1TriggerMessage:0x%x\n",
1398 myName, cdh->cdhL1TriggerMessage );
1401 if ( (cdh->cdhL1TriggerMessage & 0x01) != 0 ) {
1402 softwareTriggerIndicator = TRUE;
1404 if ( softwareTriggerIndicator ) {
1405 switch ((cdh->cdhL1TriggerMessage >> 2) & 0xF) {
1413 /* L1SwC bit = on, Clt bit = off, RoC[4..1] = 0xF --> END_OF_DATA */
1415 /* L1SwC bit = on, Clt bit = off, RoC[4..1] = 0xE0 --> START_OF_DATA */
1417 /* L1SwC bit = on, Clt bit = off, RoC[4] = 1, but not 0xE or 0xF
1418 --> SYSTEM_SOFTWARE_TRIGGER_EVENT */
1420 /* L1SwC bit = on, Clt bit = off, RoC[4] = 0
1421 --> DETECTOR_SOFTWARE_TRIGGER_EVENT */
1423 "%s: CDH trigger SOD/EOD/SST/DST (unsupported) \
1424 L1TriggerMessage:0x%x ALICETrigger:%s\n",
1426 cdh->cdhL1TriggerMessage,
1427 gotAliceTrigger ? "yes" : "no" );
1433 if ( (cdh->cdhStatusErrorBits & CDH_TRIGGER_INFORMATION_UNAVAILABLE_MASK) !=
1434 (cdhRef->cdhStatusErrorBits & CDH_TRIGGER_INFORMATION_UNAVAILABLE_MASK) ) {
1436 "%s: CDH coherency check failed. \
1437 Trigger information reference:%savailable current:%savailable\n",
1439 (cdhRef->cdhStatusErrorBits & CDH_TRIGGER_INFORMATION_UNAVAILABLE_MASK) == 0 ? "UN" : "",
1440 (cdh->cdhStatusErrorBits & CDH_TRIGGER_INFORMATION_UNAVAILABLE_MASK) == 0 ? "UN" : "" );
1443 if ( gotAliceTrigger ) {
1444 if ( cdhRef->cdhL1TriggerMessage != cdh->cdhL1TriggerMessage ) {
1446 "%s: CDH coherency check failed. \
1447 L1 trigger message reference:0x%x current:0x%x\n",
1449 cdhRef->cdhL1TriggerMessage,
1450 cdh->cdhL1TriggerMessage );
1453 if ( cdh->cdhParticipatingSubDetectors != cdhRef->cdhParticipatingSubDetectors ) {
1455 "%s: CDH coherency check failed. \
1456 ParticipatingSubDetectors reference:0x%x current:0x%x\n",
1458 cdhRef->cdhParticipatingSubDetectors,
1459 cdh->cdhParticipatingSubDetectors );
1462 if ( cdh->cdhTriggerClassesLow != cdhRef->cdhTriggerClassesLow
1463 || cdh->cdhTriggerClassesHigh != cdhRef->cdhTriggerClassesHigh ) {
1465 "%s: CDH coherency check failed. \
1466 TriggerClassesHigh/Low reference:0x%x-%x current:0x%x-%x\n",
1468 cdhRef->cdhTriggerClassesHigh, cdhRef->cdhTriggerClassesLow,
1469 cdh ->cdhTriggerClassesHigh, cdh ->cdhTriggerClassesLow );
1472 if ( cdh->cdhBlockLength != 0xffffffff ) {
1473 if ( (unsigned)payloadDesc->size != cdh->cdhBlockLength ) {
1475 "%s: CDH coherency check failed. \
1476 Payload size:%d (0x%08x) CDH block length:%d (0x%08x)\n",
1478 payloadDesc->size, payloadDesc->size,
1479 cdh->cdhBlockLength, cdh->cdhBlockLength );
1483 if ( cdh->cdhRoiLow != cdhRef->cdhRoiLow
1484 || cdh->cdhRoiHigh != cdhRef->cdhRoiHigh ) {
1486 "%s: CDH coherency check failed. \
1487 RoiHigh/Low reference:0x%x-%x current:0x%x-%x\n",
1489 cdhRef->cdhRoiHigh, cdhRef->cdhRoiLow,
1490 cdh ->cdhRoiHigh, cdh ->cdhRoiLow );
1494 if ( cdh->cdhMBZ0 != 0
1495 || cdh->cdhMBZ1 != 0
1496 || cdh->cdhMBZ2 != 0
1497 || cdh->cdhMBZ3 != 0 ) {
1499 "%s: CDH check failed. MBZ0:0x%x MBZ1:0x%x MBZ2:0x%x MBZ3:0x%x\n",
1501 cdh->cdhMBZ0, cdh->cdhMBZ1, cdh->cdhMBZ2, cdh->cdhMBZ3 );
1505 for ( attr = 0; attr != 8; attr++ ) {
1506 if ( (cdh->cdhBlockAttributes & (1<<attr)) != 0 ) {
1507 SET_USER_ATTRIBUTE( ldc->header.eventTypeAttribute, attr );
1510 for ( trig = 0; trig != 32; trig++ ) {
1511 if ( (cdh->cdhTriggerClassesLow & (1<<trig)) != 0 ) {
1512 SET_TRIGGER_IN_PATTERN( ldc->header.eventTriggerPattern,
1516 for ( trig = 0; trig != 18; trig++ ) {
1517 if ( (cdh->cdhTriggerClassesHigh & (1<<trig)) != 0 ) {
1518 SET_TRIGGER_IN_PATTERN( ldc->header.eventTriggerPattern,
1522 if ( gotAliceTrigger )
1523 VALIDATE_TRIGGER_PATTERN( ldc->header.eventTriggerPattern );
1526 } /* End of decodeCDH */
1529 assert( workingAs == ldc || workingAs == gdc );
1531 if ( workingAs == gdc ) {
1532 struct gdcEventDescriptorStruct *gdc;
1534 for ( gdc = (struct gdcEventDescriptorStruct *)eventsHead;
1537 struct ldcEventDescriptorStruct *ldc;
1539 initEvent( &gdc->header );
1540 gdc->header.eventSize = gdc->header.eventHeadSize;
1541 gdc->header.eventType = PHYSICS_EVENT;
1542 SET_SYSTEM_ATTRIBUTE( gdc->header.eventTypeAttribute, ATTR_SUPER_EVENT );
1543 gdc->header.eventGdcId = currGdcId;
1544 for ( ldc = gdc->head; ldc != NULL; ldc = ldc->next ) {
1545 struct equipmentEventDescriptorStruct *eq;
1547 initEvent( &ldc->header );
1548 ldc->header.eventSize = ldc->header.eventHeadSize;
1549 ldc->header.eventType = PHYSICS_EVENT;
1550 ldc->header.eventGdcId = currGdcId;
1551 ldc->header.eventLdcId = ldc->id;
1552 for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
1553 initEquipment( &eq->header );
1554 eq->header.equipmentId = eq->id;
1555 if ( workingMode == collider )
1556 SET_SYSTEM_ATTRIBUTE( eq->header.equipmentTypeAttribute,
1558 eq->header.equipmentSize = eq->payload->size + sizeof( eq->header );
1559 ldc->header.eventSize += eq->header.equipmentSize;
1560 decodeCDH( ldc, eq->payload );
1561 OR_ALL_ATTRIBUTES( eq->header.equipmentTypeAttribute,
1562 ldc->header.eventTypeAttribute );
1563 OR_ALL_ATTRIBUTES( eq->header.equipmentTypeAttribute,
1564 gdc->header.eventTypeAttribute );
1566 gdc->header.eventSize += ldc->header.eventSize;
1571 printf( "Headers:\n" );
1572 for ( gdc = (struct gdcEventDescriptorStruct *)eventsHead;
1575 struct ldcEventDescriptorStruct *ldc;
1577 printf( " GDC:%d size:%d vers:%08x\n",
1579 gdc->header.eventSize,
1580 gdc->header.eventVersion);
1581 for ( ldc = gdc->head; ldc != NULL; ldc = ldc->next ) {
1582 struct equipmentEventDescriptorStruct *eq;
1584 printf( " LDC:%d size:%d vers:%08x\n",
1586 ldc->header.eventSize,
1587 ldc->header.eventVersion );
1588 for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
1589 printf( " EQ:%d size:%d %spayload:%d\n",
1591 eq->header.equipmentSize,
1592 eq->header.equipmentSize - sizeof( struct equipmentHeaderStruct ) == (unsigned)eq->payload->size ? "" : "-ERROR",
1593 eq->payload->size );
1598 } else if ( workingAs == ldc ) {
1599 struct ldcEventDescriptorStruct *ldc;
1601 for ( ldc = (struct ldcEventDescriptorStruct *)eventsHead;
1604 struct equipmentEventDescriptorStruct *eq;
1606 initEvent( &ldc->header );
1607 ldc->header.eventSize = ldc->header.eventHeadSize;
1608 ldc->header.eventType = PHYSICS_EVENT;
1609 ldc->header.eventGdcId = VOID_ID;
1610 ldc->header.eventLdcId = ldc->id;
1611 for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
1612 initEquipment( &eq->header );
1613 eq->header.equipmentId = eq->id;
1614 if ( workingMode == collider )
1615 SET_SYSTEM_ATTRIBUTE( eq->header.equipmentTypeAttribute,
1617 eq->header.equipmentSize = eq->payload->size + sizeof( eq->header );
1618 ldc->header.eventSize += eq->header.equipmentSize;
1619 decodeCDH( ldc, eq->payload );
1620 OR_ALL_ATTRIBUTES( eq->header.equipmentTypeAttribute,
1621 ldc->header.eventTypeAttribute );
1625 printf( "Headers:\n" );
1626 for ( ldc = (struct ldcEventDescriptorStruct *)eventsHead;
1629 struct equipmentEventDescriptorStruct *eq;
1631 printf( " LDC:%d size:%d vers:%08x\n",
1633 ldc->header.eventSize,
1634 ldc->header.eventVersion );
1635 for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
1636 printf( " EQ:%d size:%d %spayload:%d\n",
1638 eq->header.equipmentSize,
1639 eq->header.equipmentSize - sizeof( struct equipmentHeaderStruct ) == (unsigned)eq->payload->size ? "" : "-ERROR",
1640 eq->payload->size );
1645 } /* End of initEvents */
1649 workingAs = unknown;
1650 workingMode = fixedTarget;
1651 ldcsHead = ldcsTail = NULL;
1652 eventsHead = eventsTail = NULL;
1656 payloadsHead = payloadsTail = NULL;
1660 createSorEor = TRUE;
1662 gotAliceTrigger = TRUE;
1664 } /* End of initVars */
1666 int main( int argc, char **argv ) {
1668 parseArgs( argc, argv );