mana.cxx File Reference

#include <assert.h>
#include "midas.h"
#include "msystem.h"
#include "hardware.h"
#include "mdsupport.h"
#include "zlib.h"

Include dependency graph for mana.cxx:

Go to the source code of this file.

Classes
struct	EVENT_DEF
struct	MA_FILE

Macros
#define	PVM_BUFFER_SIZE   (1024*1024)
#define	HBOOK_LREC   8190
#define	EXT_EVENT_SIZE   (2*(MAX_EVENT_SIZE+sizeof(EVENT_HEADER)))
#define	ANALYZER_REQUEST_STR   "\Event ID = INT : 0\n\Trigger mask = INT : -1\n\Sampling type = INT : 1\n\Buffer = STRING : [32] SYSTEM\n\Enabled = BOOL : 1\n\Client name = STRING : [32] \n\Host = STRING : [32] \n\"
#define	ANALYZER_STATS_STR   "\Events received = DOUBLE : 0\n\Events per sec. = DOUBLE : 0\n\Events written = DOUBLE : 0\n\"
#define	STR_INC(p, base)
#define	MA_DEVICE_DISK   1
#define	MA_DEVICE_TAPE   2
#define	MA_DEVICE_FTP   3
#define	MA_DEVICE_PVM   4
#define	MA_FORMAT_MIDAS   (1<<0)
#define	MA_FORMAT_YBOS   (1<<2)
#define	MA_FORMAT_GZIP   (1<<3)

Functions
INT	analyzer_init (void)
INT	analyzer_exit (void)
INT	analyzer_loop (void)
INT	ana_begin_of_run (INT run_number, char *error)
INT	ana_end_of_run (INT run_number, char *error)
INT	ana_pause_run (INT run_number, char *error)
INT	ana_resume_run (INT run_number, char *error)
void	update_stats ()
void	odb_load (EVENT_HEADER *pevent)
INT	getparam (int argc, char **argv)
void	add_data_dir (char *result, char *file)
EVENT_DEF *	db_get_event_definition (short int event_id)
void	test_register (ANA_TEST *t)
void	test_clear ()
void	test_increment ()
void	test_write (int delta_time)
INT	load_parameters (INT run_number)
INT	book_ntuples (void)
INT	book_ttree (void)
void	banks_changed (INT hDB, INT hKey, void *info)
INT	mana_init ()
INT	mana_exit ()
INT	bor (INT run_number, char *error)
INT	eor (INT run_number, char *error)
INT	tr_start (INT rn, char *error)
INT	tr_stop (INT rn, char *error)
INT	tr_pause (INT rn, char *error)
INT	tr_resume (INT rn, char *error)
INT	write_event_ascii (FILE *file, EVENT_HEADER *pevent, ANALYZE_REQUEST *par)
INT	write_event_midas (FILE *file, EVENT_HEADER *pevent, ANALYZE_REQUEST *par)
INT	write_event_odb (EVENT_HEADER *pevent)
void	correct_num_events (INT i)
INT	process_event (ANALYZE_REQUEST *par, EVENT_HEADER *pevent)
void	receive_event (HNDLE buffer_handle, HNDLE request_id, EVENT_HEADER *pheader, void *pevent)
void	update_request (HNDLE hDB, HNDLE hKey, void *info)
void	register_requests (void)
void	lock_histo (INT id)
void	load_last_histos ()
void	save_last_histos ()
INT	loop_online ()
INT	init_module_parameters (BOOL bclose)
MA_FILE *	ma_open (char *file_name)
int	ma_close (MA_FILE *file)
int	ma_read_event (MA_FILE *file, EVENT_HEADER *pevent, int size)
INT	analyze_run (INT run_number, char *input_file_name, char *output_file_name)
INT	loop_runs_offline ()
int	main (int argc, char *argv[])

Variables
ANA_OUTPUT_INFO	out_info
BOOL	pvm_master = FALSE
BOOL	pvm_slave = FALSE
const char *	bstr = " "
const char *	analyzer_name
INT	analyzer_loop_period
INT	odb_size
HNDLE	hDB
	main ODB handle
DWORD	current_run_number
ANALYZE_REQUEST	analyze_request []
BOOL	ntuple_flag
INT	lock_list [10000]
int	QUEST [100]
INT	pawc_size
static int	sys_max_event_size = DEFAULT_MAX_EVENT_SIZE
struct {
INT   online
char   host_name [HOST_NAME_LENGTH]
char   exp_name [NAME_LENGTH]
char   input_file_name [10][256]
char   output_file_name [256]
INT   run_number [2]
DWORD   n [4]
BOOL   filter
char   config_file_name [10][256]
char   param [10][256]
char   protect [10][256]
BOOL   rwnt
INT   lrec
BOOL   debug
BOOL   verbose
BOOL   quiet
BOOL   no_load
BOOL   daemon
INT   n_task
INT   pvm_buf_size
INT   root_port
BOOL   start_rint
}	clp
struct {
char   flag_char
char   description [1000]
void *   data
INT   type
INT   n
INT   index
}	clp_descrip []
FILE *	out_file
BOOL	out_gzip
INT	out_format
BOOL	out_append
ANA_TEST **	tl
int	n_test = 0
char	hbook_types [][8]
struct {
short int   event_id
DWORD   last_time
}	last_time_event [50]
ANALYZE_REQUEST *	_current_par

Macro Definition Documentation

ANALYZER_REQUEST_STR

#define ANALYZER_REQUEST_STR   "\Event ID = INT : 0\n\Trigger mask = INT : -1\n\Sampling type = INT : 1\n\Buffer = STRING : [32] SYSTEM\n\Enabled = BOOL : 1\n\Client name = STRING : [32] \n\Host = STRING : [32] \n\"

Definition at line 343 of file mana.cxx.

ANALYZER_STATS_STR

#define ANALYZER_STATS_STR   "\Events received = DOUBLE : 0\n\Events per sec. = DOUBLE : 0\n\Events written = DOUBLE : 0\n\"

Definition at line 353 of file mana.cxx.

EXT_EVENT_SIZE

#define EXT_EVENT_SIZE   (2*(MAX_EVENT_SIZE+sizeof(EVENT_HEADER)))

Definition at line 234 of file mana.cxx.

HBOOK_LREC

#define HBOOK_LREC   8190

Definition at line 230 of file mana.cxx.

MA_DEVICE_DISK

#define MA_DEVICE_DISK   1

Definition at line 3830 of file mana.cxx.

MA_DEVICE_FTP

#define MA_DEVICE_FTP   3

Definition at line 3832 of file mana.cxx.

MA_DEVICE_PVM

#define MA_DEVICE_PVM   4

Definition at line 3833 of file mana.cxx.

MA_DEVICE_TAPE

#define MA_DEVICE_TAPE   2

Definition at line 3831 of file mana.cxx.

MA_FORMAT_GZIP

#define MA_FORMAT_GZIP   (1<<3)

Definition at line 3837 of file mana.cxx.

MA_FORMAT_MIDAS

#define MA_FORMAT_MIDAS   (1<<0)

Definition at line 3835 of file mana.cxx.

MA_FORMAT_YBOS

#define MA_FORMAT_YBOS   (1<<2)

Definition at line 3836 of file mana.cxx.

PVM_BUFFER_SIZE

#define PVM_BUFFER_SIZE   (1024*1024)

Definition at line 151 of file mana.cxx.

STR_INC

#define STR_INC	(		p,
			base
	)

Value:

                          { p+=strlen(p); \
                          if (p > base+sizeof(base)) \
                            cm_msg(MERROR, "STR_INC", "ASCII buffer too small"); }

Definition at line 2091 of file mana.cxx.

                        { p+=strlen(p); \
                          if (p > base+sizeof(base)) \
                            cm_msg(MERROR, "STR_INC", "ASCII buffer too small"); }

Function Documentation

add_data_dir()

void add_data_dir	(	char *	result,
		char *	file
	)

Definition at line 424 of file mana.cxx.

{
   HNDLE hDB, hkey;
   char str[256];
   int size;
 
   cm_get_experiment_database(&hDB, NULL);
   db_find_key(hDB, 0, "/Logger/Data dir", &hkey);
 
   if (hkey) {
      size = sizeof(str);
      db_get_data(hDB, hkey, str, &size, TID_STRING);
      if (str[strlen(str) - 1] != DIR_SEPARATOR)
         strcat(str, DIR_SEPARATOR_STR);
      strcat(str, file);
      strcpy(result, str);
   } else
      strcpy(result, file);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ana_begin_of_run()

INT ana_begin_of_run ( INT  run_number, char *  error  )

extern

Definition at line 101 of file analyzer.c.

{
   return CM_SUCCESS;
}

Here is the caller graph for this function:

ana_end_of_run()

INT ana_end_of_run ( INT  run_number, char *  error  )

extern

Definition at line 108 of file analyzer.c.

{
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ana_pause_run()

INT ana_pause_run ( INT  run_number, char *  error  )

extern

Definition at line 115 of file analyzer.c.

{
   return CM_SUCCESS;
}

Here is the caller graph for this function:

ana_resume_run()

INT ana_resume_run ( INT  run_number, char *  error  )

extern

Definition at line 122 of file analyzer.c.

{
   return CM_SUCCESS;
}

Here is the caller graph for this function:

analyze_run()

INT analyze_run	(	INT	run_number,
		char *	input_file_name,
		char *	output_file_name
	)

Definition at line 4045 of file mana.cxx.

{
   EVENT_HEADER *pevent, *pevent_unaligned;
   ANALYZE_REQUEST *par;
   INT n, size;
   DWORD num_events_in, num_events_out;
   char error[256], str[256];
   INT status = SUCCESS;
   MA_FILE *file;
   BOOL skip;
   DWORD start_time;
 
   /* set output file name and flags in ODB */
   sprintf(str, "/%s/Output/Filename", analyzer_name);
   db_set_value(hDB, 0, str, output_file_name, 256, 1, TID_STRING);
#ifdef HAVE_HBOOK
   sprintf(str, "/%s/Output/RWNT", analyzer_name);
   db_set_value(hDB, 0, str, &clp.rwnt, sizeof(BOOL), 1, TID_BOOL);
#endif
 
   assert(run_number > 0);
 
   /* set run number in ODB */
   status = db_set_value(hDB, 0, "/Runinfo/Run number", &run_number, sizeof(run_number), 1, TID_INT);
   assert(status == SUCCESS);
 
   /* set file name in out_info */
   strcpy(out_info.filename, output_file_name);
 
   /* let changes propagate to modules */
   cm_yield(0);
 
   /* open input file, will be changed to ma_open_file later... */
   file = ma_open(input_file_name);
   if (file == NULL) {
      printf("Cannot open input file \"%s\"\n", input_file_name);
      return -1;
   }
 
   int ext_event_size = (2*(sys_max_event_size+sizeof(EVENT_HEADER)));
 
   pevent_unaligned = (EVENT_HEADER *) malloc(ext_event_size);
   if (pevent_unaligned == NULL) {
      printf("Not enough memeory\n");
      return -1;
   }
   pevent = (EVENT_HEADER *) ALIGN8((POINTER_T) pevent_unaligned);
 
   /* call analyzer bor routines */
   bor(run_number, error);
 
   num_events_in = num_events_out = 0;
 
   start_time = ss_millitime();
 
   /* event loop */
   do {
      /* read next event */
      n = ma_read_event(file, pevent, ext_event_size);
      if (n <= 0)
         break;
 
      num_events_in++;
 
      /* copy system events (BOR, EOR, MESSAGE) to output file */
      if (pevent->event_id < 0) {
         status = process_event(NULL, pevent);
         if (status < 0 || status == RPC_SHUTDOWN)      /* disk full/stop analyzer */
            break;
 
         if (out_file && out_format == FORMAT_MIDAS) {
            size = pevent->data_size + sizeof(EVENT_HEADER);
            if (out_gzip)
               status = gzwrite((gzFile)out_file, pevent, size) == size ? SUCCESS : SS_FILE_ERROR;
            else
               status =
                   fwrite(pevent, 1, size,
                          out_file) == (size_t) size ? SUCCESS : SS_FILE_ERROR;
 
            if (status != SUCCESS) {
               cm_msg(MERROR, "analyze_run", "Error writing to file (Disk full?)");
               return -1;
            }
 
            num_events_out++;
         }
 
         /* reinit start time after BOR event */
         if (pevent->event_id == EVENTID_BOR)
            start_time = ss_millitime();
      }
 
      /* check if event is in event limit */
      skip = FALSE;
 
      if (!pvm_slave) {
         if (clp.n[0] > 0 || clp.n[1] > 0) {
            if (clp.n[1] == 0) {
               /* treat n[0] as upper limit */
               if (num_events_in > clp.n[0]) {
                  num_events_in--;
                  status = SUCCESS;
                  break;
               }
            } else {
               if (num_events_in > clp.n[1]) {
                  status = SUCCESS;
                  break;
               }
               if (num_events_in < clp.n[0])
                  skip = TRUE;
               else if (clp.n[2] > 0 && num_events_in % clp.n[2] != 0)
                  skip = TRUE;
            }
         }
      }
 
      if (!skip) {
         /* find request belonging to this event */
         par = analyze_request;
         status = SUCCESS;
         for (; par->event_name[0]; par++)
            if ((par->ar_info.event_id == EVENTID_ALL ||
                 par->ar_info.event_id == pevent->event_id) &&
                (par->ar_info.trigger_mask == TRIGGER_ALL ||
                 (par->ar_info.trigger_mask & pevent->trigger_mask))
                && par->ar_info.enabled) {
               /* analyze this event */
               status = process_event(par, pevent);
               if (status == SUCCESS)
                  num_events_out++;
               if (status < 0 || status == RPC_SHUTDOWN)        /* disk full/stop analyzer */
                  break;
 
               /* check for Ctrl-C */
               status = cm_yield(0);
            }
         if (status < 0 || status == RPC_SHUTDOWN)
            break;
      }
 
      /* update ODB statistics once every 100 events */
      if (num_events_in % 100 == 0) {
         update_stats();
         if (!clp.quiet) {
            if (out_file)
               printf("%s:%d  %s:%d  events\r", input_file_name, (int) num_events_in,
                      out_info.filename, (int) num_events_out);
            else
               printf("%s:%d  events\r", input_file_name, (int) num_events_in);
 
#ifndef OS_WINNT
            fflush(stdout);
#endif
         }
      }
   } while (1);
 
#ifdef HAVE_PVM
   PVM_DEBUG("analyze_run: event loop finished, status = %d", status);
#endif
 
   /* signal EOR to slaves */
#ifdef HAVE_PVM
   if (pvm_master) {
      if (status == RPC_SHUTDOWN)
         printf("\nShutting down distributed analyzers, please wait...\n");
      pvm_eor(status == RPC_SHUTDOWN ? TAG_EXIT : TAG_EOR);
 
      /* merge slave output files */
      if (out_info.filename[0] && !out_append)
         status = pvm_merge();
 
      start_time = ss_millitime() - start_time;
 
      update_stats();
      if (!clp.quiet) {
         if (out_file)
            printf("%s:%d  %s:%d  events, %1.2lfs\n", input_file_name, num_events_in,
                   out_info.filename, num_events_out, start_time / 1000.0);
         else
            printf("%s:%d  events, %1.2lfs\n", input_file_name, num_events_in,
                   start_time / 1000.0);
      }
   } else if (pvm_slave) {
      start_time = ss_millitime() - start_time;
 
      update_stats();
      if (!clp.quiet) {
         if (out_file)
            printf("%s:%d  %s:%d  events, %1.2lfs\n", input_file_name, num_events_in,
                   out_info.filename, num_events_out, start_time / 1000.0);
         else
            printf("%s:%d  events, %1.2lfs\n", input_file_name, num_events_in,
                   start_time / 1000.0);
      }
 
      eor(current_run_number, error);
 
      /* send back tests */
      pvm_initsend(PvmDataInPlace);
 
      for (i = 0; i < n_test; i++)
         pvm_pkbyte((char *) tl[i], sizeof(ANA_TEST), 1);
 
      PVM_DEBUG("analyze_run: send %d tests back to master", n_test);
 
      status = pvm_send(pvm_myparent, TAG_EOR);
      if (status < 0) {
         pvm_perror("pvm_send");
         return RPC_SHUTDOWN;
      }
   } else {
      start_time = ss_millitime() - start_time;
 
      update_stats();
      if (!clp.quiet) {
         if (out_file)
            printf("%s:%d  %s:%d  events, %1.2lfs\n", input_file_name, num_events_in,
                   out_info.filename, num_events_out, start_time / 1000.0);
         else
            printf("%s:%d  events, %1.2lfs\n", input_file_name, num_events_in,
                   start_time / 1000.0);
      }
 
      /* call analyzer eor routines */
      eor(current_run_number, error);
   }
#else
 
   start_time = ss_millitime() - start_time;
 
   update_stats();
   if (!clp.quiet) {
      if (out_file)
         printf("%s:%d  %s:%d  events, %1.2lfs\n", input_file_name, (int) num_events_in,
                out_info.filename, (int) num_events_out, start_time / 1000.0);
      else
         printf("%s:%d  events, %1.2lfs\n", input_file_name, (int) num_events_in,
                start_time / 1000.0);
   }
 
   /* call analyzer eor routines */
   eor(current_run_number, error);
 
#endif
 
   ma_close(file);
 
   free(pevent_unaligned);
 
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

analyzer_exit()

INT analyzer_exit ( void  )

extern

Definition at line 94 of file analyzer.c.

{
   return CM_SUCCESS;
}

Here is the caller graph for this function:

analyzer_init()

INT analyzer_init ( void  )

extern

Definition at line 87 of file analyzer.c.

{
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

analyzer_loop()

INT analyzer_loop ( void  )

extern

Definition at line 129 of file analyzer.c.

{
   return CM_SUCCESS;
}

Here is the caller graph for this function:

banks_changed()

void banks_changed	(	INT	hDB,
		INT	hKey,
		void *	info
	)

Definition at line 725 of file mana.cxx.

{
   char str[80];
   HNDLE hkey;
 
   /* close previously opened hot link */
   sprintf(str, "/%s/Bank switches", analyzer_name);
   db_find_key(hDB, 0, str, &hkey);
   db_close_record(hDB, hkey);
 
#ifdef HAVE_HBOOK
   book_ntuples();
   printf("N-tuples rebooked\n");
#endif
#ifdef HAVE_ROOT
   book_ttree();
   printf("ROOT TTree rebooked\n");
#endif
}

Here is the call graph for this function:

book_ntuples()

INT book_ntuples

(

void

)

Here is the caller graph for this function:

book_ttree()

INT book_ttree

(

void

)

Here is the caller graph for this function:

bor()

INT bor	(	INT	run_number,
		char *	error
	)

Definition at line 1675 of file mana.cxx.

{
   ANA_MODULE **module;
   INT i, j, size;
   char str[256], file_name[256], *ext_str;
   BANK_LIST *bank_list;
 
   /* load parameters */
   load_parameters(run_number);
 
   for (i = 0; analyze_request[i].event_name[0]; i++) {
      /* copy output flag from ODB to bank_list */
      bank_list = analyze_request[i].bank_list;
 
      if (bank_list != NULL)
         for (; bank_list->name[0]; bank_list++) {
            sprintf(str, "/%s/Bank switches/%s", analyzer_name, bank_list->name);
            bank_list->output_flag = FALSE;
            size = sizeof(DWORD);
            db_get_value(hDB, 0, str, &bank_list->output_flag, &size, TID_DWORD, TRUE);
         }
 
      /* copy module enabled flag to ana_module */
      module = analyze_request[i].ana_module;
      for (j = 0; module != NULL && module[j] != NULL; j++) {
         sprintf(str, "/%s/Module switches/%s", analyzer_name, module[j]->name);
         module[j]->enabled = TRUE;
         size = sizeof(BOOL);
         db_get_value(hDB, 0, str, &module[j]->enabled, &size, TID_BOOL, TRUE);
      }
   }
 
   /* clear histos, N-tuples and tests */
   if (clp.online && out_info.clear_histos) {
#ifdef HAVE_HBOOK
      int hid[10000];
      int n;
 
      for (i = 0; analyze_request[i].event_name[0]; i++)
         if (analyze_request[i].bank_list != NULL)
            if (HEXIST(analyze_request[i].ar_info.event_id))
               HRESET(analyze_request[i].ar_info.event_id, bstr);
 
      /* get list of all histos */
      HIDALL(hid, n);
      for (i = 0; i < n; i++) {
         for (j = 0; j < 10000; j++)
            if (lock_list[j] == 0 || lock_list[j] == hid[i])
               break;
 
         /* clear histo if not locked */
         if (lock_list[j] != hid[i])
            HRESET(hid[i], bstr);
      }
#endif                          /* HAVE_HBOOK */
 
#ifdef HAVE_ROOT
      /* clear histos */
      if (clp.online && out_info.clear_histos)
         ClearRootHistograms(gManaHistosFolder);
#endif                          /* HAVE_ROOT */
 
      /* clear tests */
      test_clear();
   }
#ifdef HAVE_ROOT
   if (clp.online) {
      /* clear all trees when online */
      for (i = 0; i < tree_struct.n_tree; i++)
         tree_struct.event_tree[i].tree->Reset();
   }
#endif
 
   /* open output file if not already open (append mode) and in offline mode */
   if (!clp.online && out_file == NULL && !pvm_master
       && !equal_ustring(clp.output_file_name, "OFLN")) {
      if (out_info.filename[0]) {
         strcpy(str, out_info.filename);
         if (strchr(str, '%') != NULL)
            sprintf(file_name, str, run_number);
         else
            strcpy(file_name, str);
 
         /* check output file extension */
         out_gzip = FALSE;
         if (strchr(file_name, '.')) {
            ext_str = file_name + strlen(file_name) - 1;
            while (*ext_str != '.')
               ext_str--;
 
            if (strncmp(ext_str, ".gz", 3) == 0) {
               out_gzip = TRUE;
               ext_str--;
               while (*ext_str != '.' && ext_str > file_name)
                  ext_str--;
            }
 
            if (strncmp(ext_str, ".asc", 4) == 0)
               out_format = FORMAT_ASCII;
            else if (strncmp(ext_str, ".mid", 4) == 0)
               out_format = FORMAT_MIDAS;
            else if (strncmp(ext_str, ".rz", 3) == 0)
               out_format = FORMAT_HBOOK;
            else if (strncmp(ext_str, ".root", 5) == 0)
               out_format = FORMAT_ROOT;
            else {
               strcpy(error, "Unknown output data format. Please use file extension .asc, .mid, .rz or .root.\n");
               cm_msg(MERROR, "bor", "%s", error);
               return 0;
            }
         } else
            out_format = FORMAT_ASCII;
 
#ifdef HAVE_PVM
         /* use node name as filename if PVM slave */
         if (pvm_slave) {
            /* extract extension */
            if (strchr(file_name, '.')) {
               strcpy(str, strchr(file_name, '.') + 1);
               sprintf(file_name, "n%d", pvm_client_index);
               strcat(file_name, ".");
               strcat(file_name, str);
            } else {
               sprintf(file_name, "n%d", pvm_client_index);
            }
 
            PVM_DEBUG("BOR: file_name = %s", file_name);
         }
#endif
 
         /* open output file */
         if (out_format == FORMAT_HBOOK) {
#ifdef HAVE_HBOOK
            int status, lrec;
            char str2[80];
 
            lrec = clp.lrec;
#ifdef extname
            quest_[9] = 65000;
#else
            QUEST[9] = 65000;
#endif
 
            strcpy(str, "BSIZE");
            HBSET(str, HBOOK_LREC, status);
            strcpy(str, "OFFLINE");
            strcpy(str2, "NQP");
            HROPEN(1, str, file_name, str2, lrec, status);
            if (status != 0) {
               sprintf(error, "Cannot open output file %s", out_info.filename);
               cm_msg(MERROR, "bor", error);
               out_file = NULL;
               return 0;
            } else
               out_file = (FILE *) 1;
#else
            cm_msg(MERROR, "bor", "HBOOK support is not compiled in");
#endif                          /* HAVE_HBOOK */
         }
 
         else if (out_format == FORMAT_ROOT) {
#ifdef HAVE_ROOT
            // ensure the output file is closed
            assert(gManaOutputFile == NULL);
 
            gManaOutputFile =
                new TFile(file_name, "RECREATE", "Midas Analyzer output file");
            if (gManaOutputFile == NULL) {
               sprintf(error, "Cannot open output file %s", out_info.filename);
               cm_msg(MERROR, "bor", "%s", error);
               out_file = NULL;
               return 0;
            }
            // make all ROOT objects created by user module bor() functions
            // go into the output file
            gManaOutputFile->cd();
 
            out_file = (FILE *) 1;
#else
            cm_msg(MERROR, "bor", "ROOT support is not compiled in");
#endif                          /* HAVE_ROOT */
         }
 
         else {
            if (out_gzip)
               out_file = (FILE *) gzopen(file_name, "wb");
            else
            if (out_format == FORMAT_ASCII)
               out_file = fopen(file_name, "wt");
            else
               out_file = fopen(file_name, "wb");
            if (out_file == NULL) {
               sprintf(error, "Cannot open output file %s", file_name);
               cm_msg(MERROR, "bor", "%s", error);
               return 0;
            }
         }
      } else
         out_file = NULL;
 
#ifdef HAVE_HBOOK
      /* book N-tuples */
      if (out_format == FORMAT_HBOOK) {
         int status = book_ntuples();
         if (status != SUCCESS)
            return status;
      }
#endif                          /* HAVE_HBOOK */
 
#ifdef HAVE_ROOT
      /* book ROOT TTree */
      if (out_format == FORMAT_ROOT) {
         int status = book_ttree();
         if (status != SUCCESS)
            return status;
      }
#endif                          /* HAVE_ROOT */
 
   }
 
   /* if (out_file == NULL) */
   /* save run number */
   current_run_number = run_number;
 
   /* call bor for modules */
   for (i = 0; analyze_request[i].event_name[0]; i++) {
      module = analyze_request[i].ana_module;
      for (j = 0; module != NULL && module[j] != NULL; j++)
         if (module[j]->bor != NULL && module[j]->enabled) {
            module[j]->bor(run_number);
         }
   }
 
   /* call main analyzer BOR routine */
   return ana_begin_of_run(run_number, error);
}

Here is the call graph for this function:

Here is the caller graph for this function:

correct_num_events()

void correct_num_events

(

INT

i

)

Definition at line 3075 of file mana.cxx.

{
   if (_current_par)
      _current_par->events_received += i - 1;
}

db_get_event_definition()

EVENT_DEF * db_get_event_definition

(

short int

event_id

)

Definition at line 454 of file mana.cxx.

{
   INT i, index, status, size, type;
   char str[80];
   HNDLE hKey, hKeyRoot;
   WORD id;
   static EVENT_DEF *event_def = NULL;
   static int n_cache = 0;
 
   /* search free cache entry */
   for (index = 0; index < n_cache; index++)
      if (event_def[index].event_id == event_id)
         return &event_def[index];
 
   /* If we get here, we have an undefined ID;
      allocate memory for it, zero it, then cache the ODB data */
   n_cache = index + 1;
 
   event_def = (EVENT_DEF *) realloc(event_def, (n_cache) * sizeof(EVENT_DEF));
   assert(event_def);
 
   memset(&event_def[index], 0, sizeof(EVENT_DEF));
 
   /* check for system events */
   if (event_id < 0) {
      event_def[index].event_id = event_id;
      event_def[index].format = FORMAT_ASCII;
      event_def[index].hDefKey = 0;
      event_def[index].disabled = FALSE;
      return &event_def[index];
   }
 
   status = db_find_key(hDB, 0, "/equipment", &hKeyRoot);
   if (status != DB_SUCCESS) {
      cm_msg(MERROR, "db_get_event_definition", "cannot find /equipment entry in ODB");
      return NULL;
   }
 
   for (i = 0;; i++) {
      /* search for equipment with specific name */
      status = db_enum_key(hDB, hKeyRoot, i, &hKey);
      if (status == DB_NO_MORE_SUBKEYS) {
         cm_msg(MERROR, "db_get_event_definition", "Cannot find event id %d under /equipment", event_id);
         return NULL;
      }
 
      size = sizeof(id);
      status = db_get_value(hDB, hKey, "Common/Event ID", &id, &size, TID_WORD, TRUE);
      if (status != DB_SUCCESS)
         continue;
 
      size = sizeof(type);
      status = db_get_value(hDB, hKey, "Common/Type", &type, &size, TID_INT, TRUE);
      if (status != DB_SUCCESS)
         continue;
 
      if (id == event_id) {
         /* set cache entry */
         event_def[index].event_id = id;
         event_def[index].type = type;
 
         size = sizeof(str);
         str[0] = 0;
         db_get_value(hDB, hKey, "Common/Format", str, &size, TID_STRING, TRUE);
 
         if (equal_ustring(str, "Fixed"))
            event_def[index].format = FORMAT_FIXED;
         else if (equal_ustring(str, "ASCII"))
            event_def[index].format = FORMAT_ASCII;
         else if (equal_ustring(str, "MIDAS"))
            event_def[index].format = FORMAT_MIDAS;
         else if (equal_ustring(str, "YBOS"))
            event_def[index].format = FORMAT_YBOS;
         else if (equal_ustring(str, "DUMP"))
            event_def[index].format = FORMAT_DUMP;
         else {
            cm_msg(MERROR, "db_get_event_definition", "unknown data format");
            event_def[index].event_id = 0;
            return NULL;
         }
 
         db_find_key(hDB, hKey, "Variables", &event_def[index].hDefKey);
         return &event_def[index];
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

eor()

INT eor	(	INT	run_number,
		char *	error
	)

Definition at line 1914 of file mana.cxx.

{
   ANA_MODULE **module;
   BANK_LIST *bank_list;
   INT i, j, status;
   char str[256], file_name[256];
 
   /* call EOR routines modules */
   for (i = 0; analyze_request[i].event_name[0]; i++) {
      module = analyze_request[i].ana_module;
      for (j = 0; module != NULL && module[j] != NULL; j++)
         if (module[j]->eor != NULL && module[j]->enabled) {
            module[j]->eor(run_number);
         }
   }
 
   /* call main analyzer BOR routine */
   status = ana_end_of_run(run_number, error);
 
   /* save histos if requested */
   if (out_info.histo_dump && clp.online) {
      strcpy(str, out_info.histo_dump_filename);
      if (strchr(str, '%') != NULL)
         sprintf(file_name, str, run_number);
      else
         strcpy(file_name, str);
 
      add_data_dir(str, file_name);
#ifdef HAVE_HBOOK
      for (i = 0; i < (int) strlen(str); i++)
         if (isupper(str[i]))
            break;
 
      if (i < (int) strlen(str)) {
         printf
             ("Error: Due to a limitation in HBOOK, directoy names may not contain uppercase\n");
         printf("       characters. Histogram saving to %s will not work.\n", str);
      } else {
         char str2[256];
         strcpy(str2, "NT");
         HRPUT(0, str, str2);
      }
#endif                          /* HAVE_HBOOK */
 
#ifdef HAVE_ROOT
      SaveRootHistograms(gManaHistosFolder, str);
#endif                          /* HAVE_ROOT */
   }
 
   /* close output file */
   if (out_file && !out_append) {
      if (out_format == FORMAT_HBOOK) {
#ifdef HAVE_HBOOK
         HROUT(0, i, bstr);
         strcpy(str, "OFFLINE");
         HREND(str);
#else
         cm_msg(MERROR, "eor", "HBOOK support is not compiled in");
#endif                          /* HAVE_HBOOK */
      } else if (out_format == FORMAT_ROOT) {
#ifdef HAVE_ROOT
         CloseRootOutputFile();
#else
         cm_msg(MERROR, "eor", "ROOT support is not compiled in");
#endif                          /* HAVE_ROOT */
      } else {
         if (out_gzip)
            gzclose((gzFile)out_file);
         else
            fclose(out_file);
      }
 
      out_file = NULL;
 
      /* free CWNT buffer */
      for (i = 0; analyze_request[i].event_name[0]; i++) {
         bank_list = analyze_request[i].bank_list;
 
         if (bank_list == NULL) {
            if (analyze_request[i].addr) {
               free(analyze_request[i].addr);
               analyze_request[i].addr = NULL;
            }
         } else {
            for (; bank_list->name[0]; bank_list++)
               if (bank_list->addr) {
                  free(bank_list->addr);
                  bank_list->addr = NULL;
               }
         }
      }
   }
 
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getparam()

INT getparam	(	int	argc,
		char **	argv
	)

Definition at line 361 of file mana.cxx.

{
   INT index, i, j, size;
 
   /* parse command line parameters */
   for (index = 1; index < argc;) {
      /* search flag in parameter description */
      if (argv[index][0] == '-') {
         for (j = 0; clp_descrip[j].flag_char; j++)
            if (argv[index][1] == clp_descrip[j].flag_char)
               break;
 
         if (!clp_descrip[j].flag_char)
            goto usage;
 
         if (clp_descrip[j].n > 0 && index >= argc - 1)
            goto usage;
         index++;
 
         if (clp_descrip[j].type == TID_BOOL) {
            *((BOOL *) clp_descrip[j].data) = TRUE;
            continue;
         }
 
         do {
            if (clp_descrip[j].type == TID_STRING)
               strcpy((char *) clp_descrip[j].data + clp_descrip[j].index * 256,
                      argv[index]);
            else
               db_sscanf(argv[index], clp_descrip[j].data, &size, clp_descrip[j].index,
                         clp_descrip[j].type);
 
            if (clp_descrip[j].n > 1)
               clp_descrip[j].index++;
 
            if (clp_descrip[j].index > clp_descrip[j].n) {
               printf("Note more than %d options possible for flag -%c\n",
                      clp_descrip[j].n, clp_descrip[j].flag_char);
               return 0;
            }
 
            index++;
 
         } while (index < argc && argv[index][0] != '-');
 
      } else
         goto usage;
   }
 
   return SUCCESS;
 
 usage:
 
   printf("usage: analyzer [options]\n\n");
   printf("valid options are:\n");
   for (i = 0; clp_descrip[i].flag_char; i++)
      printf("  -%c %s\n", clp_descrip[i].flag_char, clp_descrip[i].description);
 
   return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_module_parameters()

INT init_module_parameters

(

BOOL

bclose

)

Definition at line 3693 of file mana.cxx.

{
   INT i, j, status, size;
   ANA_MODULE **module;
   char str[80];
   HNDLE hkey;
 
   for (i = 0; analyze_request[i].event_name[0]; i++) {
      module = analyze_request[i].ana_module;
      for (j = 0; module != NULL && module[j] != NULL; j++) {
         if (module[j]->parameters != NULL) {
            sprintf(str, "/%s/Parameters/%s", analyzer_name, module[j]->name);
 
            if (bclose) {
               db_find_key(hDB, 0, str, &hkey);
               db_close_record(hDB, hkey);
            } else {
               status = db_find_key(hDB, 0, str, &hkey);
               if (status == DB_SUCCESS) {
                  db_get_record_size(hDB, hkey, 0, &size);
                  if (size != module[j]->param_size)
                     status = 0;
               }
               if (status != DB_SUCCESS && module[j]->init_str) {
                  if (db_check_record(hDB, 0, str, strcomb1((const char **)module[j]->init_str).c_str(), TRUE) !=
                      DB_SUCCESS) {
                     cm_msg(MERROR, "init_module_parameters",
                            "Cannot create/check \"%s\" parameters in ODB", str);
                     return 0;
                  }
               }
 
               db_find_key(hDB, 0, str, &hkey);
               assert(hkey);
 
               if (db_open_record(hDB, hkey, module[j]->parameters, module[j]->param_size,
                                  MODE_READ, NULL, NULL) != DB_SUCCESS) {
                  cm_msg(MERROR, "init_module_parameters",
                         "Cannot open \"%s\" parameters in ODB", str);
                  return 0;
               }
            }
         }
      }
   }
 
   return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

load_last_histos()

void load_last_histos

(

)

Definition at line 3547 of file mana.cxx.

{
   char str[256];
 
   /* load previous online histos */
   if (!clp.no_load) {
      strcpy(str, out_info.last_histo_filename);
 
      if (strchr(str, DIR_SEPARATOR) == NULL)
         add_data_dir(str, out_info.last_histo_filename);
 
#ifdef HAVE_HBOOK
      {
         FILE *f;
         char str2[256];
         int i;
 
         for (i = 0; i < (int) strlen(str); i++)
            if (isupper(str[i]))
               break;
 
         if (i < (int) strlen(str)) {
            printf
                ("Error: Due to a limitation in HBOOK, directoy names may not contain uppercase\n");
            printf("       characters. Histogram loading from %s will not work.\n", str);
         } else {
            f = fopen(str, "r");
            if (f != NULL) {
               fclose(f);
               printf("Loading previous online histos from %s\n", str);
               strcpy(str2, "A");
               HRGET(0, str, str2);
 
               /* fix wrongly booked N-tuples at ID 100000 */
               if (HEXIST(100000))
                  HDELET(100000);
            }
         }
      }
#endif                          /* HAVE_HBOOK */
 
#ifdef HAVE_ROOT
      printf("Loading previous online histos from %s\n", str);
      LoadRootHistograms(gManaHistosFolder, str);
#endif
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

load_parameters()

INT load_parameters

(

INT

run_number

)

Definition at line 633 of file mana.cxx.

{
   INT i, size, index, status;
   HNDLE hkey;
   char file_name[256];
   char value_string[80];
   char param_string[80];
   char data[32];
 
   /* loop over configutation file names */
   for (i = 0; clp.config_file_name[i][0] && i < 10; i++) {
      if (strchr(clp.config_file_name[i], '%') != NULL)
         sprintf(file_name, clp.config_file_name[i], run_number);
      else
         strcpy(file_name, clp.config_file_name[i]);
 
      /* load file under "/" */
      if (db_load(hDB, 0, file_name, FALSE) == DB_SUCCESS)
         printf("Configuration file \"%s\" loaded\n", file_name);
   }
 
   /* loop over parameters */
   for (i = 0; clp.param[i][0] && i < 10; i++) {
      if (strchr(clp.param[i], '=') == NULL) {
         printf("Error: parameter %s contains no value\n", clp.param[i]);
      } else {
         strcpy(value_string, strchr(clp.param[i], '=') + 1);
         strcpy(param_string, clp.param[i]);
         *strchr(param_string, '=') = 0;
 
         index = 0;
         if (strchr(param_string, '[') != NULL) {
            index = atoi(strchr(param_string, '[') + 1);
            *strchr(param_string, '[') = 0;
         }
 
         char str[MAX_ODB_PATH];
 
         if (param_string[0] == '/')
            strcpy(str, param_string);
         else
            sprintf(str, "/%s/Parameters/%s", analyzer_name, param_string);
         db_find_key(hDB, 0, str, &hkey);
         if (hkey == 0) {
            printf("Error: cannot find parameter %s in ODB\n", str);
         } else {
            KEY key;
            db_get_key(hDB, hkey, &key);
            db_sscanf(value_string, data, &size, 0, key.type);
 
            status = db_set_data_index(hDB, hkey, data, size, index, key.type);
            if (status == DB_SUCCESS)
               printf("Parameter %s changed to %s\n", str, value_string);
            else
               printf("Cannot change parameter %s\n", str);
         }
      }
   }
 
   /* let parameter changes propagate to modules */
   cm_yield(0);
 
   return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

lock_histo()

void lock_histo

(

INT

id

)

Definition at line 3523 of file mana.cxx.

{
   INT i;
 
   for (i = 0; i < 10000; i++)
      if (lock_list[i] == 0)
         break;
 
   lock_list[i] = id;
}

loop_online()

INT loop_online

(

)

Definition at line 3636 of file mana.cxx.

{
   INT status = SUCCESS;
   DWORD last_time_loop, last_time_update, actual_time;
   int ch;
 
   printf("Running analyzer online. Stop with \"!\"\n");
 
   /* main loop */
   last_time_update = 0;
   last_time_loop = 0;
 
   do {
      /* calculate events per second */
      actual_time = ss_millitime();
 
      if (actual_time - last_time_update > 1000) {
         /* update statistics */
         update_stats();
         last_time_update = actual_time;
 
         /* check keyboard */
         ch = 0;
         while (ss_kbhit()) {
            ch = ss_getchar(0);
            if (ch == -1)
               ch = getchar();
 
            if ((char) ch == '!')
               break;
         }
 
         if ((char) ch == '!')
            break;
      }
 
      if (analyzer_loop_period == 0)
         status = cm_yield(1000);
      else {
         if (actual_time - last_time_loop > (DWORD) analyzer_loop_period) {
            last_time_loop = actual_time;
            analyzer_loop();
         }
 
         status = cm_yield(analyzer_loop_period);
      }
 
   } while (status != RPC_SHUTDOWN && status != SS_ABORT);
 
   /* update statistics */
   update_stats();
 
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

loop_runs_offline()

INT loop_runs_offline

(

)

Definition at line 4301 of file mana.cxx.

{
   INT i, status, run_number;
   char input_file_name[256], output_file_name[256], *prn;
   BANK_LIST *bank_list;
 
   if (!clp.quiet)
      printf("Running analyzer offline. Stop with \"!\"\n");
 
   run_number = 0;
   out_append = ((strchr(clp.input_file_name[0], '%') != NULL) &&
                 (strchr(clp.output_file_name, '%') == NULL))
       || clp.input_file_name[1][0];
 
   /* loop over range of files */
   if (clp.run_number[0] > 0) {
      if (strchr(clp.input_file_name[0], '%') == NULL) {
         printf
             ("Input file name must contain a wildcard like \"%%05d\" when using a range.\n");
         return 0;
      }
 
      if (clp.run_number[0] == 0) {
         printf("End of range not specified.\n");
         return 0;
      }
 
      for (run_number = clp.run_number[0]; run_number <= clp.run_number[1]; run_number++) {
         sprintf(input_file_name, clp.input_file_name[0], run_number);
         if (strchr(clp.output_file_name, '%') != NULL)
            sprintf(output_file_name, clp.output_file_name, run_number);
         else
            strcpy(output_file_name, clp.output_file_name);
 
         status = analyze_run(run_number, input_file_name, output_file_name);
         if (status == RPC_SHUTDOWN)
            break;
      }
   } else {
      /* loop over input file names */
      for (i = 0; clp.input_file_name[i][0] && i < 10; i++) {
         strcpy(input_file_name, clp.input_file_name[i]);
 
         /* get run number from input file */
         prn = input_file_name;
         while (strchr(prn, DIR_SEPARATOR) != NULL)
            prn = strchr(prn, DIR_SEPARATOR) + 1;
 
         if (strpbrk(prn, "0123456789"))
            run_number = atoi(strpbrk(prn, "0123456789"));
 
         if (strchr(clp.output_file_name, '%') != NULL) {
            if (run_number == 0) {
               printf("Cannot extract run number from input file name.\n");
               return 0;
            }
            sprintf(output_file_name, clp.output_file_name, run_number);
         } else
            strcpy(output_file_name, clp.output_file_name);
 
         status = analyze_run(run_number, input_file_name, output_file_name);
         if (status == RPC_SHUTDOWN)
            break;
      }
   }
 
   /* close output file in append mode */
   if (out_file && out_append) {
      if (out_format == FORMAT_HBOOK) {
#ifdef HAVE_HBOOK
         char str[80];
 
         HROUT(0, i, bstr);
         strcpy(str, "OFFLINE");
         HREND(str);
#else
         cm_msg(MERROR, "loop_runs_offline", "HBOOK support is not compiled in");
#endif
      } else if (out_format == FORMAT_ROOT) {
#ifdef HAVE_ROOT
         CloseRootOutputFile();
#else
         cm_msg(MERROR, "loop_runs_offline", "ROOT support is not compiled in");
#endif                          /* HAVE_ROOT */
      } else {
         if (out_gzip)
            gzclose((gzFile)out_file);
         else
            fclose(out_file);
      }
 
      /* free bank buffer */
      for (i = 0; analyze_request[i].event_name[0]; i++) {
         bank_list = analyze_request[i].bank_list;
 
         if (bank_list == NULL)
            continue;
 
         for (; bank_list->name[0]; bank_list++)
            if (bank_list->addr) {
               free(bank_list->addr);
               bank_list->addr = NULL;
            }
      }
   }
#ifdef HAVE_PVM
   /* merge slave output files */
   if (pvm_master && out_info.filename[0] && out_append)
      pvm_merge();
#endif
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ma_close()

int ma_close

(

MA_FILE *

file

)

Definition at line 3919 of file mana.cxx.

{
   if (file->format == MA_FORMAT_YBOS)
     assert(!"YBOS not supported anymore");
   else
      gzclose((gzFile)file->gzfile);
 
   free(file);
   return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ma_open()

MA_FILE * ma_open

(

char *

file_name

)

Definition at line 3852 of file mana.cxx.

{
   char *ext_str;
   MA_FILE *file;
 
   /* allocate MA_FILE structure */
   file = (MA_FILE *) calloc(sizeof(MA_FILE), 1);
   if (file == NULL) {
      cm_msg(MERROR, "ma_open", "Cannot allocate MA file structure");
      return NULL;
   }
 
   /* save file name */
   strcpy(file->file_name, file_name);
 
   /* for now, just read from disk */
   file->device = MA_DEVICE_DISK;
 
   /* or from PVM */
   if (pvm_slave) {
      file->device = MA_DEVICE_PVM;
      file->buffer = (char *) malloc(PVM_BUFFER_SIZE);
      file->wp = file->rp = 0;
   }
 
   /* check input file extension */
   if (strchr(file_name, '.')) {
      ext_str = file_name + strlen(file_name) - 1;
      while (*ext_str != '.')
         ext_str--;
   } else
      ext_str = (char *)"";
 
   if (strncmp(ext_str, ".gz", 3) == 0) {
      ext_str--;
      while (*ext_str != '.' && ext_str > file_name)
         ext_str--;
   }
 
   if (strncmp(file_name, "/dev/", 4) == 0)     /* assume MIDAS tape */
      file->format = MA_FORMAT_MIDAS;
   else if (strncmp(ext_str, ".mid", 4) == 0)
      file->format = MA_FORMAT_MIDAS;
   else if (strncmp(ext_str, ".ybs", 4) == 0)
     assert(!"YBOS not supported anymore");
   else {
      printf
          ("Unknown input data format \"%s\". Please use file extension .mid or mid.gz.\n",
           ext_str);
      return NULL;
   }
 
   if (file->device == MA_DEVICE_DISK) {
      if (file->format == MA_FORMAT_YBOS) {
   assert(!"YBOS not supported anymore");
      } else {
         file->gzfile = gzopen(file_name, "rb");
         if (file->gzfile == NULL)
            return NULL;
      }
   }
 
   return file;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ma_read_event()

int ma_read_event	(	MA_FILE *	file,
		EVENT_HEADER *	pevent,
		int	size
	)

Definition at line 3932 of file mana.cxx.

{
   int n;
 
   if (file->device == MA_DEVICE_DISK) {
      if (file->format == MA_FORMAT_MIDAS) {
         if (size < (int) sizeof(EVENT_HEADER)) {
            cm_msg(MERROR, "ma_read_event", "Buffer size too small");
            return -1;
         }
 
         /* read event header */
         n = gzread(file->gzfile, pevent, sizeof(EVENT_HEADER));
 
         if (n < (int) sizeof(EVENT_HEADER)) {
            if (n > 0)
               printf("Unexpected end of file %s, last event skipped\n", file->file_name);
            return -1;
         }
 
         /* swap event header if in wrong format */
#ifdef SWAP_EVENTS
         WORD_SWAP(&pevent->event_id);
         WORD_SWAP(&pevent->trigger_mask);
         DWORD_SWAP(&pevent->serial_number);
         DWORD_SWAP(&pevent->time_stamp);
         DWORD_SWAP(&pevent->data_size);
#endif
 
         /* read event */
         n = 0;
         if (pevent->data_size > 0) {
            if (size < (int) pevent->data_size + (int) sizeof(EVENT_HEADER)) {
               cm_msg(MERROR, "ma_read_event", "Buffer size too small");
               return -1;
            }
            n = gzread(file->gzfile, pevent + 1, pevent->data_size);
            if (n != (INT) pevent->data_size) {
               printf("Unexpected end of file %s, last event skipped\n", file->file_name);
               return -1;
            }
         }
 
         return n + sizeof(EVENT_HEADER);
      } else if (file->format == MA_FORMAT_YBOS) {
   assert(!"YBOS not supported anymore");
      }
   } else if (file->device == MA_DEVICE_PVM) {
#ifdef HAVE_PVM
      int bufid, len, tag, tid;
      EVENT_HEADER *pe;
      struct timeval timeout;
 
      /* check if anything in buffer */
      if (file->wp > file->rp) {
         pe = (EVENT_HEADER *) (file->buffer + file->rp);
         size = sizeof(EVENT_HEADER) + pe->data_size;
         memcpy(pevent, pe, size);
         file->rp += size;
         return size;
      }
 
      /* send data request */
      pvm_initsend(PvmDataInPlace);
      pvm_send(pvm_myparent, TAG_DATA);
 
      /* receive data */
      timeout.tv_sec = 60;
      timeout.tv_usec = 0;
 
      bufid = pvm_trecv(-1, -1, &timeout);
      if (bufid < 0) {
         pvm_perror("pvm_recv");
         return -1;
      }
      if (bufid == 0) {
         PVM_DEBUG("ma_read_event: timeout receiving data, aborting analyzer.\n");
         return -1;
      }
 
      status = pvm_bufinfo(bufid, &len, &tag, &tid);
      if (status < 0) {
         pvm_perror("pvm_bufinfo");
         return -1;
      }
 
      PVM_DEBUG("ma_read_event: receive tag %d, buflen %d", tag, len);
 
      if (tag == TAG_EOR || tag == TAG_EXIT)
         return -1;
 
      file->wp = len;
      file->rp = 0;
      status = pvm_upkbyte((char *) file->buffer, len, 1);
      if (status < 0) {
         pvm_perror("pvm_upkbyte");
         return -1;
      }
 
      /* no new data available, sleep some time to reduce network traffic */
      if (len == 0)
         ss_sleep(200);
 
      /* re-call this function */
      return ma_read_event(file, pevent, size);
#endif
   }
 
   return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 5321 of file mana.cxx.

{
   INT status, size;
   char str[256];
   HNDLE hkey;
 
#ifdef HAVE_PVM
   int i;
 
   str[0] = 0;
   for (i = 0; i < argc; i++) {
      strcat(str, argv[i]);
      strcat(str, " ");
   }
   PVM_DEBUG("Analyzer started: %s", str);
#endif
 
#ifdef HAVE_ROOT
   int argn = 1;
   char *argp = (char *) argv[0];
 
   manaApp = new TRint("ranalyzer", &argn, &argp, NULL, 0, true);
 
   /* default server port */
   clp.root_port = 9090;
#endif
 
   /* get default from environment */
   cm_get_environment(clp.host_name, sizeof(clp.host_name), clp.exp_name,
                      sizeof(clp.exp_name));
 
#ifdef HAVE_HBOOK
   /* set default lrec size */
   clp.lrec = HBOOK_LREC;
#endif                          /* HAVE_HBOOK */
 
   /* read in command line parameters into clp structure */
   status = getparam(argc, argv);
   if (status != CM_SUCCESS)
      return 1;
 
   /* become a daemon */
   if (clp.daemon) {
      printf("Becoming a daemon...\n");
      clp.quiet = TRUE;
      ss_daemon_init(FALSE);
   }
 
   /* set default buffer size */
   if (clp.pvm_buf_size == 0)
      clp.pvm_buf_size = 512 * 1024;
   else
      clp.pvm_buf_size *= 1024;
   if (clp.pvm_buf_size > PVM_BUFFER_SIZE) {
      printf("Buffer size cannot be larger than %dkB\n", PVM_BUFFER_SIZE / 1024);
      return 1;
   }
 
   /* set online mode if no input filename is given */
   clp.online = (clp.input_file_name[0][0] == 0);
 
#ifdef HAVE_HBOOK
   /* set Ntuple format to RWNT if online */
   if (clp.online || equal_ustring(clp.output_file_name, "OFLN"))
      clp.rwnt = TRUE;
#endif                          /* HAVE_HBOOK */
 
#ifdef HAVE_PVM
   status = pvm_main(argv);
   if (status != CM_SUCCESS)
      return 1;
#endif
 
   /* now connect to server */
   if (clp.online) {
      if (clp.host_name[0])
         printf("Connect to experiment %s on host %s...", clp.exp_name, clp.host_name);
      else
         printf("Connect to experiment %s...", clp.exp_name);
   }
 
   status =
       cm_connect_experiment1(clp.host_name, clp.exp_name, analyzer_name, NULL, odb_size,
                              DEFAULT_WATCHDOG_TIMEOUT);
 
   if (status == CM_UNDEF_EXP) {
      printf("\nError: Experiment \"%s\" not defined.\n", clp.exp_name);
      if (getenv("MIDAS_DIR")) {
         printf
             ("Note that \"MIDAS_DIR\" is defined, which results in a single experiment\n");
         printf
             ("called \"Default\". If you want to use the \"exptab\" file, undefine \"MIDAS_DIR\".\n");
      }
      return 1;
   } else if (status != CM_SUCCESS) {
      std::string s = cm_get_error(status);
      printf("\nError: %s\n", s.c_str());
      return 1;
   }
 
   if (clp.online)
      printf("OK\n");
 
   /* set online/offline mode */
   cm_get_experiment_database(&hDB, NULL);
 
   size = sizeof(sys_max_event_size);
   status = db_get_value(hDB, 0, "/Experiment/MAX_EVENT_SIZE", &sys_max_event_size, &size, TID_DWORD, TRUE);
 
   db_set_value(hDB, 0, "/Runinfo/Online Mode", &clp.online, sizeof(clp.online), 1, TID_INT);
 
   if (clp.online) {
      /* check for duplicate name */
      status = cm_exist(analyzer_name, FALSE);
      if (status == CM_SUCCESS) {
         cm_disconnect_experiment();
         printf("An analyzer named \"%s\" is already running in this experiment.\n",
                analyzer_name);
         printf
             ("Please select another analyzer name in analyzer.c or stop other analyzer.\n");
         return 1;
      }
 
      /* register transitions if started online */
      if (cm_register_transition(TR_START, tr_start, 300) != CM_SUCCESS ||
          cm_register_transition(TR_STOP, tr_stop, 700) != CM_SUCCESS ||
          cm_register_transition(TR_PAUSE, tr_pause, 700) != CM_SUCCESS ||
          cm_register_transition(TR_RESUME, tr_resume, 300) != CM_SUCCESS) {
         printf("Failed to start local RPC server");
         return 1;
      }
   } else {
      if (!pvm_slave) {         /* slave could run on same machine... */
         status = cm_exist(analyzer_name, FALSE);
         if (status == CM_SUCCESS) {
            /* kill hanging previous analyzer */
            cm_cleanup(analyzer_name, FALSE);
 
            status = cm_exist(analyzer_name, FALSE);
            if (status == CM_SUCCESS) {
               /* analyzer may only run once if offline */
               status = cm_shutdown(analyzer_name, FALSE);
               if (status == CM_SHUTDOWN)
                  printf("Previous analyzer stopped\n");
            }
         }
      }
   }
 
#ifdef HAVE_HBOOK
   /* register callback for clearing histos */
   cm_register_function(RPC_ANA_CLEAR_HISTOS, ana_callback);
#endif
 
   /* turn on keepalive messages */
   cm_set_watchdog_params(TRUE, DEFAULT_RPC_TIMEOUT);
 
   /* decrease watchdog timeout in offline mode */
   if (!clp.online)
      cm_set_watchdog_params(TRUE, 2000);
 
   /* turn off watchdog if in debug mode */
   if (clp.debug)
      cm_set_watchdog_params(0, 0);
 
   /* initialize module parameters */
   if (init_module_parameters(FALSE) != CM_SUCCESS) {
      cm_disconnect_experiment();
      return 1;
   }
 
   /* create ODB structure for output */
   sprintf(str, "/%s/Output", analyzer_name);
   db_check_record(hDB, 0, str, ANA_OUTPUT_INFO_STR, TRUE);
   db_find_key(hDB, 0, str, &hkey);
   assert(hkey);
   size = sizeof(out_info);
   db_get_record1(hDB, hkey, &out_info, &size, 0, ANA_OUTPUT_INFO_STR);
 
#ifdef HAVE_ROOT
   /* create the folder for analyzer histograms */
   gManaHistosFolder =
       gROOT->GetRootFolder()->AddFolder("histos", "MIDAS Analyzer Histograms");
   gHistoFolderStack = new TObjArray();
   gROOT->GetListOfBrowsables()->Add(gManaHistosFolder, "histos");
 
   /* convert .rz names to .root names */
   if (strstr(out_info.last_histo_filename, ".rz"))
      strcpy(out_info.last_histo_filename, "last.root");
 
   if (strstr(out_info.histo_dump_filename, ".rz"))
      strcpy(out_info.histo_dump_filename, "his%05d.root");
 
   db_set_record(hDB, hkey, &out_info, sizeof(out_info), 0);
 
   /* start socket server */
   if (clp.root_port)
      start_root_socket_server(clp.root_port);
 
#endif                          /* HAVE_ROOT */
 
#ifdef HAVE_HBOOK
   /* convert .root names to .rz names */
   if (strstr(out_info.last_histo_filename, ".root"))
      strcpy(out_info.last_histo_filename, "last.rz");
 
   if (strstr(out_info.histo_dump_filename, ".root"))
      strcpy(out_info.histo_dump_filename, "his%05d.rz");
 
   db_set_record(hDB, hkey, &out_info, sizeof(out_info), 0);
#endif
 
#ifdef HAVE_HBOOK
   /* create global memory */
   if (clp.online) {
      HLIMAP(pawc_size / 4, out_info.global_memory_name);
      printf("\nGLOBAL MEMORY NAME = %s\n", out_info.global_memory_name);
   } else {
      if (equal_ustring(clp.output_file_name, "OFLN")) {
         strcpy(str, "OFLN");
         HLIMAP(pawc_size / 4, str);
         printf("\nGLOBAL MEMORY NAME = %s\n", "OFLN");
      } else
         HLIMIT(pawc_size / 4);
   }
#endif                          /* HAVE_HBOOK */
 
   /* analyzer init function */
   if (mana_init() != CM_SUCCESS) {
      cm_disconnect_experiment();
      return 1;
   }
 
   /* load histos from last.xxx */
   if (clp.online)
      load_last_histos();
 
   /* reqister event requests */
   register_requests();
 
   /* initialize ss_getchar */
   if (!clp.quiet && !pvm_slave)
      ss_getchar(0);
 
   /*---- start main loop ----*/
 
   if (clp.online)
      loop_online();
   else
      loop_runs_offline();
 
   /* reset terminal */
   if (!clp.quiet && !pvm_slave)
      ss_getchar(TRUE);
 
   /* call exit function */
   mana_exit();
 
   /* save histos to last.xxx */
   if (clp.online)
      save_last_histos();
 
#ifdef HAVE_PVM
 
   PVM_DEBUG("Analyzer stopped");
 
   /* exit PVM */
   pvm_exit();
 
   /* if PVM slave, don't write *SHM file back */
   if (pvm_slave)
      disable_shm_write = TRUE;
 
#endif
 
   /* disconnect from experiment */
   cm_disconnect_experiment();
 
#ifdef HAVE_ROOT
   if (clp.start_rint)
      manaApp->Run(true);
   printf("\r               \n");       /* overwrite superflous ROOT prompt */
#endif
 
   return 0;
}

Here is the call graph for this function:

mana_exit()

INT mana_exit

(

)

Definition at line 1655 of file mana.cxx.

{
   ANA_MODULE **module;
   INT i, j;
 
   /* call exit routines from modules */
   for (i = 0; analyze_request[i].event_name[0]; i++) {
      module = analyze_request[i].ana_module;
      for (j = 0; module != NULL && module[j] != NULL; j++)
         if (module[j]->exit != NULL && module[j]->enabled) {
            module[j]->exit();
         }
   }
 
   /* call main analyzer exit routine */
   return analyzer_exit();
}

Here is the call graph for this function:

Here is the caller graph for this function:

mana_init()

INT mana_init

(

)

Definition at line 1516 of file mana.cxx.

{
   ANA_MODULE **module;
   INT i, j, status, size;
   HNDLE hkey;
   char str[256], block_name[32];
   BANK_LIST *bank_list;
   double dummy;
 
   sprintf(str, "/%s/Output", analyzer_name);
   db_find_key(hDB, 0, str, &hkey);
 
   if (clp.online) {
      status =
          db_open_record(hDB, hkey, &out_info, sizeof(out_info), MODE_READ, NULL, NULL);
      if (status != DB_SUCCESS) {
         cm_msg(MERROR, "bor", "Cannot read output info record");
         return 0;
      }
   }
 
   /* create ODB structures for banks */
   for (i = 0; analyze_request[i].event_name[0]; i++) {
      bank_list = analyze_request[i].bank_list;
 
      if (bank_list == NULL)
         continue;
 
      for (; bank_list->name[0]; bank_list++) {
         strncpy(block_name, bank_list->name, 4);
         block_name[4] = 0;
 
         if (bank_list->type == TID_STRUCT) {
            sprintf(str, "/Equipment/%s/Variables/%s", analyze_request[i].event_name,
                    block_name);
            db_check_record(hDB, 0, str, strcomb1((const char **)bank_list->init_str).c_str(), TRUE);
            db_find_key(hDB, 0, str, &hkey);
            bank_list->def_key = hkey;
         } else {
            sprintf(str, "/Equipment/%s/Variables/%s", analyze_request[i].event_name,
                    block_name);
            status = db_find_key(hDB, 0, str, &hkey);
            if (status != DB_SUCCESS) {
               dummy = 0;
               db_set_value(hDB, 0, str, &dummy, rpc_tid_size(bank_list->type), 1,
                            bank_list->type);
            }
            bank_list->def_key = hkey;
         }
      }
   }
 
   /* create ODB structures for fixed events */
   for (i = 0; analyze_request[i].event_name[0]; i++) {
      if (analyze_request[i].init_string) {
         sprintf(str, "/Equipment/%s/Variables", analyze_request[i].event_name);
         db_check_record(hDB, 0, str, strcomb1((const char **)analyze_request[i].init_string).c_str(), TRUE);
      }
   }
 
   /* delete tests in ODB */
   sprintf(str, "/%s/Tests", analyzer_name);
   db_find_key(hDB, 0, str, &hkey);
   if (hkey)
      db_delete_key(hDB, hkey, FALSE);
 
#ifdef HAVE_HBOOK
   /* create global memory */
   if (clp.online) {
      /* book online N-tuples only once when online */
      status = book_ntuples();
      if (status != SUCCESS)
         return status;
   } else {
      if (equal_ustring(clp.output_file_name, "OFLN")) {
         /* book online N-tuples only once when online */
         status = book_ntuples();
         if (status != SUCCESS)
            return status;
      }
   }
#endif                          /* HAVE_HBOOK */
 
#ifdef HAVE_ROOT
   if (clp.online) {
      /* book online N-tuples only once when online */
      status = book_ttree();
      if (status != SUCCESS)
         return status;
   }
#endif
 
   /* call main analyzer init routine */
   status = analyzer_init();
   if (status != SUCCESS)
      return status;
 
   /* initialize modules */
   for (i = 0; analyze_request[i].event_name[0]; i++) {
      module = analyze_request[i].ana_module;
      for (j = 0; module != NULL && module[j] != NULL; j++) {
 
         /* copy module enabled flag to ana_module */
         sprintf(str, "/%s/Module switches/%s", analyzer_name, module[j]->name);
         module[j]->enabled = TRUE;
         size = sizeof(BOOL);
         db_get_value(hDB, 0, str, &module[j]->enabled, &size, TID_BOOL, TRUE);
 
         if (module[j]->init != NULL && module[j]->enabled) {
 
#ifdef HAVE_ROOT
            /* create histo subfolder for module */
            sprintf(str, "Histos for module %s", module[j]->name);
            module[j]->histo_folder = (TFolder *) gROOT->FindObjectAny(module[j]->name);
            if (!module[j]->histo_folder)
               module[j]->histo_folder =
                   gManaHistosFolder->AddFolder(module[j]->name, str);
            else if (strcmp(((TObject *) module[j]->histo_folder)->ClassName(), "TFolder")
                     != 0) {
               cm_msg(MERROR, "mana_init",
                      "Fatal error: ROOT Object \"%s\" of class \"%s\" exists but it is not a TFolder, exiting!",
                      module[j]->name,
                      ((TObject *) module[j]->histo_folder)->ClassName());
               exit(1);
            }
            gHistoFolderStack->Clear();
            gHistoFolderStack->Add((TObject *) module[j]->histo_folder);
#endif
 
            module[j]->init();
         }
      }
   }
 
   return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

odb_load()

void odb_load

(

EVENT_HEADER *

pevent

)

Definition at line 3743 of file mana.cxx.

{
   BOOL flag;
   int size, i, status;
   char str[256];
   HNDLE hKey, hKeyRoot, hKeyEq;
 
   flag = TRUE;
   size = sizeof(flag);
   sprintf(str, "/%s/ODB Load", analyzer_name);
   db_get_value(hDB, 0, str, &flag, &size, TID_BOOL, TRUE);
 
   if (flag) {
      for (i = 0; i < 10; i++)
         if (clp.protect[i][0] && !clp.quiet)
            printf("Protect ODB tree \"%s\"\n", clp.protect[i]);
 
      if (!clp.quiet)
         printf("Load ODB from run %d...", (int) current_run_number);
 
      if (flag == 1) {
         /* lock all ODB values except run parameters */
         db_set_mode(hDB, 0, MODE_READ, TRUE);
 
         db_find_key(hDB, 0, "/Experiment/Run Parameters", &hKey);
         if (hKey)
            db_set_mode(hDB, hKey, MODE_READ | MODE_WRITE | MODE_DELETE, TRUE);
 
         /* and analyzer parameters */
         sprintf(str, "/%s/Parameters", analyzer_name);
         db_find_key(hDB, 0, str, &hKey);
         if (hKey)
            db_set_mode(hDB, hKey, MODE_READ | MODE_WRITE | MODE_DELETE, TRUE);
 
         /* and equipment (except /variables) */
         db_find_key(hDB, 0, "/Equipment", &hKeyRoot);
         if (hKeyRoot) {
            db_set_mode(hDB, hKeyRoot, MODE_READ | MODE_WRITE | MODE_DELETE, FALSE);
 
            for (i = 0;; i++) {
               status = db_enum_key(hDB, hKeyRoot, i, &hKeyEq);
               if (status == DB_NO_MORE_SUBKEYS)
                  break;
 
               db_set_mode(hDB, hKeyEq, MODE_READ | MODE_WRITE | MODE_DELETE, TRUE);
 
               db_find_key(hDB, hKeyEq, "Variables", &hKey);
               if (hKey)
                  db_set_mode(hDB, hKey, MODE_READ, TRUE);
            }
         }
 
         /* lock protected trees */
         for (i = 0; i < 10; i++)
            if (clp.protect[i][0]) {
               db_find_key(hDB, 0, clp.protect[i], &hKey);
               if (hKey)
                  db_set_mode(hDB, hKey, MODE_READ, TRUE);
            }
      }
 
      /* close open records to parameters */
      init_module_parameters(TRUE);
 
      if (strncmp((char *) (pevent + 1), "<?xml version=\"1.0\"", 19) == 0)
         db_paste_xml(hDB, 0, (char *) (pevent + 1));
      else
         db_paste(hDB, 0, (char *) (pevent + 1));
 
      if (flag == 1)
         db_set_mode(hDB, 0, MODE_READ | MODE_WRITE | MODE_DELETE, TRUE);
 
      /* reinit structured opened by user analyzer */
      analyzer_init();
 
      /* reload parameter files after BOR event */
      if (!clp.quiet)
         printf("OK\n");
      load_parameters(current_run_number);
 
      /* open module parameters again */
      init_module_parameters(FALSE);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

process_event()

INT process_event	(	ANALYZE_REQUEST *	par,
		EVENT_HEADER *	pevent
	)

Definition at line 3081 of file mana.cxx.

{
   INT i, status = SUCCESS, ch;
   ANA_MODULE **module;
   DWORD actual_time;
   EVENT_DEF *event_def;
   static DWORD last_time_kb = 0;
   static char *orig_event = NULL;
 
   /* verbose output */
   if (clp.verbose)
      printf("event %d, number %d, total size %d\n",
             (int) pevent->event_id,
             (int) pevent->serial_number,
             (int) (pevent->data_size + sizeof(EVENT_HEADER)));
 
   /* save analyze_request for event number correction */
   _current_par = par;
 
   /* check keyboard once every second */
   actual_time = ss_millitime();
   if (!clp.online && actual_time - last_time_kb > 1000 && !clp.quiet && !pvm_slave) {
      last_time_kb = actual_time;
 
      while (ss_kbhit()) {
         ch = ss_getchar(0);
         if (ch == -1)
            ch = getchar();
 
         if ((char) ch == '!')
            return RPC_SHUTDOWN;
      }
   }
 
   if (par == NULL) {
      /* load ODB with BOR event */
      if (pevent->event_id == EVENTID_BOR) {
         /* get run number from BOR event */
         current_run_number = pevent->serial_number;
 
         cm_msg(MINFO, "process_event", "Set run number %d in ODB", current_run_number);
         assert(current_run_number > 0);
 
         /* set run number in ODB */
         status = db_set_value(hDB, 0, "/Runinfo/Run number", &current_run_number,
                               sizeof(current_run_number), 1, TID_INT);
         assert(status == SUCCESS);
 
         /* load ODB from event */
         odb_load(pevent);
 
#ifdef HAVE_PVM
         PVM_DEBUG("process_event: ODB load");
#endif
      }
   } else
      /* increment event counter */
      par->events_received++;
 
#ifdef HAVE_PVM
 
   /* if master, distribute events to clients */
   if (pvm_master) {
      status = pvm_distribute(par, pevent);
      return status;
   }
#endif
 
   /* don't analyze special (BOR,MESSAGE,...) events */
   if (par == NULL)
      return SUCCESS;
 
   /* swap event if necessary */
   event_def = db_get_event_definition(pevent->event_id);
   if (event_def == NULL)
      return 0;
 
   if (event_def->format == FORMAT_MIDAS)
      bk_swap((BANK_HEADER *) (pevent + 1), FALSE);
 
   /* keep copy of original event */
   if (clp.filter) {
      if (orig_event == NULL)
         orig_event = (char *) malloc(sys_max_event_size + sizeof(EVENT_HEADER));
      memcpy(orig_event, pevent, pevent->data_size + sizeof(EVENT_HEADER));
   }
 
  /*---- analyze event ----*/
 
   /* call non-modular analyzer if defined */
   if (par->analyzer) {
      status = par->analyzer(pevent, (void *) (pevent + 1));
 
      /* don't continue if event was rejected */
      if (status == ANA_SKIP)
         return 0;
   }
 
   /* loop over analyzer modules */
   module = par->ana_module;
   for (i = 0; module != NULL && module[i] != NULL; i++) {
      if (module[i]->enabled) {
 
         status = module[i]->analyzer(pevent, (void *) (pevent + 1));
 
         /* don't continue if event was rejected */
         if (status == ANA_SKIP)
            return 0;
      }
   }
 
   if (event_def->format == FORMAT_MIDAS) {
      /* check if event got too large */
      i = bk_size(pevent + 1);
      if (i > sys_max_event_size)
         cm_msg(MERROR, "process_event", "Event got too large (%d Bytes) in analyzer", i);
 
      /* correct for increased event size */
      pevent->data_size = i;
   }
 
   if (event_def->format == FORMAT_YBOS) {
     assert(!"YBOS not supported anymore");
   }
 
   /* increment tests */
   if (par->use_tests)
      test_increment();
 
   /* in filter mode, use original event */
   if (clp.filter)
      pevent = (EVENT_HEADER *) orig_event;
 
   /* write resulting event */
   if (out_file) {
#ifdef HAVE_HBOOK
      if (out_format == FORMAT_HBOOK)
         status = write_event_hbook(out_file, pevent, par);
#endif                          /* HAVE_HBOOK */
#ifdef HAVE_ROOT
      if (out_format == FORMAT_ROOT)
         status = write_event_ttree(out_file, pevent, par);
#endif                          /* HAVE_ROOT */
      if (out_format == FORMAT_ASCII)
         status = write_event_ascii(out_file, pevent, par);
      if (out_format == FORMAT_MIDAS)
         status = write_event_midas(out_file, pevent, par);
 
      if (status != SUCCESS) {
         cm_msg(MERROR, "process_event", "Error writing to file (Disk full?)");
         return -1;
      }
 
      par->events_written++;
   }
#ifdef HAVE_HBOOK
   /* fill shared memory */
   if ((clp.online || equal_ustring(clp.output_file_name, "OFLN"))
       && par->rwnt_buffer_size > 0)
      write_event_hbook(NULL, pevent, par);
#endif                          /* HAVE_HBOOK */
#ifdef HAVE_ROOT
   /* fill tree, should later be replaced by cyclic filling once it's implemented in ROOT */
   if (clp.online && par->rwnt_buffer_size > 0)
      write_event_ttree(NULL, pevent, par);
#endif
 
 
   /* put event in ODB once every second */
   if (out_info.events_to_odb)
      for (i = 0; i < 50; i++) {
         if (last_time_event[i].event_id == pevent->event_id) {
            if (event_def->type == EQ_PERIODIC ||
                event_def->type == EQ_SLOW
                || actual_time - last_time_event[i].last_time > 1000) {
               last_time_event[i].last_time = actual_time;
               write_event_odb(pevent);
            }
            break;
         }
         if (last_time_event[i].event_id == 0) {
            last_time_event[i].event_id = pevent->event_id;
            last_time_event[i].last_time = actual_time;
            write_event_odb(pevent);
            break;
         }
      }
 
   return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

receive_event()

void receive_event	(	HNDLE	buffer_handle,
		HNDLE	request_id,
		EVENT_HEADER *	pheader,
		void *	pevent
	)

Definition at line 3274 of file mana.cxx.

{
   ANALYZE_REQUEST *par;
   static DWORD buffer_size = 0;
   static char *buffer = NULL;
   char *pb;
 
   if (buffer == NULL) {
      buffer = (char *) malloc(sys_max_event_size + sizeof(EVENT_HEADER));
 
      if (buffer == NULL) {
         cm_msg(MERROR, "receive_event", "Not enough memory to buffer event of size %d", buffer_size);
         return;
      }
   }
 
   /* align buffer */
   pb = (char *) ALIGN8((POINTER_T) buffer);
 
   /* copy event to local buffer */
   memcpy(pb, pheader, pheader->data_size + sizeof(EVENT_HEADER));
 
   par = analyze_request;
 
   for (; par->event_name[0]; par++)
      if (par->buffer_handle == buffer_handle && par->request_id == request_id) {
         process_event(par, (EVENT_HEADER *) pb);
      }
}

Here is the call graph for this function:

Here is the caller graph for this function:

register_requests()

void register_requests

(

void

)

Definition at line 3338 of file mana.cxx.

{
   INT index, status;
   char str[256];
   AR_INFO *ar_info;
   AR_STATS *ar_stats;
   HNDLE hKey;
 
   /* scan ANALYZE_REQUEST table from ANALYZE.C */
   for (index = 0; analyze_request[index].event_name[0]; index++) {
      ar_info = &analyze_request[index].ar_info;
      ar_stats = &analyze_request[index].ar_stats;
 
      /* create common subtree from analyze_request table in analyze.c */
      sprintf(str, "/%s/%s/Common", analyzer_name, analyze_request[index].event_name);
      db_check_record(hDB, 0, str, ANALYZER_REQUEST_STR, TRUE);
      db_find_key(hDB, 0, str, &hKey);
      analyze_request[index].hkey_common = hKey;
 
      strcpy(ar_info->client_name, analyzer_name);
      auto host = ss_gethostname();
      strlcpy(ar_info->host, host.c_str(), sizeof(ar_info->host));
      db_set_record(hDB, hKey, ar_info, sizeof(AR_INFO), 0);
 
      /* open hot link to analyzer request info */
      db_open_record(hDB, hKey, ar_info, sizeof(AR_INFO), MODE_READ, update_request,
                     NULL);
 
      /* create statistics tree */
      sprintf(str, "/%s/%s/Statistics", analyzer_name, analyze_request[index].event_name);
      db_check_record(hDB, 0, str, ANALYZER_STATS_STR, TRUE);
      db_find_key(hDB, 0, str, &hKey);
      assert(hKey);
 
      ar_stats->events_received = 0;
      ar_stats->events_per_sec = 0;
      ar_stats->events_written = 0;
 
      /* open hot link to statistics tree */
      status =
          db_open_record(hDB, hKey, ar_stats, sizeof(AR_STATS), MODE_WRITE, NULL, NULL);
      if (status != DB_SUCCESS)
         printf("Cannot open statistics record, probably other analyzer is using it\n");
 
      if (clp.online) {
         /*---- open event buffer ---------------------------------------*/
         bm_open_buffer(ar_info->buffer, DEFAULT_BUFFER_SIZE, &analyze_request[index].buffer_handle);
 
         /* set the default buffer cache size */
         bm_set_cache_size(analyze_request[index].buffer_handle, 100000, 0);
 
         /*---- request event -------------------------------------------*/
         if (ar_info->enabled)
            bm_request_event(analyze_request[index].buffer_handle,
                             (short) ar_info->event_id, (short) ar_info->trigger_mask,
                             ar_info->sampling_type, &analyze_request[index].request_id,
                             receive_event);
         else
            analyze_request[index].request_id = -1;
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

save_last_histos()

void save_last_histos

(

)

Definition at line 3597 of file mana.cxx.

{
   char str[256];
 
   /* save online histos */
   strcpy(str, out_info.last_histo_filename);
   if (strchr(str, DIR_SEPARATOR) == NULL)
      add_data_dir(str, out_info.last_histo_filename);
 
   printf("Saving current online histos to %s\n", str);
 
#ifdef HAVE_HBOOK
   {
      int i;
      char str2[256];
 
      for (i = 0; i < (int) strlen(str); i++)
         if (isupper(str[i]))
            break;
 
      if (i < (int) strlen(str)) {
         printf
             ("Error: Due to a limitation in HBOOK, directoy names may not contain uppercase\n");
         printf("       characters. Histogram saving to %s will not work.\n", str);
      } else {
         strcpy(str2, "NT");
         HRPUT(0, str, str2);
      }
   }
#endif
 
#ifdef HAVE_ROOT
   SaveRootHistograms(gManaHistosFolder, str);
#endif
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_clear()

void test_clear

(

)

Definition at line 582 of file mana.cxx.

{
   int i;
 
   /* clear all tests in interal list */
   for (i = 0; i < n_test; i++) {
      tl[i]->count = 0;
      tl[i]->value = FALSE;
   }
 
   /* set "always true" test */
   if (n_test > 0)
      tl[0]->value = TRUE;
}

Here is the caller graph for this function:

test_increment()

void test_increment

(

)

Definition at line 597 of file mana.cxx.

{
   int i;
 
   /* increment test counters based on their value and reset them */
   for (i = 0; i < n_test; i++) {
      if (tl[i]->value)
         tl[i]->count++;
      if (i > 0)
         tl[i]->value = FALSE;
   }
}

Here is the caller graph for this function:

test_register()

void test_register

(

ANA_TEST *

t

)

Definition at line 546 of file mana.cxx.

{
   int i;
 
   /* check if test already registered */
   for (i = 0; i < n_test; i++)
      if (tl[i] == t)
         break;
   if (i < n_test) {
      t->registered = TRUE;
      return;
   }
 
   /* allocate space for pointer to test */
   if (n_test == 0) {
      tl = (ANA_TEST **) malloc(2 * sizeof(void *));
 
      /* define "always true" test */
      tl[0] = (ANA_TEST *) malloc(sizeof(ANA_TEST));
      strcpy(tl[0]->name, "Always true");
      tl[0]->count = 0;
      tl[0]->previous_count = 0;
      tl[0]->value = TRUE;
      tl[0]->registered = TRUE;
      n_test++;
   } else
      tl = (ANA_TEST **) realloc(tl, (n_test + 1) * sizeof(void *));
 
   tl[n_test] = t;
   t->count = 0;
   t->value = FALSE;
   t->registered = TRUE;
 
   n_test++;
}

Here is the call graph for this function:

test_write()

void test_write

(

int

delta_time

)

Definition at line 610 of file mana.cxx.

{
   int i;
   char str[256];
   float rate;
 
   /* write all test counts to /analyzer/tests/<name> */
   for (i = 0; i < n_test; i++) {
      sprintf(str, "/%s/Tests/%s/Count", analyzer_name, tl[i]->name);
      db_set_value(hDB, 0, str, &tl[i]->count, sizeof(DWORD), 1, TID_DWORD);
 
      /* calcluate rate */
      if (delta_time > 0) {
         rate = (float) ((tl[i]->count - tl[i]->previous_count) / (delta_time / 1000.0));
         tl[i]->previous_count = tl[i]->count;
         sprintf(str, "/%s/Tests/%s/Rate [Hz]", analyzer_name, tl[i]->name);
         db_set_value(hDB, 0, str, &rate, sizeof(float), 1, TID_FLOAT);
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

tr_pause()

INT tr_pause	(	INT	rn,
		char *	error
	)

Definition at line 2065 of file mana.cxx.

{
   INT status;
 
   status = ana_pause_run(rn, error);
   if (status != CM_SUCCESS)
      return status;
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

tr_resume()

INT tr_resume	(	INT	rn,
		char *	error
	)

Definition at line 2078 of file mana.cxx.

{
   INT status;
 
   status = ana_resume_run(rn, error);
   if (status != CM_SUCCESS)
      return status;
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

tr_start()

INT tr_start	(	INT	rn,
		char *	error
	)

Definition at line 2014 of file mana.cxx.

{
   INT status, i;
 
   /* reset counters */
   for (i = 0; analyze_request[i].event_name[0]; i++) {
      analyze_request[i].ar_stats.events_received = 0;
      analyze_request[i].ar_stats.events_per_sec = 0;
      analyze_request[i].ar_stats.events_written = 0;
      analyze_request[i].events_received = 0;
      analyze_request[i].events_written = 0;
   }
 
   status = bor(rn, error);
   if (status != SUCCESS)
      return status;
 
   return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

tr_stop()

INT tr_stop	(	INT	rn,
		char *	error
	)

Definition at line 2036 of file mana.cxx.

{
   INT i, status, n_bytes;
 
   /* wait until all events in buffers are analyzed */
 
   if (rpc_is_remote())
      while (bm_poll_event());
   else
      for (i = 0; analyze_request[i].event_name[0]; i++) {
         do {
            bm_get_buffer_level(analyze_request[i].buffer_handle, &n_bytes);
            if (n_bytes > 0)
               cm_yield(100);
         } while (n_bytes > 0);
      }
 
   /* update statistics */
   update_stats();
 
   status = eor(rn, error);
   if (status != SUCCESS)
      return status;
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_request()

void update_request	(	HNDLE	hDB,
		HNDLE	hKey,
		void *	info
	)

Definition at line 3308 of file mana.cxx.

{
   AR_INFO *ar_info;
   INT i;
 
   if (!clp.online)
      return;
 
   /* check which request's key has changed */
   for (i = 0; analyze_request[i].event_name[0]; i++)
      if (analyze_request[i].hkey_common == hKey) {
         ar_info = &analyze_request[i].ar_info;
 
         /* remove previous request */
         if (analyze_request[i].request_id != -1)
            bm_delete_request(analyze_request[i].request_id);
 
         /* if enabled, add new request */
         if (ar_info->enabled)
            bm_request_event(analyze_request[i].buffer_handle, (short) ar_info->event_id,
                             (short) ar_info->trigger_mask, ar_info->sampling_type,
                             &analyze_request[i].request_id, receive_event);
         else
            analyze_request[i].request_id = -1;
      }
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_stats()

void update_stats

(

)

Definition at line 3403 of file mana.cxx.

{
   int i;
   AR_STATS *ar_stats;
   static DWORD last_time = 0;
   DWORD actual_time;
 
   actual_time = ss_millitime();
 
   if (last_time == 0)
      last_time = actual_time;
 
   if (actual_time - last_time == 0)
      return;
 
   for (i = 0; analyze_request[i].event_name[0]; i++) {
      ar_stats = &analyze_request[i].ar_stats;
      ar_stats->events_received += analyze_request[i].events_received;
      ar_stats->events_written += analyze_request[i].events_written;
      ar_stats->events_per_sec =
          (analyze_request[i].events_received / ((actual_time - last_time) / 1000.0));
      analyze_request[i].events_received = 0;
      analyze_request[i].events_written = 0;
   }
 
   /* propagate new statistics to ODB */
   db_send_changed_records();
 
   /* save tests in ODB */
   test_write(actual_time - last_time);
 
   last_time = actual_time;
}

Here is the call graph for this function:

Here is the caller graph for this function:

write_event_ascii()

INT write_event_ascii	(	FILE *	file,
		EVENT_HEADER *	pevent,
		ANALYZE_REQUEST *	par
	)

Definition at line 2096 of file mana.cxx.

{
   INT status, size, i, j, count;
   BOOL exclude;
   BANK_HEADER *pbh;
   BANK_LIST *pbl;
   EVENT_DEF *event_def;
   BANK *pbk;
   BANK32 *pbk32;
   BANK32A *pbk32a;
   void *pdata;
   char *pbuf, name[5], type_name[10];
   LRS1882_DATA *lrs1882;
   LRS1877_DATA *lrs1877;
   LRS1877_HEADER *lrs1877_header;
   HNDLE hKey;
   KEY key;
   char buffer[100000];
   DWORD bkname;
   WORD bktype;
 
   event_def = db_get_event_definition(pevent->event_id);
   if (event_def == NULL)
      return SS_SUCCESS;
 
   /* write event header */
   pbuf = buffer;
   name[4] = 0;
 
   if (pevent->event_id == EVENTID_BOR)
      sprintf(pbuf, "%%ID BOR NR %d\n", (int) pevent->serial_number);
   else if (pevent->event_id == EVENTID_EOR)
      sprintf(pbuf, "%%ID EOR NR %d\n", (int) pevent->serial_number);
   else
      sprintf(pbuf, "%%ID %d TR %d NR %d\n", pevent->event_id, pevent->trigger_mask,
              (int) pevent->serial_number);
   STR_INC(pbuf, buffer);
 
  /*---- MIDAS format ----------------------------------------------*/
   if (event_def->format == FORMAT_MIDAS) {
      pbh = (BANK_HEADER *) (pevent + 1);
      pbk = NULL;
      pbk32 = NULL;
      pbk32a = NULL;
      do {
         /* scan all banks */
         if (bk_is32a(pbh)) {
            size = bk_iterate32a(pbh, &pbk32a, &pdata);
            if (pbk32a == NULL)
               break;
            bkname = *((DWORD *) pbk32a->name);
            bktype = (WORD) pbk32a->type;
         } else if (bk_is32(pbh)) {
            size = bk_iterate32(pbh, &pbk32, &pdata);
            if (pbk32 == NULL)
               break;
            bkname = *((DWORD *) pbk32->name);
            bktype = (WORD) pbk32->type;
         } else {
            size = bk_iterate(pbh, &pbk, &pdata);
            if (pbk == NULL)
               break;
            bkname = *((DWORD *) pbk->name);
            bktype = (WORD) pbk->type;
         }
 
         /* look if bank is in exclude list */
         exclude = FALSE;
         pbl = NULL;
         if (par->bank_list != NULL)
            for (i = 0; par->bank_list[i].name[0]; i++)
               if (*((DWORD *) par->bank_list[i].name) == bkname) {
                  pbl = &par->bank_list[i];
                  exclude = (pbl->output_flag == 0);
                  break;
               }
 
         if (!exclude) {
            if (rpc_tid_size(bktype & 0xFF))
               size /= rpc_tid_size(bktype & 0xFF);
 
            lrs1882 = (LRS1882_DATA *) pdata;
            lrs1877 = (LRS1877_DATA *) pdata;
 
            /* write bank header */
            *((DWORD *) name) = bkname;
 
            if ((bktype & 0xFF00) == 0)
               strcpy(type_name, rpc_tid_name(bktype & 0xFF));
            else if ((bktype & 0xFF00) == TID_LRS1882)
               strcpy(type_name, "LRS1882");
            else if ((bktype & 0xFF00) == TID_LRS1877)
               strcpy(type_name, "LRS1877");
            else if ((bktype & 0xFF00) == TID_PCOS3)
               strcpy(type_name, "PCOS3");
            else
               strcpy(type_name, "unknown");
 
            sprintf(pbuf, "BK %s TP %s SZ %d\n", name, type_name, size);
            STR_INC(pbuf, buffer);
 
            if (bktype == TID_STRUCT) {
               if (pbl == NULL)
                  cm_msg(MERROR, "write_event_ascii", "received unknown bank %s", name);
               else
                  /* write structured bank */
                  for (i = 0;; i++) {
                     status = db_enum_key(hDB, pbl->def_key, i, &hKey);
                     if (status == DB_NO_MORE_SUBKEYS)
                        break;
 
                     db_get_key(hDB, hKey, &key);
                     sprintf(pbuf, "%s:\n", key.name);
                     STR_INC(pbuf, buffer);
 
                     /* adjust for alignment */
                     pdata =
                         (void *) VALIGN(pdata,
                                         MIN(ss_get_struct_align(), key.item_size));
 
                     for (j = 0; j < key.num_values; j++) {
                        db_sprintf(pbuf, pdata, key.item_size, j, key.type);
                        strcat(pbuf, "\n");
                        STR_INC(pbuf, buffer);
                     }
 
                     /* shift data pointer to next item */
                     pdata = (char *) pdata + key.item_size * key.num_values;
                  }
            } else {
               /* write variable length bank  */
               if ((bktype & 0xFF00) == TID_LRS1877) {
                  for (i = 0; i < size;) {
                     lrs1877_header = (LRS1877_HEADER *) & lrs1877[i];
 
                     /* print header */
                     sprintf(pbuf, "GA %d BF %d CN %d",
                             lrs1877_header->geo_addr, lrs1877_header->buffer,
                             lrs1877_header->count);
                     strcat(pbuf, "\n");
                     STR_INC(pbuf, buffer);
 
                     count = lrs1877_header->count;
                     if (count == 0)
                        break;
                     for (j = 1; j < count; j++) {
                        /* print data */
                        sprintf(pbuf, "GA %d CH %02d ED %d DA %1.1lf",
                                lrs1877[i].geo_addr, lrs1877[i + j].channel,
                                lrs1877[i + j].edge, lrs1877[i + j].data * 0.5);
                        strcat(pbuf, "\n");
                        STR_INC(pbuf, buffer);
                     }
 
                     i += count;
                  }
               } else
                  for (i = 0; i < size; i++) {
                     if ((bktype & 0xFF00) == 0)
                        db_sprintf(pbuf, pdata, size, i, bktype & 0xFF);
 
                     else if ((bktype & 0xFF00) == TID_LRS1882)
                        sprintf(pbuf, "GA %d CH %02d DA %d",
                                lrs1882[i].geo_addr, lrs1882[i].channel, lrs1882[i].data);
 
                     else if ((bktype & 0xFF00) == TID_PCOS3)
                        sprintf(pbuf, "TBD");
                     else
                        db_sprintf(pbuf, pdata, size, i, bktype & 0xFF);
 
                     strcat(pbuf, "\n");
                     STR_INC(pbuf, buffer);
                  }
            }
         }
 
      } while (1);
   }
 
  /*---- FIXED format ----------------------------------------------*/
   if (event_def->format == FORMAT_FIXED) {
      if (event_def->hDefKey == 0)
         cm_msg(MERROR, "write_event_ascii", "cannot find event definition");
      else {
         pdata = (char *) (pevent + 1);
         for (i = 0;; i++) {
            status = db_enum_key(hDB, event_def->hDefKey, i, &hKey);
            if (status == DB_NO_MORE_SUBKEYS)
               break;
 
            db_get_key(hDB, hKey, &key);
            sprintf(pbuf, "%s\n", key.name);
            STR_INC(pbuf, buffer);
 
            /* adjust for alignment */
            pdata = (void *) VALIGN(pdata, MIN(ss_get_struct_align(), key.item_size));
 
            for (j = 0; j < key.num_values; j++) {
               db_sprintf(pbuf, pdata, key.item_size, j, key.type);
               strcat(pbuf, "\n");
               STR_INC(pbuf, buffer);
            }
 
            /* shift data pointer to next item */
            pdata = (char *) pdata + key.item_size * key.num_values;
         }
      }
   }
 
   /* insert empty line after each event */
   strcat(pbuf, "\n");
   size = strlen(buffer);
 
   /* write record to device */
   if (out_gzip)
      status = gzwrite((gzFile)file, buffer, size) == size ? SS_SUCCESS : SS_FILE_ERROR;
   else
      status =
          fwrite(buffer, 1, size, file) == (size_t) size ? SS_SUCCESS : SS_FILE_ERROR;
 
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

write_event_midas()

INT write_event_midas	(	FILE *	file,
		EVENT_HEADER *	pevent,
		ANALYZE_REQUEST *	par
	)

Definition at line 2321 of file mana.cxx.

{
   INT status, size = 0, i;
   BOOL exclude;
   BANK_HEADER *pbh;
   BANK_LIST *pbl;
   EVENT_DEF *event_def;
   BANK *pbk;
   BANK32 *pbk32;
   BANK32A *pbk32a;
   char *pdata, *pdata_copy;
   char *pbuf;
   EVENT_HEADER *pevent_copy;
   DWORD bkname, bksize;
   WORD bktype;
   static char *buffer = NULL;
 
   if (buffer == NULL)
      buffer = (char *) malloc(sys_max_event_size);
 
   pevent_copy = (EVENT_HEADER *) ALIGN8((POINTER_T) buffer);
 
   if (clp.filter) {
      /* use original event */
      size = pevent->data_size + sizeof(EVENT_HEADER);
      memcpy(pevent_copy, pevent, size);
   } else {
      /* copy only banks which are turned on via /analyzer/bank switches */
 
    /*---- MIDAS format ----------------------------------------------*/
 
      event_def = db_get_event_definition(pevent->event_id);
      if (event_def == NULL)
         return SUCCESS;
 
      if (event_def->format == FORMAT_MIDAS) {
         /* copy event header */
         pbuf = (char *) pevent_copy;
         memcpy(pbuf, pevent, sizeof(EVENT_HEADER));
         pbuf += sizeof(EVENT_HEADER);
 
         pbh = (BANK_HEADER *) (pevent + 1);
 
         if (bk_is32(pbh))
            bk_init32(pbuf);
         else
            bk_init(pbuf);
 
         pbk = NULL;
         pbk32 = NULL;
         pbk32a = NULL;
         pdata_copy = pbuf;
         do {
            /* scan all banks */
            if (bk_is32a(pbh)) {
               size = bk_iterate32a(pbh, &pbk32a, &pdata);
               if (pbk32a == NULL)
                  break;
               bkname = *((DWORD *) pbk32a->name);
               bktype = (WORD) pbk32a->type;
               bksize = pbk32a->data_size;
            } else if (bk_is32(pbh)) {
               size = bk_iterate32(pbh, &pbk32, &pdata);
               if (pbk32 == NULL)
                  break;
               bkname = *((DWORD *) pbk32->name);
               bktype = (WORD) pbk32->type;
               bksize = pbk32->data_size;
            } else {
               size = bk_iterate(pbh, &pbk, &pdata);
               if (pbk == NULL)
                  break;
               bkname = *((DWORD *) pbk->name);
               bktype = (WORD) pbk->type;
               bksize = pbk->data_size;
            }
 
            /* look if bank is in exclude list */
            exclude = FALSE;
            pbl = NULL;
            if (par->bank_list != NULL)
               for (i = 0; par->bank_list[i].name[0]; i++)
                  if (*((DWORD *) par->bank_list[i].name) == bkname) {
                     pbl = &par->bank_list[i];
                     exclude = (pbl->output_flag == 0);
                     break;
                  }
 
            if (!exclude) {
               /* copy bank */
          bk_create(pbuf, (char *) (&bkname), bktype, (void **)&pdata_copy);
               memcpy(pdata_copy, pdata, bksize);
               pdata_copy += bksize;
               bk_close(pbuf, pdata_copy);
            }
 
         } while (1);
 
         /* set event size in header */
         size = ALIGN8((POINTER_T) pdata_copy - (POINTER_T) pbuf);
         pevent_copy->data_size = size;
         size += sizeof(EVENT_HEADER);
      }
 
    /*---- FIXED format ----------------------------------------------*/
      if (event_def->format == FORMAT_FIXED) {
         size = pevent->data_size + sizeof(EVENT_HEADER);
         memcpy(pevent_copy, pevent, size);
      }
 
      if (pevent_copy->data_size == 0)
         return SUCCESS;
   }
 
   /* write record to device */
   if (out_gzip)
      status = gzwrite((gzFile)file, pevent_copy, size) == size ? SUCCESS : SS_FILE_ERROR;
   else
      status =
          fwrite(pevent_copy, 1, size, file) == (size_t) size ? SUCCESS : SS_FILE_ERROR;
 
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

write_event_odb()

INT write_event_odb

(

EVENT_HEADER *

pevent

)

Definition at line 2953 of file mana.cxx.

{
   INT status, size, n_data, i;
   BANK_HEADER *pbh;
   EVENT_DEF *event_def;
   BANK *pbk;
   BANK32 *pbk32;
   BANK32A *pbk32a;
   void *pdata;
   char name[5];
   HNDLE hKeyRoot, hKey;
   KEY key;
   DWORD bkname;
   WORD bktype;
 
   event_def = db_get_event_definition(pevent->event_id);
   if (event_def == NULL)
      return SS_SUCCESS;
 
   /*---- MIDAS format ----------------------------------------------*/
 
   if (event_def->format == FORMAT_MIDAS) {
      pbh = (BANK_HEADER *) (pevent + 1);
      pbk = NULL;
      pbk32 = NULL;
      pbk32a = NULL;
      do {
         /* scan all banks */
         if (bk_is32a(pbh)) {
            size = bk_iterate32a(pbh, &pbk32a, &pdata);
            if (pbk32a == NULL)
               break;
            bkname = *((DWORD *) pbk32a->name);
            bktype = (WORD) pbk32a->type;
         } else if (bk_is32(pbh)) {
            size = bk_iterate32(pbh, &pbk32, &pdata);
            if (pbk32 == NULL)
               break;
            bkname = *((DWORD *) pbk32->name);
            bktype = (WORD) pbk32->type;
         } else {
            size = bk_iterate(pbh, &pbk, &pdata);
            if (pbk == NULL)
               break;
            bkname = *((DWORD *) pbk->name);
            bktype = (WORD) pbk->type;
         }
 
         n_data = size;
         if (rpc_tid_size(bktype & 0xFF))
            n_data /= rpc_tid_size(bktype & 0xFF);
 
         /* get bank key */
         *((DWORD *) name) = bkname;
         name[4] = 0;
 
         status = db_find_key(hDB, event_def->hDefKey, name, &hKeyRoot);
         if (status != DB_SUCCESS) {
            cm_msg(MERROR, "write_event_odb", "received unknown bank %s", name);
            continue;
         }
 
         if (bktype == TID_STRUCT) {
            /* write structured bank */
            for (i = 0;; i++) {
               status = db_enum_key(hDB, hKeyRoot, i, &hKey);
               if (status == DB_NO_MORE_SUBKEYS)
                  break;
 
               db_get_key(hDB, hKey, &key);
 
               /* adjust for alignment */
               if (key.type != TID_STRING && key.type != TID_LINK)
                  pdata =
                      (void *) VALIGN(pdata, MIN(ss_get_struct_align(), key.item_size));
 
               status = db_set_data(hDB, hKey, pdata, key.item_size * key.num_values,
                                    key.num_values, key.type);
               if (status != DB_SUCCESS) {
                  cm_msg(MERROR, "write_event_odb", "cannot write %s to ODB", name);
                  continue;
               }
 
               /* shift data pointer to next item */
               pdata = (char *) pdata + key.item_size * key.num_values;
            }
         } else {
            db_get_key(hDB, hKeyRoot, &key);
 
            /* write variable length bank  */
            if (n_data > 0) {
               status = db_set_data(hDB, hKeyRoot, pdata, size, n_data, key.type);
               if (status != DB_SUCCESS) {
                  cm_msg(MERROR, "write_event_odb", "cannot write %s to ODB", name);
                  continue;
               }
            }
         }
      } while (1);
   }
 
   /*---- FIXED format ----------------------------------------------*/
 
   if (event_def->format == FORMAT_FIXED && !clp.online) {
      if (db_set_record
          (hDB, event_def->hDefKey, (char *) (pevent + 1), pevent->data_size,
           0) != DB_SUCCESS)
         cm_msg(MERROR, "write_event_odb", "event #%d size mismatch", pevent->event_id);
   }
 
   return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

_current_par

ANALYZE_REQUEST* _current_par

Definition at line 3073 of file mana.cxx.

analyze_request

ANALYZE_REQUEST analyze_request[]

extern

Definition at line 37 of file analyzer.c.

                                    {
 
   {"Trigger",                  /* event name */
    1,                          /* event ID */
    TRIGGER_ALL,                /* trigger mask */
    GET_SOME,                   /* get some events */
    "SYSTEM",                   /* event buffer */
    TRUE,                       /* enabled */
    "", "",
    analyze_trigger_event,      /* analyzer routine */
    },
 
   {"Scaler",                   /* equipment name */
    2,                          /* event ID */
    TRIGGER_ALL,                /* trigger mask */
    GET_ALL,                    /* get all events */
    "SYSTEM",                   /* event buffer */
    TRUE,                       /* enabled */
    "", "",
    analyze_scaler_event        /* analyzer routine */
    },
 
   {""}
};

analyzer_loop_period

INT analyzer_loop_period

extern

Definition at line 28 of file analyzer.c.

analyzer_name

const char* analyzer_name

extern

Definition at line 25 of file analyzer.c.

bstr

const char* bstr = " "

Definition at line 188 of file mana.cxx.

[struct]

struct { ... } clp

[struct]

struct { ... } clp_descrip[]

config_file_name

char config_file_name[10][256]

Definition at line 249 of file mana.cxx.

current_run_number

DWORD current_run_number

Definition at line 210 of file mana.cxx.

daemon

BOOL daemon

Definition at line 258 of file mana.cxx.

data

void* data

Definition at line 268 of file mana.cxx.

debug

BOOL debug

debug printouts

Definition at line 254 of file mana.cxx.

description

char description[1000]

Definition at line 267 of file mana.cxx.

event_id

short int event_id

Definition at line 3069 of file mana.cxx.

exp_name

char exp_name[NAME_LENGTH]

Definition at line 243 of file mana.cxx.

filter

BOOL filter

Definition at line 248 of file mana.cxx.

flag_char

char flag_char

Definition at line 266 of file mana.cxx.

hbook_types

char hbook_types[][8]

Initial value:

= {
   "",
   ":U:8",                      
   ":I:8",                      
   ":I:8",                      
   ":U:16",                     
   ":I:16",                     
   ":U*4",                      
   ":I*4",                      
   ":I*4",                      
   ":R*4",                      
   ":R*8",                      
   ":U*4",                      
   ":C:32",                     
   "",                          
   "",                          
   "",                          
   "",                          
   "",                          
 
}

Definition at line 700 of file mana.cxx.

                        {
   "",
   ":U:8",                      /* TID_BYTE      */
   ":I:8",                      /* TID_SBYTE     */
   ":I:8",                      /* TID_CHAR      */
   ":U:16",                     /* TID_WORD      */
   ":I:16",                     /* TID_SHORT     */
   ":U*4",                      /* TID_DWORD     */
   ":I*4",                      /* TID_INT       */
   ":I*4",                      /* TID_BOOL      */
   ":R*4",                      /* TID_FLOAT     */
   ":R*8",                      /* TID_DOUBLE    */
   ":U*4",                      /* TID_BITFIELD  */
   ":C:32",                     /* TID_STRING    */
   "",                          /* TID_ARRAY     */
   "",                          /* TID_STRUCT    */
   "",                          /* TID_KEY       */
   "",                          /* TID_LINK      */
   "",                          /* TID_LAST      */
 
};

hDB

HNDLE hDB

main ODB handle

Definition at line 207 of file mana.cxx.

host_name

char host_name[HOST_NAME_LENGTH]

Definition at line 242 of file mana.cxx.

index

INT index

Definition at line 271 of file mana.cxx.

input_file_name

char input_file_name[10][256]

Definition at line 244 of file mana.cxx.

last_time

DWORD last_time

Definition at line 3070 of file mana.cxx.

[struct]

struct { ... } last_time_event[50]

lock_list

INT lock_list[10000]

Definition at line 219 of file mana.cxx.

lrec

INT lrec

Definition at line 253 of file mana.cxx.

n

INT n

Definition at line 247 of file mana.cxx.

n_task

INT n_task

Definition at line 259 of file mana.cxx.

n_test

int n_test = 0

Definition at line 544 of file mana.cxx.

no_load

BOOL no_load

Definition at line 257 of file mana.cxx.

ntuple_flag

BOOL ntuple_flag

Definition at line 216 of file mana.cxx.

odb_size

INT odb_size

extern

Definition at line 46 of file analyzer.cxx.

online

INT online

Definition at line 241 of file mana.cxx.

out_append

BOOL out_append

Definition at line 336 of file mana.cxx.

out_file

FILE* out_file

Definition at line 333 of file mana.cxx.

out_format

INT out_format

Definition at line 335 of file mana.cxx.

out_gzip

BOOL out_gzip

Definition at line 334 of file mana.cxx.

out_info

ANA_OUTPUT_INFO out_info

Definition at line 49 of file mana.cxx.

output_file_name

char output_file_name[256]

Definition at line 245 of file mana.cxx.

param

char param[10][256]

Definition at line 250 of file mana.cxx.

pawc_size

INT pawc_size

extern

protect

char protect[10][256]

Definition at line 251 of file mana.cxx.

pvm_buf_size

INT pvm_buf_size

Definition at line 260 of file mana.cxx.

pvm_master

BOOL pvm_master = FALSE

Definition at line 186 of file mana.cxx.

pvm_slave

BOOL pvm_slave = FALSE

Definition at line 186 of file mana.cxx.

QUEST

int QUEST[100]

extern

quiet

BOOL quiet

Definition at line 256 of file mana.cxx.

root_port

INT root_port

Definition at line 261 of file mana.cxx.

run_number

INT run_number[2]

Definition at line 246 of file mana.cxx.

rwnt

BOOL rwnt

Definition at line 252 of file mana.cxx.

start_rint

BOOL start_rint

Definition at line 262 of file mana.cxx.

sys_max_event_size

int sys_max_event_size = DEFAULT_MAX_EVENT_SIZE

static

Definition at line 237 of file mana.cxx.

tl

ANA_TEST** tl

Definition at line 543 of file mana.cxx.

type

INT type

Definition at line 269 of file mana.cxx.

verbose

BOOL verbose

Definition at line 255 of file mana.cxx.