#include <assert.h>
#include <ctype.h>
#include <time.h>
-
+#include <cassert>
#include "event.h"
#define DESCRIPTION "DATE raw data stream simulator"
const char *myName;
int debug;
FILE *outF;
-enum { unknown, ldc, gdc } workingAs;
-enum { collider, fixedTarget } workingMode;
+typedef enum { unknown, ldc, gdc } workingAsType;
+typedef enum { collider, fixedTarget } workingModeType;
+workingAsType workingAs;
+workingModeType workingMode;
struct ldcDescriptorStruct {
eventLdcIdType id;
struct ldcDescriptorStruct *next;
} *payloadsHead, *payloadsTail;
int lineNo;
eventGdcIdType currGdcId;
+unsigned long32 currDetPattern;
eventLdcIdType currLdcId;
equipmentIdType currEquipmentId;
int currRunNb;
int gotAliceTrigger;
int bufferData;
+struct commonDataHeaderStruct *cdhRef = NULL;
+
void dumpPayload( const struct payloadDescriptorStruct *p ) {
char *c;
int i;
}
if ( i < p->size ) {
int j = 0;
-
+
printf( "\n " );
while ( i != p->size ) {
printf( "%02x ", *((char *)p->data + p->size - j - 1) & 0xff );
gdc = gdc->next ) {
struct ldcEventDescriptorStruct *ldc;
- printf( " GDC (%p)\n", gdc );
+ printf( " GDC (%p)\n", (void*)gdc );
for ( ldc = gdc->head; ldc != NULL; ldc = ldc->next ) {
struct equipmentEventDescriptorStruct *eq;
- printf( " LDC (%p): %d\n", ldc, ldc->id );
+ printf( " LDC (%p): %d\n", (void*)ldc, ldc->id );
for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
printf( " EQUIPMENT (%p): %d PAYLOAD (%p):",
- eq,
+ (void*)eq,
eq->id,
- eq->payload );
+ (void*)eq->payload );
fflush( stdout );
printf( "\"%s\" (%d bytes)\n",
eq->payload->fileName,
printf( " LDC\n" );
for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
printf( " EQUIPMENT (%p): %d PAYLOAD (%p):",
- eq,
+ (void*)eq,
eq->id,
- eq->payload );
+ (void*)eq->payload );
fflush( stdout );
printf( "\"%s\" (%d bytes)\n",
eq->payload->fileName,
void getLine( char *line, const int maxSize ) {
int read;
int c;
-
+
for ( read = 0; !feof( stdin ) && !ferror( stdin ) && read != maxSize; read++ ) {
if ( (line[read] = getchar()) == '\n' ) break;
}
} else {
struct ldcEventDescriptorStruct *q =
(struct ldcEventDescriptorStruct *)eventsTail;
-
+
q->next = p;
eventsTail = p;
}
} else {
struct gdcEventDescriptorStruct *q =
(struct gdcEventDescriptorStruct *)eventsTail;
-
+
q->next = p;
eventsTail = p;
}
void loadBuffer( struct payloadDescriptorStruct * const payload ) {
FILE *f;
int bytesRead;
-
+
if ( (f = fopen( payload->fileName, "r" )) == NULL ) {
fprintf( stderr,
"%s: line:%d payload file \"%s\" not found or not readable, errno:%d. ",
}
if ( payload == NULL ) {
FILE *f;
-
+
if ( (payload = (struct payloadDescriptorStruct *)malloc( sizeof( *payload ) ))
== NULL ) {
fprintf( stderr,
payload->fileSize = payload->size;
while ( (payload->size & 3) != 0 ) payload->size++;
fclose( f );
-
+
if ( bufferData ) {
loadBuffer( payload );
} else {
}
DBG_VERBOSE {
int b, n;
-
+
printf( "%d) Payload \"%s\" loaded at %p\n",
lineNo,
fileName,
- payload );
+ (void*)payload );
if ( bufferData ) {
- if ( handleCDH ) {
+ if ( handleCDH &&
+ strncmp(fileName,"TRG_",4) != 0 ) {
struct commonDataHeaderStruct *cdh =
(struct commonDataHeaderStruct *)payload->data;
printf( " CDH: blockLenght:%d=0x%08x ",
cdh->cdhBlockLength, cdh->cdhBlockLength );
if ( cdh->cdhBlockLength < sizeof( *cdh ) ) {
- printf( "TOO SMALL (minimum:%d=0x%08x)\n",
- sizeof( *cdh ), sizeof( *cdh ) );
+ printf( "TOO SMALL (minimum:%ld=0x%08lx)\n",
+ (unsigned long)sizeof( *cdh ),
+ (unsigned long)sizeof( *cdh ) );
} else {
printf( "version:%d=0x%x ", cdh->cdhVersion, cdh->cdhVersion );
if ( cdh->cdhVersion != CDH_VERSION ) {
printf( "%d) Payload \"%s\" already loaded at %p\n",
lineNo,
fileName,
- payload );
+ (void*)payload );
}
currEvent->payload = payload;
void parseGdc( char * const line ) {
char *p;
char *keyword;
-
+
p = line;
while ( (keyword = strtok_r( p, " \t", &p )) != NULL ) {
if ( strcasecmp( "id", keyword ) == 0 ) {
lineNo );
exit( 1 );
}
- if ( sscanf( idNum, "%d", &currGdcId ) != 1 ) {
+ if ( sscanf( idNum, "%d", (int*)&currGdcId ) != 1 ) {
fprintf( stderr,
"%s: line:%d GDC declaration, numeric ID needed (%s)",
myName,
DBG_VERBOSE printf( "%d) GDC - ID:%d\n",
lineNo,
currGdcId );
+ } else if ( strcasecmp( "DetectorPattern", keyword ) == 0 ) {
+ char *detPattern;
+
+ if ( (detPattern = strtok_r( p, " \t", &p )) == NULL ) {
+ fprintf( stderr,
+ "%s: line:%d GDC declaration, DetectorPattern needed",
+ myName,
+ lineNo );
+ exit( 1 );
+ }
+ if ( sscanf( detPattern, "%u", &currDetPattern ) != 1 ) {
+ fprintf( stderr,
+ "%s: line:%d GDC declaration, numeric DetectorPattern needed (%s)",
+ myName,
+ lineNo,
+ detPattern );
+ exit( 1 );
+ }
+ DBG_VERBOSE printf( "%d) GDC - DetectorPattern:%u\n",
+ lineNo,
+ currDetPattern );
} else {
fprintf( stderr,
"%s: line:%d GDC declaration, unknown keyword \"%s\"\n",
void parseLdc( char * const line ) {
char *p;
char *keyword;
-
+
p = line;
while ( (keyword = strtok_r( p, " \t", &p )) != NULL ) {
if ( strcasecmp( "id", keyword ) == 0 ) {
lineNo );
exit( 1 );
}
- if ( sscanf( idNum, "%d", &currLdcId ) != 1 ) {
+ if ( sscanf( idNum, "%d", (int*)&currLdcId ) != 1 ) {
fprintf( stderr,
"%s: line:%d LDC declaration, numeric ID needed (%s)",
myName,
currLdcId = HOST_ID_MIN;
currGdcId = HOST_ID_MIN;
+ currDetPattern = 0;
for ( lineNo = 1; !feof( stdin ); lineNo++ ) {
getLine( line, sizeof(line) );
}
}
}
- } while ( !feof( stdin ) );
+ } while ( !feof( stdin ) ) {}
lineNo -= 2;
DBG_VERBOSE {
"UNKNOWN" );
if ( workingAs == gdc ) {
struct ldcDescriptorStruct *ldc;
-
+
printf( "LDCs (%d):", numOfLdcs );
for ( ldc = ldcsHead; ldc != NULL; ldc = ldc->next ) {
printf( " %d", ldc->id );
if ( workingAs == gdc ) {
struct ldcDescriptorStruct *ldc;
-
+
assert( ldcsHead != NULL );
assert( ldcsTail != NULL );
assert( ldcsTail->next == NULL );
- for ( ldc = ldcsHead; ldc->next != NULL; ldc = ldc->next );
+ for ( ldc = ldcsHead; ldc->next != NULL; ldc = ldc->next ) {}
assert ( ldc == ldcsTail );
}
void loadTimestamp( struct eventHeaderStruct * const ev ) {
time_t t;
-
+
if ( time( &t ) == (time_t)-1 ) {
fprintf( stderr,
"%s: failed to get system time errno:%d (%s)\n",
loadTimestamp( ev );
} /* End of initEvent */
+int Swap(int x)
+{
+ // Swap the endianess of the integer value 'x'
+
+ return (((x & 0x000000ffU) << 24) | ((x & 0x0000ff00U) << 8) |
+ ((x & 0x00ff0000U) >> 8) | ((x & 0xff000000U) >> 24));
+}
+
void outputEvent( const void * const ev,
const int size ) {
int done;
DBG_VERBOSE {
- const long32 * const v = (long32 *)ev;
+ const long32 * const v = (long32 *)ev;
printf( "Writing %d bytes @ %p (%d)\n", size, ev, *v );
}
-
- if ( (done = fwrite( ev, size, 1, outF )) != 1 ) {
- fprintf( stderr,
- "%s: failed to write event size:%d bytes, errno:%d (%s)\n",
- myName, size, errno, strerror( errno ) );
- exit( 1 );
+
+ // .............................Test endianess..............................
+ int temp = 1;
+ char* ptemp = (char*) &temp;
+
+ if (ptemp[0]!=1) { // Mac platform: ptemp != 1..............................................................................
+ int bufSize= size; if (bufSize > (int) sizeof(eventHeaderStruct)) { bufSize = sizeof(eventHeaderStruct); }
+ char* evTemp = (char*) malloc (bufSize);
+ memcpy(evTemp, ev, bufSize);
+
+ if ((bufSize % sizeof(int)) != 0) {
+ fprintf( stderr, "%s: size of the input buffer ev is not multiple of 4 (size = %d)\n", myName, bufSize);
+ exit( 1 );
+ }
+ else {
+ // Invert header to evTemp.....................................................
+ int* buf = (int*) evTemp;
+ for (int i=0; i < (int) (bufSize / sizeof(int)); i++, buf++) {
+ int value = Swap(*buf);
+ memcpy(evTemp + (i * sizeof(int)), &value, sizeof(int));
+ }
+
+ // Write inverted header to file...............................................
+ if ((done = fwrite( evTemp, bufSize, 1, outF )) != 1 ) {
+ fprintf( stderr, "%s: failed to write inverted header. event size:%d bytes, errno:%d (%s)\n", myName, size, errno, strerror( errno ) );
+ exit( 1 );
+ }
+
+ if (size > bufSize) { // Still theraw-data payload to write (but not inverted, since it is inverted eariler).............
+ if ((done = fwrite( (char*)ev + bufSize, size - bufSize, 1, outF )) != 1 ) {
+ fprintf( stderr, "%s: failed to write additional event size:%d bytes, errno:%d (%s)\n", myName, size, errno, strerror( errno ) );
+ exit( 1 );
+ }
+ }
+ }
+ free(evTemp);
+ }
+ else { // Intel platform: ptemp == 1............................................................................
+ if ((done = fwrite( ev, size, 1, outF )) != 1 ) {
+ fprintf( stderr, "%s: failed to write event size:%d bytes, errno:%d (%s)\n", myName, size, errno, strerror( errno ) );
+ exit( 1 );
+ }
}
} /* End of outputEvent */
struct eventHeaderStruct sev;
assert( workingAs == ldc || workingAs == gdc );
-
+
if ( !createSorEor ) return;
ev = (struct eventHeaderStruct *)event;
initEvent( ev );
currLdc = currGdc->head;
}
ev->eventLdcId = currLdc->id;
-
+
if ( workingAs == ldc ) {
loadTimestamp( ev );
outputEvent( ev, ev->eventSize );
struct ldcDescriptorStruct *ldc;
loadTimestamp( ev );
-
+
sev.eventSize = sizeof( sev ) + numOfLdcs * ev->eventSize;
sev.eventType = sor ? START_OF_RUN : END_OF_RUN ;
COPY_EVENT_ID( ev->eventId, sev.eventId );
outputEvent( ev, ev->eventSize );
}
}
-
+
ADD_EVENT_ID( ev->eventId, oneEventDelta );
ev->eventSize = ev->eventSize / 2;
ev->eventType = sor ? START_OF_RUN_FILES : END_OF_RUN_FILES;
struct ldcDescriptorStruct *ldc;
loadTimestamp( ev );
-
+
sev.eventSize = ev->eventSize;
sev.eventType = sor ? START_OF_RUN_FILES : END_OF_RUN_FILES;
COPY_EVENT_ID( ev->eventId, sev.eventId );
COPY_EVENT_ID( ev->eventId, sev.eventId );
COPY_SYSTEM_ATTRIBUTES( ev->eventTypeAttribute, sev.eventTypeAttribute );
SET_SYSTEM_ATTRIBUTE( sev.eventTypeAttribute, ATTR_SUPER_EVENT );
-
+
loadTimestamp( &sev );
ev->eventGdcId = currGdcId;
COPY_SYSTEM_ATTRIBUTES( ev->eventTypeAttribute, sev.eventTypeAttribute );
SET_SYSTEM_ATTRIBUTE( sev.eventTypeAttribute, ATTR_SUPER_EVENT );
loadTimestamp( &sev );
-
+
outputEvent( &sev, sizeof( sev ) );
for ( ldc = ldcsHead; ldc != NULL; ldc = ldc->next ) {
} /* End of createEor */
void loadCdh( struct commonDataHeaderStruct * const cdh,
- eventIdType * const eventId ) {
+ eventIdType * const eventId,
+ equipmentIdType id ) {
if ( !handleCDH ) return;
+ // CTP raw-data does not contain CDH
+ if ( id == 4352) return;
+
if ( gotAliceTrigger ) {
cdh->cdhEventId1 = EVENT_ID_GET_BUNCH_CROSSING( *eventId );
cdh->cdhEventId2 = EVENT_ID_GET_ORBIT( *eventId );
cdh->cdhMiniEventId = cdh->cdhEventId1;
}
void decodeCDH( struct ldcEventDescriptorStruct * const ldc,
- const struct payloadDescriptorStruct * const payloadDesc );
+ const struct payloadDescriptorStruct * const payloadDesc,
+ equipmentIdType id );
void createEvent( void ) {
assert( workingAs == ldc || workingAs == gdc );
/* Step 1: load all buffers (if needed) and compose the GDC/LDC headers */
if ( workingAs == gdc ) {
struct ldcEventDescriptorStruct *ldc;
-
+
for( ldc = currGdc->head; ldc != NULL; ldc = ldc->next ) {
COPY_EVENT_ID( currEventId, ldc->header.eventId );
loadTimestamp( &ldc->header );
}
COPY_EVENT_ID( currEventId, currGdc->header.eventId );
loadTimestamp( &currGdc->header );
-
+
for( ldc = currGdc->head; ldc != NULL; ldc = ldc->next ) {
struct equipmentEventDescriptorStruct *eq;
int n;
for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
if ( !bufferData ) {
loadBuffer( eq->payload );
- if ( !currGdc->loaded ) decodeCDH( ldc, eq->payload );
+ decodeCDH( ldc, eq->payload, eq->id );
}
loadCdh( (struct commonDataHeaderStruct*)eq->payload->data,
- &currEventId );
+ &currEventId,
+ eq->id);
}
if ( !currGdc->loaded ) {
currGdc->loaded = TRUE;
}
}
+ cdhRef = NULL;
} else if ( workingAs == ldc ) {
struct equipmentEventDescriptorStruct *eq;
for ( eq = currLdc->head; eq != NULL; eq = eq->next ) {
if ( !bufferData ) {
loadBuffer( eq->payload );
- if ( !currLdc->loaded ) decodeCDH( currLdc, eq->payload );
+ decodeCDH( currLdc, eq->payload, eq->id );
}
loadCdh( (struct commonDataHeaderStruct*)eq->payload->data,
- &currEventId );
+ &currEventId,
+ eq->id);
currLdc->loaded = TRUE;
}
+ cdhRef = NULL;
}
ADD_EVENT_ID( currEventId, oneEventDelta );
/* Step 2: output the event */
if ( workingAs == gdc ) {
struct ldcEventDescriptorStruct *ldc;
-
+
outputEvent( &currGdc->header, sizeof( currGdc->header ) );
for( ldc = currGdc->head; ldc != NULL; ldc = ldc->next ) {
struct equipmentEventDescriptorStruct *eq;
-
+
outputEvent( &ldc->header, sizeof( ldc->header ) );
for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
currGdc = (struct gdcEventDescriptorStruct *)eventsHead;
} else if ( workingAs == ldc ) {
struct equipmentEventDescriptorStruct *eq;
-
+
outputEvent( &currLdc->header, sizeof( currLdc->header ) );
-
+
for ( eq = currLdc->head; eq != NULL; eq = eq->next ) {
outputEvent( &eq->header, sizeof( eq->header ) );
outputEvent( eq->payload->data, eq->payload->size );
outFileName = arg;
} else if ( strcmp( "-#", argv[ arg ] ) == 0 ) {
int n;
-
+
if ( ++arg == argc ) exit( usage() );
if ( sscanf( argv[ arg ], "%d", &n ) != 1 ) exit( usage() );
if ( n < 0 ) exit( usage() );
handleCDH = TRUE;
} else if ( strcmp( "-D", argv[ arg ] ) == 0 ) {
bufferData = FALSE;
+ } else if ( strcmp( "-run", argv[ arg ] ) == 0 ) {
+ int runnumber;
+ if ( ++arg == argc ) exit( usage() );
+ if ( sscanf( argv[ arg ], "%d", &runnumber ) != 1 ) exit( usage() );
+ if ( runnumber < 0 ) exit( usage() );
+ currRunNb = runnumber;
} else {
fprintf( stderr, "%s: Unknown switch \"%s\"\n", myName, argv[argc] );
exit( usage() );
} /* End of initEquipment */
void decodeCDH( struct ldcEventDescriptorStruct * const ldc,
- const struct payloadDescriptorStruct * const payloadDesc ) {
- if ( handleCDH ) {
- static struct commonDataHeaderStruct *cdhRef = NULL;
+ const struct payloadDescriptorStruct * const payloadDesc,
+ equipmentIdType id ) {
+ if ( handleCDH &&
+ id != 4352 ) {
struct commonDataHeaderStruct *cdh;
static int softwareTriggerIndicator = FALSE;
int attr;
int trig;
-
+
if ( payloadDesc->size < CDH_SIZE ) {
fprintf( stderr,
"%s: payload too small got:%d CDH:%d\n",
gdc != NULL;
gdc = gdc->next ) {
struct ldcEventDescriptorStruct *ldc;
-
+
initEvent( &gdc->header );
gdc->header.eventSize = gdc->header.eventHeadSize;
gdc->header.eventType = PHYSICS_EVENT;
SET_SYSTEM_ATTRIBUTE( gdc->header.eventTypeAttribute, ATTR_SUPER_EVENT );
gdc->header.eventGdcId = currGdcId;
+ COPY_DETECTOR_PATTERN(&currDetPattern, gdc->header.eventDetectorPattern);
for ( ldc = gdc->head; ldc != NULL; ldc = ldc->next ) {
struct equipmentEventDescriptorStruct *eq;
ldc->header.eventSize = ldc->header.eventHeadSize;
ldc->header.eventType = PHYSICS_EVENT;
ldc->header.eventGdcId = currGdcId;
+ COPY_DETECTOR_PATTERN(&currDetPattern, ldc->header.eventDetectorPattern);
ldc->header.eventLdcId = ldc->id;
for ( eq = ldc->head; eq != NULL; eq = eq->next ) {
initEquipment( &eq->header );
ATTR_ORBIT_BC );
eq->header.equipmentSize = eq->payload->size + sizeof( eq->header );
ldc->header.eventSize += eq->header.equipmentSize;
- decodeCDH( ldc, eq->payload );
+ decodeCDH( ldc, eq->payload, eq->id );
OR_ALL_ATTRIBUTES( eq->header.equipmentTypeAttribute,
ldc->header.eventTypeAttribute );
OR_ALL_ATTRIBUTES( eq->header.equipmentTypeAttribute,
}
gdc->header.eventSize += ldc->header.eventSize;
}
+ cdhRef = NULL;
}
DBG_VERBOSE {
}
} else if ( workingAs == ldc ) {
struct ldcEventDescriptorStruct *ldc;
-
+
for ( ldc = (struct ldcEventDescriptorStruct *)eventsHead;
ldc != NULL;
ldc = ldc->next ) {
ATTR_ORBIT_BC );
eq->header.equipmentSize = eq->payload->size + sizeof( eq->header );
ldc->header.eventSize += eq->header.equipmentSize;
- decodeCDH( ldc, eq->payload );
+ decodeCDH( ldc, eq->payload, eq->id );
OR_ALL_ATTRIBUTES( eq->header.equipmentTypeAttribute,
ldc->header.eventTypeAttribute );
}
+ cdhRef = NULL;
}
DBG_VERBOSE {
printf( "Headers:\n" );
currLdc = NULL;
currEvent = NULL;
payloadsHead = payloadsTail = NULL;
- currRunNb = 1;
+ currRunNb = -1;
numOfLdcs = 0;
numOfEvents = 1;
createSorEor = TRUE;
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff