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