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 struct commonDataHeaderStruct *cdhRef = NULL;
101 void dumpPayload( const struct payloadDescriptorStruct *p ) {
106 if ( p->data != NULL ) {
107 for ( i = 0, c = (char *)p->data, printable = TRUE;
108 printable && i != p->size;
110 printable = isascii( *c );
113 for ( i = 0, c = (char *)p->data; i != p->size; c++, i++ ) {
119 if ( *c != '\n' ) printf( "\"\n" );
122 for ( i = 0, v = (long32 *)p->data;
125 if ( i % (4*8) == 0 ) {
126 if ( i != 0 ) printf( "\n" );
129 printf( "%08x ", *v );
135 while ( i != p->size ) {
136 printf( "%02x ", *((char *)p->data + p->size - j - 1) & 0xff );
144 } /* End of dumpPayload */
147 assert( workingAs == ldc || workingAs == gdc );
148 if ( eventsHead != NULL ) {
149 printf( "Events:\n" );
150 if ( workingAs == gdc ) {
151 struct gdcEventDescriptorStruct *gdc;
153 for ( gdc = (struct gdcEventDescriptorStruct *)eventsHead;
156 struct ldcEventDescriptorStruct *ldc;
158 printf( " GDC (%p)\n", gdc );
159 for ( ldc = gdc->head; ldc != NULL; ldc = ldc->next ) {
160 struct equipmentEventDescriptorStruct *eq;
162 printf( " LDC (%p): %d\n", ldc, ldc->id );
163 for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
164 printf( " EQUIPMENT (%p): %d PAYLOAD (%p):",
169 printf( "\"%s\" (%d bytes)\n",
170 eq->payload->fileName,
172 dumpPayload( eq->payload );
177 if ( workingAs == ldc ) {
178 struct ldcEventDescriptorStruct *ldc;
180 for ( ldc = (struct ldcEventDescriptorStruct *)eventsHead;
183 struct equipmentEventDescriptorStruct *eq;
186 for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
187 printf( " EQUIPMENT (%p): %d PAYLOAD (%p):",
192 printf( "\"%s\" (%d bytes)\n",
193 eq->payload->fileName,
195 dumpPayload( eq->payload );
200 printf( "Events: EMPTY\n" );
202 } /* End of dumpEvents */
204 void getLine( char *line, const int maxSize ) {
208 for ( read = 0; !feof( stdin ) && !ferror( stdin ) && read != maxSize; read++ ) {
209 if ( (line[read] = getchar()) == '\n' ) break;
211 if ( ferror( stdin ) ) {
213 "%s: failed to read configuration input errno:%d ",
218 if ( feof( stdin ) ) read--;
219 if ( read == maxSize && line[read] != '\n' ) {
221 "%s: Input line # %d too long (%d chars max)\n",
222 myName, lineNo, maxSize-1 );
227 if ( !( read == 0 && feof( stdin ) ) ) {
228 printf( "%d) [%3d] \"%s\"", lineNo, read, line );
231 for ( c = 0; c != read; c++ ) {
232 if ( line[c] == '#' ) {
239 printf( " => \"%s\"", line );
241 if ( feof( stdin ) ) printf( "<<< EOF >>>" );
242 if ( ferror( stdin ) ) printf( "<<< FERROR >>>" );
245 } /* End of getLine */
247 void handleLdc( eventLdcIdType ldcId ) {
248 struct ldcDescriptorStruct *ldc;
250 if ( ldcsHead != NULL ) {
251 for ( ldc = ldcsHead; ldc != NULL; ldc = ldc->next ) {
252 if ( ldc->id == ldcId ) {
257 if ( (ldc = (struct ldcDescriptorStruct *)malloc( sizeof( *ldc ) )) == NULL ) {
259 "%s: Failed to malloc for %d bytes (struct ldcDescriptorStruct)\n",
260 myName, (int)sizeof( *ldc ) );
265 if ( ldcsHead == NULL ) {
266 ldcsHead = ldcsTail = ldc;
268 ldcsTail->next = ldc;
272 } /* End of handleLdc */
274 void createNewEvent() {
275 assert( workingAs == ldc || workingAs == gdc );
276 if ( workingAs == ldc ) {
277 struct ldcEventDescriptorStruct *p;
279 if ( (p = (struct ldcEventDescriptorStruct *)malloc( sizeof( *p ) ))
282 "%s: failed to malloc for %d bytes (createNewEvent: struct ldcEventDescriptorStruct)",
283 myName, (int)sizeof( *p ) );
288 p->head = p->tail = NULL;
291 if ( eventsHead == NULL ) {
292 eventsHead = eventsTail = p;
294 struct ldcEventDescriptorStruct *q =
295 (struct ldcEventDescriptorStruct *)eventsTail;
301 } else if ( workingAs == gdc ) {
302 struct gdcEventDescriptorStruct *p;
304 if ( (p = (struct gdcEventDescriptorStruct *)malloc( sizeof( *p ) ))
307 "%s: failed to malloc for %d bytes (createNewEvent: struct gdcEventDescriptorStruct)",
308 myName, (int)sizeof( *p ) );
314 p->head = p->tail = NULL;
316 if ( eventsHead == NULL ) {
317 eventsHead = eventsTail = p;
319 struct gdcEventDescriptorStruct *q =
320 (struct gdcEventDescriptorStruct *)eventsTail;
326 } /* End of createNewEvent */
328 void createNewLdcEvent() {
329 struct gdcEventDescriptorStruct *gdcDesc;
330 struct ldcEventDescriptorStruct *p;
332 if ( (p = (struct ldcEventDescriptorStruct *)malloc( sizeof( *p ) ))
335 "%s: failed to malloc for %d bytes (createNewLdcEvent: struct ldcEventDescriptorStruct)",
336 myName, (int)sizeof( *p ) );
341 p->head = p->tail = NULL;
343 gdcDesc = (struct gdcEventDescriptorStruct *)eventsTail;
344 if ( gdcDesc->head == NULL ) {
345 gdcDesc->head = gdcDesc->tail = p;
347 gdcDesc->tail->next = p;
351 } /* End of createNewLdcEvent */
353 void loadBuffer( struct payloadDescriptorStruct * const payload ) {
357 if ( (f = fopen( payload->fileName, "r" )) == NULL ) {
359 "%s: line:%d payload file \"%s\" not found or not readable, errno:%d. ",
364 perror( "System-dependent error " );
367 if ( (payload->data = malloc( payload->size )) == NULL ) {
369 "%s: line:%d Failed to malloc for payload file \"%s\" size:%d errno:%d ",
375 perror( "System-dependent status " );
378 if ( (bytesRead = fread( payload->data, payload->fileSize, 1, f )) != 1 ) {
380 "%s: line:%d Failed to read payload file \"%s\" size:%d requested:1 got:%d feof:%s ferror:%s errno:%d ",
386 feof(f) ? "TRUE" : "false",
387 ferror(f) ? "TRUE" : "false",
389 perror( "System-dependent status " );
393 if ( payload->size != payload->fileSize ) {
394 memset( (char *)payload->data + payload->fileSize,
396 payload->size - payload->fileSize );
398 } /* End of loadBuffer */
400 void unloadBuffer( struct payloadDescriptorStruct * const payload ) {
401 if ( payload->data != NULL ) {
402 free( payload->data );
403 payload->data = NULL;
405 } /* End of unloadBuffer */
407 void unloadAllBuffers() {
408 struct payloadDescriptorStruct *payload;
410 for ( payload = payloadsHead; payload != NULL; payload = payload->next ) {
411 unloadBuffer( payload );
413 } /* End of unloadAllBuffers */
415 void loadPayload( const char *fileName ) {
416 struct payloadDescriptorStruct *payload;
418 for ( payload = payloadsHead; payload != NULL; payload = payload->next ) {
419 if ( strcmp( fileName, payload->fileName ) == 0 )
422 if ( payload == NULL ) {
425 if ( (payload = (struct payloadDescriptorStruct *)malloc( sizeof( *payload ) ))
428 "%s: failed to malloc for %d bytes (loadPayload/payloadDescriptorStruct)\n",
430 (int)sizeof( *payload ) );
433 if ( (payload->fileName = strdup( fileName )) == NULL ) {
435 "%s: failed to duplicate string \"%s\" (loadPaload/fileName)\n",
440 if ( (f = fopen( fileName, "r" )) == NULL ) {
442 "%s: line:%d payload file \"%s\" not found or not readable, errno:%d. ",
447 perror( "System-dependent error " );
450 if ( fseek( f, 0L, SEEK_END ) != 0 ) {
452 "%s: line:%d Failed to seek payload file \"%s\" errno:%d ",
457 perror( "System-dependent error " );
460 if ( (payload->size = ftell( f )) <= 0 ) {
462 "%s: line:%d Failed to get file \"%s\" size size:%d errno:%d ",
468 perror( "System-dependent status " );
471 payload->fileSize = payload->size;
472 while ( (payload->size & 3) != 0 ) payload->size++;
476 loadBuffer( payload );
478 payload->data = NULL;
481 payload->next = NULL;
482 if ( payloadsHead == NULL ) {
483 payloadsHead = payloadsTail = payload;
485 payloadsTail->next = payload;
486 payloadsTail = payload;
491 printf( "%d) Payload \"%s\" loaded at %p\n",
497 struct commonDataHeaderStruct *cdh =
498 (struct commonDataHeaderStruct *)payload->data;
500 printf( " CDH: blockLenght:%d=0x%08x ",
501 cdh->cdhBlockLength, cdh->cdhBlockLength );
502 if ( cdh->cdhBlockLength < sizeof( *cdh ) ) {
503 printf( "TOO SMALL (minimum:%ld=0x%08lx)\n",
504 (unsigned long)sizeof( *cdh ),
505 (unsigned long)sizeof( *cdh ) );
507 printf( "version:%d=0x%x ", cdh->cdhVersion, cdh->cdhVersion );
508 if ( cdh->cdhVersion != CDH_VERSION ) {
509 printf( "EXPECTED:%d=%x (decoding may be inaccurate) ",
510 CDH_VERSION, CDH_VERSION );
513 printf( "L1TriggerMessage:0x%x", cdh->cdhL1TriggerMessage );
514 if ( cdh->cdhL1TriggerMessage != 0 ) {
515 for ( b = 0, n = 0; b != 10; b++ ) {
516 if ( (cdh->cdhL1TriggerMessage & (1<<b)) != 0 ) {
517 if ( n++ != 0 )printf( "+" );
519 case 0: printf( "L1SwC" ); break;
520 case 1: printf( "ESR" ); break;
521 case 2: printf( "RoC1" ); break;
522 case 3: printf( "RoC2" ); break;
523 case 4: printf( "RoC3" ); break;
524 case 5: printf( "RoC4" ); break;
525 case 6: printf( "ClT" ); break;
526 default: printf( "spare %d", b+14 );
533 if ( cdh->cdhMBZ0 != 0 )
534 printf( "MBZ0:0x%x ",
539 printf( "EventId2(orbit):%d=0x%x ",
540 cdh->cdhEventId2, cdh->cdhEventId2 );
541 printf( "EventId1(bunchCrossing):%d=0x%x ",
542 cdh->cdhEventId1, cdh->cdhEventId1 );
546 if ( cdh->cdhMBZ1 != 0 )
547 printf( "MBZ1:0x%x ",
549 printf( "BlockAttributes:0x%x",
550 cdh->cdhBlockAttributes );
551 if ( cdh->cdhBlockAttributes != 0 ) {
553 for ( b = 0, n = 0; b != 8; b++ ) {
554 if ( (cdh->cdhBlockAttributes & (1<<b)) != 0 ) {
563 printf( "ParticipatingSubDetectors:0x%x ",
564 cdh->cdhParticipatingSubDetectors );
568 if ( cdh->cdhMBZ2 != 0 )
569 printf( "MBZ2:0x%x ",
571 printf( "Status/Error:0x%x", cdh->cdhStatusErrorBits );
572 if ( cdh->cdhStatusErrorBits != 0 ) {
574 for ( b = 0,n = 0; b != 16; b++ ) {
575 if ( (cdh->cdhStatusErrorBits & (1<<b)) != 0 ) {
576 if ( n++ != 0 ) printf( "+" );
578 case 0: printf( "TriggerOverLapError" ); break;
579 case 1: printf( "TriggerMissingError" ); break;
580 case 2: printf( "DataParityError" ); break;
581 case 3: printf( "ControlParityError" ); break;
582 case 4: printf( "TriggerInformationUnavailable" ); break;
583 case 5: printf( "FEEError" ); break;
584 case 6: printf( "HLTDecision" ); break;
585 case 7: printf( "HLTPayload" ); break;
586 case 8: printf( "DDGPayload" ); break;
587 default: printf( "spare %d", b );
594 printf( "MiniEventId(bunchCrossing):%d=0x%x ",
595 cdh->cdhMiniEventId, cdh->cdhMiniEventId );
599 printf( "Trigger classes: 0x(%05x-%08x)",
600 cdh->cdhTriggerClassesHigh,
601 cdh->cdhTriggerClassesLow );
602 if ( cdh->cdhTriggerClassesHigh != 0
603 || cdh->cdhTriggerClassesLow != 0 ) {
605 for ( b=0, n=0; b != 32; b++ ) {
606 if ( (cdh->cdhTriggerClassesLow & (1<<b)) != 0 ) {
607 if ( n++ != 0 ) printf( "+" );
611 for ( b=0; b != 18; b++ ) {
612 if ( (cdh->cdhTriggerClassesHigh & (1<<b)) != 0 ) {
613 if ( n++ != 0 ) printf( "+" );
614 printf( "%d", b+32 );
622 if ( cdh->cdhMBZ3 != 0 ) {
623 printf( "MBZ3:0x%x ",
626 printf( "ROI:0x(%08x-%01x)", cdh->cdhRoiHigh, cdh->cdhRoiLow );
627 if ( cdh->cdhRoiHigh != 0
628 || cdh->cdhRoiLow != 0 ) {
630 for ( b=0, n=0; b != 5; b++ ) {
631 if ( (cdh->cdhRoiLow & (1<<b)) != 0 ) {
632 if ( n++ != 0 ) printf( "+" );
636 for ( b=0; b != 32; b++ ) {
637 if ( (cdh->cdhRoiHigh & (1<<b)) != 0 ) {
638 if ( n++ != 0 ) printf( "+" );
650 printf( "%d) Payload \"%s\" already loaded at %p\n",
656 currEvent->payload = payload;
657 } /* End of loadPayload */
659 void parseEquipment( char * const line ) {
660 struct equipmentEventDescriptorStruct *equipment;
661 int payloadFound = FALSE;
666 (struct equipmentEventDescriptorStruct *)malloc( sizeof( *equipment ) )) == NULL ) {
668 "%s: filed to malloc for %d bytes (parseEquipment/equipmentEventDescriptorStruct) errno:%d ",
670 (int)sizeof( *equipment ),
675 currEvent = equipment;
678 while ( (keyword = strtok_r( p, " \t", &p )) != NULL ) {
679 DBG_VERBOSE printf( "%d) Equipment - Keyword:\"%s\"\n",
682 if ( strcasecmp( "id", keyword ) == 0 ) {
685 if ( (idNum = strtok_r( p, " \t", &p )) == NULL ) {
687 "%s: line:%d EQUIPMENT declaration, ID needed",
692 if ( sscanf( idNum, "%d", &currEquipmentId ) != 1 ) {
694 "%s: line:%d EQUIPMENT declaration, numeric ID needed (%s)",
700 DBG_VERBOSE printf( "%d) EQUIPMENT - ID:%d\n",
703 } else if ( strncasecmp( "pay", keyword, 3 ) == 0 ) {
706 if ( (fileName = strtok_r( p, " \t", &p )) == NULL ) {
708 "%s line:%d Payload without filename found\n",
713 DBG_VERBOSE printf( "%d) Equipment - Payload:\"%s\"\n",
716 if ( payloadFound ) {
718 "%s line:%d Payload with multiple filenames found\n",
723 loadPayload( fileName );
727 "%s: line:%d Equipment declaration, unknown keyword \"%s\"\n",
734 if ( !payloadFound ) {
736 "%s: line:%d Equipment without payload found\n",
742 equipment->id = currEquipmentId;
743 equipment->next = NULL;
744 if ( currLdc->head == NULL ) {
745 currLdc->head = currLdc->tail = equipment;
747 currLdc->tail->next = equipment;
748 currLdc->tail = equipment;
750 } /* End of parseEquipment */
752 void parseGdc( char * const line ) {
757 while ( (keyword = strtok_r( p, " \t", &p )) != NULL ) {
758 if ( strcasecmp( "id", keyword ) == 0 ) {
761 if ( (idNum = strtok_r( p, " \t", &p )) == NULL ) {
763 "%s: line:%d GDC declaration, ID needed",
768 if ( sscanf( idNum, "%d", &currGdcId ) != 1 ) {
770 "%s: line:%d GDC declaration, numeric ID needed (%s)",
776 DBG_VERBOSE printf( "%d) GDC - ID:%d\n",
781 "%s: line:%d GDC declaration, unknown keyword \"%s\"\n",
788 } /* End of parseGdc */
790 void parseLdc( char * const line ) {
795 while ( (keyword = strtok_r( p, " \t", &p )) != NULL ) {
796 if ( strcasecmp( "id", keyword ) == 0 ) {
799 if ( (idNum = strtok_r( p, " \t", &p )) == NULL ) {
801 "%s: line:%d LDC declaration, ID needed",
806 if ( sscanf( idNum, "%d", &currLdcId ) != 1 ) {
808 "%s: line:%d LDC declaration, numeric ID needed (%s)",
814 DBG_VERBOSE printf( "%d) LDC - ID:%d\n",
819 "%s: line:%d LDC declaration, unknown keyword \"%s\"\n",
826 } /* End of parseLdc */
831 currLdcId = HOST_ID_MIN;
832 currGdcId = HOST_ID_MIN;
834 for ( lineNo = 1; !feof( stdin ); lineNo++ ) {
835 getLine( line, sizeof(line) );
836 if ( strlen(line) != 0 ) {
840 if ( (keyword = strtok_r( line, " \t", &p )) != NULL ) {
841 DBG_VERBOSE printf( "%d) Keyword:\"%s\"\n", lineNo, keyword );
842 if ( strcasecmp( "gdc", keyword ) == 0 ) {
843 if ( workingAs != gdc && workingAs != unknown ) {
845 "%s: line:%d GDC found when working in non-GDC mode (e.g. as a LDC)\n",
852 currLdcId = HOST_ID_MIN;
855 } else if ( strcasecmp( "ldc", keyword ) == 0 ) {
856 if ( workingAs != gdc && workingAs != ldc && workingAs != unknown ) {
858 "%s: line:%d LDC found when working in non-LDC/GDC mode\n",
862 if ( workingAs == unknown ) workingAs = ldc;
864 if ( workingAs == ldc ) {
869 handleLdc( currLdcId );
873 } else if ( strncasecmp( "equ", keyword, 3 ) == 0 ) {
874 if ( workingAs == unknown
875 || (workingAs == ldc && currLdc == NULL )
876 || (workingAs == gdc && currGdc == NULL ) ) {
878 "%s: line:%d Unexpected EQUIPMENT declaration (LDC or GDC needed first)\n",
887 "%s: line:%d Parse error in \"%s\" unknown keyword\n",
895 } while ( !feof( stdin ) );
899 printf( "End of parse: %d line%s found\n",
901 lineNo != 1 ? "s" : "" );
902 printf( "Working as %s\n",
903 workingAs == gdc ? "GDC" :
904 workingAs == ldc ? "LDC" :
906 if ( workingAs == gdc ) {
907 struct ldcDescriptorStruct *ldc;
909 printf( "LDCs (%d):", numOfLdcs );
910 for ( ldc = ldcsHead; ldc != NULL; ldc = ldc->next ) {
911 printf( " %d", ldc->id );
918 if ( workingAs == ldc ) {
919 assert( ldcsHead == ldcsTail );
920 assert( ldcsTail == NULL );
923 if ( workingAs == gdc ) {
924 struct ldcDescriptorStruct *ldc;
926 assert( ldcsHead != NULL );
927 assert( ldcsTail != NULL );
928 assert( ldcsTail->next == NULL );
929 for ( ldc = ldcsHead; ldc->next != NULL; ldc = ldc->next );
930 assert ( ldc == ldcsTail );
933 if ( workingAs == unknown ) {
934 DBG_VERBOSE printf( "Empty configuration: nothing to do!\n" );
938 assert( (eventsHead == NULL && eventsTail == NULL)
939 || (eventsHead != NULL && eventsTail != NULL) );
940 } /* End of parseRules */
942 void loadTimestamp( struct eventHeaderStruct * const ev ) {
945 if ( time( &t ) == (time_t)-1 ) {
947 "%s: failed to get system time errno:%d (%s)\n",
948 myName, errno, strerror( errno ) );
951 ev->eventTimestamp = (eventTimestampType)t;
952 } /* End of loadTimestamp */
954 void initEvent( struct eventHeaderStruct * const ev ) {
955 memset( ev, 0, sizeof( *ev ) );
957 ev->eventMagic = EVENT_MAGIC_NUMBER;
958 ev->eventHeadSize = EVENT_HEAD_BASE_SIZE;
959 ev->eventVersion = EVENT_CURRENT_VERSION;
960 ev->eventRunNb = currRunNb;
961 ZERO_EVENT_ID( ev->eventId );
962 ZERO_TRIGGER_PATTERN( ev->eventTriggerPattern );
963 ZERO_DETECTOR_PATTERN( ev->eventDetectorPattern );
964 RESET_ATTRIBUTES( ev->eventTypeAttribute );
965 if ( workingMode == collider )
966 SET_SYSTEM_ATTRIBUTE( ev->eventTypeAttribute, ATTR_ORBIT_BC );
967 ev->eventLdcId = VOID_ID;
968 ev->eventGdcId = VOID_ID;
970 } /* End of initEvent */
974 // Swap the endianess of the integer value 'x'
976 return (((x & 0x000000ffU) << 24) | ((x & 0x0000ff00U) << 8) |
977 ((x & 0x00ff0000U) >> 8) | ((x & 0xff000000U) >> 24));
980 void outputEvent( const void * const ev,
985 const long32 * const v = (long32 *)ev;
986 printf( "Writing %d bytes @ %p (%d)\n", size, ev, *v );
989 // .............................Test endianess..............................
991 char* ptemp = (char*) &temp;
993 if (ptemp[0]!=1) { // Mac platform: ptemp != 1..............................................................................
994 int bufSize= size; if (bufSize > (int) sizeof(eventHeaderStruct)) { bufSize = sizeof(eventHeaderStruct); }
995 char* evTemp = (char*) malloc (bufSize);
996 memcpy(evTemp, ev, bufSize);
998 if ((bufSize % sizeof(int)) != 0) {
999 fprintf( stderr, "%s: size of the input buffer ev is not multiple of 4 (size = %d)\n", myName, bufSize);
1003 // Invert header to evTemp.....................................................
1004 int* buf = (int*) evTemp;
1005 for (int i=0; i < (int) (bufSize / sizeof(int)); i++, buf++) {
1006 int value = Swap(*buf);
1007 memcpy(evTemp + (i * sizeof(int)), &value, sizeof(int));
1010 // Write inverted header to file...............................................
1011 if ((done = fwrite( evTemp, bufSize, 1, outF )) != 1 ) {
1012 fprintf( stderr, "%s: failed to write inverted header. event size:%d bytes, errno:%d (%s)\n", myName, size, errno, strerror( errno ) );
1016 if (size > bufSize) { // Still theraw-data payload to write (but not inverted, since it is inverted eariler).............
1017 if ((done = fwrite( (char*)ev + bufSize, size - bufSize, 1, outF )) != 1 ) {
1018 fprintf( stderr, "%s: failed to write additional event size:%d bytes, errno:%d (%s)\n", myName, size, errno, strerror( errno ) );
1025 else { // Intel platform: ptemp == 1............................................................................
1026 if ((done = fwrite( ev, size, 1, outF )) != 1 ) {
1027 fprintf( stderr, "%s: failed to write event size:%d bytes, errno:%d (%s)\n", myName, size, errno, strerror( errno ) );
1031 } /* End of outputEvent */
1033 void createSorAndEor( const int sor ) {
1034 unsigned char event[ 1000 ];
1035 struct eventHeaderStruct *ev;
1036 struct eventHeaderStruct sev;
1038 assert( workingAs == ldc || workingAs == gdc );
1040 if ( !createSorEor ) return;
1041 ev = (struct eventHeaderStruct *)event;
1043 ev->eventSize = sizeof( event );
1044 ev->eventType = sor ? START_OF_RUN : END_OF_RUN;
1045 if ( workingMode == fixedTarget )
1046 LOAD_RAW_EVENT_ID( ev->eventId, 0, 0, 0 );
1048 LOAD_EVENT_ID( ev->eventId, 0, 0, 0 );
1049 SET_SYSTEM_ATTRIBUTE( ev->eventTypeAttribute, ATTR_P_START );
1051 if ( workingAs == ldc ) {
1052 currLdc = (struct ldcEventDescriptorStruct *)eventsHead;
1054 if ( workingAs == gdc ) {
1056 sev.eventGdcId = currGdcId;
1057 ev->eventGdcId = currGdcId;
1058 currGdc = (struct gdcEventDescriptorStruct *)eventsHead;
1059 currLdc = currGdc->head;
1061 ev->eventLdcId = currLdc->id;
1063 if ( workingAs == ldc ) {
1064 loadTimestamp( ev );
1065 outputEvent( ev, ev->eventSize );
1067 if ( workingAs == gdc ) {
1068 struct ldcDescriptorStruct *ldc;
1070 loadTimestamp( ev );
1072 sev.eventSize = sizeof( sev ) + numOfLdcs * ev->eventSize;
1073 sev.eventType = sor ? START_OF_RUN : END_OF_RUN ;
1074 COPY_EVENT_ID( ev->eventId, sev.eventId );
1075 COPY_SYSTEM_ATTRIBUTES( ev->eventTypeAttribute, sev.eventTypeAttribute );
1076 SET_SYSTEM_ATTRIBUTE( sev.eventTypeAttribute, ATTR_SUPER_EVENT );
1077 loadTimestamp( &sev );
1078 outputEvent( &sev, sizeof( sev ) );
1080 ev->eventGdcId = currGdcId;
1081 for ( ldc = ldcsHead; ldc != NULL; ldc = ldc->next ) {
1082 ev->eventLdcId = ldc->id;
1083 outputEvent( ev, ev->eventSize );
1087 ADD_EVENT_ID( ev->eventId, oneEventDelta );
1088 ev->eventSize = ev->eventSize / 2;
1089 ev->eventType = sor ? START_OF_RUN_FILES : END_OF_RUN_FILES;
1090 CLEAR_SYSTEM_ATTRIBUTE( ev->eventTypeAttribute, ATTR_P_START );
1091 if ( workingAs == ldc ) {
1092 loadTimestamp( ev );
1093 outputEvent( ev, ev->eventSize );
1095 if ( workingAs == gdc ) {
1096 struct ldcDescriptorStruct *ldc;
1098 loadTimestamp( ev );
1100 sev.eventSize = ev->eventSize;
1101 sev.eventType = sor ? START_OF_RUN_FILES : END_OF_RUN_FILES;
1102 COPY_EVENT_ID( ev->eventId, sev.eventId );
1103 COPY_SYSTEM_ATTRIBUTES( ev->eventTypeAttribute, sev.eventTypeAttribute );
1104 CLEAR_SYSTEM_ATTRIBUTE( sev.eventTypeAttribute, ATTR_SUPER_EVENT );
1105 outputEvent( &sev, sizeof( sev ) );
1106 outputEvent( ev, ev->eventSize - sizeof( sev ) );
1108 sev.eventSize = sizeof( sev ) + ev->eventSize;
1109 sev.eventType = sor ? START_OF_RUN_FILES : END_OF_RUN_FILES;
1110 COPY_EVENT_ID( ev->eventId, sev.eventId );
1111 COPY_SYSTEM_ATTRIBUTES( ev->eventTypeAttribute, sev.eventTypeAttribute );
1112 SET_SYSTEM_ATTRIBUTE( sev.eventTypeAttribute, ATTR_SUPER_EVENT );
1114 loadTimestamp( &sev );
1116 ev->eventGdcId = currGdcId;
1117 for ( ldc = ldcsHead; ldc != NULL; ldc = ldc->next ) {
1118 loadTimestamp( &sev );
1119 outputEvent( &sev, sizeof( sev ) );
1120 ev->eventLdcId = ldc->id;
1121 outputEvent( ev, ev->eventSize );
1125 ADD_EVENT_ID( ev->eventId, oneEventDelta );
1126 ev->eventSize = sizeof( *ev );
1127 ev->eventType = sor ? START_OF_RUN : END_OF_RUN;
1128 SET_SYSTEM_ATTRIBUTE( ev->eventTypeAttribute, ATTR_P_END );
1129 if ( workingAs == ldc ) {
1130 loadTimestamp( ev );
1131 outputEvent( ev, ev->eventSize );
1133 if ( workingAs == gdc ) {
1134 struct ldcDescriptorStruct *ldc;
1136 loadTimestamp( ev );
1138 sev.eventSize = sizeof( sev ) + numOfLdcs * ev->eventSize;
1139 sev.eventType = sor ? START_OF_RUN : END_OF_RUN;
1140 COPY_EVENT_ID( ev->eventId, sev.eventId );
1141 COPY_SYSTEM_ATTRIBUTES( ev->eventTypeAttribute, sev.eventTypeAttribute );
1142 SET_SYSTEM_ATTRIBUTE( sev.eventTypeAttribute, ATTR_SUPER_EVENT );
1143 loadTimestamp( &sev );
1145 outputEvent( &sev, sizeof( sev ) );
1147 for ( ldc = ldcsHead; ldc != NULL; ldc = ldc->next ) {
1148 ev->eventLdcId = ldc->id;
1149 outputEvent( ev, ev->eventSize );
1152 } /* End of createSorEor */
1155 createSorAndEor( TRUE );
1156 } /* End of createSor */
1159 createSorAndEor( FALSE );
1160 } /* End of createEor */
1162 void loadCdh( struct commonDataHeaderStruct * const cdh,
1163 eventIdType * const eventId ) {
1164 if ( !handleCDH ) return;
1166 if ( gotAliceTrigger ) {
1167 cdh->cdhEventId1 = EVENT_ID_GET_BUNCH_CROSSING( *eventId );
1168 cdh->cdhEventId2 = EVENT_ID_GET_ORBIT( *eventId );
1170 cdh->cdhEventId1 = 0;
1171 cdh->cdhEventId2 = EVENT_ID_GET_NB_IN_RUN( *eventId );
1173 cdh->cdhMiniEventId = cdh->cdhEventId1;
1175 void decodeCDH( struct ldcEventDescriptorStruct * const ldc,
1176 const struct payloadDescriptorStruct * const payloadDesc );
1178 void createEvent( void ) {
1179 assert( workingAs == ldc || workingAs == gdc );
1181 /* Step 1: load all buffers (if needed) and compose the GDC/LDC headers */
1182 if ( workingAs == gdc ) {
1183 struct ldcEventDescriptorStruct *ldc;
1185 for( ldc = currGdc->head; ldc != NULL; ldc = ldc->next ) {
1186 COPY_EVENT_ID( currEventId, ldc->header.eventId );
1187 loadTimestamp( &ldc->header );
1189 COPY_EVENT_ID( currEventId, currGdc->header.eventId );
1190 loadTimestamp( &currGdc->header );
1192 for( ldc = currGdc->head; ldc != NULL; ldc = ldc->next ) {
1193 struct equipmentEventDescriptorStruct *eq;
1196 for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
1197 if ( !bufferData ) {
1198 loadBuffer( eq->payload );
1199 decodeCDH( ldc, eq->payload );
1201 loadCdh( (struct commonDataHeaderStruct*)eq->payload->data,
1205 if ( !currGdc->loaded ) {
1206 for ( n = 0; n != EVENT_TRIGGER_PATTERN_WORDS; n++ )
1207 currGdc->header.eventTriggerPattern[n] |= ldc->header.eventTriggerPattern[n];
1208 for ( n = 0; n != EVENT_DETECTOR_PATTERN_WORDS; n++ )
1209 currGdc->header.eventDetectorPattern[n] |= ldc->header.eventDetectorPattern[n];
1210 for ( n = 0; n != ALL_ATTRIBUTE_WORDS; n++ )
1211 currGdc->header.eventTypeAttribute[n] |= ldc->header.eventTypeAttribute[n];
1212 currGdc->loaded = TRUE;
1216 } else if ( workingAs == ldc ) {
1217 struct equipmentEventDescriptorStruct *eq;
1219 COPY_EVENT_ID( currEventId, currLdc->header.eventId );
1220 loadTimestamp( &currLdc->header );
1222 for ( eq = currLdc->head; eq != NULL; eq = eq->next ) {
1223 if ( !bufferData ) {
1224 loadBuffer( eq->payload );
1225 decodeCDH( currLdc, eq->payload );
1227 loadCdh( (struct commonDataHeaderStruct*)eq->payload->data,
1229 currLdc->loaded = TRUE;
1233 ADD_EVENT_ID( currEventId, oneEventDelta );
1235 /* Step 2: output the event */
1236 if ( workingAs == gdc ) {
1237 struct ldcEventDescriptorStruct *ldc;
1239 outputEvent( &currGdc->header, sizeof( currGdc->header ) );
1241 for( ldc = currGdc->head; ldc != NULL; ldc = ldc->next ) {
1242 struct equipmentEventDescriptorStruct *eq;
1244 outputEvent( &ldc->header, sizeof( ldc->header ) );
1246 for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
1247 outputEvent( &eq->header, sizeof( eq->header ) );
1248 outputEvent( eq->payload->data, eq->payload->size );
1249 if ( !bufferData ) unloadBuffer( eq->payload );
1252 if ( (currGdc = currGdc->next) == NULL )
1253 currGdc = (struct gdcEventDescriptorStruct *)eventsHead;
1254 } else if ( workingAs == ldc ) {
1255 struct equipmentEventDescriptorStruct *eq;
1257 outputEvent( &currLdc->header, sizeof( currLdc->header ) );
1259 for ( eq = currLdc->head; eq != NULL; eq = eq->next ) {
1260 outputEvent( &eq->header, sizeof( eq->header ) );
1261 outputEvent( eq->payload->data, eq->payload->size );
1262 if ( !bufferData ) unloadBuffer( eq->payload );
1264 if ( (currLdc = currLdc->next) == NULL )
1265 currLdc = (struct ldcEventDescriptorStruct *)eventsHead;
1267 } /* End of createEvent */
1269 void createEvents() {
1272 currGdc = (struct gdcEventDescriptorStruct *)eventsHead;
1273 currLdc = (struct ldcEventDescriptorStruct *)eventsHead;
1278 eventNum != numOfEvents && numOfEvents != 0;
1283 } /* End of createEvents */
1287 "Usage: %s [-?][-d][-i definitionFile][-o outputFile][-# numOfEvents][-s][-F|-C]\n\
1289 -v Print version ID and exit\n\
1290 -d Enable debug (repeat for more verbosity)\n\
1291 -i definitionFile File with the description of the events to create (default: stdin)\n\
1292 -o outputFile File used to store events (default: stdout)\n\
1293 -# numOfEvents Number of events to generate (default: 1 event)\n\
1294 -s Do not generate SOR/EOR files (valid only for GDCs)\n\
1295 -F/-C Working in Fixed Target (F) or Collider (C) mode\n\
1297 -D Direct disc access (no buffering)\n",
1300 } /* End of usage */
1302 void parseArgs( int argc, char **argv ) {
1304 int inFileName = -1;
1305 int outFileName = -1;
1308 while ( arg < argc ) {
1309 if ( strcmp( "-?", argv[ arg ] ) == 0 ) {
1313 if ( strcmp( "-i", argv[ arg ] ) == 0 ) {
1314 if ( ++arg == argc ) exit( usage() );
1316 if ( freopen( argv[arg], "r", stdin ) == NULL ){
1318 "%s: failed to open input definition \"%s\" errno:%d ",
1319 myName, argv[arg], errno );
1323 } else if ( strcmp( "-v", argv[ arg ] ) == 0 ) {
1324 printf( "%s\n", fileHandlerIdent );
1326 } else if ( strcmp( "-o", argv[ arg ] ) == 0 ) {
1327 if ( ++arg == argc ) exit( usage() );
1329 } else if ( strcmp( "-#", argv[ arg ] ) == 0 ) {
1332 if ( ++arg == argc ) exit( usage() );
1333 if ( sscanf( argv[ arg ], "%d", &n ) != 1 ) exit( usage() );
1334 if ( n < 0 ) exit( usage() );
1336 } else if ( strcmp( "-s", argv[ arg ] ) == 0 ) {
1337 createSorEor = FALSE;
1338 } else if ( strcmp( "-F", argv[ arg ] ) == 0 ) {
1339 workingMode = fixedTarget;
1340 } else if ( strcmp( "-C", argv[ arg ] ) == 0 ) {
1341 workingMode = collider;
1342 } else if ( strcmp( "-d", argv[ arg ] ) == 0 ) {
1344 } else if ( strcmp( "-c", argv[ arg ] ) == 0 ) {
1346 } else if ( strcmp( "-D", argv[ arg ] ) == 0 ) {
1348 } else if ( strcmp( "-run", argv[ arg ] ) == 0 ) {
1350 if ( ++arg == argc ) exit( usage() );
1351 if ( sscanf( argv[ arg ], "%d", &runnumber ) != 1 ) exit( usage() );
1352 if ( runnumber < 0 ) exit( usage() );
1353 currRunNb = runnumber;
1355 fprintf( stderr, "%s: Unknown switch \"%s\"\n", myName, argv[argc] );
1361 if ( workingMode == fixedTarget )
1362 LOAD_RAW_EVENT_ID( oneEventDelta, 1, 0, 1 );
1364 LOAD_EVENT_ID( oneEventDelta, 0, 0, 1 );
1365 ZERO_EVENT_ID( currEventId );
1368 printf( "Configuration:\n" );
1369 printf( " Debug level: %d\n", debug );
1370 printf( " Configuration: %s\n",
1371 inFileName == -1 ? "stdin" : argv[ inFileName ] );
1372 printf( " Output: %s\n",
1373 outFileName == -1 ? "stdout" : argv[ outFileName ] );
1374 printf( " Working mode: %s\n",
1375 workingMode == fixedTarget ? "fixed target" : "collider" );
1376 printf( " Number of events: %d\n", numOfEvents );
1377 printf( " %s SOR/EOR files\n",
1378 createSorEor ? "Create" : "Do not create" );
1379 printf( " CDH handling: %s\n",
1380 handleCDH ? "enabled" : "disabled" );
1381 printf( " data buffering: %s\n",
1382 bufferData ? "enabled" : "DISABLED" );
1385 if ( outFileName == -1 ) {
1387 printf( "No more trace information from this point...\n" );
1391 if ( ( outF = fopen( argv[ outFileName ], "w" ) ) == NULL ) {
1393 "%s: failed to open output file \"%s\" for writing, errno:%d (%s)\n",
1395 argv[ outFileName ],
1397 strerror( errno ) );
1401 printf( "Output file \"%s\" opened OK for writing\n",
1402 argv[ outFileName ] );
1404 } /* End of parseArgs */
1405 void initEquipment( struct equipmentHeaderStruct * const eq ) {
1406 memset( eq, 0, sizeof( *eq ) );
1407 RESET_ATTRIBUTES( eq->equipmentTypeAttribute );
1408 eq->equipmentBasicElementSize = 4;
1409 } /* End of initEquipment */
1411 void decodeCDH( struct ldcEventDescriptorStruct * const ldc,
1412 const struct payloadDescriptorStruct * const payloadDesc ) {
1414 struct commonDataHeaderStruct *cdh;
1415 static int softwareTriggerIndicator = FALSE;
1419 if ( payloadDesc->size < CDH_SIZE ) {
1421 "%s: payload too small got:%d CDH:%d\n",
1427 if ( (cdh = (struct commonDataHeaderStruct *)payloadDesc->data) != NULL ) {
1428 if ( cdh->cdhVersion != CDH_VERSION ) {
1430 "%s: CDH version mismatch expected:%d got:%d\n",
1436 if ( cdhRef == NULL ) {
1438 #define CDH_TRIGGER_INFORMATION_UNAVAILABLE_MASK (1<<CDH_TRIGGER_INFORMATION_UNAVAILABLE_BIT)
1439 gotAliceTrigger = (cdhRef->cdhStatusErrorBits & CDH_TRIGGER_INFORMATION_UNAVAILABLE_MASK) == 0;
1440 if ( gotAliceTrigger && workingMode == fixedTarget ) {
1442 "%s: ALICE trigger and fixed target mode are not compatible.\n\
1443 Either work in Collider mode or set the trigger unavailable status bit in the CDH.\n",
1447 if ( gotAliceTrigger ) {
1448 if ( (cdh->cdhL1TriggerMessage & 0x40) != 0 ) {
1450 "%s: CDH is a calibration trigger (unsupported) L1TriggerMessage:0x%x\n",
1451 myName, cdh->cdhL1TriggerMessage );
1454 if ( (cdh->cdhL1TriggerMessage & 0x01) != 0 ) {
1455 softwareTriggerIndicator = TRUE;
1457 if ( softwareTriggerIndicator ) {
1458 switch ((cdh->cdhL1TriggerMessage >> 2) & 0xF) {
1466 /* L1SwC bit = on, Clt bit = off, RoC[4..1] = 0xF --> END_OF_DATA */
1468 /* L1SwC bit = on, Clt bit = off, RoC[4..1] = 0xE0 --> START_OF_DATA */
1470 /* L1SwC bit = on, Clt bit = off, RoC[4] = 1, but not 0xE or 0xF
1471 --> SYSTEM_SOFTWARE_TRIGGER_EVENT */
1473 /* L1SwC bit = on, Clt bit = off, RoC[4] = 0
1474 --> DETECTOR_SOFTWARE_TRIGGER_EVENT */
1476 "%s: CDH trigger SOD/EOD/SST/DST (unsupported) \
1477 L1TriggerMessage:0x%x ALICETrigger:%s\n",
1479 cdh->cdhL1TriggerMessage,
1480 gotAliceTrigger ? "yes" : "no" );
1486 if ( (cdh->cdhStatusErrorBits & CDH_TRIGGER_INFORMATION_UNAVAILABLE_MASK) !=
1487 (cdhRef->cdhStatusErrorBits & CDH_TRIGGER_INFORMATION_UNAVAILABLE_MASK) ) {
1489 "%s: CDH coherency check failed. \
1490 Trigger information reference:%savailable current:%savailable\n",
1492 (cdhRef->cdhStatusErrorBits & CDH_TRIGGER_INFORMATION_UNAVAILABLE_MASK) == 0 ? "UN" : "",
1493 (cdh->cdhStatusErrorBits & CDH_TRIGGER_INFORMATION_UNAVAILABLE_MASK) == 0 ? "UN" : "" );
1496 if ( gotAliceTrigger ) {
1497 if ( cdhRef->cdhL1TriggerMessage != cdh->cdhL1TriggerMessage ) {
1499 "%s: CDH coherency check failed. \
1500 L1 trigger message reference:0x%x current:0x%x\n",
1502 cdhRef->cdhL1TriggerMessage,
1503 cdh->cdhL1TriggerMessage );
1506 if ( cdh->cdhParticipatingSubDetectors != cdhRef->cdhParticipatingSubDetectors ) {
1508 "%s: CDH coherency check failed. \
1509 ParticipatingSubDetectors reference:0x%x current:0x%x\n",
1511 cdhRef->cdhParticipatingSubDetectors,
1512 cdh->cdhParticipatingSubDetectors );
1515 if ( cdh->cdhTriggerClassesLow != cdhRef->cdhTriggerClassesLow
1516 || cdh->cdhTriggerClassesHigh != cdhRef->cdhTriggerClassesHigh ) {
1518 "%s: CDH coherency check failed. \
1519 TriggerClassesHigh/Low reference:0x%x-%x current:0x%x-%x\n",
1521 cdhRef->cdhTriggerClassesHigh, cdhRef->cdhTriggerClassesLow,
1522 cdh ->cdhTriggerClassesHigh, cdh ->cdhTriggerClassesLow );
1525 if ( cdh->cdhBlockLength != 0xffffffff ) {
1526 if ( (unsigned)payloadDesc->size != cdh->cdhBlockLength ) {
1528 "%s: CDH coherency check failed. \
1529 Payload size:%d (0x%08x) CDH block length:%d (0x%08x)\n",
1531 payloadDesc->size, payloadDesc->size,
1532 cdh->cdhBlockLength, cdh->cdhBlockLength );
1536 if ( cdh->cdhRoiLow != cdhRef->cdhRoiLow
1537 || cdh->cdhRoiHigh != cdhRef->cdhRoiHigh ) {
1539 "%s: CDH coherency check failed. \
1540 RoiHigh/Low reference:0x%x-%x current:0x%x-%x\n",
1542 cdhRef->cdhRoiHigh, cdhRef->cdhRoiLow,
1543 cdh ->cdhRoiHigh, cdh ->cdhRoiLow );
1547 if ( cdh->cdhMBZ0 != 0
1548 || cdh->cdhMBZ1 != 0
1549 || cdh->cdhMBZ2 != 0
1550 || cdh->cdhMBZ3 != 0 ) {
1552 "%s: CDH check failed. MBZ0:0x%x MBZ1:0x%x MBZ2:0x%x MBZ3:0x%x\n",
1554 cdh->cdhMBZ0, cdh->cdhMBZ1, cdh->cdhMBZ2, cdh->cdhMBZ3 );
1558 for ( attr = 0; attr != 8; attr++ ) {
1559 if ( (cdh->cdhBlockAttributes & (1<<attr)) != 0 ) {
1560 SET_USER_ATTRIBUTE( ldc->header.eventTypeAttribute, attr );
1563 for ( trig = 0; trig != 32; trig++ ) {
1564 if ( (cdh->cdhTriggerClassesLow & (1<<trig)) != 0 ) {
1565 SET_TRIGGER_IN_PATTERN( ldc->header.eventTriggerPattern,
1569 for ( trig = 0; trig != 18; trig++ ) {
1570 if ( (cdh->cdhTriggerClassesHigh & (1<<trig)) != 0 ) {
1571 SET_TRIGGER_IN_PATTERN( ldc->header.eventTriggerPattern,
1575 if ( gotAliceTrigger )
1576 VALIDATE_TRIGGER_PATTERN( ldc->header.eventTriggerPattern );
1579 } /* End of decodeCDH */
1582 assert( workingAs == ldc || workingAs == gdc );
1584 if ( workingAs == gdc ) {
1585 struct gdcEventDescriptorStruct *gdc;
1587 for ( gdc = (struct gdcEventDescriptorStruct *)eventsHead;
1590 struct ldcEventDescriptorStruct *ldc;
1592 initEvent( &gdc->header );
1593 gdc->header.eventSize = gdc->header.eventHeadSize;
1594 gdc->header.eventType = PHYSICS_EVENT;
1595 SET_SYSTEM_ATTRIBUTE( gdc->header.eventTypeAttribute, ATTR_SUPER_EVENT );
1596 gdc->header.eventGdcId = currGdcId;
1597 for ( ldc = gdc->head; ldc != NULL; ldc = ldc->next ) {
1598 struct equipmentEventDescriptorStruct *eq;
1600 initEvent( &ldc->header );
1601 ldc->header.eventSize = ldc->header.eventHeadSize;
1602 ldc->header.eventType = PHYSICS_EVENT;
1603 ldc->header.eventGdcId = currGdcId;
1604 ldc->header.eventLdcId = ldc->id;
1605 for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
1606 initEquipment( &eq->header );
1607 eq->header.equipmentId = eq->id;
1608 if ( workingMode == collider )
1609 SET_SYSTEM_ATTRIBUTE( eq->header.equipmentTypeAttribute,
1611 eq->header.equipmentSize = eq->payload->size + sizeof( eq->header );
1612 ldc->header.eventSize += eq->header.equipmentSize;
1613 decodeCDH( ldc, eq->payload );
1614 OR_ALL_ATTRIBUTES( eq->header.equipmentTypeAttribute,
1615 ldc->header.eventTypeAttribute );
1616 OR_ALL_ATTRIBUTES( eq->header.equipmentTypeAttribute,
1617 gdc->header.eventTypeAttribute );
1619 gdc->header.eventSize += ldc->header.eventSize;
1625 printf( "Headers:\n" );
1626 for ( gdc = (struct gdcEventDescriptorStruct *)eventsHead;
1629 struct ldcEventDescriptorStruct *ldc;
1631 printf( " GDC:%d size:%d vers:%08x\n",
1633 gdc->header.eventSize,
1634 gdc->header.eventVersion);
1635 for ( ldc = gdc->head; ldc != NULL; ldc = ldc->next ) {
1636 struct equipmentEventDescriptorStruct *eq;
1638 printf( " LDC:%d size:%d vers:%08x\n",
1640 ldc->header.eventSize,
1641 ldc->header.eventVersion );
1642 for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
1643 printf( " EQ:%d size:%d %spayload:%d\n",
1645 eq->header.equipmentSize,
1646 eq->header.equipmentSize - sizeof( struct equipmentHeaderStruct ) == (unsigned)eq->payload->size ? "" : "-ERROR",
1647 eq->payload->size );
1652 } else if ( workingAs == ldc ) {
1653 struct ldcEventDescriptorStruct *ldc;
1655 for ( ldc = (struct ldcEventDescriptorStruct *)eventsHead;
1658 struct equipmentEventDescriptorStruct *eq;
1660 initEvent( &ldc->header );
1661 ldc->header.eventSize = ldc->header.eventHeadSize;
1662 ldc->header.eventType = PHYSICS_EVENT;
1663 ldc->header.eventGdcId = VOID_ID;
1664 ldc->header.eventLdcId = ldc->id;
1665 for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
1666 initEquipment( &eq->header );
1667 eq->header.equipmentId = eq->id;
1668 if ( workingMode == collider )
1669 SET_SYSTEM_ATTRIBUTE( eq->header.equipmentTypeAttribute,
1671 eq->header.equipmentSize = eq->payload->size + sizeof( eq->header );
1672 ldc->header.eventSize += eq->header.equipmentSize;
1673 decodeCDH( ldc, eq->payload );
1674 OR_ALL_ATTRIBUTES( eq->header.equipmentTypeAttribute,
1675 ldc->header.eventTypeAttribute );
1680 printf( "Headers:\n" );
1681 for ( ldc = (struct ldcEventDescriptorStruct *)eventsHead;
1684 struct equipmentEventDescriptorStruct *eq;
1686 printf( " LDC:%d size:%d vers:%08x\n",
1688 ldc->header.eventSize,
1689 ldc->header.eventVersion );
1690 for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
1691 printf( " EQ:%d size:%d %spayload:%d\n",
1693 eq->header.equipmentSize,
1694 eq->header.equipmentSize - sizeof( struct equipmentHeaderStruct ) == (unsigned)eq->payload->size ? "" : "-ERROR",
1695 eq->payload->size );
1700 } /* End of initEvents */
1704 workingAs = unknown;
1705 workingMode = fixedTarget;
1706 ldcsHead = ldcsTail = NULL;
1707 eventsHead = eventsTail = NULL;
1711 payloadsHead = payloadsTail = NULL;
1715 createSorEor = TRUE;
1717 gotAliceTrigger = TRUE;
1719 } /* End of initVars */
1721 int main( int argc, char **argv ) {
1723 parseArgs( argc, argv );