#include <stdio.h>
#include "midas.h"
#include "mevb.h"
#include "msystem.h"
#include "ybos.h"

Macros
#define	SERVER_CACHE_SIZE 0 /* event cache before buffer */

#define	ODB_UPDATE_TIME 1000 /* 1 seconds for ODB update */

#define	DEFAULT_FE_TIMEOUT 60000 /* 60 seconds for watchdog timeout */

#define	EQUIPMENT_COMMON_STR "\Event ID = WORD : 0\n\Trigger mask = WORD : 0\n\Buffer = STRING : [32] SYSTEM\n\Type = INT : 0\n\Source = INT : 0\n\Format = STRING : [8] FIXED\n\Enabled = BOOL : 0\n\Read on = INT : 0\n\Period = INT : 0\n\Event limit = DOUBLE : 0\n\Num subevents = DWORD : 0\n\Log history = INT : 0\n\Frontend host = STRING : [32] \n\Frontend name = STRING : [32] \n\Frontend file name = STRING : [256] \n\"

#define	EQUIPMENT_STATISTICS_STR "\Events sent = DOUBLE : 0\n\Events per sec. = DOUBLE : 0\n\kBytes per sec. = DOUBLE : 0\n\"

Functions
INT	handFlush (void)

INT	source_booking (void)

INT	source_unbooking (void)

INT	close_buffers (void)

INT	source_scan (INT fmt, EQUIPMENT_INFO *eq_info)

INT	eb_mfragment_add (char pdest, char psrce, INT *size)

INT	eb_yfragment_add (char pdest, char psrce, INT *size)

INT	eb_begin_of_run (INT, char , char )

INT	eb_end_of_run (INT, char *)

INT	eb_user (INT, BOOL mismatch, EBUILDER_CHANNEL , EVENT_HEADER , void , INT )

INT	load_fragment (void)

INT	scan_fragment (void)

INT	ebuilder_init (void)

INT	ebuilder_exit (void)

INT	ebuilder_loop (void)

INT	ybos_event_swap (DWORD *pevt)

INT	register_equipment (void)

INT	tr_start (INT rn, char *error)

INT	tr_stop (INT rn, char *error)

void	free_event_buffer (INT nfrag)

int	main (unsigned int argc, char **argv)

Variables
EBUILDER_SETTINGS	ebset

EBUILDER_CHANNEL	ebch [MAX_CHANNELS]

INT	run_state

INT	run_number

DWORD	last_time

DWORD	actual_time

DWORD	actual_millitime

char	host_name [HOST_NAME_LENGTH]

char	expt_name [NAME_LENGTH]

char	full_frontend_name [256]

char	buffer_name [NAME_LENGTH]

INT	nfragment

char *	dest_event

HNDLE	hDB

HNDLE	hKey

HNDLE	hStatKey

HNDLE	hSubkey

HNDLE	hEqKey

HNDLE	hESetKey

BOOL	debug = FALSE

BOOL	debug1 = FALSE

BOOL	wheel = FALSE

char	bars [] = "\|\\-/"

int	i_bar

BOOL	abort_requested = FALSE

BOOL	stop_requested = TRUE

DWORD	stop_time = 0

DWORD	request_stop_time = 0

INT(*	meb_fragment_add )(char , char , INT *)

char *	frontend_name

char *	frontend_file_name

BOOL	frontend_call_loop

INT	max_event_size

INT	max_event_size_frag

INT	event_buffer_size

INT	display_period

EQUIPMENT	equipment []

Macro Definition Documentation

#define DEFAULT_FE_TIMEOUT 60000 /* 60 seconds for watchdog timeout */

Definition at line 83 of file mevb.cpp.

#define EQUIPMENT_COMMON_STR "\Event ID = WORD : 0\n\Trigger mask = WORD : 0\n\Buffer = STRING : [32] SYSTEM\n\Type = INT : 0\n\Source = INT : 0\n\Format = STRING : [8] FIXED\n\Enabled = BOOL : 0\n\Read on = INT : 0\n\Period = INT : 0\n\Event limit = DOUBLE : 0\n\Num subevents = DWORD : 0\n\Log history = INT : 0\n\Frontend host = STRING : [32] \n\Frontend name = STRING : [32] \n\Frontend file name = STRING : [256] \n\"

Definition at line 140 of file mevb.cpp.

Referenced by register_equipment().

#define EQUIPMENT_STATISTICS_STR "\Events sent = DOUBLE : 0\n\Events per sec. = DOUBLE : 0\n\kBytes per sec. = DOUBLE : 0\n\"

Definition at line 158 of file mevb.cpp.

Referenced by register_equipment().

#define ODB_UPDATE_TIME 1000 /* 1 seconds for ODB update */

Definition at line 81 of file mevb.cpp.

#define SERVER_CACHE_SIZE 0 /* event cache before buffer */

dox

Definition at line 79 of file mevb.cpp.

Referenced by register_equipment().

Function Documentation

INT close_buffers ( void )

Definition at line 866 of file mevb.cpp.

References abort_requested, eb_end_of_run(), eq, equipment, FALSE, handFlush(), request_stop_time, run_number, run_state, source_unbooking(), sprintf(), status, and stop_time.

Referenced by scan_fragment().

 {
   INT status;
   char error[256];
   EQUIPMENT *eq;
 
   eq = &equipment[0];
 
   /* Flush local destination cache */
   bm_flush_cache(equipment[0].buffer_handle, SYNC);
   /* Call user function */
   eb_end_of_run(run_number, error);
   /* Cleanup buffers */
   handFlush();
   /* Detach all source from midas */
   status = source_unbooking();
 
   /* Compose message */
   stop_time = ss_millitime() - request_stop_time;
   sprintf(error, "Run %d Stop after %1.0lf events sent DT:%d[ms]",
     run_number, eq->stats.events_sent, stop_time);
   cm_msg(MINFO, "EBuilder", "%s", error);
 
   run_state = STATE_STOPPED;
   abort_requested = FALSE;
   return status;
 }

INT eb_begin_of_run	(	INT	,
		char *	,
		char *
	)

Hook to the event builder task at PreStart transition.

Parameters

rn	run number
UserField	argument from /Ebuilder/Settings
error	error string to be passed back to the system.

Returns: EB_SUCCESS

eb_begin_of_run()

Hook to the event builder task at PreStart transition. {verbatim} {verbatim}

Parameters

rn	run number
UserField	argument from /Ebuilder/Settings
error	error string to be passed back to the system.

Returns: EB_SUCCESS

eb_begin_of_run()

Hook to the event builder task at PreStart transition. {verbatim} {verbatim}

Parameters

rn	run number
UserField	argument from /Ebuilder/Settings
error	error string to be passed back to the system.

Returns: EB_SUCCESS

Definition at line 145 of file ebuser.cpp.

 {
 #if 0
   extern EBUILDER_SETTINGS ebset;
   extern EBUILDER_CHANNEL  ebch[MAX_CHANNELS];
   extern HNDLE hDB;
     
   int n;
   int mask = 0;
   
   char keyName[256]; 
   BOOL enabled;
   int size;
   
   /* 
    * Determine which crates are enabled and set up the mask 
    * accordingly.
    */
   for(n = 1; n <= NUMCRATES; n++) {
     sprintf(keyName, "/Equipment/Crate %d/Settings/Enabled", n);
     size = sizeof(enabled);
     db_get_value(hDB, 0, keyName, &enabled, &size, TID_BOOL, FALSE);
     if(size == sizeof(enabled) && enabled) {
        ebch[n-1].trigger_mask = (1 << (n-1));
        mask |= ebch[n-1].trigger_mask;
     } else {
        ebch[n-1].trigger_mask = 0;
     }
   }
 
   cm_msg(MINFO, "eb_begin_of_run", "Setting event mask to 0x%x", mask);
   ebset.trigger_mask = mask;
 #endif
 
   // Initialize online compression
   compress_load_all();
 
   return EB_SUCCESS;
 }

INT eb_end_of_run	(	INT	,
		char *
	)

Hook to the event builder task at completion of event collection after receiving the Stop transition.

Parameters

rn	run number
error	error string to be passed back to the system.

Returns: EB_SUCCESS

eb_end_of_run()

Hook to the event builder task at completion of event collection after receiving the Stop transition. {verbatim} {verbatim}

Parameters

rn	run number
error	error string to be passed back to the system.

Returns: EB_SUCCESS

eb_end_of_run()

Hook to the event builder task at completion of event collection after receiving the Stop transition. {verbatim} {verbatim}

Parameters

rn	run number
error	error string to be passed back to the system.

Returns: EB_SUCCESS

Definition at line 193 of file ebuser.cpp.

 {
    return EB_SUCCESS;
 }

INT eb_mfragment_add	(	char *	pdest,
		char *	psrce,
		INT *	size
	)

Definition at line 471 of file mevb.cpp.

References FALSE, psbh, and size.

Referenced by load_fragment(), and main().

 {
    BANK_HEADER *psbh, *pdbh;
    char *psdata, *pddata;
    INT bksize;
 
    /* Condition for new EVENT the data_size should be ZERO */
    *size = ((EVENT_HEADER *) pdest)->data_size;
 
    /* destination pointer */
    pddata = pdest + *size + sizeof(EVENT_HEADER);
 
    if (*size) {
       /* NOT the first fragment */
 
       /* Swap event source if necessary */
       psbh = (BANK_HEADER *) (((EVENT_HEADER *) psrce) + 1);
       bk_swap(psbh, FALSE);
 
       /* source pointer */
       psbh = (BANK_HEADER *) (((EVENT_HEADER *) psrce) + 1);
       psdata = (char *) (psbh + 1);
 
       /* copy all banks without the bank header */
       bksize = psbh->data_size;
 
       /* copy */
       memcpy(pddata, psdata, bksize);
 
       /* update event size */
       ((EVENT_HEADER *) pdest)->data_size += bksize;
 
       /* update bank size */
       pdbh = (BANK_HEADER *) (((EVENT_HEADER *) pdest) + 1);
       pdbh->data_size += bksize;
 
       *size = ((EVENT_HEADER *) pdest)->data_size;
    } else {
       /* First event without the event header but with the 
          bank header as the size is zero */
       *size = ((EVENT_HEADER *) psrce)->data_size;
 
       /* Swap event if necessary */
       psbh = (BANK_HEADER *) (((EVENT_HEADER *) psrce) + 1);
       bk_swap(psbh, FALSE);
 
       /* copy first fragment */
       memcpy(pddata, psbh, *size);
 
       /* update destination event size */
       ((EVENT_HEADER *) pdest)->data_size = *size;
    }
    return CM_SUCCESS;
 }

INT eb_user	(	INT	nfrag,
		BOOL	mismatch,
		EBUILDER_CHANNEL *	ebch,
		EVENT_HEADER *	pheader,
		void *	pevent,
		INT *	dest_size
	)

Hook to the event builder task after the reception of all fragments of the same serial number. The destination event has already the final EVENT_HEADER setup with the data size set to 0. It is than possible to add private data at this point using the proper bank calls.

The ebch[] array structure points to nfragment channel structure with the following content:

typedef struct {
    char  name[32];         // Fragment name (Buffer name).
    DWORD serial;           // Serial fragment number.
    char *pfragment;        // Pointer to fragment (EVENT_HEADER *)
    ...
} EBUILDER_CHANNEL;

The correct code for including your own MIDAS bank is shown below where TID_xxx is one of the valid Bank type starting with TID_ for midas format or xxx_BKTYPE for Ybos data format. bank_name is a 4 character descriptor. pdata has to be declared accordingly with the bank type. Refers to the ebuser.c source code for further description.

It is not possible to mix within the same destination event different event format!

// Event is empty, fill it with BANK_HEADER
// If you need to add your own bank at this stage
bk_init(pevent);
bk_create(pevent, bank_name, TID_xxxx, &pdata);
 pdata++ = ...;
 dest_size = bk_close(pevent, pdata);
pheader->data_size = *dest_size + sizeof(EVENT_HEADER);

For YBOS format, use the following example.

ybk_init(pevent);
ybk_create(pevent, "EBBK", I4_BKTYPE, &pdata);
 pdata++ = 0x12345678;
 pdata++ = 0x87654321;
 dest_size = ybk_close(pevent, pdata);
 dest_size *= 4;
pheader->data_size = *dest_size + sizeof(YBOS_BANK_HEADER);

Parameters

nfrag	Number of fragment.
mismatch	Midas Serial number mismatch flag.
ebch	Structure to all the fragments.
pheader	Destination pointer to the header.
pevent	Destination pointer to the bank header.
dest_size	Destination event size in bytes.

Returns: EB_SUCCESS

Definition at line 259 of file ebuser.cpp.

 {
   if (mismatch){
     printf("Serial number do not match across fragments\n");
     for (int i = 0; i < nfrag; i++) {
       int serial = ((EVENT_HEADER *) ebch[i].pfragment)->serial_number;
       printf("Ser[%i]:%d ", i + 1, serial);
     }
     printf("\n");
     return EB_USER_ERROR;
   }
 
   // Initialize output event
   bk_init32(pevent);
 
   // Loop over the event fragments, performing compression into the output event
   for(int i = 0; i < nfrag; i++) {
     void *fragment =  ebch[i].pfragment;
 
     if(fragment != NULL) {
       compress_event(((EVENT_HEADER *) fragment) + 1, pevent);
       pheader->serial_number =
         ((EVENT_HEADER *) ebch[i].pfragment)->serial_number;
     }
   }
 
   // Set the size of the output event properly
   pheader->data_size = *dest_size = bk_size(pevent);
 
   // printf("Returning size %d\n", pheader->data_size);
 
   return EB_SUCCESS;
 
 }

INT eb_yfragment_add	(	char *	pdest,
		char *	psrce,
		INT *	size
	)

Definition at line 527 of file mevb.cpp.

References size, status, and ybos_event_swap().

Referenced by load_fragment(), and main().

 {
    /* pdest : EVENT_HEADER pointer
       psrce : EVENT_HEADER pointer
       Keep pbkh for later incrementation
     */
    char *psdata, *pddata;
    DWORD *pslrl, *pdlrl;
    INT i4frgsize, i1frgsize, status;
 
    /* Condition for new EVENT the data_size should be ZERO */
    *size = ((EVENT_HEADER *) pdest)->data_size;
 
    /* destination pointer skip the header as it has been already
       composed and the usere may have modified it on purpose (Midas Control) */
    pddata = pdest + *size + sizeof(EVENT_HEADER);
 
    /* the Midas header is present for logger */
    if (*size) {                 /* already filled with a fragment */
 
       /* source pointer: number of DWORD (lrl included) */
       pslrl = (DWORD *) (((EVENT_HEADER *) psrce) + 1);
 
       /* Swap event if necessary */
       status = ybos_event_swap(pslrl);
 
       /* copy done in bytes, do not include LRL */
       psdata = (char *) (pslrl + 1);
 
       /* copy size in I*4 (lrl included, remove it) */
       i4frgsize = (*pslrl);
       i1frgsize = 4 * i4frgsize;
 
       /* append fragment */
       memcpy(pddata, psdata, i1frgsize);
 
       /* update Midas header event size */
       ((EVENT_HEADER *) pdest)->data_size += i1frgsize;
 
       /* update LRL size (I*4) */
       pdlrl = (DWORD *) (((EVENT_HEADER *) pdest) + 1);
       *pdlrl += i4frgsize;
 
       /* Return event size in bytes */
       *size = ((EVENT_HEADER *) pdest)->data_size;
    } else {                     /* new destination event */
       /* The composed event has already the MIDAS header.
          which may have been modified by the user in ebuser.c
          Will be stripped by the logger (YBOS).
          Copy the first full event ( no EVID suppression )
          First event (without the event header) */
 
       /* source pointer */
       pslrl = (DWORD *) (((EVENT_HEADER *) psrce) + 1);
 
       /* Swap event if necessary */
       status = ybos_event_swap(pslrl);
 
       /* size in byte from the source midas header */
       *size = ((EVENT_HEADER *) psrce)->data_size;
 
       /* copy first fragment */
       memcpy(pddata, (char *) pslrl, *size);
 
       /* update destination Midas header event size */
       ((EVENT_HEADER *) pdest)->data_size += *size;
 
    }
    return CM_SUCCESS;
 }

INT ebuilder_exit ( void )

Definition at line 126 of file ebuser.cpp.

 {
   return EB_SUCCESS;
 }

INT ebuilder_init ( void )

Definition at line 120 of file ebuser.cpp.

 {
   return EB_SUCCESS;
 }

INT ebuilder_loop ( void )

Definition at line 132 of file ebuser.cpp.

 {
   return EB_SUCCESS;
 }

void free_event_buffer ( INT nfrag)

Definition at line 712 of file mevb.cpp.

References i, and EBUILDER_CHANNEL::pfragment.

Referenced by main(), source_booking(), and source_unbooking().

 {
    INT i;
    for (i = 0; i < nfrag; i++) {
       if (ebch[i].pfragment) {
          free(ebch[i].pfragment);
          ebch[i].pfragment = NULL;
       }
    }
 }

INT handFlush ( void )

Definition at line 724 of file mevb.cpp.

References debug, debug1, i, max_event_size, nfragment, printf(), run_state, size, sprintf(), and status.

Referenced by close_buffers(), and main().

 {
    int i, size, status;
    char strout[256];
 
    /* Do Hand flush until better way to  garantee the input buffer to be empty */
    if (debug)
       printf("Hand flushing system buffer... \n");
    for (i = 0; i < nfragment; i++) {
       do {
          size = max_event_size;
          status = bm_receive_event(ebch[i].hBuf, ebch[i].pfragment, &size, ASYNC);
          if (debug1) {
             sprintf(strout,
                     "booking:Hand flush bm_receive_event[%d] hndle:%d stat:%d  Last Ser:%d",
                     i, ebch[i].hBuf, status,
                     ((EVENT_HEADER *) ebch[i].pfragment)->serial_number);
             printf("%s\n", strout);
          }
       } while (status == BM_SUCCESS);
    }
 
    /* Empty source buffer */
    status = bm_empty_buffers();
    if (status != BM_SUCCESS)
       cm_msg(MERROR, "handFlush", "bm_empty_buffers failure [%d]", status);
    run_state = STATE_STOPPED;
    return status;
 }

INT load_fragment ( void )

Definition at line 292 of file mevb.cpp.

References buffer_name, debug, dest_event, EB_ERROR, eb_mfragment_add(), EB_SUCCESS, eb_yfragment_add(), enabled, equipment, event_id, FALSE, full_frontend_name, hDB, hEqKey, hSubkey, i, key, max_event_size, meb_fragment_add, nfragment, printf(), and size.

Referenced by main().

 {
   INT i, size, type;
   BOOL enabled;
   HNDLE hEqKey, hSubkey;
   EQUIPMENT_INFO *eq_info;
   KEY  key;
   char  buffer[NAME_LENGTH];
   char  format[8];
 
   /* Get equipment pointer, only one eqp for now */
   eq_info = &equipment[0].info;
 
   /* Scan Equipment/Common listing */
   if (db_find_key(hDB, 0, "Equipment", &hEqKey) != DB_SUCCESS) {
     cm_msg(MINFO, "load_fragment", "Equipment listing not found");
     return EB_ERROR;
   }
 
   /* Scan the Equipment list for fragment info collection */
   for (i = 0, nfragment=0 ; ; i++) {
     db_enum_key(hDB, hEqKey, i, &hSubkey);
     if (!hSubkey)
       break;
     db_get_key(hDB, hSubkey, &key);
     if (key.type == TID_KEY) {
       /* Equipment name */
       if (debug) printf("Equipment name:%s\n", key.name);
       /* Check if equipment is EQ_EB */
       size = sizeof(INT);
       db_get_value(hDB, hSubkey, "common/type", &type, &size, TID_INT, 0);
       size = sizeof(buffer);
       db_get_value(hDB, hSubkey, "common/Buffer", buffer, &size, TID_STRING, 0);
       size = sizeof(format);
       db_get_value(hDB, hSubkey, "common/Format", format, &size, TID_STRING, 0);
       size = sizeof(BOOL);
       enabled = FALSE;
       db_get_value(hDB, hSubkey, "Settings/Enabled", &enabled, &size, TID_BOOL, 0);
       /* Check if equipment match EB requirements */
       if ((type & EQ_EB) && enabled 
         && (strncmp(buffer, buffer_name, strlen(buffer_name)) == 0)
         && (strncmp(format, eq_info->format, strlen(format)) == 0)) {
           /* match=> fill internal eb structure */
           strcpy(ebch[nfragment].format, format);
           strcpy(ebch[nfragment].buffer, buffer);
           size = sizeof(WORD);
           db_get_value(hDB, hSubkey, "common/Trigger Mask", &ebch[nfragment].trigger_mask, &size, TID_WORD, 0);
           size = sizeof(WORD);
           db_get_value(hDB, hSubkey, "common/Event ID", &ebch[nfragment].event_id, &size, TID_WORD, 0);
           printf("%s enabled\n",key.name);
           nfragment++;
         }
     }
   }
 
   printf("Found %d fragment matching EB setting\n", nfragment);
   /* Point to the Ebuilder settings */
   /* Set fragment_add function based on the format */
   if (equipment[0].format == FORMAT_MIDAS)
     meb_fragment_add = eb_mfragment_add;
   else if (equipment[0].format == FORMAT_YBOS)
     meb_fragment_add = eb_yfragment_add;
   else {
     cm_msg(MERROR, "mevb", "Unknown data format :%d", format);
     return EB_ERROR;
   }
 
   /* allocate destination event buffer */
   dest_event = (char *) malloc(nfragment * (max_event_size + sizeof(EVENT_HEADER)));
   memset(dest_event, 0, nfragment * (max_event_size + sizeof(EVENT_HEADER)));
   if (dest_event == NULL) {
     cm_msg(MERROR, "EBuilder", "%s: Not enough memory for event buffer", full_frontend_name);
     return EB_ERROR;
   }
   return EB_SUCCESS;
 }

int main	(	unsigned int	argc,
		char **	argv
	)

Definition at line 1092 of file mevb.cpp.

References buffer_name, cm_get_environment(), debug, debug1, EB_SUCCESS, ebuilder_exit(), ebuilder_init(), expt_name, FALSE, free_event_buffer(), frontend_name, full_frontend_name, hDB, hKey, host_name, i, load_fragment(), EBUILDER_SETTINGS::nfragment, printf(), register_equipment(), scan_fragment(), source_unbooking(), status, SUCCESS, tr_start(), tr_stop, TRUE, usage(), and wheel.

 {
   INT status;
   unsigned int i;
   BOOL daemon = FALSE;
   
   /* init structure */
   memset(&ebch[0], 0, sizeof(ebch));
 
   /* set default */
   cm_get_environment(host_name, sizeof(host_name), expt_name, sizeof(expt_name));
 
   /* get parameters */
   for (i = 1; i < argc; i++) {
     if (argv[i][0] == '-' && argv[i][1] == 'd') {
       debug = TRUE;
       debug1 = TRUE;
     }
     else if (argv[i][0] == '-' && argv[i][1] == 'D')
       daemon = TRUE;
     else if (argv[i][0] == '-' && argv[i][1] == 'w')
       wheel = TRUE;
     else if (argv[i][0] == '-') {
       if (i + 1 >= argc || argv[i + 1][0] == '-')
         goto usage;
       if (strncmp(argv[i], "-e", 2) == 0)
         strcpy(expt_name, argv[++i]);
       else if (strncmp(argv[i], "-h", 2) == 0)
         strcpy(host_name, argv[++i]);
       else if (strncmp(argv[i], "-b", 2) == 0)
         strcpy(buffer_name, argv[++i]);
     } else {
 usage:
       printf("usage: mevb [-h <Hostname>] [-e <Experiment>] -b <buffername> [-d debug]\n");
       printf("             -w show wheel -D to start as a daemon\n\n");
       return 0;
     }
   }
 
   printf("Program mevb version 5 started\n\n");
   if (daemon) {
     printf("Becoming a daemon...\n");
     ss_daemon_init(FALSE);
   }
 
   /* Check buffer arg */
   if (buffer_name[0] == 0) {
     printf("Buffer name must be specified with -b argument\n");
     goto exit;
   }
 
   /* Compose frontend name */
    strcpy(full_frontend_name, frontend_name);
 
   /* Connect to experiment */
   status = cm_connect_experiment(host_name, expt_name, full_frontend_name, NULL);
   if (status != CM_SUCCESS) {
     ss_sleep(5000);
     goto exit;
   }
 
   if (debug)
     cm_set_watchdog_params(TRUE, 0);
 
   /* Connect to ODB */
   status = cm_get_experiment_database(&hDB, &hKey);
   if (status != EB_SUCCESS) {
     ss_sleep(5000);
     goto exit;
   }
   
   /* check if Ebuilder is already running */
   status = cm_exist(full_frontend_name, TRUE);
   if (status == CM_SUCCESS) {
     cm_msg(MERROR, "Ebuilder", "%s running already!.", full_frontend_name);
     cm_disconnect_experiment();
     goto exit;
   }
 
   if (ebuilder_init() != SUCCESS) {
     cm_disconnect_experiment();
     /* let user read message before window might close */
     ss_sleep(5000);
     goto exit;
   }
 
   /* Register single equipment */
   status = register_equipment();
   if (status != EB_SUCCESS) {
     ss_sleep(5000);
     goto exit;
   }
 
   /* Load Fragment info */
   status = load_fragment();
   if (status != EB_SUCCESS) {
     ss_sleep(5000);
     goto exit;
   }
 
   /* Register transition for reset counters */
   if (cm_register_transition(TR_START, tr_start, 300) != CM_SUCCESS)
     return status;
   if (cm_register_transition(TR_STOP, tr_stop, 700) != CM_SUCCESS)
     goto exit;
 
   /* Scan fragments... will stay in */
   status = scan_fragment();
   printf("%s-Out of scan_fragment\n", full_frontend_name);
 
   /* Detach all source from midas */
   printf("%s-Unbooking\n", full_frontend_name);
   source_unbooking();
   
   ebuilder_exit();
 
 exit:
   /* Free local memory */
   free_event_buffer(ebset.nfragment);
 
   /* Clean disconnect from midas */
   cm_disconnect_experiment();
   return 0;
 }

INT register_equipment ( void )

Definition at line 165 of file mevb.cpp.

References EB_SUCCESS, equipment, EQUIPMENT_COMMON_STR, EQUIPMENT_STATISTICS_STR, frontend_file_name, full_frontend_name, hDB, hKey, printf(), run_number, run_state, SERVER_CACHE_SIZE, size, sprintf(), status, SUCCESS, and TRUE.

 {
   INT index, size, status;
   char str[256];
   EQUIPMENT_INFO *eq_info;
   EQUIPMENT_STATS *eq_stats;
   HNDLE hKey;
 
   /* get current ODB run state */
   size = sizeof(run_state);
   run_state = STATE_STOPPED;
   db_get_value(hDB, 0, "/Runinfo/State", &run_state, &size, TID_INT, TRUE);
   size = sizeof(run_number);
   run_number = 1;
   status = db_get_value(hDB, 0, "/Runinfo/Run number", &run_number, &size, TID_INT, TRUE);
   assert(status == SUCCESS);
 
   /* scan EQUIPMENT table from mevb.C */
   for (index = 0; equipment[index].name[0]; index++) {
     eq_info = &equipment[index].info;
     eq_stats = &equipment[index].stats;
 
     if (eq_info->event_id == 0) {
       printf("\nEvent ID 0 for %s not allowed\n", equipment[index].name);
       cm_disconnect_experiment();
       ss_sleep(5000);
       exit(0);
     }
 
     /* init status */
     equipment[index].status = EB_SUCCESS;
 
     sprintf(str, "/Equipment/%s/Common", equipment[index].name);
 
     /* get last event limit from ODB */
     if (eq_info->eq_type != EQ_SLOW) {
       db_find_key(hDB, 0, str, &hKey);
       size = sizeof(double);
       if (hKey)
         db_get_value(hDB, hKey, "Event limit", &eq_info->event_limit, &size,
         TID_DOUBLE, TRUE);
     }
 
     /* Create common subtree */
     status = db_check_record(hDB, 0, str, EQUIPMENT_COMMON_STR, TRUE);
     if (status != DB_SUCCESS) {
       printf("Cannot check equipment record, status = %d\n", status);
       ss_sleep(3000);
     }
     db_find_key(hDB, 0, str, &hKey);
 
     if (equal_ustring(eq_info->format, "YBOS"))
       equipment[index].format = FORMAT_YBOS;
     else if (equal_ustring(eq_info->format, "FIXED"))
       equipment[index].format = FORMAT_FIXED;
     else    /* default format is MIDAS */
       equipment[index].format = FORMAT_MIDAS;
 
     gethostname(eq_info->frontend_host, sizeof(eq_info->frontend_host));
     strcpy(eq_info->frontend_name, full_frontend_name);
     strcpy(eq_info->frontend_file_name, frontend_file_name);
 
     /* set record from equipment[] table in frontend.c */
     db_set_record(hDB, hKey, eq_info, sizeof(EQUIPMENT_INFO), 0);
 
     /* get record once at the start equipment info */
     size = sizeof(EQUIPMENT_INFO);
     db_get_record(hDB, hKey, eq_info, &size, 0);
 
     /*---- Create just the key , leave it empty ---------------------------------*/
     sprintf(str, "/Equipment/%s/Variables", equipment[index].name);
     db_create_key(hDB, 0, str, TID_KEY);
     db_find_key(hDB, 0, str, &hKey);
     equipment[index].hkey_variables = hKey;
 
     /*---- Create and initialize statistics tree -------------------*/
     sprintf(str, "/Equipment/%s/Statistics", equipment[index].name);
 
     status = db_check_record(hDB, 0, str, EQUIPMENT_STATISTICS_STR, TRUE);
     if (status != DB_SUCCESS) {
       printf("Cannot create/check statistics record, error %d\n", status);
       ss_sleep(3000);
     }
 
     status = db_find_key(hDB, 0, str, &hKey);
     if (status != DB_SUCCESS) {
       printf("Cannot find statistics record, error %d\n", status);
       ss_sleep(3000);
     }
 
     eq_stats->events_sent = 0;
     eq_stats->events_per_sec = 0;
     eq_stats->kbytes_per_sec = 0;
 
     /* open hot link to statistics tree */
     status = db_open_record(hDB, hKey, eq_stats, sizeof(EQUIPMENT_STATS)
       , MODE_WRITE, NULL, NULL);
     if (status != DB_SUCCESS) {
       cm_msg(MERROR, "register_equipment", 
         "Cannot open statistics record, error %d. Probably other FE is using it",
         status);
       ss_sleep(3000);
     }
 
     /*---- open event buffer ---------------------------------------*/
     if (eq_info->buffer[0]) {
       status = bm_open_buffer(eq_info->buffer, EVENT_BUFFER_SIZE,
         &equipment[index].buffer_handle);
       if (status != BM_SUCCESS && status != BM_CREATED) {
         cm_msg(MERROR, "register_equipment",
           "Cannot open event buffer. Try to reduce EVENT_BUFFER_SIZE in midas.h \
           and rebuild the system.");
         return 0;
       }
 
       /* set the default buffer cache size */
       bm_set_cache_size(equipment[index].buffer_handle, 0, SERVER_CACHE_SIZE);
     } else {
       cm_msg(MERROR, "register_equipment", "Destination buffer must be present");
       ss_sleep(3000);
       exit(0);
     }
   }
   return SUCCESS;
 }

INT scan_fragment ( void )

Definition at line 370 of file mevb.cpp.

References abort_requested, actual_millitime, bars, close_buffers(), debug, EB_ERROR, EB_SKIP, EB_SUCCESS, EB_USER_ERROR, eq, equipment, full_frontend_name, i_bar, last_time, nfragment, printf(), run_state, source_scan(), status, stop_requested, timeout, TIMEOUT, TRUE, and wheel.

Referenced by main().

 {
   INT fragn, status;
   EQUIPMENT *eq;
   EQUIPMENT_INFO *eq_info;
 
   /* Get equipment pointer, only one eqp for now */
   eq_info = &equipment[0].info;
 
   /* Main event loop */
   do {
     switch (run_state) {
       case STATE_STOPPED:
       case STATE_PAUSED:
         /* skip the source scan and yield */
         status = cm_yield(500);
         if (wheel) {
           printf("...%c Snoring\r", bars[i_bar++ % 4]);
           fflush(stdout);
         }
         break;
       case STATE_RUNNING:
         status = source_scan(equipment[0].format, eq_info);
         switch (status) {
             case BM_ASYNC_RETURN:  // No event found for now, Check for timeout 
               for (fragn = 0; fragn < nfragment; fragn++) {
                 if (ebch[fragn].timeout > TIMEOUT) {        /* Timeout */
                   if (stop_requested) {                     /* Stop */
                     if (debug) printf("Stop requested on timeout %d\n", status);
                       status = close_buffers();
                     break;
                   } 
                   else {         /* No stop requested  but timeout */
                     if (wheel) {
                       printf("...%c Timoing on %1.0lf\r", bars[i_bar++ % 4],
                         eq->stats.events_sent);
                       fflush(stdout);
                       status = cm_yield(50);
                     }
                   }
                 }
                 //else { /* No timeout loop back */
               } // for loop over all fragments
               break;
             case EB_ERROR:
             case EB_USER_ERROR:
               abort_requested = TRUE;
               if (status == EB_USER_ERROR)
                 cm_msg(MTALK, "EBuilder", "%s: Error signaled by user code - stopping run...", full_frontend_name);
               else
                 cm_msg(MTALK, "EBuilder", "%s: Event mismatch - Stopping run...", full_frontend_name);
               if (cm_transition(TR_STOP, 0, NULL, 0, ASYNC, 0) != CM_SUCCESS) {
                 cm_msg(MERROR, "EBuilder", "%s: Stop Transition request failed", full_frontend_name);
                 status = close_buffers();
                 return status;
               }
               if (debug) printf("Stop requested on Error %d\n", status);
               status = close_buffers();
               return status;
               break;
             case EB_SUCCESS:
             case EB_SKIP:
               //   Normal path if event has been assembled
               //   No yield in this case.
               break;
             default:
               cm_msg(MERROR, "Source_scan", "unexpected return %d", status);
               status = SS_ABORT;
               }  // switch scan_source
         break;
     }
     /* EB job done, update statistics if its time */
     /* Check if it's time to do statistics job */
     if ((actual_millitime = ss_millitime()) - last_time > 1000) {
       /* Force event to appear at the destination if Ebuilder is remote */
       rpc_flush_event();
       /* Force event ot appear at the destination if Ebuilder is local */
       bm_flush_cache(equipment[0].buffer_handle, ASYNC);
 
       status = cm_yield(10);
 
       eq = &equipment[0];
       eq->stats.events_sent += eq->events_sent;
       eq->stats.events_per_sec =
         eq->events_sent / ((actual_millitime - last_time) / 1000.0);
       eq->stats.kbytes_per_sec =
         eq->bytes_sent / 1024.0 / ((actual_millitime - last_time) /
         1000.0);
       eq->bytes_sent = 0;
       eq->events_sent = 0;
       /* update destination statistics */
       db_send_changed_records();
       /* Keep track of last ODB update */
       last_time = ss_millitime();
     }
   } while (status != RPC_SHUTDOWN && status != SS_ABORT);
 
   return status;
   }

INT source_booking ( void )

Definition at line 756 of file mevb.cpp.

References debug, event_id, free_event_buffer(), i, max_event_size, EBUILDER_SETTINGS::nfragment, nfragment, EBUILDER_CHANNEL::pfragment, EBUILDER_SETTINGS::preqfrag, printf(), status, and SUCCESS.

Referenced by tr_prestart(), and tr_start().

 {
    INT j, i, status, status1, status2;
 
    if (debug)
       printf("Entering booking\n");
 
    /* Book all the source channels */
    for (i = 0; i < nfragment; i++) {
       /* Book only the requested event mask */
      if (ebset.preqfrag[i]) {
          /* Connect channel to source buffer */
          status1 = bm_open_buffer(ebch[i].buffer, EVENT_BUFFER_SIZE, &(ebch[i].hBuf));
 
          if (debug)
            printf("bm_open_buffer frag:%d buf:%s handle:%d stat:%d\n",
                    i, ebch[i].buffer, ebch[i].hBuf, status1);
          /* Register for specified channel event ID and Trigger mask */
          status2 =
              bm_request_event(ebch[i].hBuf, ebch[i].event_id,
                               ebch[i].trigger_mask, GET_ALL, &ebch[i].req_id, NULL);
          if (debug)
            printf("bm_request_event frag:%d id:%d msk:%d req_id:%d stat:%d\n",
                    i, ebch[i].event_id, ebch[i].trigger_mask, ebch[i].req_id, status2);
          if (((status1 != BM_SUCCESS) && (status1 != BM_CREATED)) ||
              ((status2 != BM_SUCCESS) && (status2 != BM_CREATED))) {
             cm_msg(MERROR, "source_booking",
                    "Open buffer/event request failure [%d %d %d]", i, status1, status2);
             return BM_CONFLICT;
          }
 
          /* allocate local source event buffer */
          if (ebch[i].pfragment)
             free(ebch[i].pfragment);
          ebch[i].pfragment = (char *) malloc(max_event_size + sizeof(EVENT_HEADER));
          if (debug)
             printf("malloc pevent frag:%d pevent:%p\n", i, ebch[i].pfragment);
          if (ebch[i].pfragment == NULL) {
             free_event_buffer(nfragment);
             cm_msg(MERROR, "source_booking", "Can't allocate space for buffer");
             return BM_NO_MEMORY;
          }
       }
    }
 
    /* Empty source buffer */
    status = bm_empty_buffers();
    if (status != BM_SUCCESS) {
       cm_msg(MERROR, "source_booking", "bm_empty_buffers failure [%d]", status);
       return status;
    }
 
    if (debug) {
       printf("bm_empty_buffers stat:%d\n", status);
       for (j = 0; j < ebset.nfragment; j++) {
          printf(" buff:%s", ebch[j].buffer);
          printf(" ser#:%d", ebch[j].serial);
          printf(" hbuf:%2d", ebch[j].hBuf);
          printf(" rqid:%2d", ebch[j].req_id);
          printf(" opst:%d", status1);
          printf(" rqst:%d", status2);
          printf(" evid:%2d", ebch[j].event_id);
          printf(" tmsk:0x%4.4x\n", ebch[j].trigger_mask);
       }
    }
 
    return SUCCESS;
 }

INT source_scan	(	INT	fmt,
		EQUIPMENT_INFO *	eq_info
	)

Scan all the fragment source once per call.

This will retrieve the full midas event not swapped (except the MIDAS_HEADER) for each fragment if possible. The fragment will be stored in the channel event pointer.
if after a full nfrag path some frag are still not cellected, it returns with the frag# missing for timeout check.
If ALL fragments are present it will check the midas serial# for a full match across all the fragments.
If the serial check fails it returns with "event mismatch" and will abort the event builder but not stop the run for now.
If the serial check is passed, it will call the user_build function where the destination event is going to be composed.

Parameters

fmt	Fragment format type
eq_info	Equipement pointer
dest_hBuf	Destination buffer handle

Returns: EB_NO_MORE_EVENT, EB_COMPOSE_TIMEOUT if different then SUCCESS (bm_compose, rpc_sent error)

Definition at line 916 of file mevb.cpp.

References debug, debug1, dest_event, EB_ERROR, EB_SKIP, EB_SUCCESS, eb_user(), equipment, event_mismatch, FALSE, found, full_frontend_name, i, max_event_size, meb_fragment_add, nfragment, EBUILDER_CHANNEL::pfragment, EBUILDER_SETTINGS::preqfrag, printf(), psbh, EBUILDER_SETTINGS::received, EBUILDER_CHANNEL::serial, size, sprintf(), status, stop_requested, SUCCESS, EBUILDER_CHANNEL::timeout, TRUE, EBUILDER_SETTINGS::user_build, and ybos_event_swap().

Referenced by main(), and scan_fragment().

 {
 //   static char bars[] = "|/-\\";
 //   static int i_bar;
    static DWORD serial;
    DWORD *plrl;
    BOOL   complete;
    INT i, j, status, size;
    INT act_size;
    BOOL found, event_mismatch;
    BANK_HEADER *psbh;
    BOOL got_a_fragment;
 
    status = SUCCESS;
    got_a_fragment = FALSE;
 
    /* Scan all channels at least once */
    for (i = 0; i < nfragment; i++) {
       /* Check if current channel needs to be received */
      if (ebset.preqfrag[i] && !ebset.received[i]) {
          /* Get fragment and store it in ebch[i].pfragment */
          size = max_event_size;
          status = bm_receive_event(ebch[i].hBuf, ebch[i].pfragment, &size, ASYNC);
          switch (status) {
          case BM_SUCCESS:      /* event received */
             /* Mask event */
             ebset.received[i] = TRUE;
             /* Keep local serial */
             ebch[i].serial = ((EVENT_HEADER *) ebch[i].pfragment)->serial_number;
             got_a_fragment = TRUE;
 
             /* Swap event depending on data format */
             switch (fmt) {
             case FORMAT_YBOS:
                plrl = (DWORD *) (((EVENT_HEADER *) ebch[i].pfragment) + 1);
                ybos_event_swap(plrl);
                break;
             case FORMAT_MIDAS:
                psbh = (BANK_HEADER *) (((EVENT_HEADER *) ebch[i].pfragment) + 1);
                bk_swap(psbh, FALSE);
                break;
             }
 
             if (debug1) {
               printf("SUCC: ch:%d ser:%d rec:%d sz:%d\n", i,
                       ebch[i].serial, ebset.received[i], size);
             }
             break;
          case BM_ASYNC_RETURN: /* timeout */
             ebch[i].timeout++;
             if (debug1) {
 //              printf("ASYNC: ch:%d ser:%d rec:%d sz:%d\n", i,
 //                      ebch[i].serial, ebset.received[i], size);
             }
             break;
          default:              /* Error */
             cm_msg(MERROR, "event_scan", "bm_receive_event error %d", status);
             return status;
             break;
          }
       }    /* next channel */
    }
 
 
    /* Check if all fragments have been received */
    complete = FALSE;
    for (i = 0; i < nfragment;i++) {
      if (ebset.preqfrag[i] && !ebset.received[i])
        break;
    }
    if (i == nfragment) {
      complete = TRUE;
      /* Check if serial matches */
      found = event_mismatch = FALSE;
      /* Check Serial, mark first serial */
      for (i = 0; i < nfragment; i++) {
          if (ebset.preqfrag[i] && ebset.received[i] && !found) {
             serial = ebch[i].serial;
             found = TRUE;
          } else {
             if (ebset.preqfrag[i] && ebset.received[i] && (serial != ebch[i].serial)) {
                /* Event mismatch */
                event_mismatch = TRUE;
             }
          }
       }
 
     /* internal action in case of event mismatch */
      if (event_mismatch && debug) {
        char str[256];
        char strsub[128];
        strcpy(str, "event mismatch: ");
        for (j = 0; j < nfragment; j++) {
          sprintf(strsub, "Ser[%d]:%d ", j, ebch[j].serial);
          strcat(str, strsub);
        }
        printf("event serial mismatch %s\n", str);
      }
 
      /* In any case reset destination buffer */
      memset(dest_event, 0, sizeof(EVENT_HEADER));
      act_size = 0;
 
      /* Fill reserved header space of destination event with
      final header information */
      bm_compose_event((EVENT_HEADER *) dest_event, eq_info->event_id, eq_info->trigger_mask,
        act_size, ebch[0].serial);
 
      /* Pass fragments to user with mismatch flag, for final check before assembly */
      status = eb_user(nfragment, event_mismatch, ebch
        , (EVENT_HEADER *) dest_event,(void *) ((EVENT_HEADER *) dest_event + 1), &act_size);
      if (status != EB_SUCCESS) {
        if (status == EB_SKIP) {
          /* Reset mask and timeouts as even thave been succesfully send */
          for (i = 0; i < nfragment; i++) {
            ebch[i].timeout = 0;
            ebset.received[i] = FALSE;
          }
        }
        return status;        // Event mark as EB_SKIP or EB_ABORT by user
      }
 
      /* Overall event to be sent */
      act_size = ((EVENT_HEADER *) dest_event)->data_size + sizeof(EVENT_HEADER);
 
      /* Allow bypass of fragment assembly if user did it on its own */
      if (!ebset.user_build) {
        for (j = 0; j < nfragment; j++) {
          if (ebch[j].trigger_mask) {
            status = meb_fragment_add(dest_event, ebch[j].pfragment, &act_size);
            if (status != EB_SUCCESS) {
              cm_msg(MERROR, "source_scan",
                "compose fragment:%d current size:%d (%d)", j, act_size, status);
              return EB_ERROR;
            }
          }
        }
      }
 
      /* Overall event to be sent */
      act_size = ((EVENT_HEADER *) dest_event)->data_size + sizeof(EVENT_HEADER);
 
      /* Send event and wait for completion */
      status = rpc_send_event(equipment[0].buffer_handle, dest_event, act_size, SYNC);
      if (status != BM_SUCCESS) {
        if (debug)
          printf("rpc_send_event returned error %d, event_size %d\n",
          status, act_size);
        cm_msg(MERROR, "EBuilder", "%s: rpc_send_event returned error %d", full_frontend_name, status);
        return EB_ERROR;
      }
 
      /* Keep track of the total byte count */
      equipment[0].bytes_sent += act_size;
 
      /* update destination event count */
      equipment[0].events_sent++;
 
      /* Reset mask and timeouts as even thave been succesfully send */
      for (i = 0; i < nfragment; i++) {
        ebch[i].timeout = 0;
        ebset.received[i] = FALSE;
      }
    } // all fragment recieved for this event
 
    // If we did not receive any fragments, then take a break and let the 
    // CPU get some other work done.  The "stop_requested" condition protects
    // against a race between the end of one run and the start of the next.
    if(!got_a_fragment && !stop_requested) {
      cm_yield(10);
    }
 
    return status;
 }

INT source_unbooking ( void )

Definition at line 826 of file mevb.cpp.

References debug, EB_SUCCESS, free_event_buffer(), i, nfragment, printf(), and status.

Referenced by close_buffers(), and main().

 {
    INT i, status;
 
 #if 0
    /* Skip unbooking if already done */
    if (ebch[0].pfragment == NULL)
       return EB_SUCCESS;
 #endif
 
    /* unbook all source channels */
    for (i = 0; i< nfragment; i++) {
       bm_empty_buffers();
 
       if (ebch[i].trigger_mask) {
         /* Remove event ID registration */
         status = bm_delete_request(ebch[i].req_id);
         if (debug)
            printf("unbook: bm_delete_req[%d] req_id:%d stat:%d\n", i, ebch[i].req_id,
                   status);
 
         /* Close source buffer */
         status = bm_close_buffer(ebch[i].hBuf);
         if (debug)
            printf("unbook: bm_close_buffer[%d] hndle:%d stat:%d\n", i, ebch[i].hBuf,
                   status);
         if (status != BM_SUCCESS) {
            cm_msg(MERROR, "source_unbooking", "Close buffer[%d] stat:", i, status);
            return status;
         }
      }
    }
 
    /* release local event buffer memory */
    free_event_buffer(nfragment);
 
    return EB_SUCCESS;
 }

INT tr_start	(	INT	rn,
		char *	error
	)

Definition at line 599 of file mevb.cpp.

References abort_requested, eb_begin_of_run(), EB_SUCCESS, EBUILDER, equipment, FALSE, full_frontend_name, hDB, hKey, i, key, EBUILDER_SETTINGS::nfragment, nfragment, EBUILDER_SETTINGS::preqfrag, printf(), EBUILDER_SETTINGS::received, run_number, run_state, size, source_booking(), sprintf(), status, stop_requested, SUCCESS, TRUE, EBUILDER_SETTINGS::user_build, and EBUILDER_SETTINGS::user_field.

 {
   EBUILDER(ebuilder_str);
   INT status, size, i;
   char   str[128];
   KEY    key;
   HNDLE  hKey, hEqkey, hEqFRkey;
   EQUIPMENT_INFO *eq_info;
   
 
   eq_info = &equipment[0].info;
 
   /* Get update eq_info from ODB */
   sprintf(str, "/Equipment/%s/Common", equipment[0].name);
   status = db_find_key(hDB, 0, str, &hKey);
   size = sizeof(EQUIPMENT_INFO);
   db_get_record(hDB, hKey, eq_info, &size, 0);
 
   ebset.nfragment = nfragment;
 
   /* reset serial numbers */
   for (i = 0; equipment[i].name[0]; i++) {
     equipment[i].serial_number = 1;
     equipment[i].subevent_number = 0;
     equipment[i].stats.events_sent = 0;
     equipment[i].odb_in = equipment[i].odb_out = 0;
   }
 
   /* Get / Set Settings */
   sprintf(str, "/Equipment/%s/Settings", equipment[0].name);
   if (db_find_key(hDB, 0, str, &hEqkey) != DB_SUCCESS) {
     status = db_create_record(hDB, 0, str, strcomb(ebuilder_str));
   }
 
   /* Keep Key on Ebuilder/Settings */
   sprintf(str, "/Equipment/%s/Settings", equipment[0].name);
   if (db_find_key(hDB, 0, str, &hEqkey) != DB_SUCCESS) {
     cm_msg(MINFO, "load_fragment", "/Equipment/%s/Settings not found", equipment[0].name);
   }
   
   /* Update or Create User_field */
   size = sizeof(ebset.user_field);
   status = db_get_value(hDB, hEqkey, "User Field", ebset.user_field, &size, TID_STRING, TRUE);
 
   /* Update or Create User_Build */
   size = sizeof(ebset.user_build);
   status = db_get_value(hDB, hEqkey, "User Build", &ebset.user_build, &size, TID_BOOL, TRUE);
 
   /* update ODB */
   size = sizeof(INT);
   status = db_set_value(hDB, hEqkey, "Number of Fragment", &ebset.nfragment, size, 1, TID_INT);  
 
     /* Create or update the fragment request list */
   status = db_find_key(hDB, hEqkey, "Fragment Required", &hEqFRkey);
   status = db_get_key (hDB, hEqFRkey, &key);
   if (key.num_values != ebset.nfragment) {
     cm_msg(MINFO, "mevb", "Number of Fragment mismatch ODB:%d - CUR:%d", key.num_values, ebset.nfragment);
     free (ebset.preqfrag);
     size = ebset.nfragment*sizeof(BOOL);
     ebset.preqfrag = (BOOL *) malloc(size);
     for (i=0 ; i<ebset.nfragment ; i++)
       ebset.preqfrag[i] = TRUE;
     status = db_set_value(hDB, hEqkey, "Fragment Required", ebset.preqfrag, size, ebset.nfragment, TID_BOOL);  
   } else {  // Take from ODBedit
     size = key.total_size;
     free (ebset.preqfrag);
     ebset.preqfrag = (BOOL *) malloc(size);
     status = db_get_data(hDB, hEqFRkey, ebset.preqfrag, &size, TID_BOOL);
   }
   /* Cleanup fragment flags */
   free (ebset.received);
   ebset.received = (BOOL *) malloc(size);
   for (i=0 ; i < ebset.nfragment ; i++) 
     ebset.received[i] = FALSE;
 
   /* Call BOR user function */
   status = eb_begin_of_run(run_number, ebset.user_field, error);
   if (status != EB_SUCCESS) {
     cm_msg(MERROR, "eb_prestart", "run start aborted due to eb_begin_of_run (%d)",
       status);
     return status;
   }
 
   /* Book all fragment */
   status = source_booking();
   if (status != SUCCESS)
     return status;
 
   /* local run state */
   run_state = STATE_RUNNING;
   run_number = rn;
   stop_requested = FALSE;
   abort_requested = FALSE;
   printf("%s-Starting New Run: %d\n", full_frontend_name, rn);
 
   /* Reset global trigger mask */
   return CM_SUCCESS;
 }

INT tr_stop	(	INT	rn,
		char *	error
	)

Definition at line 699 of file mevb.cpp.

References full_frontend_name, printf(), request_stop_time, stop_requested, and TRUE.

 {
    printf("\n%s-Stopping Run: %d detected\n", full_frontend_name, rn);
 
    /* local stop */
    stop_requested = TRUE;
 
    /* local stop time */
    request_stop_time = ss_millitime();
    return CM_SUCCESS;
 }