diff --git a/frontend/bulk_monitor_scfe.cxx b/frontend/bulk_monitor_scfe.cxx
new file mode 100644
index 0000000..785ee18
--- /dev/null
+++ b/frontend/bulk_monitor_scfe.cxx
@@ -0,0 +1,6811 @@
+/* *******************************************************************\
+
+  Name:         mon_do.c
+  Created by:   RA95 (Stefan Ritt's sample Slow Control Front end program)
+
+  Contents:     Slow Control Frontend program for muSR monitor & logging.
+                Originally being used without device driver and equipment name.
+                Using bulk_monitor.c device driver and adding slow control 
+                equipment mon1 with frontend_loop() now to integrate it into Midas 
+                as a frontend program.
+
+  Revision 1.1  2017/01/26 20:49:35  raselli
+  Original bulk muSR Midas 1.9.5 version
+
+  Revision 1.5  2016/12/20 15:53:55  raselli
+  Integrated Agilent agva1
+
+  Revision 1.4  2016/12/02 13:34:43  raselli
+  Modified equipment name to mon1
+
+  Revision 1.3  2016/11/16 13:31:47  raselli
+  Added additional equipment to be omitted
+
+  Revision 1.2  2016/11/11 12:47:36  raselli
+  Mercury iTC devices heliox0 and variox0 added as equipment to monitor
+
+  Revision 1.1  2016/09/09 13:15:29  raselli
+  Bulk musr 09-SEP-2016
+
+
+
+  Date        Name        Modification
+  -----------------------------------------------------------------
+  11-FEB-2002 RA95        SUCCESS replaced by CM_SUCCESS to avoid interference
+                          with onc rpc definition
+                          NOTE: definitions of SUCCESS and RPC_SUCCESS are
+                                opposite to definitions in midas.h
+  19-APR-2002 RA95        count number of TC channels if reloading TC
+  25-APR-2002 RA95        renamed include gen_tc_dd.h to gen_tc.h for 8.1.3
+  25-APR-2002 RA95        renamed include cd_tc.h to tc.h for 8.1.3
+  15-MAY-2002 RA95        tested on VMS VAX
+  10-OCT-2003 RA95        modified for usage with DVM
+  06-NOV-2003 RA95        modified for usage with MON
+  20-NOV-2003 RA95        gnchans & gmondevs added
+  08-DEC-2003 RA95        EOB & EOC markers added
+  08-DEC-2003 RA95        Now reading monitor/device_list from ODB
+  09-DEC-2003 RA95        Modified reading device_list
+  10-DEC-2003 RA95        title of old statistics in mon_do BEGIN_RUN
+  18-MAY-2004 RA35        New writing active_list to ODB
+  12-AUG-2004 RA35        LOOP in mon_do changed to avoid MON_INIT when device falls off
+  12-AUG-2004 RA35        meantemp & tempdev in ODB limited to TEMPLISTSTR
+  15-NOV-2004 RA35        release of (all) class drivers before swapping mode types
+                          to avoid memory leaks
+  12-JAN-2010 RA36        added handling templtc equipment
+  08-APR-2016 RA36        renamed frontend.c to mon_do.c and removed monc overhead and
+                          /muSR/ dependencies
+  09-APR-2016 RA36        added handling of templs3361 equipment
+    -APR-2016 RA36        added handling of dmm270x1 equipment
+  13-JUN-2016 RA36        added external n_mon_devices and n_reg_devices for
+                          bulk_monitor device driver
+  10-NOV-2016 RA36        heliox0 and variox0 equipment added
+  01-FEB-2018 RA36        changed equipment templtc to templtc0
+  16-OCT-2018 RA36        added hvdistr1 and hvdistr2
+                          NOTE: hvdistr1 and hvdistr2 are updated every second
+                                without checking when last updated
+  13-JUN-2019 RA36        PROPOSAL: <proposal ID> added to run title information
+  13-AUG-2019 RA36        heliox0 and variox0 may now be used at the same time
+                          lckinamp0, lckinamp1 and lckinamp2 equipment added
+  14-APR-2020 RA36        hvdistr1 and hvdistr2 with kV units were replaced by
+                          hvdistr3 and hvdistr4 with V units
+  15-AUG-2025 RA36        added mitchlxprc0 to code of handled but not used equipment.
+                          warning about unknown equipment is suppressed for
+                          equipment containing string vms.
+
+  Revision 1.3  1998/10/23 08:46:26  midas
+  Added #include "null.h"
+
+  Revision 1.2  1998/10/12 12:18:59  midas
+  Added Log tag in header
+
+\********************************************************************/
+
+/*! \def MAXNDEVS
+    \brief max. number of devices
+ */
+#define MAXNDEVS     10                  /* max number of devices */
+#define LIST_LENGTH  (4*NAME_LENGTH)     /* size of Device_list and Active_list in DD */
+                                         /* REMEMBER: also modify BULK_MONITOR_SETTINGS 
+                                          *           in drivers/device/bulk_monitor.c */
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "midas.h"
+
+#include <math.h>
+#ifdef OS_VMS
+#include <stat.h>
+#else
+#include <sys/stat.h>
+#endif
+#include <errno.h>
+
+extern int errno;
+
+#include "midas.h"
+#include "../frontend/musr_midas.h"
+#include "class/generic.h"
+#include "device/bulk_monitor.h"
+
+#ifdef FORTIFY
+#include "fortify.h"
+#endif
+
+//#define MIDEBUG   /* essential DEBUG information */
+//#define MIDEBUG0  /* slow down sleeping 10sec  (this blocks timed logging) */
+//#define MIDEBUG1  /* more DEBUG information */
+//#define MIDEBUG2  /* even more DEBUG information */
+
+/*-- Globals -------------------------------------------------------*/
+
+/* The frontend name (client name) as seen by other MIDAS clients   */
+char *frontend_name = "MONITOR mon1";
+
+/* The frontend file name, don't change it */
+char *frontend_file_name = __FILE__;
+
+/*! \var frontend_call_loop
+    \brief frontend_loop is called periodically if this variable is TRUE
+ */
+BOOL frontend_call_loop = TRUE;
+
+/*! \var display_period
+    \brief the frontend status page is displayed with this frequency in ms
+ */
+INT display_period = 1000;
+
+/* maximum event size produced by this frontend */
+INT max_event_size = 10000;
+
+/* maximum event size for fragmented events (EQ_FRAGMENTED) */
+INT max_event_size_frag = 5*1024*1024;
+
+/* buffer size to hold events */
+INT event_buffer_size = 10*10000;
+
+BOOL  connected;           /* dummy value for musr_midas routines */
+
+/* mon() and mon_do() specific definitions */
+
+extern INT   n_mon_devices;    /* number of monitored devices in bulk_monitor DD */
+extern INT   n_reg_devices;    /* number of registered devices in bulk_monitor DD */
+
+static INT   n_avail_devices;  /* number of available devices of registered dev */
+static INT   gnchans;                 /* number of total channels */
+static char  gmondevs[LIST_LENGTH]; /* list of monitored devices */
+
+typedef struct _MonChannelRec {     /* Channel info */
+
+  char   Label[NAME_LENGTH];          /* Channel label */
+
+  INT    Nvals;                       /* Number of values */
+  double Offset;                      /* Offset to increase accuracy */
+  double Sum;                         /* Sum of all (values-offset) */
+  double Sum2;                        /* Sum of all (values-offset)**2 */
+  double Mean;                        /* Mean value (offset added) */
+  double Devn;                        /* Standard deviation */
+
+} MonChannelRec, *MonChannelPtr;
+
+typedef struct _MonDeviceRec{       /* Device info */
+
+  char           Name[NAME_LENGTH];   /* Device name */
+  INT            Nchans;              /* Number of channels */
+  MonChannelPtr *pChannels;
+  MonChannelPtr *pRawChannels;
+  double        *pSetpointChannels;
+
+} MonDeviceRec, *MonDevicePtr;
+
+typedef struct _MonMonRec {         /* Monitor info */
+
+  INT           Ndevs;                /* Number of devices */
+  MonDevicePtr *pDevices;
+  INT           Interval;             /* Interval [msec] */
+
+} MonMonRec, *MonMonPtr;
+
+/* --------------------------------------------- */
+
+static MonMonRec smon = {0, NULL, 1000};
+
+static INT mon_old_number = -1;
+static INT mon_old_state  = 0;
+
+static INT mon_cur_number = -1;
+static INT mon_cur_state  = 0;
+
+static INT mon_last_checked = 0;
+static INT mon_last_loop    = 0;
+static INT mon_elapsed_loop = 0;
+static INT mon_last_title   = 0;
+
+static BOOL mon_tc_enabled       = FALSE;
+static BOOL mon_dvm_enabled      = FALSE;
+static BOOL mon_ltc1_enabled     = FALSE;
+static BOOL mon_ls3360_enabled   = FALSE;
+static BOOL mon_ls3361_enabled   = FALSE;
+static BOOL mon_heliox0_enabled  = FALSE;
+static BOOL mon_variox0_enabled  = FALSE;
+static BOOL mon_dmm270x1_enabled = FALSE;
+static BOOL mon_hvdistr3_enabled = FALSE;
+static BOOL mon_hvdistr4_enabled = FALSE;
+static BOOL mon_lckinamp0_enabled = FALSE;
+static BOOL mon_lckinamp1_enabled = FALSE;
+static BOOL mon_lckinamp2_enabled = FALSE;
+
+static BOOL mon_tc_active       = FALSE;
+static BOOL mon_dvm_active      = FALSE;
+static BOOL mon_ltc1_active     = FALSE;
+static BOOL mon_ls3360_active   = FALSE;
+static BOOL mon_ls3361_active   = FALSE;
+static BOOL mon_heliox0_active  = FALSE;
+static BOOL mon_variox0_active  = FALSE;
+static BOOL mon_dmm270x1_active = FALSE;
+static BOOL mon_hvdistr3_active = FALSE;
+static BOOL mon_hvdistr4_active = FALSE;
+static BOOL mon_lckinamp0_active = FALSE;
+static BOOL mon_lckinamp1_active = FALSE;
+static BOOL mon_lckinamp2_active = FALSE;
+
+static BOOL mon_update_old_rns = FALSE;
+
+static BOOL mon_do_statistics = FALSE;
+
+static char mon_monfile_name[MAX_STRING_LENGTH];
+static char mon_rlogfile_name[MAX_STRING_LENGTH];
+
+static INT old_year   = -1;
+static INT old_month  = -1;
+static INT old_day    = -1;
+
+static time_t start_of_run_time = 0;
+
+static INT dmm270x1_channel_used[22];
+
+INT mon       (char *, INT, INT, char *);
+INT mon_do    (char *, INT, INT, char *);
+INT mon_device_list(void);
+INT mon_active_list(char *);
+
+/*-- Equipment list ------------------------------------------------*/
+
+/* device driver list */
+DEVICE_DRIVER mon_driver[] = {
+  { "MON", bulk_monitor, 2, NULL, DF_READ_ONLY },
+  { "" }
+};
+
+EQUIPMENT equipment[] = {
+
+  { "mon1",               /* equipment name */
+   {6, 0,                 /* event ID, trigger mask */
+    "SYSTEM",             /* event buffer */
+    EQ_SLOW,              /* equipment type */
+    0,                    /* event source */
+    "FIXED",              /* format */
+    TRUE,                 /* NOTE: equipment is NOT enabled */
+    RO_RUNNING |
+    RO_TRANSITIONS,       /* read when running and on transitions */
+    1000,                 /* read every 5 sec */
+    0,                    /* stop run after this event limit */
+    0,                    /* number of events in super event */
+    1,                    /* log history every event */
+    "", "", ""},
+    cd_gen_read,          /* readout routine */
+    cd_gen,               /* class driver main routine */
+    mon_driver,           /* device driver list */
+    NULL,                 /* init string */
+  },
+
+  { "" }
+};
+
+
+/*-- Dummy routines ------------------------------------------------*/
+
+INT  poll_event(INT source[], INT count, BOOL test) {return 1;}
+INT  interrupt_configure(INT cmd, INT source[], PTYPE adr) {return 1;}
+
+/*-- Frontend Init -------------------------------------------------*/
+
+INT frontend_init()
+{
+#ifdef FORTIFY
+  Fortify_CheckAllMemory();
+#endif
+
+#ifdef MIDEBUG1
+  printf("frontend_init()\n");
+#endif
+
+  mon("MON_INIT",-1,-1,"MON_INIT");
+
+  return CM_SUCCESS;
+}
+
+/*-- Frontend Exit -------------------------------------------------*/
+
+INT frontend_exit()
+{
+
+#ifdef FORTIFY
+  Fortify_CheckAllMemory();
+  Fortify_OutputStatistics();
+#endif
+
+#ifdef MIDEBUG1
+  printf("frontend_exit()\n");
+#endif
+
+  mon("MON_EXIT",-1,-1,"MON_EXIT");
+  mon_active_list("NONE");
+
+  return CM_SUCCESS;
+}
+
+/*-- Frontend Loop -------------------------------------------------*/
+
+//OBS static DWORD last_time_cmd  = 0;
+static DWORD last_time_loop = 0;
+#ifdef FORTIFY
+static DWORD last_time_fortify = 0;
+#endif
+
+INT frontend_loop() {
+  INT   status;
+  DWORD curtime;
+  HNDLE hDB;
+
+#ifdef MIDEBUG2
+  printf(">>>frontend_loop()\n");
+#endif
+
+#ifdef FORTIFY
+  Fortify_CheckAllMemory();
+#endif
+
+  curtime = ss_millitime();
+
+  cm_get_experiment_database(&hDB,NULL);
+
+  status = cm_client_in_list();
+  if (status == SS_ABORT) return status;
+
+  /* --- check for cmd variable in frontend part of ODB ---- */
+#ifdef OBSOLETE
+  curtime = ss_millitime();
+
+  /* time to check? */
+  if (curtime-last_time_cmd >  5000) {
+    INT size;
+    char  odbtmp[MAX_ODB_PATH];        /* front end type specific abs. ODB path */
+    char  odbstr[MAX_ODB_PATH];
+
+    /* cmd is located in frontend specific part */
+    sprintf(odbtmp,"%scmd",feodbpath);
+    size = sizeof(odbstr);
+    if ((status = db_get_value(hDB,0,odbtmp,odbstr,&size,TID_STRING,FALSE))==DB_SUCCESS){
+      if (!equal_ustring(odbstr,"NONE")) {
+        int exitflag;
+
+#ifdef MIDEBUG
+        printf("cmd = %s\n",odbstr);
+#endif
+        exitflag = FALSE;
+
+        /* execute command */
+        if (equal_ustring(odbstr,"MON_INIT")) {
+          mon("MON_INIT",-1,-1,"MON_INIT"); /* initialise MONITOR */
+        } else if (equal_ustring(odbstr,"EXIT")) {
+          mon("MON_EXIT",-1,-1,"MON_EXIT");
+          mon_active_list("NONE");
+          exitflag = TRUE;
+        }
+
+        /* overwrite command */
+        strcpy(odbstr,"None");
+        db_set_value(hDB,0,odbtmp,odbstr,strlen(odbstr)+1,1,TID_STRING);
+
+        if (exitflag) return RPC_SHUTDOWN;
+      }
+    }
+
+    last_time_cmd = ss_millitime();
+  }
+#endif /* #ifdef OBSOLETE */
+
+  /* slow down, this is still slow control */
+  curtime=ss_millitime();
+
+  /* only log data once per monitor interval */
+  if (curtime-mon_last_loop+mon_elapsed_loop >= smon.Interval) {
+    mon("LOOP",-1,-1,NULL);
+    mon_last_loop = ss_millitime();
+    mon_elapsed_loop = mon_last_loop - curtime;
+  }
+
+#ifdef MIDEBUG2
+  printf("elapsed %d ms\n",curtime-last_time_loop);
+#endif
+
+  /* take shorter naps if the monitor interval is almost reached */
+  if (smon.Interval -curtime+mon_last_loop-mon_elapsed_loop > 500) {
+    if (curtime-last_time_loop<500) {
+      ss_sleep(500-curtime+last_time_loop);
+    }
+  } else {
+    if (curtime-last_time_loop<50) {
+      ss_sleep(50-curtime+last_time_loop);
+    }
+  }
+
+  last_time_loop = ss_millitime();
+
+#ifdef MIDEBUG0
+    ss_sleep(10000);                 /* slow down to be able to see processing */
+#endif                               /* NOTE: this will reduce logging rate */
+
+#ifdef FORTIFY
+  /* time to display fortify output? */
+  if (curtime-last_time_fortify >  600000) {
+    Fortify_OutputStatistics();
+    last_time_fortify = ss_millitime();
+  }
+#endif
+
+#ifdef MIDEBUG2
+  printf("<<<frontend_loop()\n");
+#endif
+  return CM_SUCCESS;
+}
+
+/*-- Begin of Run --------------------------------------------------*/
+
+INT begin_of_run(INT run_number, char *error)
+{
+#ifdef MIDEBUG1
+  printf("begin_of_run(%d)\n",run_number);
+#endif
+
+  /* write begin of run to log files */
+  mon("BEGIN_RUN",run_number,STATE_RUNNING,"RCHANGE");
+  return CM_SUCCESS;
+}
+
+/*-- End of Run ----------------------------------------------------*/
+
+INT end_of_run(INT run_number, char *error)
+{
+#ifdef MIDEBUG1
+  printf("end_of_run(%d)\n", run_number);
+#endif
+  /* write end of run to log files */
+  mon("END_RUN",run_number,STATE_STOPPED,"RCHANGE");
+  return CM_SUCCESS;
+}
+
+/*-- Pause Run -----------------------------------------------------*/
+
+INT pause_run(INT run_number, char *error)
+{
+#ifdef MIDEBUG1
+  printf("pause_run(%d)\n", run_number);
+#endif
+  /* write pause run to log files */
+  mon("PAUSE_RUN",run_number,STATE_PAUSED,"RCHANGE");
+  return CM_SUCCESS;
+}
+
+/*-- Resume Run ----------------------------------------------------*/
+
+INT resume_run(INT run_number, char *error)
+{
+#ifdef MIDEBUG1
+  printf("resume_run(%d)\n", run_number);
+#endif
+  /* write resume run to log files */
+  mon("RESUME_RUN",run_number,STATE_RUNNING,"RCHANGE");
+  return CM_SUCCESS;
+}
+
+/*------------------------------------------------------------------*/
+
+INT mon ( char *cmd, INT runnumber, INT runstate, char *icmd) {
+
+/********************************************************************\
+
+  Routine:  mon
+
+  Purpose:  Process monitor cmd
+
+  Input:
+    char *cmd        command to be executed
+    INT   runnumber  run number to be used
+    INT   runstate   run state to be used
+    char *icmd       invoking command
+
+  Output:
+    NONE
+
+  Function value:
+    INT                     SS_SUCCESS : Success
+
+\********************************************************************/
+
+  INT status;
+  HNDLE hDB;
+
+#ifdef MIDEBUG
+  printf(">> mon (%s,%d,%d,%s)\n",(cmd==NULL)?"NULL":cmd,runnumber,runstate,
+                                  (icmd==NULL)?"NULL":icmd);
+#endif
+  status = CM_SUCCESS;
+
+  cm_get_experiment_database(&hDB,NULL);
+
+  if ((cmd != NULL) && (strlen(cmd)>0)) {
+
+    /* check if mon structure is initialised */
+    if ((strcmp(cmd,"MON_INIT") != 0) && (strcmp(cmd,"INIT")!=0)){
+     if ((smon.Ndevs == 0) && (smon.pDevices == NULL))
+       mon_do("INIT",-1,-1,NULL);
+    }
+
+    /* update mon_last_checked to avoid flipping of state until
+     * ODB is updated */
+    if ((icmd != NULL) && (strcmp(icmd,"RCHANGE")==0))
+      mon_last_checked = ss_millitime();
+
+    /* if not called by special command, check run number and state periodically */
+    if (((icmd == NULL) || ((strcmp(icmd,"MON_INIT")!=0) &&
+                            (strcmp(icmd,"RCHANGE") !=0) &&
+                            (strcmp(icmd,"MON_EXIT")!=0)   )) &&
+        ((ss_millitime()-mon_last_checked) > 5000) ) {
+      /* RA36 11-NOV-2016 was 30000 now 5000 */
+
+      /* get current run number and run state */
+      if (mon_cur_number == -1) mon_cur_number = mon_old_number;
+      current_runnumber(hDB,&mon_cur_number);
+#ifdef MIDEBUG
+      printf("   current_runnumber(%d) \n", mon_cur_number);
+#endif
+      if (mon_old_number == -1) {
+        mon_old_number = mon_cur_number;
+        mon_update_old_rns = TRUE;
+      }
+
+      if (mon_cur_state == 0) mon_cur_state = mon_old_state;
+      current_runstate(hDB, &mon_cur_state);
+#ifdef MIDEBUG
+      printf("   current_runstate(%d) \n", mon_cur_state);
+#endif
+      if (mon_old_state == 0) {
+        mon_old_state = mon_cur_state;
+        mon_update_old_rns = TRUE;
+      }
+
+      if (mon_old_number != mon_cur_number) {
+        INT moncurnumber,moncurstate;
+
+        /* save new number and state as they will be overwritten */
+        moncurnumber = mon_cur_number;
+        moncurstate  = mon_cur_state;
+
+        if ((mon_old_state == STATE_RUNNING) ||(mon_old_state == STATE_PAUSED))
+          mon("END_RUN",mon_old_number,mon_old_state,"RCHANGE");
+
+        if ((moncurstate == STATE_RUNNING)||(moncurstate == STATE_PAUSED))
+          mon("BEGIN_RUN",moncurnumber,moncurstate,"RCHANGE");
+
+        if (moncurstate == STATE_PAUSED)
+          mon("PAUSE_RUN",moncurnumber,moncurstate,"RCHANGE");
+
+        mon_cur_number = moncurnumber;  /* restore */
+        mon_cur_state  = moncurstate;
+        mon_update_old_rns = TRUE;
+
+      } else if (mon_old_state != mon_cur_state) {
+
+        if (mon_cur_state == STATE_PAUSED) {
+
+          if (mon_old_state != STATE_RUNNING)
+            mon("BEGIN_RUN", mon_cur_number, mon_cur_state, "RCHANGE");
+
+          mon("PAUSE_RUN", mon_cur_number, mon_cur_state,"RCHANGE");
+
+        } else if (mon_cur_state == STATE_RUNNING) {
+
+          if (mon_old_state == STATE_STOPPED)
+            mon("BEGIN_RUN", mon_cur_number, mon_cur_state, "RCHANGE");
+          else if (mon_old_state == STATE_PAUSED)
+            mon("RESUME_RUN", mon_cur_number, mon_cur_state, "RCHANGE");
+
+        } else if (mon_cur_state == STATE_STOPPED) {
+          if ((mon_old_state == STATE_RUNNING)||(mon_old_state == STATE_PAUSED))
+          mon("END_RUN", mon_cur_number, mon_cur_state,"RCHANGE");
+        }
+        mon_update_old_rns = TRUE;
+      }
+
+      mon_last_checked = ss_millitime();
+
+    } /* if not special cmd, check run number and run state periodically */
+
+   /* -- run number was not specified */
+    if (runnumber == -1) {
+      runnumber = mon_cur_number;
+      /* get current number if not initialised */
+      if (runnumber == -1) current_runnumber(hDB,&runnumber);
+    }
+
+   /* -- run state was not specified */
+    if (runstate == -1) {
+      runstate = mon_cur_state;
+      /* get current state if not initialised */
+      if (runstate == 0) current_runstate(hDB,&runstate);
+    }
+
+   /* -- execute command */
+    if        (strcmp(cmd,"MON_INIT")   == 0) {
+
+      mon_do("MON_INIT",runnumber,runstate,"MON_INIT");
+
+      if ((runstate == STATE_RUNNING) || (runstate == STATE_PAUSED))
+        mon("BEGIN_RUN",runnumber,runstate,"MON_INIT");
+
+      if (runstate == STATE_PAUSED)
+        mon("PAUSE_RUN",runnumber,runstate,"MON_INIT");
+
+    } else if (strcmp(cmd,"MON_EXIT")   == 0) {
+
+      mon("END_RUN",runnumber,runstate,"MON_EXIT");
+      mon_do("MON_EXIT",runnumber,runstate,"MON_EXIT");
+
+    } else if (strcmp(cmd,"BEGIN_RUN")  == 0) {
+
+      mon_do("BEGIN_RUN",runnumber,runstate,icmd);
+
+    } else if (strcmp(cmd,"END_RUN")    == 0) {
+
+      mon_do("END_RUN",runnumber,runstate,icmd);
+
+    } else if (strcmp(cmd,"PAUSE_RUN")  == 0) {
+
+      mon_do("PAUSE_RUN",runnumber, runstate, icmd);
+
+    } else if (strcmp(cmd,"RESUME_RUN") == 0) {
+
+      mon_do("RESUME_RUN",runnumber, runstate, icmd);
+
+    } else if (strcmp(cmd,"LOOP")       == 0) {
+
+      mon_do("LOOP",runnumber, runstate, icmd);
+
+    } else {
+      cm_msg(MERROR,"mon","Unknown command %s",cmd);
+      status = CM_SET_ERROR;
+    }
+
+    /* run number has changed */
+    if ((icmd != NULL) && (strcmp(icmd,"RCHANGE")==0)) {
+      mon_cur_number = runnumber;
+      mon_cur_state  = runstate;
+      mon_update_old_rns = TRUE;
+    }
+
+    /* if update flag update old run number and state */
+    if (mon_update_old_rns) {
+      mon_old_number = mon_cur_number;
+      mon_old_state  = mon_cur_state;
+      mon_update_old_rns = FALSE;
+    }
+
+
+  } else {
+    cm_msg(MERROR,"mon","NULL pointer or empty string supplied as command");
+  }
+#ifdef MIDEBUG
+  printf("<< mon(%s)\n",(cmd==NULL)?"NULL":cmd);
+#endif
+  return status;
+}
+
+/*------------------------------------------------------------------*/
+
+BOOL file_exists(char *fname){
+/********************************************************************\
+
+  Routine:            file_exists
+
+  Purpose:            check if file exists
+
+  Input:
+    char *fname       file name
+
+  Output:
+    NONE
+
+  Function value:
+    BOOL              TRUE  : File exists
+                      FALSE : File does not exist or error
+
+\********************************************************************/
+
+  BOOL status;
+  struct stat statbuf;
+
+  status = FALSE;
+
+#ifdef MIDEBUG1
+  printf("      >>file_exists(%s)\n",fname);
+#endif
+
+  if (stat(fname,&statbuf) != -1) {       /* use stat to get file info */
+
+#ifdef MIDEBUG1
+    printf("        file %s exists\n",fname);
+#endif
+    status = TRUE;
+
+  } else {
+
+#ifdef MIDEBUG2
+    printf("        errno = %d \n", errno);
+#endif
+    if (errno != ENOENT) {               /* file not found */
+      cm_msg(MERROR,"file_exists","stat() returned errno = %d\n",errno);
+    } else {
+#ifdef MIDEBUG1
+      printf("        file %s does not exist\n",fname);
+#endif
+    }
+
+  }
+
+  return status;
+}
+
+/*------------------------------------------------------------------*/
+BOOL mon_file_exists(INT cyear, INT cmonth, INT cday){
+/********************************************************************\
+
+  Routine:            mon_file_exists
+
+  Purpose:            check if mon file exists
+                      when file exists mon_monfile_name will be updated
+
+  Input:
+    INT   cyear       year
+    INT   cmonth      month
+    INT   cday        day
+
+  Output:
+    NONE
+
+  Function value:
+    BOOL              TRUE  : File exists
+                      FALSE : File does not exist or error
+
+\********************************************************************/
+
+  BOOL status;
+  char fname[NAME_LENGTH];
+
+  sprintf(fname,"%4.4d_%2.2d_%2.2d.mon",cyear,cmonth,cday);
+#ifdef MIDEBUG1
+  printf("    >>mon_file_exists(%s)\n",fname);
+#endif
+
+  if (strcmp(fname,mon_monfile_name) != 0) {      /* check if current */
+    status = file_exists(fname);
+    if (status) strcpy(mon_monfile_name,fname);   /* exists->now current */
+  } else {
+    status = TRUE;
+  }
+  return status;
+}
+
+/*------------------------------------------------------------------*/
+BOOL rlog_file_exists(INT runnumber){
+/********************************************************************\
+
+  Routine:            rlog_file_exists
+
+  Purpose:            check if run specific mon log file exists
+                      when file exists mon_rlogfile_name will be updated
+
+  Input:
+    INT  runnumber    run number
+
+  Output:
+    NONE
+
+  Function value:
+    BOOL              TRUE  : File exists
+                      FALSE : File does not exist or error
+
+\********************************************************************/
+
+  BOOL status;
+  char fname[NAME_LENGTH];
+
+  sprintf(fname,"run_%4.4d.mon",runnumber);
+#ifdef MIDEBUG1
+  printf("    >>rlog_file_exists(%s)\n",fname);
+#endif
+  if (strcmp(fname,mon_rlogfile_name) != 0) {      /* check if current */
+    status = file_exists(fname);
+    if (status) strcpy(mon_rlogfile_name,fname);   /* exists->now current */
+  } else {
+    status = TRUE;
+  }
+  return status;
+}
+
+/*------------------------------------------------------------------*/
+FILE *mon_monfile_open(INT cyear, INT cmonth, INT cday){
+/********************************************************************\
+
+  Routine:            mon_monfile_open
+
+  Purpose:            open mon file to append text
+
+  Input:
+    INT   cyear       year
+    INT   cmonth      month
+    INT   cday        day
+
+  Output:
+    NONE
+
+  Function value:
+    FILE*             <> NULL  : File opened for append
+                      NULL     : ERROR
+
+\********************************************************************/
+
+  FILE *pfile;
+  char fname[NAME_LENGTH];
+  INT  itry;
+
+  sprintf(fname,"%4.4d_%2.2d_%2.2d.mon",cyear,cmonth,cday);
+#ifdef MIDEBUG1
+  printf("  >> mon_monfile_open(%s)\n",fname);
+#endif
+
+  itry = 0;
+
+try_again:   ;
+  if ((pfile = fopen(fname,"a")) != NULL) {
+    strcpy(mon_monfile_name,fname);                 /* now current */
+  } else {
+    itry++;
+    if (itry < 10) {
+      ss_sleep(100);
+      goto try_again;
+    }
+    cm_msg(MERROR,"mon_monfile_open","ERROR Opening mon file %s",fname);
+  }
+#ifdef MIDEBUG1
+  printf("  << mon_monfile_open()\n");
+#endif
+  return pfile;
+}
+
+/*------------------------------------------------------------------*/
+FILE *mon_rlogfile_open(INT runnumber){
+/********************************************************************\
+
+  Routine:            mon_rlogfile_open
+
+  Purpose:            open run specific mon file to append text
+
+  Input:
+    INT  runnumber    run number
+
+  Output:
+    NONE
+
+  Function value:
+    FILE*             <>NULL  : File openend for append
+                      NULL    : Error
+
+\********************************************************************/
+
+  FILE *pfile;
+  char fname[NAME_LENGTH];
+  INT  itry;
+
+  sprintf(fname,"run_%4.4d.mon",runnumber);
+#ifdef MIDEBUG1
+  printf("  >> mon_rlogfile_open(%s)\n",fname);
+#endif
+
+  itry = 0;
+
+try_again:   ;
+  if ((pfile = fopen(fname,"a")) != NULL) {
+    strcpy(mon_rlogfile_name,fname);                 /* now current */
+  } else {
+    itry++;
+    if (itry < 10) {
+      ss_sleep(100);
+      goto try_again;
+    }
+    cm_msg(MERROR,"mon_rlogfile_open","ERROR Opening rlog file %s",fname);
+  }
+#ifdef MIDEBUG1
+  printf("  << mon_rlogfile_open()\n");
+#endif
+  return pfile;
+}
+
+/*------------------------------------------------------------------*/
+INT mon_file_text(INT cyear, INT cmonth, INT cday, char *msg,
+                            INT rnum){
+/********************************************************************\
+
+  Routine:            mon_file_text
+
+  Purpose:            write text to mon and rlog log files
+
+  Input:
+    INT   cyear     year   of log file
+    INT   cmonth    month  of log file
+    INT   cday      day    of log file
+    char *msg       message to be appended
+    INT   rnum      run number of rlog log file
+
+  Output:
+    NONE
+
+  Function value:
+    INT                     SS_SUCCESS : Success
+
+\********************************************************************/
+
+  INT status;
+
+#ifdef MIDEBUG1
+  printf("  >> mon_file_text(%4.4d,%2.2d,%2.2d,%4.4d)\n",cyear,cmonth,cday,rnum);
+#endif
+  if ((msg != NULL) && (strlen(msg)>0)) {
+    time_t ti;
+    struct tm* lt;
+
+    time(&ti);
+    if ((lt = localtime(&ti)) != NULL) {
+      char line[1024];
+
+      if ((cyear != 0) && (cmonth != 0) && (cday != 0)) {
+        FILE *pfile;
+
+        if (!mon_file_exists(cyear,cmonth,cday)) {
+
+          if ((pfile=mon_monfile_open(cyear,cmonth,cday)) != NULL) {
+
+            /* write file header */
+            sprintf(line,"!M File = %s\n",mon_monfile_name);
+            fputs(line,pfile);
+            fputs("!\n",pfile);
+            fputs("! Record format is : \n",pfile);
+            fputs("!\n",pfile);
+            fputs("!  <time>\\<device>\\<n_vals>\\<val1> ... \\[<raw1> ...\\]\n",
+                     pfile);
+            fputs("!\n",pfile);
+          }
+        } else {
+          pfile = mon_monfile_open(cyear,cmonth,cday);
+        }
+
+        if (pfile != NULL) {
+          if (msg[0] == '\\') {
+           /* precede data line with time hh:mm:sec */
+           /* e.g. hh:mm:ss\TC\nchans\values */
+            sprintf(line,"%2.2d:%2.2d:%2.2d%s\n",lt->tm_hour,lt->tm_min,
+                    lt->tm_sec,msg);
+            fputs(line,pfile);
+          } else {
+            strcpy(line,msg);
+            strcat(line,"\n");
+            fputs(line,pfile);
+          }
+          fclose(pfile);
+        } else {
+          /* error handled by mon_monfile_open */
+        }
+      }
+
+      if (rnum >= 0) {
+        FILE *pfile;
+
+        if (!rlog_file_exists(rnum)) {
+
+          if ((pfile=mon_rlogfile_open(rnum)) != NULL) {
+
+            /* write file header */
+            sprintf(line,"!R File = %s\n",mon_rlogfile_name);
+            fputs(line,pfile);
+            fputs("!\n",pfile);
+            fputs("! Record format is : \n",pfile);
+            fputs("!\n",pfile);
+            fputs("!  <delta_time>\\<device>\\<n_vals>\\<val1> ... \\[<raw1> ...\\]\n",
+                     pfile);
+            fputs("!    <delta_time> = [dd ]hh:mm:ss\n",pfile);
+            fputs("!\n",pfile);
+          }
+
+        } else {
+          pfile = mon_rlogfile_open(rnum);
+        }
+
+        if (pfile != NULL) {
+
+          if (start_of_run_time != 0) {
+            if (msg[0] == '\\') {
+              INT dd,hh,mm,ss;
+
+              /* get number of seconds since start of run */
+              ss = ti-start_of_run_time;
+              mm = ss/60;
+              ss = ss%60;
+              hh = mm/60;
+              mm = mm%60;
+              dd = hh/24;
+              hh = hh%24;
+
+              /* precede data line with delta time [dd ]hh:mm:sec */
+              /* e.g. [dd ]hh:mm:ss\TC\nchans\values */
+              if (dd > 0)
+                sprintf(line,"%d %2.2d:%2.2d:%2.2d%s\n",dd,hh,mm,ss,msg);
+              else
+                sprintf(line,"%2.2d:%2.2d:%2.2d%s\n",hh,mm,ss,msg);
+
+              fputs(line,pfile);
+            } else {
+              strcpy(line,msg);
+              strcat(line,"\n");
+              fputs(line,pfile);
+            }
+          }
+          fclose(pfile);
+        } else {
+          /* error handled by mon_rlogfile_open */
+        }
+      }
+    } else {
+      cm_msg(MERROR,"mon_file_text",
+           "ERROR localtime() returned NULL pointer to lt structure");
+    }
+  }
+  status = CM_SUCCESS;
+#ifdef MIDEBUG1
+  printf("  << mon_file_text()\n");
+#endif
+  return status;
+}
+
+/*------------------------------------------------------------------*/
+static char *months[] = {"JAN","FEB","MAR","APR","MAY","JUN","JUL","AUG",
+                         "SEP","OCT","NOV","DEC"};
+
+INT mon_file_comment(INT cyear, INT cmonth, INT cday, char *msg, INT rnum){
+/********************************************************************\
+
+  Routine:   mon_file_comment
+
+  Purpose:   prepare comment to be saved to file
+
+  Input:
+    INT   cyear     year   of log file
+    INT   cmonth    month  of log file
+    INT   cday      day    of log file
+    char *msg       message to be appended
+    INT   rnum      run number of log rlog file
+
+  Output:
+    NONE
+
+  Function value:
+    INT                     SS_SUCCESS : Success
+
+\********************************************************************/
+
+  INT status;
+
+  status = CM_SUCCESS;
+#ifdef MIDEBUG1
+  printf("  >> mon_file_comment(%4.4d,%2.2d,%2.2d,%4.4d)\n",cyear,cmonth,cday,rnum);
+#endif
+  if ((msg != NULL) && (strlen(msg)>0)) {
+    char   text[MAX_STRING_LENGTH];
+    time_t ti;
+    struct tm* lt;
+
+    time(&ti);
+    if ((lt = localtime(&ti)) != NULL) {
+
+      /* prevent string overflow */
+      if (strlen(msg)>MAX_STRING_LENGTH-26) *(msg+MAX_STRING_LENGTH-27) = '\0';
+
+      /* add time stamp to comment in the format *\
+         123456789012345678901234567
+      \* !I 05-NOV-2003 10:09:37 : Exit.         */
+      sprintf(text,"!I %2.2d-%3.3s-%4.4d %2.2d:%2.2d:%2.2d : %s",
+            lt->tm_mday,months[lt->tm_mon],lt->tm_year+1900,lt->tm_hour,
+            lt->tm_min,lt->tm_sec,msg);
+    } else {
+      if (strlen(msg)>MAX_STRING_LENGTH-26) *(msg+MAX_STRING_LENGTH-27) = '\0';
+      sprintf(text,"!I                      : %s",msg);
+    }
+    if ((strcmp(msg,"End of day.")==0) ||
+        (strcmp(msg,"Statistics due to end of day.") ==0)) {
+      sprintf(text,"!I %2.2d-%3.3s-%4.4d 23:59:59 : %s",cday,months[cmonth-1],
+              cyear,msg);
+    }
+    status = mon_file_text(cyear,cmonth,cday,text,rnum);
+  }
+
+#ifdef MIDEBUG1
+  printf("  << mon_file_comment()\n");
+#endif
+  return status;
+}
+
+/*------------------------------------------------------------------*/
+
+INT mon_file_title(INT cyear, INT cmonth, INT cday, INT rnum) {
+  INT   status,size;
+  char  odbtmp[MAX_ODB_PATH];        /* front end type specific abs. ODB path */
+  char  odbstr[MAX_ODB_PATH];
+  char  tempstr[MAX_STRING_LENGTH];
+  HNDLE hDB;
+
+  cm_get_experiment_database(&hDB,NULL);
+
+  strcpy(odbtmp,"/musr/td_musr/runinfo/runtitle");
+  size = sizeof(odbstr);
+  if ((status = db_get_value(hDB,0,odbtmp,odbstr,&size,TID_STRING,FALSE))==DB_SUCCESS){
+    if (size > 0) {
+      snprintf(tempstr,MAX_STRING_LENGTH,"TITLE   : %10.10s %10.10s %10.10s %10.10s",
+                       &odbstr[0], &odbstr[10], &odbstr[20], &odbstr[30]);
+      mon_file_comment(cyear,cmonth,cday,tempstr,rnum);
+    }
+  }
+  strcpy(odbtmp,"/musr/td_musr/runinfo/runsubtitle");
+  size = sizeof(odbstr);
+  if ((status = db_get_value(hDB,0,odbtmp,odbstr,&size,TID_STRING,FALSE))==DB_SUCCESS){
+    if (size > 0) {
+      snprintf(tempstr,MAX_STRING_LENGTH,"COMMENT : %s",odbstr);
+      mon_file_comment(cyear,cmonth,cday,tempstr,rnum);
+    }
+  }
+  strcpy(odbtmp,"/musr/td_musr/runinfo/Proposal");
+  size = sizeof(odbstr);
+  if ((status = db_get_value(hDB,0,odbtmp,odbstr,&size,TID_STRING,FALSE))==DB_SUCCESS){
+    if (size > 0) {
+      snprintf(tempstr,MAX_STRING_LENGTH,"PROPOSAL: %s",odbstr);
+      mon_file_comment(cyear,cmonth,cday,tempstr,rnum);
+    }
+  }
+  return CM_SUCCESS;
+}
+
+/*------------------------------------------------------------------*/
+
+INT mon_file_channels(INT cyear, INT cmonth, INT cday, INT rnum, char *dev,
+                      INT nchans, float *pvalues1, float *pvalues2) {
+/********************************************************************\
+
+  Routine:  mon_file_channels
+
+  Purpose:  write channel data to string
+            as \'dev'\'nchans'\'pvalues1'\['pvalues2'\]
+  Input:
+    INT     cyear     year   of log file
+    INT     cmonth    month  of log file
+    INT     cday      day    of log file
+    INT     rnum      run number of log rlog file
+    char   *dev       device name
+    INT     nchans    number of channels
+    float  *pvalues1  first set of values
+    float  *pvalues2  second set of values   [optional]
+
+  Output:
+    NONE
+
+  Function value:
+    INT                     SS_SUCCESS : Success
+
+\********************************************************************/
+
+  INT  status;
+  char text[1024];
+  char text1[30];
+
+  status = CM_SUCCESS;
+
+#ifdef MIDEBUG1
+  printf("  >>mon_file_channels(%4.4d,%2.2d,%2.2d,%4.4d,%s,%2.2d)\n",cyear,cmonth,cday,
+                                rnum,dev,nchans);
+#endif
+    sprintf(text,"\\%s\\%d\\",dev,nchans);
+    if (nchans > 0) {
+      INT i;
+
+      if (pvalues1 != NULL) {
+        for (i=0;i<nchans;i++) {
+          if (*(pvalues1+i) == 0.0)
+            strcpy(text1,"0.0 ");
+          else
+            sprintf(text1,"%G ",*(pvalues1+i));
+          strcat(text,text1);
+        }
+        text[strlen(text)-1] = '\\';
+      }
+      if (pvalues2 != NULL) {
+        for (i=0;i<nchans;i++) {
+          if (*(pvalues2+i) == 0.0)
+            strcpy(text1,"0.0 ");
+          else
+            sprintf(text1,"%G ",*(pvalues2+i));
+          strcat(text,text1);
+        }
+        text[strlen(text)-1] = '\\';
+      }
+    }
+    status = mon_file_text(cyear,cmonth,cday,text,rnum);
+
+  return status;
+}
+/*------------------------------------------------------------------*/
+
+/*!
+  \brief write mean & std deviation of each channel of each device to mon and run log files
+
+   \param[in] cyear year of log file
+   \param[in] cmonth month of log file
+   \param[in] cday day of log file
+   \param[in] pmon pointer to monitor data
+   \param[in] rnum run number of \a run <b> log </b> file
+   \return CM_SUCCESS : Success
+ */
+
+INT mon_file_statistics(INT cyear, INT cmonth, INT cday, MonMonPtr pmon,
+                        INT rnum){
+/********************************************************************\
+
+  Routine:            mon_file_statistics
+
+  Purpose:            write mean & std deviation of each channel of
+                      each device to mon and rlog log files
+
+  Input:
+    INT     cyear     year   of log file
+    INT     cmonth    month  of log file
+    INT     cday      day    of log file
+    MonMonPtr pmon    pointer to monitor data
+    INT     rnum      run number of log rlog file
+
+  Output:
+    NONE
+
+  Function value:
+    INT                     CM_SUCCESS : Success
+
+\********************************************************************/
+
+  INT status;
+
+#ifdef MIDEBUG1
+  printf("  >> mon_file_statistics(%4.4d,%2.2d,%2.2d,%4.4d)\n",cyear,cmonth,cday,rnum);
+#endif
+
+  if (pmon != NULL) {
+    INT   idev,i;
+    char  tempstr[MAX_STRING_LENGTH];
+    FILE *pmonf;
+    FILE *plogf;
+    MonDevicePtr pmondev;
+
+    if ((cyear != 0) && (cmonth != 0) && (cday != 0)) {
+      pmonf = mon_monfile_open(cyear,cmonth,cday);
+    } else
+      pmonf = NULL;
+
+    if ((rnum > 0) && (start_of_run_time != 0)) {
+      plogf = mon_rlogfile_open(rnum);
+    } else
+      plogf = NULL;
+
+    if (smon.pDevices != NULL) {
+      /* for all monitor devices */
+      for (idev=0; idev<smon.Ndevs; idev++) {
+        pmondev = *(smon.pDevices+idev);
+        if (pmondev == NULL) continue;
+
+        if (pmonf != NULL) fputs("!\n",pmonf);
+        if (plogf != NULL) fputs("!\n",plogf);
+
+        sprintf(tempstr,"!D  Device: %s, %d channels\n",pmondev->Name,
+                pmondev->Nchans);
+        if (pmonf != NULL) fputs(tempstr,pmonf);
+        if (plogf != NULL) fputs(tempstr,plogf);
+
+        if (pmondev->pChannels != NULL) {
+          /* for all channels of this device */
+          for (i=0;i<pmondev->Nchans;i++) {
+            if (*(pmondev->pChannels+i) != NULL) {
+              if ((pmondev->pRawChannels != NULL) &&
+                  (*(pmondev->pChannels+i) != NULL)) {
+                sprintf(tempstr,"!S  %d : %-20.20s : %d : %.8G %.8G : %.8G %.8G :\n",
+                  i,(*(pmondev->pChannels+i))->Label,
+                    (*(pmondev->pChannels+i))->Nvals,
+                    (*(pmondev->pChannels+i))->Mean,
+                    (*(pmondev->pChannels+i))->Devn,
+                    (*(pmondev->pRawChannels+i))->Mean,
+                    (*(pmondev->pRawChannels+i))->Devn);
+              } else {
+
+                sprintf(tempstr,"!S  %d : %-20.20s : %d : %.8G %.8G :\n",
+                  i,(*(pmondev->pChannels+i))->Label,
+                    (*(pmondev->pChannels+i))->Nvals,
+                    (*(pmondev->pChannels+i))->Mean,
+                    (*(pmondev->pChannels+i))->Devn);
+              }
+
+              if (pmonf != NULL) fputs(tempstr,pmonf);
+              if (plogf != NULL) fputs(tempstr,plogf);
+
+            }
+          } /* for all channels of this device */
+        }
+
+      } /* for all monitor devices */
+
+    } else {
+      cm_msg(MLOG,"mon_file_statistics","No devices to write statistics of?");
+    }
+
+    if (pmonf != NULL) fputs("!\n!EOS\n!\n",pmonf);
+    if (plogf != NULL) fputs("!\n!EOS\n!\n",plogf);
+
+    if (pmonf != NULL) fclose(pmonf);
+    if (plogf != NULL) fclose(plogf);
+  }
+  status = CM_SUCCESS;
+#ifdef MIDEBUG1
+  printf("  << mon_file_statistics()\n");
+#endif
+  return status;
+}
+
+/*------------------------------------------------------------------*/
+/*!
+    \brief free monitor device data
+    \param[in] pmondev pointer to monitored device
+    \return SS_SUCCESS : Success
+ */
+INT mon_free_device(MonDevicePtr pmondev) {
+/********************************************************************\
+
+  Routine:            mon_free_device
+
+  Purpose:            free monitor device data
+
+  Input:
+    MonDevicePtr      pmondev    pointer to monitor device
+
+  Output:
+    NONE
+
+  Function value:
+    INT                     SS_SUCCESS : Success
+
+\********************************************************************/
+
+#ifdef MIDEBUG1
+  printf("  mon_free_device()\n");
+#endif
+  if (pmondev != NULL) {
+    INT i;
+
+    for (i=0;i<pmondev->Nchans;i++) {
+      if (pmondev->pChannels != NULL)
+        if (*(pmondev->pChannels+i)    != NULL)
+          free(*(pmondev->pChannels+i));
+      if (pmondev->pRawChannels != NULL)
+        if (*(pmondev->pRawChannels+i) != NULL)
+          free(*(pmondev->pRawChannels+i));
+    } /* for all channels in device */
+
+    pmondev->Nchans       = 0;
+
+    if (pmondev->pChannels != NULL) free(pmondev->pChannels);
+    pmondev->pChannels    = NULL;
+
+    if (pmondev->pRawChannels != NULL) free(pmondev->pRawChannels);
+    pmondev->pRawChannels = NULL;
+
+    if (pmondev->pSetpointChannels != NULL) free(pmondev->pSetpointChannels);
+    pmondev->pSetpointChannels = NULL;
+
+    free(pmondev);
+  }
+  return CM_SUCCESS;
+}
+/*------------------------------------------------------------------*/
+
+INT mon_chan_statistics(MonChannelPtr pchan, float value) {
+/********************************************************************\
+
+  Routine:            mon_chan_statistics
+
+  Purpose:            calculate mean and std of channel after adding value
+
+  Input:
+    MonChannelPtr     pchan       pointer to channel data
+    float             value       value to be added
+
+  Output:
+    NONE
+
+  Function value:
+    INT                     SS_SUCCESS : Success
+
+\********************************************************************/
+
+  INT status;
+
+  status = CM_SUCCESS;
+#ifdef MIDEBUG1
+  printf("  mon_chan_statistics()\n");
+#endif
+  if (pchan != NULL) {
+    double delta;
+
+    /* use offset to improve accuracy */
+    delta = (double)value - pchan->Offset;
+
+    pchan->Sum  += delta;
+    pchan->Sum2 += (delta*delta);
+    pchan->Nvals++;
+
+    pchan->Mean  = pchan->Sum/(double)pchan->Nvals;
+
+    pchan->Devn  = pchan->Sum2/(double)pchan->Nvals-pchan->Mean*pchan->Mean;
+    pchan->Devn  = sqrt(fabs(pchan->Devn));
+
+    pchan->Mean += pchan->Offset;
+
+#ifdef MIDEBUG
+    printf("%s : Nvals = %d, Mean = %f, Devn = %f\n",pchan->Label,pchan->Nvals,
+                                                     pchan->Mean, pchan->Devn);
+#endif
+  }
+  return status;
+}
+
+/*------------------------------------------------------------------*/
+INT reg_equipment_available(const char *requi) {
+/********************************************************************\
+
+  Routine:            reg_equipment_available
+
+  Purpose:            check if requi (key) is in /Equipment/
+
+  Input:
+    requi             Name of registered equipment
+               
+  Output:
+    NONE
+
+  Function value:
+    INT                     TRUE : Success
+                            FALSE: Equipment requi not found in ODB
+
+\********************************************************************/
+  INT ret;
+
+  ret = FALSE;
+  if (requi && (strlen(requi) >0)) {
+    HNDLE hDB,tkey;
+    char tmpstr[MAX_ODB_PATH];
+
+    cm_get_experiment_database(&hDB,NULL);
+    snprintf(tmpstr,MAX_ODB_PATH,"/Equipment/%s", requi);
+    if (db_find_key(hDB,0,tmpstr,&tkey) != DB_SUCCESS) {
+      cm_msg(MLOG,"","ERROR Equipment (%s) registered in DD/Device_list "
+                     "is not present in ODB!", requi); 
+    }
+  } else {
+    // NIY error invalid parameter requi == NULL or strlen() < 1
+  }
+  return ret;
+}
+/*------------------------------------------------------------------*/
+INT blank_string(char *pos, INT nchar) {
+  INT ret;
+  ret = 0;
+  if (pos && (nchar > 0) ) {
+    int i;
+    for (i=0; i < nchar; i++) {
+      *(pos+i) = ' ';
+    }
+  } else {
+    // NIY err
+  }
+  return ret;
+}
+INT mon_device_list(void) {
+/********************************************************************\
+
+  Routine:            mon_device_list
+
+  Purpose:            read device_list from ODB and set mon_DEV_enabled
+                      TRUE if device is in the list else set FALSE
+
+  Input:
+    NONE
+
+  Output:
+    static BOOL mon_tc_enabled
+    static BOOL mon_dvm_enabled
+    static BOOL mon_ltc1_enabled
+    static BOOL mon_ls3360_enabled
+    static BOOL mon_ls3361_enabled
+    static BOOL mon_heliox0_enabled
+    static BOOL mon_variox0_enabled
+    static BOOL mon_dmm270x1_enabled
+    static BOOL mon_hvdistr3_enabled
+    static BOOL mon_hvdistr4_enabled
+    static BOOL mon_lckinamp0_enabled
+    static BOOL mon_lckinamp1_enabled
+    static BOOL mon_lckinamp2_enabled
+
+  Function value:
+    INT                     SS_SUCCESS : Success
+
+\********************************************************************/
+  INT   ret,j,found;
+  char  tempstr[LIST_LENGTH];
+  char  odbtmp[MAX_ODB_PATH];
+  char *pos;
+  HNDLE hDB;
+
+#ifdef MIDEBUG1
+  printf("  mon_device_list()\n");
+#endif
+  ret = CM_SUCCESS;
+
+  n_reg_devices = 0;
+  n_avail_devices = 0;
+  pos = NULL;
+
+  cm_get_experiment_database(&hDB,NULL);
+
+  sprintf(odbtmp,"/Equipment/%s/Settings/Devices/MON/DD/Device_list",equipment[0].name);
+
+#ifdef MIDEBUG2
+  printf("Device list ODB path is %s\n", odbtmp);
+#endif
+
+  tempstr[0] = '\0';
+  if (db_get_string(hDB,odbtmp,tempstr,sizeof(tempstr),"monitor device list")
+                                                                       == CM_SUCCESS){
+
+#ifdef MIDEBUG2
+  printf("Device list is \"%s\"\n", tempstr);
+#endif
+    strcat(tempstr," ");    /* append blank to be able to search for <DEV>" " */
+
+    /* check for each possible equipment once -> when found replace name in list by blanks */
+
+    /* is TC in device_list? */
+    if ((pos=strstr(tempstr,"TC ")) != NULL) {
+#ifdef MIDEBUG2
+      printf("enabling TC logging\n");
+#endif
+      mon_tc_enabled = TRUE;
+      if (reg_equipment_available("TC")) n_avail_devices++;
+      n_reg_devices++;
+      blank_string(pos,2);
+    } else 
+      mon_tc_enabled     = FALSE;
+
+    /* is DVM in device_list? */
+    if ((pos=strstr(tempstr,"DVM ")) != NULL) {
+#ifdef MIDEBUG2
+      printf("enabling DVM logging\n");
+#endif
+      mon_dvm_enabled = TRUE;
+      if (reg_equipment_available("DVM")) n_avail_devices++;
+      n_reg_devices++;
+      blank_string(pos,3);
+    } else
+      mon_dvm_enabled    = FALSE;
+
+    /* is templtc0 in device_list? */
+    if ((pos=strstr(tempstr,"templtc0 ")) != NULL) {
+#ifdef MIDEBUG2
+      printf("enabling templtc0 logging\n");
+#endif
+      mon_ltc1_enabled = TRUE;
+      if (reg_equipment_available("templtc0")) n_avail_devices++;
+      n_reg_devices++;
+      blank_string(pos,8);
+    } else
+      mon_ltc1_enabled = FALSE;
+
+    /* is templs3360 in device_list? */
+    if ((pos=strstr(tempstr,"templs3360 ")) != NULL) {
+#ifdef MIDEBUG2
+      printf("enabling templs3360 logging\n");
+#endif
+      mon_ls3360_enabled = TRUE;
+      if (reg_equipment_available("templs3360")) n_avail_devices++;
+      n_reg_devices++;
+      blank_string(pos,10);
+    } else
+      mon_ls3360_enabled = FALSE;
+
+    /* is templs3361 in device_list? */
+    if ((pos=strstr(tempstr,"templs3361 ")) != NULL) {
+#ifdef MIDEBUG2
+      printf("enabling templs3361 logging\n");
+#endif
+      mon_ls3361_enabled = TRUE;
+      if (reg_equipment_available("templs3361")) n_avail_devices++;
+      n_reg_devices++;
+      blank_string(pos,10);
+    } else
+      mon_ls3361_enabled = FALSE;
+
+    /* is heliox0 in device_list? */
+    if ((pos=strstr(tempstr,"heliox0 ")) != NULL) {
+#ifdef MIDEBUG2
+      printf("enabling mercury itc (heliox0) logging\n");
+#endif
+      mon_heliox0_enabled = TRUE;
+      if (reg_equipment_available("heliox0")) n_avail_devices++;
+      n_reg_devices++;
+      blank_string(pos,7);
+    }
+
+    /* is variox0 in device_list? */
+    if ((pos=strstr(tempstr,"variox0 ")) != NULL) {
+#ifdef MIDEBUG2
+      printf("enabling mercury itc (variox0) logging\n");
+#endif
+      mon_variox0_enabled = TRUE;
+      if (reg_equipment_available("variox0")) n_avail_devices++;
+      n_reg_devices++;
+      blank_string(pos,7);
+    }
+
+    /* NOTE: NIY another mercury iTC maybe handled as variox0 */
+
+    /* is dmm270x1 in device_list? */
+    if ((pos=strstr(tempstr,"dmm270x1 ")) != NULL) {
+#ifdef MIDEBUG2
+      printf("enabling dmm270x1 logging\n");
+#endif
+      mon_dmm270x1_enabled = TRUE;
+      if (reg_equipment_available("dmm270x1")) n_avail_devices++;
+      n_reg_devices++;
+      blank_string(pos,8);
+    } else
+      mon_dmm270x1_enabled = FALSE;
+
+    /* is hvdistr3 in device_list? */
+    if ((pos=strstr(tempstr,"hvdistr3 ")) != NULL) {
+#ifdef MIDEBUG2
+      printf("enabling hvdistr3 logging\n");
+#endif
+      mon_hvdistr3_enabled = TRUE;
+      if (reg_equipment_available("hvdistr3")) n_avail_devices++;
+      n_reg_devices++;
+      blank_string(pos,8);
+    } else
+      mon_hvdistr3_enabled = FALSE;
+
+    /* is hvdistr4 in device_list? */
+    if ((pos=strstr(tempstr,"hvdistr4 ")) != NULL) {
+#ifdef MIDEBUG2
+      printf("enabling hvdistr4 logging\n");
+#endif
+      mon_hvdistr4_enabled = TRUE;
+      if (reg_equipment_available("hvdistr4")) n_avail_devices++;
+      n_reg_devices++;
+      blank_string(pos,8);
+    } else
+      mon_hvdistr4_enabled =  FALSE;
+
+    /* is lckinamp0 in device_list? */
+    if ((pos=strstr(tempstr,"lckinamp0 ")) != NULL) {
+#ifdef MIDEBUG2
+      printf("enabling lckinamp0 logging\n");
+#endif
+      mon_lckinamp0_enabled = TRUE;
+      if (reg_equipment_available("lckinamp0")) n_avail_devices++;
+      n_reg_devices++;
+      blank_string(pos,9);
+    } else
+      mon_lckinamp0_enabled = FALSE;
+
+    /* is lckinamp1 in device_list? */
+    if ((pos=strstr(tempstr,"lckinamp1 ")) != NULL) {
+#ifdef MIDEBUG2
+      printf("enabling lckinamp1 logging\n");
+#endif
+      mon_lckinamp1_enabled = TRUE;
+      if (reg_equipment_available("lckinamp1")) n_avail_devices++;
+      n_reg_devices++;
+      blank_string(pos,9);
+    } else
+      mon_lckinamp1_enabled = FALSE;
+
+    /* is lckinamp2 in device_list? */
+    if ((pos=strstr(tempstr,"lckinamp2 ")) != NULL) {
+#ifdef MIDEBUG2
+      printf("enabling lckinamp2 logging\n");
+#endif
+      mon_lckinamp2_enabled = TRUE;
+      if (reg_equipment_available("lckinamp2")) n_avail_devices++;
+      n_reg_devices++;
+      blank_string(pos,9);
+    } else
+      mon_lckinamp2_enabled = FALSE;
+
+    // check if something was not handled in tempstr
+    found=FALSE;
+    for(j=strlen(tempstr)-1; j >= 0; j--){ // start from the end
+      if (tempstr[j] == ' ') {
+        if (found) {
+          cm_msg(MLOG,"","ERROR Unhandled equipment in DD/Device_list: %s",&tempstr[j+1]);
+          found = FALSE;
+        }
+        tempstr[j] = '\0';
+      } else {
+        found = TRUE; /* non blank character */
+      }         
+    }
+    if (found) { // handle first (without leading blank)
+      cm_msg(MLOG,"","ERROR Unhandled equipment in DD/Device_list: %s",&tempstr[0]);
+    }
+
+  } else {
+    cm_msg(MLOG,"mon_device_list","WARNING monitor/device_list does not exist! "
+                                  "All devices will be monitored!");
+#ifdef MIDEBUG2
+    printf("WARNING monitor/device_list does not exist! All devices monitored! \n");
+#endif
+    mon_tc_enabled = mon_dvm_enabled = mon_ltc1_enabled = mon_ls3360_enabled =
+    mon_ls3361_enabled = mon_variox0_enabled = mon_heliox0_enabled =
+    mon_dmm270x1_enabled = mon_hvdistr3_enabled = mon_hvdistr4_enabled = TRUE;
+    mon_lckinamp0_enabled = mon_lckinamp1_enabled = mon_lckinamp2_enabled = TRUE;
+    ret = CM_SET_ERROR;
+  }
+  return ret;
+}
+
+/*------------------------------------------------------------------*/
+
+INT mon_active_list(char *list) {
+/********************************************************************\
+
+  Routine:            mon_active_list
+
+  Purpose:            write active_list to ODB
+
+  Input:
+    NONE
+
+  Output:
+
+  Function value:
+    INT                     SS_SUCCESS : Success
+
+\********************************************************************/
+  INT   ret;
+  char  tempstr[MAX_STRING_LENGTH];
+  char  odbtmp[MAX_ODB_PATH];
+  HNDLE hDB;
+
+#ifdef MIDEBUG1
+  printf("  mon_active_list()\n");
+#endif
+  ret = CM_SUCCESS;
+
+  if ((list == NULL) || (strlen(list) <= 0))
+    strncpy(tempstr,"NONE",LIST_LENGTH);
+  else
+    strncpy(tempstr,list,LIST_LENGTH);
+  tempstr[LIST_LENGTH-1] = '\0';
+
+#ifdef MIDEBUG1
+  printf("  mon_active list is \"%s\"\n", tempstr);
+#endif
+  cm_get_experiment_database(&hDB,NULL);
+
+  sprintf(odbtmp,"/Equipment/%s/Settings/Devices/MON/DD/Active_list",equipment[0].name);
+
+#ifdef MIDEBUG1
+  printf("  active_list ODB path is %s\n",odbtmp);
+#endif
+  if (db_set_value(hDB,0,odbtmp,tempstr,LIST_LENGTH,1,TID_STRING) != CM_SUCCESS){
+
+    cm_msg(MLOG,"mon_active_list","ERROR Writing MON/DD/Active_list to ODB!");
+    ret = CM_SET_ERROR;
+  }
+  return ret;
+}
+
+/*------------------------------------------------------------------*/
+INT dmm270x1_get_channellist(BOOL verbose) {
+/********************************************************************\
+
+  Routine:  dmm270x1_get_channellist
+
+  Purpose:  read dmm270x1 channel list from ODB
+
+  Input:
+    char *cmd        command to be executed
+    INT   runnumber  run number to be used
+    INT   runstate   run state to be used
+    char *icmd       invoking command
+
+  Output:
+    static int dmm270x1_channel_used[i=0,21]  is 1 for channels in
+                                              ChannelList
+
+  Function value:
+    INT              number of channels in ChannelList
+
+\********************************************************************/
+  static int  nreadings = 0;
+  static int  numchans = 0;
+  INT i;
+
+  if (nreadings > 120)
+    nreadings = 0;
+
+  if (nreadings == 0) {
+    HNDLE hDB,kchanlist;
+
+    numchans = -1;
+    cm_get_experiment_database(&hDB,NULL);
+    if (db_find_key(hDB,0,"/Equipment/dmm270x1/Settings/Devices/KEITHLEY_270X/DD"
+                            "/ChannelList", &kchanlist) == DB_SUCCESS) {
+      char channellist[64];
+      INT  size;
+
+      channellist[0] = '\0';
+      size = sizeof(channellist);
+      if (db_get_data(hDB, kchanlist, channellist, &size, TID_STRING) == DB_SUCCESS) {
+        char *pos,*pos1;
+#ifdef MIDEBUG
+        cm_msg(MLOG,"","channel list is >%s<", channellist);
+#endif
+        /* "0,2,;2." */
+        if ((pos = strchr(&channellist[0],';')) != NULL) {
+          if ((pos1 = strchr(pos,'.')) != NULL) {
+            INT tnum;
+
+            tnum = -1;
+            *pos1 = '\0';
+            if (sscanf(pos,";%d",&tnum) == 1) {
+              if (tnum >= 0) {
+                *(pos+1) = '\0';
+
+                for (i=0; i<22; i++)
+                  dmm270x1_channel_used[i] = 0;
+
+                pos = &channellist[0];
+                i = 0;
+decode_next:
+                if ((pos1 = strchr(pos,',')) != NULL) {
+                  INT tchani;
+
+                  if (sscanf(pos++,"%d,",&tchani) == 1) {
+                    if ((tchani >= 0) && (tchani < 22)) {
+                      i++;
+                      dmm270x1_channel_used[tchani] = 1;
+#ifdef MIDEBUG
+                      cm_msg(MLOG,"","dmm270x1 channel index %d is used",tchani);
+#endif
+                      pos = pos1+1;
+                      if ((*pos != ';') && (*pos != '\0')) goto decode_next;
+                      if (i == tnum) {
+                        numchans = tnum;
+                      } else {
+                        // if (verbose) NIY problem numchans does not match channellist
+                      }
+                    } else {
+                      // if (verbose) NIY problem channel index out of range
+                    }
+                  } else {
+                    // if (verbose) NIY problem reading channel index
+                  }
+                } else {
+                  // if (verbose) NIY problem reading channel index field terminator
+                }
+
+              } else {
+                if (verbose) cm_msg(MLOG,"","problem number of channels %d < 0",tnum);
+              }
+            } else {
+              if (verbose) cm_msg(MLOG,"","problem reading number of channels");
+            }
+          } else {
+            if (verbose) cm_msg(MLOG,"","problem finding . in channellist");
+          }
+        } else {
+          if (verbose) cm_msg(MLOG,"","problem finding ; in channellist");
+        }
+      } else {
+        if (verbose) cm_msg(MLOG,"","Failed to read /Equipment/dmm270x1/Settings/"
+                                    "Devices/KEITHLEY_270X/DD/ChannelList");
+      }
+
+    } else {
+      if (verbose) cm_msg(MLOG,"","Failed to find /Equipment/dmm270x1/Settings/Devices"
+                                  "/KEITHLEY_270X/DD/ChannelList");
+    }
+    if (numchans < 0) {
+      for (i=0; i<22; i++)
+        dmm270x1_channel_used[i] = 0;
+    }
+  }
+  nreadings++;
+
+  return numchans;
+}
+
+/*------------------------------------------------------------------*/
+
+INT mon_do (char *cmd, INT runnumber, INT runstate, char *icmd) {
+/********************************************************************\
+
+  Routine:  mon_do
+
+  Purpose:  execute monitor command
+
+  Input:
+    char *cmd        command to be executed
+    INT   runnumber  run number to be used
+    INT   runstate   run state to be used
+    char *icmd       invoking command
+
+  Output:
+    NONE
+
+  Function value:
+    INT                     SS_SUCCESS : Success
+
+\********************************************************************/
+
+  INT    status;
+  INT    cur_year;
+  INT    cur_month;
+  INT    cur_day;
+  time_t ti;
+  struct tm* lt;
+  char   tempstr[MAX_STRING_LENGTH];
+
+#ifdef MIDEBUG
+  printf(">> mon_do (%s,%4.4d,%d,%s)\n",(cmd==NULL)?"NULL":cmd,runnumber,runstate,
+                                        (icmd==NULL)?"NULL":icmd);
+#endif
+
+  status = CM_SUCCESS;
+
+  time(&ti);
+
+  if ((lt = localtime(&ti)) != NULL) {
+
+    cur_day   = lt->tm_mday;
+    cur_month = lt->tm_mon+1;
+    cur_year  = lt->tm_year+1900;
+
+    if (old_year  == -1) old_year  = cur_year;
+    if (old_month == -1) old_month = cur_month;
+    if (old_day   == -1) old_day   = cur_day;
+
+    /* date changed -> write end of day to yesterday's mon_file */
+    if ((old_year != cur_year)||(old_month != cur_month)||
+        (old_day  != cur_day)) {
+
+      if (mon_file_exists(old_year,old_month,old_day)) {
+        /* write last statistics of day */
+        mon_file_comment(old_year,old_month,old_day,
+                         "Statistics due to end of day.",runnumber);
+        mon_file_statistics(old_year,old_month,old_day,&smon,runnumber);
+        mon_file_comment(old_year,old_month,old_day,"End of day.",runnumber);
+      }
+
+      /* write statistics to top of today's mon_file */
+      if (!mon_file_exists(cur_year,cur_month,cur_day)) {
+        mon_file_comment(cur_year,cur_month,cur_day,
+                         "Statistics due to start of new day.",-1);
+        mon_file_statistics(cur_year,cur_month,cur_day,&smon,-1);
+      }
+
+      old_year  = cur_year;
+      old_month = cur_month;
+      old_day   = cur_day;
+    }
+#ifdef MIDEBUG2
+    printf(" %4.4d_%2.2d_%2.2d \n", cur_year, cur_month, cur_day);
+#endif
+    if ((cmd != NULL)&&(strlen(cmd)>0)) {
+      HNDLE hDB;
+
+      cm_get_experiment_database(&hDB,NULL);
+
+    /* -- INIT */
+      if     (strcmp(cmd,"INIT") == 0) {
+        HNDLE tkey,subkey;
+        INT i,nmdevs,nctc,ncdvm,ncltc1,ncls3360,ncls3361,ncheliox0;
+        INT ncvariox0,ncdmm270x1,nchvdistr3,nchvdistr4,ncliamp0,ncliamp1,ncliamp2;
+        KEY skey;
+
+        mon_tc_enabled = mon_dvm_enabled = mon_ltc1_enabled = mon_ls3360_enabled =
+        mon_ls3361_enabled = mon_heliox0_enabled = mon_variox0_enabled =
+        mon_dmm270x1_enabled = mon_hvdistr3_enabled = mon_hvdistr4_enabled = FALSE;
+        mon_lckinamp0_enabled = mon_lckinamp1_enabled = mon_lckinamp2_enabled = FALSE;
+
+        nctc=ncdvm=ncltc1=ncls3360=ncls3361=ncheliox0=ncvariox0=ncdmm270x1=
+        nchvdistr3=nchvdistr4=ncliamp0=ncliamp1=ncliamp2=0;
+
+        /* read info from ODB /Equipment/  */
+        if (db_find_key(hDB,0,"/Equipment",&tkey) == CM_SUCCESS) {
+
+          /* find subkeys in /Equipment */
+          for (i=0;;i++) {
+
+            /* process subkeys */
+            db_enum_key(hDB,tkey,i,&subkey);
+
+            if (subkey == 0) break; /* No more keys, terminate */
+
+            /* get subkey information */
+            db_get_key(hDB,subkey,&skey);
+
+            /* only process directory type sub keys */
+            if (skey.type != TID_KEY) continue;
+#ifdef MIDEBUG2
+            printf("Sub key = >%s<\n",skey.name);
+#endif
+            /* omit "MON" sub key */
+            if (equal_ustring(skey.name,"MON")) continue;
+
+            /* "TC" sub key contains temperature controller information */
+            if (equal_ustring(skey.name,"TC")) {
+              INT tcstate;
+#ifdef MIDEBUG2
+              printf("TC found \n");
+#endif
+              /* get state of TC */
+              if (db_get_int(hDB,"/Equipment/TC/Settings/Devices/TC/State",
+                  &tcstate,"TC state") == DB_SUCCESS) {
+                if (tcstate == 1) {
+                  /* get number number of TC channels */
+                  if (db_get_int(hDB,"/Equipment/TC/Settings/Channels/TC",
+                                 &nctc,"Number of TC channels") == DB_SUCCESS){
+                    if (nctc < 0) nctc = 0;
+#ifdef MIDEBUG1
+                    printf("Number of TC channels = %d\n",nctc);
+#endif
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR Reading number of TC channels");
+                  }
+                }
+              } else {
+                cm_msg(MERROR,"mon_do","ERROR Reading TC state");
+              }
+
+            /* "DVM" sub key contains digital voltmeter information */
+            } else if (equal_ustring(skey.name,"DVM")) {
+              INT dvmstate;
+#ifdef MIDEBUG2
+              printf("DVM found\n");
+#endif
+              /* get state of DVM */
+              if (db_get_int(hDB,"/Equipment/DVM/Settings/Devices/DVM/State",
+                  &dvmstate,"DVM state") == DB_SUCCESS) {
+                if (dvmstate == 1) {
+                  /* get number number of DVM channels */
+                  if (db_get_int(hDB,"/Equipment/DVM/Settings/Channels/DVM",
+                                 &ncdvm,"Number of DVM channels") == DB_SUCCESS){
+                    if (ncdvm < 0) ncdvm = 0;
+#ifdef MIDEBUG1
+                    printf("Number of DVM channels = %d\n",ncdvm);
+#endif
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR Reading number of DVM channels");
+                  }
+                }
+              } else {
+                cm_msg(MERROR,"mon_do","ERROR Reading DVM state");
+              }
+
+            /* Agilent E364xA */
+            } else if (equal_ustring(skey.name,"heflowag") ||
+                       equal_ustring(skey.name,"agamp0")   ||
+                       equal_ustring(skey.name,"agva0")    ||
+                       equal_ustring(skey.name,"agva1")    ||
+                       equal_ustring(skey.name,"agvolt0")  ||
+                       equal_ustring(skey.name,"tubehagil")) {
+              /* not handled here */
+            /* Keysight E3610xA */
+            } else if (equal_ustring(skey.name,"heflowks0") ||
+                       equal_ustring(skey.name,"ksamp0")   ||
+                       equal_ustring(skey.name,"ksva0")    ||
+                       equal_ustring(skey.name,"ksva1")    ||
+                       equal_ustring(skey.name,"ksvolt0")  ||
+                       equal_ustring(skey.name,"ksvolt1")  ||
+                       equal_ustring(skey.name,"tubehks")) {
+              /* not handled here */
+            /* EL734 */
+            } else if (equal_ustring(skey.name,"smel734")  ||
+                       equal_ustring(skey.name,"smel734n") ||
+                       equal_ustring(skey.name,"smel734o") ||
+                       equal_ustring(skey.name,"smngpd")) {
+              /* not handled here */
+            /* Stray Field */
+            } else if (equal_ustring(skey.name,"Stray Field") ||
+                       equal_ustring(skey.name,"stray_field")    )   {
+              /* not handled here */
+            /* ZFC */
+            } else if (equal_ustring(skey.name,"ZFC")) {
+              /* not handled here */
+            /* EXPMAG */
+            } else if (equal_ustring(skey.name,"expmag")) {
+              /* not handled here */
+            /* GOSSEN SSP120 */
+            } else if (equal_ustring(skey.name,"pzfcgssp")) {
+            /* GOSSEN SSP120 */
+            } else if (equal_ustring(skey.name,"tubehgssp")) {
+              /* not handled here */
+            /* Oxford ILM200 */
+            } else if (equal_ustring(skey.name,"ilm2000")) {
+              /* not handled here */
+            /* Oxford IPS120 */
+            } else if (equal_ustring(skey.name,"magnetips")) {
+              /* not handled here */
+            /* Keithley 19x */
+            } else if (equal_ustring(skey.name,"hallprobe")) {
+              /* not handled here */
+            /* Keithley 19x */
+            } else if (equal_ustring(skey.name,"samplete")) {
+              /* not handled here */
+            /* Lakeshore LS340 */
+            } else if (equal_ustring(skey.name,"templs0") ||
+                       equal_ustring(skey.name,"templs1")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"templs3360")) {
+              ncls3360 = 6; /* always handle sensor_1..sensor_4, heater1 & heater2 */
+            } else if (equal_ustring(skey.name,"templs3361")) {
+              ncls3361 = 6; /* always handle sensor_1..sensor_4, heater1 & heater2 */
+            /* Neocera LTCxx */
+            } else if (equal_ustring(skey.name,"templtc0")) {
+              ncltc1 = 4; /* always handle sensor_1, sensor_2, heater & analog */
+#ifdef MIDEBUG1
+              printf("Number of templtc0 channels = %d\n",ncltc1);
+#endif
+            /* Metrolab PT2025 */
+            } else if (equal_ustring(skey.name,"nmrprobe")) {
+              /* not handled here */
+            /* Pfeiffer RVC200 */
+            } else if (equal_ustring(skey.name,"flowr200")) {
+              /* not handled here */
+            /* Pfeiffer RVC300 */
+            } else if (equal_ustring(skey.name,"flowr300")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"dmm270x")||
+                       equal_ustring(skey.name,"dmm270x0")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"dmm270x1")) {
+
+              ncdmm270x1 = dmm270x1_get_channellist(TRUE);
+              if (ncdmm270x1 < 0) ncdmm270x1 = 0;
+
+            } else if (equal_ustring(skey.name,"mon1")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"mitc0")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"heliox0")) {
+
+              /* Heliox mercury heliox0 iTC sensors: HelioxX, Variox, HeHigh, HeLow, Sorb */
+              ncheliox0 = 5;
+
+            } else if (equal_ustring(skey.name,"variox0")) {
+
+              ncvariox0 = 2; /* Variox mercury variox0 iTC sensors: Variox, Sample */
+
+            } else if (equal_ustring(skey.name,"seats0")||
+                       equal_ustring(skey.name,"seats1")||
+                       equal_ustring(skey.name,"seats2")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"haloxmag0")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"tpg252a0")||
+                       equal_ustring(skey.name,"tpg3000")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"sis38200")||
+                       equal_ustring(skey.name,"sis38201")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"tdcv11900")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"cfdgpd0")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"pavs0")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"apcups0")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"ps01")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"hpx3000") ||
+                       equal_ustring(skey.name,"hpx3001") ||
+                       equal_ustring(skey.name,"hpx3002")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"lm5100")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"mitcpressc0")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"mitchlxprc0")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"ctm140")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"hlm20")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"tmard0")) {
+              /* not handled here */
+            } else if (equal_ustring(skey.name,"hvdistr3")) {
+              HNDLE t1key;
+              KEY tskey;
+
+              if (db_find_key(hDB, 0, "/Equipment/hvdistr3/Variables/Measured", &t1key)
+                  == DB_SUCCESS){
+                if (db_get_key(hDB, t1key, &tskey) == DB_SUCCESS) {
+                  if (tskey.num_values >= 1) nchvdistr3 = tskey.num_values;
+                } else {
+                  cm_msg(MLOG,"mon_do","ODB Key /Equipment/hvdistr3/Variables/Measured "
+                                       "ERROR reading KEY info");
+                }
+              } else {
+                cm_msg(MLOG,"mon_do","ODB Key /Equipment/hvdistr3/Variables/Measured "
+                                     "not found");
+              }
+            } else if (equal_ustring(skey.name,"hvdistr4")) {
+              HNDLE t1key;
+              KEY tskey;
+
+              if (db_find_key(hDB, 0, "/Equipment/hvdistr4/Variables/Measured", &t1key)
+                  == DB_SUCCESS){
+                if (db_get_key(hDB, t1key, &tskey) == DB_SUCCESS) {
+                  if (tskey.num_values >= 1) nchvdistr4 = tskey.num_values;
+                } else {
+                  cm_msg(MLOG,"mon_do","ODB Key /Equipment/hvdistr4/Variables/Measured "
+                                       "ERROR reading KEY info");
+                }
+              } else {
+                cm_msg(MLOG,"mon_do","ODB Key /Equipment/hvdistr4/Variables/Measured "
+                                     "not found");
+              }
+
+            } else if (equal_ustring(skey.name,"lckinamp0")) {
+              ncliamp0 = 10; // only the first 10 input parameter are logged
+
+            } else if (equal_ustring(skey.name,"lckinamp1")) {
+              ncliamp1 = 10; // only the first 10 input parameter are logged
+
+            } else if (equal_ustring(skey.name,"lckinamp2")) {
+              ncliamp2 = 10; // only the first 10 input parameter are logged
+
+            } else {
+              if ((strstr(skey.name,"pie") == NULL) && (strstr(skey.name,"vms") == NULL) &&
+                  (strstr(skey.name,"dolly") == NULL))
+              cm_msg(MLOG,"mon_do","WARNING Unknown Equipment >%s< in /Equipment/",
+                                   skey.name);
+            }
+
+          } /* for() Find subkeys in /Equipment */
+
+          /* get monitor setup information about monitored devices from ODB */
+          mon_device_list();
+
+          if (!mon_tc_enabled)       nctc       = 0;
+          if (!mon_dvm_enabled)      ncdvm      = 0;
+          if (!mon_ltc1_enabled)     ncltc1     = 0;
+          if (!mon_ls3360_enabled)   ncls3360   = 0;
+          if (!mon_ls3361_enabled)   ncls3361   = 0;
+          if (!mon_heliox0_enabled)  ncheliox0  = 0;
+          if (!mon_variox0_enabled)  ncvariox0  = 0;
+          if (!mon_dmm270x1_enabled) ncdmm270x1 = 0;
+          if (!mon_hvdistr3_enabled) nchvdistr3 = 0;
+          if (!mon_hvdistr4_enabled) nchvdistr4 = 0;
+          if (!mon_lckinamp0_enabled) ncliamp0  = 0;
+          if (!mon_lckinamp1_enabled) ncliamp1  = 0;
+          if (!mon_lckinamp2_enabled) ncliamp2  = 0;
+
+          /* get number of devices */
+          nmdevs = 0;
+          if (nctc       > 0) nmdevs++;      /* TC */
+          if (ncdvm      > 0) nmdevs++;      /* DVM */
+          if (ncltc1     > 0) nmdevs++;      /* templtc0 */
+          if (ncls3360   > 0) nmdevs++;      /* templs3360 */
+          if (ncls3361   > 0) nmdevs++;      /* templs3361 */
+          if (ncheliox0  > 0) nmdevs++;      /* heliox0 */
+          if (ncvariox0  > 0) nmdevs++;      /* variox0 */
+          if (ncdmm270x1 > 0) nmdevs++;      /* dmm270x1 */
+          if (nchvdistr3 > 0) nmdevs++;      /* hvdistr3 */
+          if (nchvdistr4 > 0) nmdevs++;      /* hvdistr4 */
+          if (ncliamp0   > 0) nmdevs++;      /* lckinamp0 */
+          if (ncliamp1   > 0) nmdevs++;      /* lckinamp1 */
+          if (ncliamp2   > 0) nmdevs++;      /* lckinamp2 */
+
+          mon_tc_active       = FALSE;
+          mon_dvm_active      = FALSE;
+          mon_ltc1_active     = FALSE;
+          mon_ls3360_active   = FALSE;
+          mon_ls3361_active   = FALSE;
+          mon_heliox0_active  = FALSE;
+          mon_variox0_active  = FALSE;
+          mon_dmm270x1_active = FALSE;
+          mon_hvdistr3_active = FALSE;
+          mon_hvdistr4_active = FALSE;
+          mon_lckinamp0_active = FALSE;
+          mon_lckinamp1_active = FALSE;
+          mon_lckinamp2_active = FALSE;
+
+          /* process devices */
+          if (nmdevs > 0) {
+
+            /* init MON data */
+            smon.Ndevs = nmdevs;
+
+            /* check for memory leak */
+            if (smon.pDevices != NULL)
+              cm_msg(MERROR,"mon_do","smon.pDevices != NULL : Memory leak!");
+
+            smon.pDevices = (MonDevicePtr *) calloc(smon.Ndevs,sizeof(MonDevicePtr));
+            if (smon.pDevices != NULL) {
+              MonDevicePtr pmondev;
+
+              nmdevs = 0;
+
+              /* any TC channels? */
+              if (nctc > 0) {
+
+                /* allocate data for TC */
+                pmondev = (MonDevicePtr) calloc(1,sizeof(MonDeviceRec));
+                if (pmondev != NULL) {
+                  float *pvalues;
+                  float *psetpoints;
+                  char  *pnames;
+                  INT   size,ret1,ret2;
+
+                  ret1 = CM_SUCCESS;
+
+                  pvalues    = NULL;
+                  psetpoints = NULL;
+                  pnames     = NULL;
+
+                  strcpy(pmondev->Name,"TC");
+                  pmondev->Nchans = nctc;
+
+                  pmondev->pChannels =
+                    (MonChannelPtr *) calloc(nctc,sizeof(MonChannelPtr));
+                  if (pmondev->pChannels != NULL) {
+                    for (i=0;i<nctc;i++) {
+                      *(pmondev->pChannels+i) =
+                        (MonChannelPtr) calloc(1,sizeof(MonChannelRec));
+                      if (*(pmondev->pChannels+i) == NULL) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Allocating MonChannelRec for channel %d",i);
+                        ret1 = SS_NO_MEMORY;
+                      }
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR Allocating array of MonChannelPtr");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  pmondev->pSetpointChannels = (double *) calloc(nctc,sizeof(double));
+                  if (pmondev->pSetpointChannels == NULL) {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Allocating array to hold Setpoint of channels");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  /* read Variables/Measured */
+                  ret2 = db_find_key(hDB,0,"/Equipment/TC/Variables/Measured",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pvalues = (float *) calloc(nctc,sizeof(float));
+                    if (pvalues != NULL) {
+                      size = nctc*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)pvalues,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Reading Measured Variable of TC channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                             "ERROR Allocating array to hold Measured of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                  "ERROR Finding Measured Variable of TC channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Variables/Setpoint */
+                  ret2 = db_find_key(hDB,0,"/Equipment/TC/Variables/Setpoint",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    psetpoints = (float *) calloc(nctc,sizeof(float));
+                    if (psetpoints != NULL) {
+                      size = nctc*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)psetpoints,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                                      "ERROR Reading Setpoint Variable of TC channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                                 "ERROR Allocating array to hold Setpoints of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                  "ERROR Finding Setpoint Variable of TC channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Settings/Names */
+                  ret2 = db_find_key(hDB,0,"/Equipment/TC/Settings/Names",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pnames = (char *) calloc(nctc,NAME_LENGTH);
+                    if (pnames != NULL) {
+                      size = nctc*NAME_LENGTH;
+                      ret2 = db_get_data(hDB,tkey,(void *)pnames,&size,TID_STRING);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                                      "ERROR Reading Settings Names of TC channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                                  "ERROR Allocating array to hold Names of TC channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                  "ERROR Finding Settings/Names of TC channels");
+                    ret1 = ret2;
+                  }
+
+                  if (ret1 == CM_SUCCESS) {
+
+                    mon_tc_active = TRUE;
+
+                    /* write info about TC device */
+                    sprintf(tempstr,"!");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!D  Device: TC, %d channels",nctc);
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!F       Channel : %-20.20s : Setpoint [K]",
+                            "Label");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    for (i=0;i<nctc;i++) {
+                      /* use readout value as offset */
+                      /* NOTE: INIT must therefore be called from BEGIN_RUN */
+                      (*(pmondev->pChannels+i))->Offset = *(pvalues+i);
+                      (*(pmondev->pChannels+i))->Nvals  = 0;
+                      (*(pmondev->pChannels+i))->Sum    = 0.0;
+                      (*(pmondev->pChannels+i))->Sum2   = 0.0;
+                      (*(pmondev->pChannels+i))->Mean   = 0.0;
+                      (*(pmondev->pChannels+i))->Devn   = 0.0;
+
+                      /* copy setpoint */
+                      *(pmondev->pSetpointChannels+i) = (double) *(psetpoints+i);
+
+                      /* copy labels */
+#ifdef MIDEBUG2
+                      printf("Name[%d] = >%s<\n",i,pnames+i*NAME_LENGTH);
+#endif
+                      strcpy((*(pmondev->pChannels+i))->Label,pnames+i*NAME_LENGTH);
+
+                      /* log info about labels */
+                      sprintf(tempstr,"!C            %2.2d : %-20.20s : %G",i,
+                              (*(pmondev->pChannels+i))->Label,
+                              *(pmondev->pSetpointChannels+i));
+                      mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+                    }
+
+                    *(smon.pDevices+nmdevs) = pmondev;
+                    nmdevs++;
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR During TC device init");
+                    mon_free_device(pmondev);
+                  }
+
+                  if (pvalues    != NULL) free(pvalues);
+                  if (psetpoints != NULL) free(psetpoints);
+                  if (pnames     != NULL) free(pnames);
+
+                } else {
+                  cm_msg(MERROR,"mon_do","ERROR Allocating MonDevRec for TC");
+                }
+              } /* any TC channels? */
+
+              /* any DVM channels? */
+              if (ncdvm > 0) {
+                /* allocate data for DVM */
+                pmondev = (MonDevicePtr) calloc(1,sizeof(MonDeviceRec));
+                if (pmondev != NULL) {
+                  float *pvalues;
+                  float *prawvalues;
+                  char  *pnames;
+                  INT   size,ret1,ret2;
+
+                  ret1 = CM_SUCCESS;
+
+                  pvalues    = NULL;
+                  prawvalues = NULL;
+                  pnames     = NULL;
+
+                  strcpy(pmondev->Name,"DVM");
+                  pmondev->Nchans = ncdvm;
+
+                  pmondev->pChannels    =
+                    (MonChannelPtr *) calloc(ncdvm,sizeof(MonChannelPtr));
+                  pmondev->pRawChannels =
+                    (MonChannelPtr *) calloc(ncdvm,sizeof(MonChannelPtr));
+                  if ((pmondev->pChannels != NULL)&&(pmondev->pRawChannels != NULL)) {
+                    for (i=0;i<ncdvm;i++) {
+                      *(pmondev->pChannels+i) =
+                        (MonChannelPtr) calloc(1,sizeof(MonChannelRec));
+                      if (*(pmondev->pChannels+i) == NULL) {
+                        cm_msg(MERROR,"mon_do",
+                                      "ERROR Allocating MonChannelRec for channel %d",i);
+                        ret1 = SS_NO_MEMORY;
+                      }
+                      *(pmondev->pRawChannels+i) =
+                        (MonChannelPtr) calloc(1,sizeof(MonChannelRec));
+                      if (*(pmondev->pRawChannels+i) == NULL) {
+                        cm_msg(MERROR,"mon_do",
+                                  "ERROR Allocating MonChannelRec for raw channel %d",i);
+                        ret1 = SS_NO_MEMORY;
+                      }
+                    }
+                  } else {
+                    if (pmondev->pChannels == NULL)
+                      cm_msg(MERROR,"mon_do",
+                             "ERROR Allocating array of MonChannelPtr for channel");
+                    if (pmondev->pRawChannels == NULL)
+                      cm_msg(MERROR,"mon_do",
+                             "ERROR Allocating array of MonChannelPtr for raw channel");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  /* read Variables/Measured */
+                  ret2 = db_find_key(hDB,0,"/Equipment/DVM/Variables/Measured",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pvalues = (float *) calloc(ncdvm,sizeof(float));
+                    if (pvalues != NULL) {
+                      size = ncdvm*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)pvalues,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Reading Measured Variable of DVM channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                             "ERROR Allocating array to hold Measured of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Finding Measured Variable of DVM channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Variables/RawMeasured */
+                  ret2 = db_find_key(hDB,0,"/Equipment/DVM/Variables/RawMeasured",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    prawvalues = (float *) calloc(ncdvm,sizeof(float));
+                    if (prawvalues != NULL) {
+                      size = ncdvm*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)prawvalues,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Reading RawMeasured Variable of DVM channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                             "ERROR Allocating array to hold RawMeasured of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Finding RawMeasured Variable of DVM channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Settings/Names */
+                  ret2 = db_find_key(hDB,0,"/Equipment/DVM/Settings/Names",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pnames = (char *) calloc(ncdvm,NAME_LENGTH);
+                    if (pnames != NULL) {
+                      size = ncdvm*NAME_LENGTH;
+                      ret2 = db_get_data(hDB,tkey,(void *)pnames,&size,TID_STRING);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                                      "ERROR Reading Settings Names of DVM channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                                    "ERROR Allocating array to hold Names of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                  "ERROR Finding Settings/Names of DVM channels");
+                    ret1 = ret2;
+                  }
+
+                  if (ret1 == CM_SUCCESS) {
+
+                    mon_dvm_active = TRUE;
+
+                    /* write info about DVM device */
+                    sprintf(tempstr,"!");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+                    sprintf(tempstr,"!D  Device: DVM, %d channels",ncdvm);
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!F       Channel : %-20.20s ","Label");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    for (i=0;i<ncdvm;i++) {
+
+                      /* use readout value as offset */
+                      /* NOTE: INIT must therefore be called from BEGIN_RUN */
+                      (*(pmondev->pChannels+i))->Offset = *(pvalues+i);
+                      (*(pmondev->pChannels+i))->Nvals  = 0;
+                      (*(pmondev->pChannels+i))->Sum    = 0.0;
+                      (*(pmondev->pChannels+i))->Sum2   = 0.0;
+                      (*(pmondev->pChannels+i))->Mean   = 0.0;
+                      (*(pmondev->pChannels+i))->Devn   = 0.0;
+
+                      /* use raw readout value as offset */
+                      /* NOTE: INIT must therefore be called from BEGIN_RUN */
+                      (*(pmondev->pRawChannels+i))->Offset = *(prawvalues+i);
+                      (*(pmondev->pRawChannels+i))->Nvals  = 0;
+                      (*(pmondev->pRawChannels+i))->Sum    = 0.0;
+                      (*(pmondev->pRawChannels+i))->Sum2   = 0.0;
+                      (*(pmondev->pRawChannels+i))->Mean   = 0.0;
+                      (*(pmondev->pRawChannels+i))->Devn   = 0.0;
+
+                      /* copy labels */
+#ifdef MIDEBUG2
+                      printf("Name[%d] = >%s<\n",i,pnames+i*NAME_LENGTH);
+#endif
+                      strcpy((*(pmondev->pChannels+i))->Label,pnames+i*NAME_LENGTH);
+                      strcpy((*(pmondev->pRawChannels+i))->Label,
+                             (*(pmondev->pChannels+i))->Label);
+                      strcat((*(pmondev->pRawChannels+i))->Label," (RAW)");
+
+                      /* log info about labels */
+                      sprintf(tempstr,"!C            %2.2d : %-20.20s",i,
+                              (*(pmondev->pChannels+i))->Label);
+                      mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+                    }
+
+                    *(smon.pDevices+nmdevs) = pmondev;
+                    nmdevs++;
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR During DVM device init");
+                    mon_free_device(pmondev);
+                  }
+
+                  if (pvalues    != NULL) free(pvalues);
+                  if (prawvalues != NULL) free(prawvalues);
+                  if (pnames     != NULL) free(pnames);
+
+                } else {
+                  cm_msg(MERROR,"mon_do","ERROR Allocating MonDevRec for DVM");
+                }
+              } /* any DVM channels? */
+
+              /* any templtc0 channels? */
+              if (ncltc1 > 0) {
+
+                /* allocate data for templtc0 */
+                pmondev = (MonDevicePtr) calloc(1,sizeof(MonDeviceRec));
+                if (pmondev != NULL) {
+                  float *pvalues;
+                  float *psetpoints;
+                  char  *pnames;
+                  INT   size,ret1,ret2;
+
+                  ret1 = CM_SUCCESS;
+
+                  pvalues    = NULL;
+                  psetpoints = NULL;
+                  pnames     = NULL;
+
+                  strcpy(pmondev->Name,"templtc0");
+                  pmondev->Nchans = ncltc1;
+
+                  pmondev->pChannels =
+                    (MonChannelPtr *) calloc(ncltc1,sizeof(MonChannelPtr));
+                  if (pmondev->pChannels != NULL) {
+                    for (i=0;i<ncltc1;i++) {
+                      *(pmondev->pChannels+i) =
+                        (MonChannelPtr) calloc(1,sizeof(MonChannelRec));
+                      if (*(pmondev->pChannels+i) == NULL) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Allocating MonChannelRec for channel %d",i);
+                        ret1 = SS_NO_MEMORY;
+                      }
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR Allocating array of MonChannelPtr");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  pmondev->pSetpointChannels = (double *) calloc(ncltc1,sizeof(double));
+                  if (pmondev->pSetpointChannels == NULL) {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Allocating array to hold Setpoint of channels");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  /* read Variables/Input */
+                  ret2 = db_find_key(hDB,0,"/Equipment/templtc0/Variables/Input",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pvalues = (float *) calloc(36,sizeof(float));
+                    if (pvalues != NULL) {
+                      size = 36*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)pvalues,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Reading Input Variable of templtc0 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                             "ERROR Allocating array to hold Input of templtc0 channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                  "ERROR Finding Input Variable of templtc0 channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Variables/Output */
+                  ret2 = db_find_key(hDB,0,"/Equipment/templtc0/Variables/Output",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    psetpoints = (float *) calloc(25,sizeof(float));
+                    if (psetpoints != NULL) {
+                      size = 25*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)psetpoints,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                                  "ERROR Reading Output Variable of templtc0 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                        "ERROR Allocating array to hold Output of templtc0 channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                  "ERROR Finding Output Variable of templtc0 channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Settings/Names */
+                  ret2 = db_find_key(hDB,0,"/Equipment/templtc0/Settings/Names Input",
+                                           &tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pnames = (char *) calloc(36,NAME_LENGTH);
+                    if (pnames != NULL) {
+                      size = 36*NAME_LENGTH;
+                      ret2 = db_get_data(hDB,tkey,(void *)pnames,&size,TID_STRING);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                             "ERROR Reading Settings Names Input of templtc0 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                      "ERROR Allocating array to hold Names Input of templtc0 channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                             "ERROR Finding Settings/Names Input of templtc0 channels");
+                    ret1 = ret2;
+                  }
+
+                  if (ret1 == CM_SUCCESS) {
+
+                    mon_ltc1_active = TRUE;
+
+                    /* write info about TC device */
+                    sprintf(tempstr,"!");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!D  Device: templtc0, %d channels",ncltc1);
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!F       Channel : %-20.20s : Setpoint [K]",
+                            "Label");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    for (i=0;i<ncltc1;i++) {
+                      /* use readout value as offset */
+                      /* NOTE: INIT must therefore be called from BEGIN_RUN */
+                      if        (i == 0) {
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+0);
+                        /* invalidate setpoint */
+                        *(pmondev->pSetpointChannels+i) = (double) -1;
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        printf("Name[%d] = >%s<\n",0,pnames+0*NAME_LENGTH);
+#endif
+                        strcpy((*(pmondev->pChannels+i))->Label,pnames+0*NAME_LENGTH);
+                      } else if (i == 1) {
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+1);
+                        /* invalidate setpoint */
+                        *(pmondev->pSetpointChannels+i) = (double) -1;
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        printf("Name[%d] = >%s<\n",1,pnames+1*NAME_LENGTH);
+#endif
+                        strcpy((*(pmondev->pChannels+i))->Label,pnames+1*NAME_LENGTH);
+                      } else if (i == 2) {
+                        if (*(pvalues+8) != 3.f) {
+                          (*(pmondev->pChannels+i))->Offset = *(pvalues+11);
+                          /* copy setpoint */
+                          *(pmondev->pSetpointChannels+i) = (double) *(psetpoints+1);
+                        } else {
+                          (*(pmondev->pChannels+i))->Offset = -1.f;
+                          /* invalidate setpoint */
+                          *(pmondev->pSetpointChannels+i) = (double) -1;
+                        }
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        printf("Name[%d] = >%s<\n",11,pnames+11*NAME_LENGTH);
+#endif
+                        strcpy((*(pmondev->pChannels+i))->Label,pnames+11*NAME_LENGTH);
+                      } else if (i == 3) {
+                        if (*(pvalues+17) != 3.f) {
+                          (*(pmondev->pChannels+i))->Offset = *(pvalues+19);
+                          /* copy setpoint */
+                          *(pmondev->pSetpointChannels+i) = (double) *(psetpoints+9);
+                        } else {
+                          (*(pmondev->pChannels+i))->Offset = -1.f;
+                          /* invalidate setpoint */
+                          *(pmondev->pSetpointChannels+i) = (double) -1;
+                        }
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        printf("Name[%d] = >%s<\n",19,pnames+19*NAME_LENGTH);
+#endif
+                        strcpy((*(pmondev->pChannels+i))->Label,pnames+19*NAME_LENGTH);
+                      }
+                      (*(pmondev->pChannels+i))->Nvals  = 0;
+                      (*(pmondev->pChannels+i))->Sum    = 0.0;
+                      (*(pmondev->pChannels+i))->Sum2   = 0.0;
+                      (*(pmondev->pChannels+i))->Mean   = 0.0;
+                      (*(pmondev->pChannels+i))->Devn   = 0.0;
+
+                      /* log info about labels */
+                      sprintf(tempstr,"!C            %2.2d : %-20.20s : %G",i,
+                              (*(pmondev->pChannels+i))->Label,
+                              *(pmondev->pSetpointChannels+i));
+                      mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+                    }
+
+                    *(smon.pDevices+nmdevs) = pmondev;
+                    nmdevs++;
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR During templtc0 device init");
+                    mon_free_device(pmondev);
+                  }
+
+                  if (pvalues    != NULL) free(pvalues);
+                  if (psetpoints != NULL) free(psetpoints);
+                  if (pnames     != NULL) free(pnames);
+
+                } else {
+                  cm_msg(MERROR,"mon_do","ERROR Allocating MonDevRec for templtc0");
+                }
+              } /* any templtc0 channels? */
+
+              /* any templs3360 channels? */
+              if (ncls3360 > 0) {
+
+                /* allocate data for templs3360 */
+                pmondev = (MonDevicePtr) calloc(1,sizeof(MonDeviceRec));
+                if (pmondev != NULL) {
+                  float *pvalues;
+                  float *psetpoints;
+                  char  *pnames;
+                  INT   size,ret1,ret2;
+
+                  ret1 = CM_SUCCESS;
+
+                  pvalues    = NULL;
+                  psetpoints = NULL;
+                  pnames     = NULL;
+
+                  strcpy(pmondev->Name,"templs3360");
+                  pmondev->Nchans = ncls3360;
+
+                  pmondev->pChannels =
+                    (MonChannelPtr *) calloc(ncls3360,sizeof(MonChannelPtr));
+                  if (pmondev->pChannels != NULL) {
+                    for (i=0;i<ncls3360;i++) {
+                      *(pmondev->pChannels+i) =
+                        (MonChannelPtr) calloc(1,sizeof(MonChannelRec));
+                      if (*(pmondev->pChannels+i) == NULL) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Allocating MonChannelRec for channel %d",i);
+                        ret1 = SS_NO_MEMORY;
+                      }
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR Allocating array of MonChannelPtr");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  pmondev->pSetpointChannels = (double *)calloc(ncls3360,sizeof(double));
+                  if (pmondev->pSetpointChannels == NULL) {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Allocating array to hold Setpoint of channels");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  /* read Variables/Input */
+                  ret2=db_find_key(hDB,0,"/Equipment/templs3360/Variables/Input",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pvalues = (float *) calloc(60,sizeof(float));
+                    if (pvalues != NULL) {
+                      size = 60*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)pvalues,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Reading Input Variable of templs3360 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                             "ERROR Allocating array to hold Input of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                  "ERROR Finding Input Variable of templs3360 channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Variables/Output */
+                  ret2=db_find_key(hDB,0,"/Equipment/templs3360/Variables/Output",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    psetpoints = (float *) calloc(36,sizeof(float));
+                    if (psetpoints != NULL) {
+                      size = 36*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)psetpoints,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                                 "ERROR Reading Output Variable of templs3360 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                                 "ERROR Allocating array to hold Output of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                 "ERROR Finding Output Variable of templs3360 channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Settings/Names */
+                  ret2 = db_find_key(hDB,0,"/Equipment/templs3360/Settings/Names Input",
+                                           &tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pnames = (char *) calloc(60,NAME_LENGTH);
+                    if (pnames != NULL) {
+                      size = 60*NAME_LENGTH;
+                      ret2 = db_get_data(hDB,tkey,(void *)pnames,&size,TID_STRING);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                            "ERROR Reading Settings Names Input of templs3360 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Allocating array to hold "
+                                              "Names Input of templs3360 channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                          "ERROR Finding Settings/Names Input of templs3360 channels");
+                    ret1 = ret2;
+                  }
+
+                  if (ret1 == CM_SUCCESS) {
+
+                    mon_ls3360_active = TRUE;
+
+                    /* write info about TC device */
+                    sprintf(tempstr,"!");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!D  Device: templs3360, %d channels",ncls3360);
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!F       Channel : %-20.20s : Setpoint [K]",
+                            "Label");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    for (i=0;i<ncls3360;i++) {
+                      /* use readout value as offset */
+                      /* NOTE: INIT must therefore be called from BEGIN_RUN */
+                      if        (i == 0) {
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+0);
+                        /* invalidate setpoint */
+                        *(pmondev->pSetpointChannels+i) = (double) -1;
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        printf("Name[%d] = >%s<\n",0,pnames+0*NAME_LENGTH);
+#endif
+                        strcpy((*(pmondev->pChannels+i))->Label,pnames+0*NAME_LENGTH);
+                      } else if (i == 1) {
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+1);
+                        /* invalidate setpoint */
+                        *(pmondev->pSetpointChannels+i) = (double) -1;
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        printf("Name[%d] = >%s<\n",1,pnames+1*NAME_LENGTH);
+#endif
+                        strcpy((*(pmondev->pChannels+i))->Label,pnames+1*NAME_LENGTH);
+                      } else if (i == 2) {
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+2);
+                        /* invalidate setpoint */
+                        *(pmondev->pSetpointChannels+i) = (double) -1;
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        printf("Name[%d] = >%s<\n",2,pnames+2*NAME_LENGTH);
+#endif
+                        strcpy((*(pmondev->pChannels+i))->Label,pnames+2*NAME_LENGTH);
+                      } else if (i == 3) {
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+3);
+                        /* invalidate setpoint */
+                        *(pmondev->pSetpointChannels+i) = (double) -1;
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        printf("Name[%d] = >%s<\n",3,pnames+3*NAME_LENGTH);
+#endif
+                        strcpy((*(pmondev->pChannels+i))->Label,pnames+3*NAME_LENGTH);
+                      } else if (i == 4) {
+                        if (*(pvalues+9) > 0.f) {
+                          (*(pmondev->pChannels+i))->Offset = *(pvalues+39);
+                          /* copy setpoint */
+                          *(pmondev->pSetpointChannels+i) = (double) *(psetpoints+1);
+                        } else {
+                          (*(pmondev->pChannels+i))->Offset = -1.f;
+                          /* invalidate setpoint */
+                          *(pmondev->pSetpointChannels+i) = (double) -1;
+                        }
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        printf("Name[%d] = >%s<\n",39,pnames+39*NAME_LENGTH);
+#endif
+                        strcpy((*(pmondev->pChannels+i))->Label,pnames+39*NAME_LENGTH);
+                      } else if (i == 5) {
+                        if (*(pvalues+18) > 0.f) {
+                          (*(pmondev->pChannels+i))->Offset = *(pvalues+40);
+                          /* copy setpoint */
+                          *(pmondev->pSetpointChannels+i) = (double) *(psetpoints+8);
+                        } else {
+                          (*(pmondev->pChannels+i))->Offset = -1.f;
+                          /* invalidate setpoint */
+                          *(pmondev->pSetpointChannels+i) = (double) -1;
+                        }
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        printf("Name[%d] = >%s<\n",40,pnames+40*NAME_LENGTH);
+#endif
+                        strcpy((*(pmondev->pChannels+i))->Label,pnames+40*NAME_LENGTH);
+                      }
+                      (*(pmondev->pChannels+i))->Nvals  = 0;
+                      (*(pmondev->pChannels+i))->Sum    = 0.0;
+                      (*(pmondev->pChannels+i))->Sum2   = 0.0;
+                      (*(pmondev->pChannels+i))->Mean   = 0.0;
+                      (*(pmondev->pChannels+i))->Devn   = 0.0;
+
+                      /* log info about labels */
+                      sprintf(tempstr,"!C            %2.2d : %-20.20s : %G",i,
+                              (*(pmondev->pChannels+i))->Label,
+                              *(pmondev->pSetpointChannels+i));
+                      mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+                    }
+
+                    *(smon.pDevices+nmdevs) = pmondev;
+                    nmdevs++;
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR During templs3360 device init");
+                    mon_free_device(pmondev);
+                  }
+
+                  if (pvalues    != NULL) free(pvalues);
+                  if (psetpoints != NULL) free(psetpoints);
+                  if (pnames     != NULL) free(pnames);
+
+                } else {
+                  cm_msg(MERROR,"mon_do","ERROR Allocating MonDevRec for templs3360");
+                }
+              } /* any templs3360 channels? */
+
+              /* any templs3361 channels? */
+              if (ncls3361 > 0) {
+
+                /* allocate data for templs3361 */
+                pmondev = (MonDevicePtr) calloc(1,sizeof(MonDeviceRec));
+                if (pmondev != NULL) {
+                  float *pvalues;
+                  float *psetpoints;
+                  char  *pnames;
+                  INT   size,ret1,ret2;
+
+                  ret1 = CM_SUCCESS;
+
+                  pvalues    = NULL;
+                  psetpoints = NULL;
+                  pnames     = NULL;
+
+                  strcpy(pmondev->Name,"templs3361");
+                  pmondev->Nchans = ncls3361;
+
+                  pmondev->pChannels =
+                    (MonChannelPtr *) calloc(ncls3361,sizeof(MonChannelPtr));
+                  if (pmondev->pChannels != NULL) {
+                    for (i=0;i<ncls3361;i++) {
+                      *(pmondev->pChannels+i) =
+                        (MonChannelPtr) calloc(1,sizeof(MonChannelRec));
+                      if (*(pmondev->pChannels+i) == NULL) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Allocating MonChannelRec for channel %d",i);
+                        ret1 = SS_NO_MEMORY;
+                      }
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR Allocating array of MonChannelPtr");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  pmondev->pSetpointChannels = (double *)calloc(ncls3361,sizeof(double));
+                  if (pmondev->pSetpointChannels == NULL) {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Allocating array to hold Setpoint of channels");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  /* read Variables/Input */
+                  ret2=db_find_key(hDB,0,"/Equipment/templs3361/Variables/Input",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pvalues = (float *) calloc(60,sizeof(float));
+                    if (pvalues != NULL) {
+                      size = 60*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)pvalues,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Reading Input Variable of templs3361 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                             "ERROR Allocating array to hold Input of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                  "ERROR Finding Input Variable of templs3361 channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Variables/Output */
+                  ret2=db_find_key(hDB,0,"/Equipment/templs3361/Variables/Output",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    psetpoints = (float *) calloc(36,sizeof(float));
+                    if (psetpoints != NULL) {
+                      size = 36*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)psetpoints,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                                 "ERROR Reading Output Variable of templs3361 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                                 "ERROR Allocating array to hold Output of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                 "ERROR Finding Output Variable of templs3361 channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Settings/Names */
+                  ret2 = db_find_key(hDB,0,"/Equipment/templs3361/Settings/Names Input",
+                                           &tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pnames = (char *) calloc(60,NAME_LENGTH);
+                    if (pnames != NULL) {
+                      size = 60*NAME_LENGTH;
+                      ret2 = db_get_data(hDB,tkey,(void *)pnames,&size,TID_STRING);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                            "ERROR Reading Settings Names Input of templs3361 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Allocating array to hold "
+                                              "Names Input of templs3361 channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                          "ERROR Finding Settings/Names Input of templs3361 channels");
+                    ret1 = ret2;
+                  }
+
+                  if (ret1 == CM_SUCCESS) {
+
+                    mon_ls3361_active = TRUE;
+
+                    /* write info about TC device */
+                    sprintf(tempstr,"!");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!D  Device: templs3361, %d channels",ncls3361);
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!F       Channel : %-20.20s : Setpoint [K]",
+                            "Label");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    for (i=0;i<ncls3361;i++) {
+                      /* use readout value as offset */
+                      /* NOTE: INIT must therefore be called from BEGIN_RUN */
+                      if        (i == 0) {
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+0);
+                        /* invalidate setpoint */
+                        *(pmondev->pSetpointChannels+i) = (double) -1;
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        printf("Name[%d] = >%s<\n",0,pnames+0*NAME_LENGTH);
+#endif
+                        strcpy((*(pmondev->pChannels+i))->Label,pnames+0*NAME_LENGTH);
+                      } else if (i == 1) {
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+1);
+                        /* invalidate setpoint */
+                        *(pmondev->pSetpointChannels+i) = (double) -1;
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        printf("Name[%d] = >%s<\n",1,pnames+1*NAME_LENGTH);
+#endif
+                        strcpy((*(pmondev->pChannels+i))->Label,pnames+1*NAME_LENGTH);
+                      } else if (i == 2) {
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+2);
+                        /* invalidate setpoint */
+                        *(pmondev->pSetpointChannels+i) = (double) -1;
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        printf("Name[%d] = >%s<\n",2,pnames+2*NAME_LENGTH);
+#endif
+                        strcpy((*(pmondev->pChannels+i))->Label,pnames+2*NAME_LENGTH);
+                      } else if (i == 3) {
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+3);
+                        /* invalidate setpoint */
+                        *(pmondev->pSetpointChannels+i) = (double) -1;
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        printf("Name[%d] = >%s<\n",3,pnames+3*NAME_LENGTH);
+#endif
+                        strcpy((*(pmondev->pChannels+i))->Label,pnames+3*NAME_LENGTH);
+                      } else if (i == 4) {
+                        if (*(pvalues+9) > 0.f) {
+                          (*(pmondev->pChannels+i))->Offset = *(pvalues+39);
+                          /* copy setpoint */
+                          *(pmondev->pSetpointChannels+i) = (double) *(psetpoints+1);
+                        } else {
+                          (*(pmondev->pChannels+i))->Offset = -1.f;
+                          /* invalidate setpoint */
+                          *(pmondev->pSetpointChannels+i) = (double) -1;
+                        }
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        printf("Name[%d] = >%s<\n",39,pnames+39*NAME_LENGTH);
+#endif
+                        strcpy((*(pmondev->pChannels+i))->Label,pnames+39*NAME_LENGTH);
+                      } else if (i == 5) {
+                        if (*(pvalues+18) > 0.f) {
+                          (*(pmondev->pChannels+i))->Offset = *(pvalues+40);
+                          /* copy setpoint */
+                          *(pmondev->pSetpointChannels+i) = (double) *(psetpoints+8);
+                        } else {
+                          (*(pmondev->pChannels+i))->Offset = -1.f;
+                          /* invalidate setpoint */
+                          *(pmondev->pSetpointChannels+i) = (double) -1;
+                        }
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        printf("Name[%d] = >%s<\n",40,pnames+40*NAME_LENGTH);
+#endif
+                        strcpy((*(pmondev->pChannels+i))->Label,pnames+40*NAME_LENGTH);
+                      }
+                      (*(pmondev->pChannels+i))->Nvals  = 0;
+                      (*(pmondev->pChannels+i))->Sum    = 0.0;
+                      (*(pmondev->pChannels+i))->Sum2   = 0.0;
+                      (*(pmondev->pChannels+i))->Mean   = 0.0;
+                      (*(pmondev->pChannels+i))->Devn   = 0.0;
+
+                      /* log info about labels */
+                      sprintf(tempstr,"!C            %2.2d : %-20.20s : %G",i,
+                              (*(pmondev->pChannels+i))->Label,
+                              *(pmondev->pSetpointChannels+i));
+                      mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+                    }
+
+                    *(smon.pDevices+nmdevs) = pmondev;
+                    nmdevs++;
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR During templs3361 device init");
+                    mon_free_device(pmondev);
+                  }
+
+                  if (pvalues    != NULL) free(pvalues);
+                  if (psetpoints != NULL) free(psetpoints);
+                  if (pnames     != NULL) free(pnames);
+
+                } else {
+                  cm_msg(MERROR,"mon_do","ERROR Allocating MonDevRec for templs3361");
+                }
+              } /* any templs3361 channels? */
+
+              /* any mercury heliox0 itc channels? */
+              if (ncheliox0 > 0) {
+
+                /* allocate data for mercury heliox0 itc */
+                pmondev = (MonDevicePtr) calloc(1,sizeof(MonDeviceRec));
+                if (pmondev != NULL) {
+                  float *pvalues;
+                  float *psetpoints;
+                  char  *pnames;
+                  INT   size,ret1,ret2;
+
+                  ret1 = CM_SUCCESS;
+
+                  pvalues    = NULL;
+                  psetpoints = NULL;
+                  pnames     = NULL;
+
+                  strcpy(pmondev->Name,"heliox0");
+                  pmondev->Nchans = ncheliox0;
+
+                  pmondev->pChannels =
+                    (MonChannelPtr *) calloc(ncheliox0,sizeof(MonChannelPtr));
+                  if (pmondev->pChannels != NULL) {
+                    for (i=0;i<ncheliox0;i++) {
+                      *(pmondev->pChannels+i) =
+                        (MonChannelPtr) calloc(1,sizeof(MonChannelRec));
+                      if (*(pmondev->pChannels+i) == NULL) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Allocating MonChannelRec for channel %d",i);
+                        ret1 = SS_NO_MEMORY;
+                      }
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR Allocating array of MonChannelPtr");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  pmondev->pSetpointChannels= (double *)calloc(ncheliox0,sizeof(double));
+                  if (pmondev->pSetpointChannels == NULL) {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Allocating array to hold Setpoint of channels");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  /* read Variables/Input */
+                  ret2=db_find_key(hDB,0,"/Equipment/heliox0/Variables/Input",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pvalues = (float *) calloc(44,sizeof(float)); // changed from 43 to 44 channels RA36 08-AUG-2023
+                    if (pvalues != NULL) {
+                      size = 44*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)pvalues,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Reading Input Variable of heliox0 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                             "ERROR Allocating array to hold Input of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                  "ERROR Finding Input Variable of heliox0 channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Variables/Output */
+                  ret2=db_find_key(hDB,0,"/Equipment/heliox0/Variables/Output",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    psetpoints = (float *) calloc(12,sizeof(float));
+                    if (psetpoints != NULL) {
+                      size = 12*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)psetpoints,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                                 "ERROR Reading Output Variable of heliox0 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                                 "ERROR Allocating array to hold Output of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                 "ERROR Finding Output Variable of heliox0 channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Settings/Names */
+#ifdef USE_MERCURY_ODB_NAMES
+                  ret2 = db_find_key(hDB,0,"/Equipment/heliox0/Settings/Names Input",
+                                           &tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pnames = (char *) calloc(44,NAME_LENGTH); // changed from 43 to 44 channels RA36 08-AUG-2023
+                    if (pnames != NULL) {
+                      size = 44*NAME_LENGTH;
+                      ret2 = db_get_data(hDB,tkey,(void *)pnames,&size,TID_STRING);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                            "ERROR Reading Settings Names Input of heliox0 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Allocating array to hold "
+                                              "Names Input of heliox0 channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do", "ERROR Finding Settings/Names Input of "
+                                            "heliox0 channels");
+                    ret1 = ret2;
+                  }
+#endif
+
+                  if (ret1 == CM_SUCCESS) {
+
+                    mon_heliox0_active = TRUE;
+
+                    /* write info about mercury heliox0 iTC device */
+                    sprintf(tempstr,"!");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!D  Device: heliox0, %d channels",ncheliox0);
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!F       Channel : %-20.20s : Setpoint [K]",
+                            "Label");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    /*
+                     * hardcoded channel numbers
+                     * should actually be read from
+                     * /Equipment/<device>/Settings/Devices/MITCin/DD/
+                     * SetChannelList for Temperature Setpoint (Output[]) channels and
+                     * ReadSChannelList for Sensor temperature (Input[]) channels
+                     *
+                     * heliox0   Input[] channel        Output[] Channel
+                     * Sensors   Sensor temperature     Temperature Setpoint
+                     * --------  -------------------    --------------------
+                     * HelioxX   10                     2
+                     * Variox    0                      1
+                     * HeHigh    24                     2 (same as HelioxX)
+                     * HeLow     31                     2 (same as HelioxX)
+                     * Sorb      17                     11
+                     *
+                     */
+
+                    for (i=0;i<ncheliox0;i++) {
+                      /* use readout value as offset */
+                      /* NOTE: INIT must therefore be called from BEGIN_RUN */
+                      if        (i == 0) {
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+10);
+                        /* copy setpoint */
+                        *(pmondev->pSetpointChannels+i) = (double) *(psetpoints+2);
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        if (pnames)
+                          printf("Name[%d] = >%s<\n",10,pnames+10*NAME_LENGTH);
+#endif
+                   //   strcpy((*(pmondev->pChannels+i))->Label,pnames+10*NAME_LENGTH);
+                        strcpy((*(pmondev->pChannels+i))->Label,"Heliox");
+                      } else if (i == 1) {
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+0);
+                        /* copy setpoint */
+                        *(pmondev->pSetpointChannels+i) = (double) *(psetpoints+1);
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        if (pnames) printf("Name[%d] = >%s<\n",0,pnames+0*NAME_LENGTH);
+#endif
+                 //     strcpy((*(pmondev->pChannels+i))->Label,pnames+0*NAME_LENGTH);
+                        strcpy((*(pmondev->pChannels+i))->Label,"Variox");
+                      } else if (i == 2) {
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+24);
+                        /* copy setpoint */
+                        *(pmondev->pSetpointChannels+i) = (double) *(psetpoints+2);
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        if (pnames)
+                          printf("Name[%d] = >%s<\n",24,pnames+24*NAME_LENGTH);
+#endif
+               //       strcpy((*(pmondev->pChannels+i))->Label,pnames+24*NAME_LENGTH);
+                        strcpy((*(pmondev->pChannels+i))->Label,"HeHigh");
+                      } else if (i == 3) {
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+31);
+                        /* copy setpoint */
+                        *(pmondev->pSetpointChannels+i) = (double) *(psetpoints+2);
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        if (pnames)
+                          printf("Name[%d] = >%s<\n",31,pnames+31*NAME_LENGTH);
+#endif
+              //        strcpy((*(pmondev->pChannels+i))->Label,pnames+31*NAME_LENGTH);
+                        strcpy((*(pmondev->pChannels+i))->Label,"HeLow");
+                      } else if (i == 4) {
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+17);
+                        /* copy setpoint */
+                        *(pmondev->pSetpointChannels+i) = (double) *(psetpoints+11);
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        if (pnames)
+                          printf("Name[%d] = >%s<\n",17,pnames+17*NAME_LENGTH);
+#endif
+                  //    strcpy((*(pmondev->pChannels+i))->Label,pnames+17*NAME_LENGTH);
+                        strcpy((*(pmondev->pChannels+i))->Label,"Sorb");
+                      }
+                      (*(pmondev->pChannels+i))->Nvals  = 0;
+                      (*(pmondev->pChannels+i))->Sum    = 0.0;
+                      (*(pmondev->pChannels+i))->Sum2   = 0.0;
+                      (*(pmondev->pChannels+i))->Mean   = 0.0;
+                      (*(pmondev->pChannels+i))->Devn   = 0.0;
+
+                      /* log info about labels */
+                      sprintf(tempstr,"!C            %2.2d : %-20.20s : %G",i,
+                              (*(pmondev->pChannels+i))->Label,
+                              *(pmondev->pSetpointChannels+i));
+                      mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+                    }
+
+                    *(smon.pDevices+nmdevs) = pmondev;
+                    nmdevs++;
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR During heliox0 device init");
+                    mon_free_device(pmondev);
+                  }
+
+                  if (pvalues    != NULL) free(pvalues);
+                  if (psetpoints != NULL) free(psetpoints);
+                  if (pnames     != NULL) free(pnames);
+
+                } else {
+                  cm_msg(MERROR,"mon_do",
+                                "ERROR Allocating MonDevRec for heliox0");
+                }
+              } /* any heliox0 itc channels? */
+
+              /* any mercury variox0 itc channels? */
+              if (ncvariox0 > 0) {
+
+                /* allocate data for mercury variox0 itc */
+                pmondev = (MonDevicePtr) calloc(1,sizeof(MonDeviceRec));
+                if (pmondev != NULL) {
+                  float *pvalues;
+                  float *psetpoints;
+                  char  *pnames;
+                  INT   size,ret1,ret2;
+
+                  ret1 = CM_SUCCESS;
+
+                  pvalues    = NULL;
+                  psetpoints = NULL;
+                  pnames     = NULL;
+
+                  strcpy(pmondev->Name,"variox0");
+                  pmondev->Nchans = ncvariox0;
+
+                  pmondev->pChannels =
+                    (MonChannelPtr *) calloc(ncvariox0,sizeof(MonChannelPtr));
+                  if (pmondev->pChannels != NULL) {
+                    for (i=0;i<ncvariox0;i++) {
+                      *(pmondev->pChannels+i) =
+                        (MonChannelPtr) calloc(1,sizeof(MonChannelRec));
+                      if (*(pmondev->pChannels+i) == NULL) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Allocating MonChannelRec for channel %d",i);
+                        ret1 = SS_NO_MEMORY;
+                      }
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR Allocating array of MonChannelPtr");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  pmondev->pSetpointChannels= (double *)calloc(ncvariox0,sizeof(double));
+                  if (pmondev->pSetpointChannels == NULL) {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Allocating array to hold Setpoint of channels");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  /* read Variables/Input */
+                  ret2=db_find_key(hDB,0,"/Equipment/variox0/Variables/Input",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pvalues = (float *) calloc(36,sizeof(float));
+                    if (pvalues != NULL) {
+                      size = 36*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)pvalues,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Reading Input Variable of variox0 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                             "ERROR Allocating array to hold Input of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                  "ERROR Finding Input Variable of variox0 channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Variables/Output */
+                  ret2=db_find_key(hDB,0,"/Equipment/variox0/Variables/Output",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    psetpoints = (float *) calloc(12,sizeof(float));
+                    if (psetpoints != NULL) {
+                      size = 12*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)psetpoints,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                                 "ERROR Reading Output Variable of variox0 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                                 "ERROR Allocating array to hold Output of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                 "ERROR Finding Output Variable of variox0 channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Settings/Names */
+#ifdef USE_MERCURY_ODB_NAMES
+                  ret2 = db_find_key(hDB,0,"/Equipment/variox0/Settings/Names Input",
+                                             &tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pnames = (char *) calloc(36,NAME_LENGTH);
+                    if (pnames != NULL) {
+                      size = 36*NAME_LENGTH;
+                      ret2 = db_get_data(hDB,tkey,(void *)pnames,&size,TID_STRING);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                            "ERROR Reading Settings Names Input of variox0 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Allocating array to hold "
+                                              "Names Input of variox0 channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do", "ERROR Finding Settings/Names Input of "
+                                            "variox0 channels");
+                    ret1 = ret2;
+                  }
+#endif
+
+                  if (ret1 == CM_SUCCESS) {
+
+                    mon_variox0_active = TRUE;
+
+                    /* write info about mercury variox0 iTC device */
+                    sprintf(tempstr,"!");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!D  Device: variox0, %d channels",ncvariox0);
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!F       Channel : %-20.20s : Setpoint [K]",
+                            "Label");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    /*
+                     * hardcoded channel numbers
+                     * should actually be read from
+                     * /Equipment/<device>/Settings/Devices/MITCin/DD/
+                     * SetChannelList for Temperature Setpoint (Output[]) channels and
+                     * ReadSChannelList for Sensor temperature (Input[]) channels
+                     *
+                     * variox0   Input[] channel        Output[] Channel
+                     * Sensors   Sensor temperature     Temperature Setpoint
+                     * --------  -------------------    --------------------
+                     * Variox    0                      1
+                     * Sample    11                     2
+                     *
+                     */
+
+                    for (i=0;i<ncvariox0;i++) {
+                      /* use readout value as offset */
+                      /* NOTE: INIT must therefore be called from BEGIN_RUN */
+                      if        (i == 0) {
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+0);
+                        /* copy setpoint */
+                        *(pmondev->pSetpointChannels+i) = (double) *(psetpoints+1);
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        if (pnames)
+                          printf("Name[%d] = >%s<\n",0,pnames+0*NAME_LENGTH);
+#endif
+                   //   strcpy((*(pmondev->pChannels+i))->Label,pnames+0*NAME_LENGTH);
+                        strcpy((*(pmondev->pChannels+i))->Label,"Variox");
+                      } else if (i == 1) {
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+11);
+                        *(pmondev->pSetpointChannels+i) = (double) *(psetpoints+2);
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        if (pnames)
+                          printf("Name[%d] = >%s<\n",11,pnames+11*NAME_LENGTH);
+#endif
+                 //     strcpy((*(pmondev->pChannels+i))->Label,pnames+11*NAME_LENGTH);
+                        strcpy((*(pmondev->pChannels+i))->Label,"Sample");
+                      }
+                      (*(pmondev->pChannels+i))->Nvals  = 0;
+                      (*(pmondev->pChannels+i))->Sum    = 0.0;
+                      (*(pmondev->pChannels+i))->Sum2   = 0.0;
+                      (*(pmondev->pChannels+i))->Mean   = 0.0;
+                      (*(pmondev->pChannels+i))->Devn   = 0.0;
+
+                      /* log info about labels */
+                      sprintf(tempstr,"!C            %2.2d : %-20.20s : %G",i,
+                              (*(pmondev->pChannels+i))->Label,
+                              *(pmondev->pSetpointChannels+i));
+                      mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+                    }
+
+                    *(smon.pDevices+nmdevs) = pmondev;
+                    nmdevs++;
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR During variox0 device init");
+                    mon_free_device(pmondev);
+                  }
+
+                  if (pvalues    != NULL) free(pvalues);
+                  if (psetpoints != NULL) free(psetpoints);
+                  if (pnames     != NULL) free(pnames);
+
+                } else {
+                  cm_msg(MERROR,"mon_do",
+                                "ERROR Allocating MonDevRec for variox0");
+                }
+              } /* any mercury variox0 itc channels? */
+
+              /* any dmm270x1 channels? */
+              if (ncdmm270x1 > 0) {
+
+                /* allocate data for dmm270x1 */
+                pmondev = (MonDevicePtr) calloc(1,sizeof(MonDeviceRec));
+                if (pmondev != NULL) {
+                  float *pvalues;
+                  char  *pnames;
+                  INT   size,ret1,ret2;
+
+                  ret1 = CM_SUCCESS;
+
+                  pvalues    = NULL;
+                  pnames     = NULL;
+
+                  strcpy(pmondev->Name,"dmm270x1");
+                  pmondev->Nchans = ncdmm270x1;
+
+                  pmondev->pChannels =
+                    (MonChannelPtr *) calloc(ncdmm270x1,sizeof(MonChannelPtr));
+                  if (pmondev->pChannels != NULL) {
+                    for (i=0;i<ncdmm270x1;i++) {
+                      *(pmondev->pChannels+i) =
+                        (MonChannelPtr) calloc(1,sizeof(MonChannelRec));
+                      if (*(pmondev->pChannels+i) == NULL) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Allocating MonChannelRec for channel %d",i);
+                        ret1 = SS_NO_MEMORY;
+                      }
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR Allocating array of MonChannelPtr");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  /* read Variables/Measured */
+                  ret2=db_find_key(hDB,0,"/Equipment/dmm270x1/Variables/Measured",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pvalues = (float *) calloc(22,sizeof(float));
+                    if (pvalues != NULL) {
+                      size = 22*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)pvalues,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Reading Measured Variable of dmm270x1 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                             "ERROR Allocating array to hold Measured of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                "ERROR Finding Measured Variable of dmm270x1 channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Settings/Names */
+                  ret2 = db_find_key(hDB,0,"/Equipment/dmm270x1/Settings/Names",
+                                           &tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pnames = (char *) calloc(22,NAME_LENGTH);
+                    if (pnames != NULL) {
+                      size = 22*NAME_LENGTH;
+                      ret2 = db_get_data(hDB,tkey,(void *)pnames,&size,TID_STRING);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                            "ERROR Reading Settings Names of dmm270x1 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Allocating array to hold "
+                                              "Names of dmm270x1 channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                          "ERROR Finding Settings/Names of dmm270x1 channels");
+                    ret1 = ret2;
+                  }
+
+                  if (ret1 == CM_SUCCESS) {
+                    INT ichan;
+
+                    mon_dmm270x1_active = TRUE;
+
+                    /* write info about TC device */
+                    sprintf(tempstr,"!");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!D  Device: dmm270x1, %d channels",ncdmm270x1);
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!F       Channel : %-20.20s ", "Label");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    ichan = -1;
+                    for (i=0;i<ncdmm270x1;i++) {
+                      /* find next used channel */
+                      for (ichan+=1;ichan < 22; ichan++) {
+                        if (dmm270x1_channel_used[ichan] != 0)
+                          break;
+                      }
+
+                      /* use readout value as offset */
+                      /* NOTE: INIT must therefore be called from BEGIN_RUN */
+                      if (ichan < 22) {
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+ichan);
+
+                        /* no setpoint */
+
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        printf("%d: Name[%d] = >%s<\n",i,ichan,pnames+ichan*NAME_LENGTH);
+#endif
+                       strcpy((*(pmondev->pChannels+i))->Label,pnames+ichan*NAME_LENGTH);
+                      } else {
+                        // NIY error used dmm270x1 channel index is out of range
+                      }
+
+                      (*(pmondev->pChannels+i))->Nvals  = 0;
+                      (*(pmondev->pChannels+i))->Sum    = 0.0;
+                      (*(pmondev->pChannels+i))->Sum2   = 0.0;
+                      (*(pmondev->pChannels+i))->Mean   = 0.0;
+                      (*(pmondev->pChannels+i))->Devn   = 0.0;
+
+                      /* log info about labels */
+                      sprintf(tempstr,"!C            %2.2d : %-20.20s ",i,
+                              (*(pmondev->pChannels+i))->Label);
+                      mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+                    }
+
+                    *(smon.pDevices+nmdevs) = pmondev;
+                    nmdevs++;
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR During dmm270x1 device init");
+                    mon_free_device(pmondev);
+                  }
+
+                  if (pvalues    != NULL) free(pvalues);
+                  if (pnames     != NULL) free(pnames);
+
+                } else {
+                  cm_msg(MERROR,"mon_do","ERROR Allocating MonDevRec for dmm270x1");
+                }
+              } /* any dmm270x1 channels? */
+
+              /* any hvdistr3 channels? */
+              if (nchvdistr3 > 0) {
+
+                /* allocate data for hvdistr3 */
+                pmondev = (MonDevicePtr) calloc(1,sizeof(MonDeviceRec));
+                if (pmondev != NULL) {
+                  float *pvalues;
+                  float *psetpoints;
+                  char  *pnames;
+                  INT   size,ret1,ret2;
+
+                  ret1 = CM_SUCCESS;
+
+                  pvalues    = NULL;
+                  psetpoints = NULL;
+                  pnames     = NULL;
+
+                  strcpy(pmondev->Name,"hvdistr3");
+                  pmondev->Nchans = nchvdistr3;
+
+                  pmondev->pChannels =
+                    (MonChannelPtr *) calloc(nchvdistr3,sizeof(MonChannelPtr));
+                  if (pmondev->pChannels != NULL) {
+                    for (i=0;i<nchvdistr3;i++) {
+                      *(pmondev->pChannels+i) =
+                        (MonChannelPtr) calloc(1,sizeof(MonChannelRec));
+                      if (*(pmondev->pChannels+i) == NULL) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Allocating MonChannelRec for channel %d",i);
+                        ret1 = SS_NO_MEMORY;
+                      }
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR Allocating array of MonChannelPtr");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  pmondev->pSetpointChannels=(double *)calloc(nchvdistr3,sizeof(double));
+                  if (pmondev->pSetpointChannels == NULL) {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Allocating array to hold Setpoint of channels");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  /* read Variables/Measured */
+                  ret2=db_find_key(hDB,0,"/Equipment/hvdistr3/Variables/Measured",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pvalues = (float *) calloc(nchvdistr3,sizeof(float));
+                    if (pvalues != NULL) {
+                      size = nchvdistr3*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)pvalues,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Reading Measured Variable of hvdistr3 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                             "ERROR Allocating array to hold Measured of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                 "ERROR Finding Measured Variable of hvdistr3 channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Variables/Demand */
+                  ret2=db_find_key(hDB,0,"/Equipment/hvdistr3/Variables/Demand",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    psetpoints = (float *) calloc(nchvdistr3,sizeof(float));
+                    if (psetpoints != NULL) {
+                      size = nchvdistr3*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)psetpoints,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                                 "ERROR Reading Demand Variable of hvdistr3 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                                 "ERROR Allocating array to hold Demand of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                 "ERROR Finding Demand Variable of hvdistr3 channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Settings/Names */
+                  ret2 = db_find_key(hDB,0,"/Equipment/hvdistr3/Settings/Names",
+                                           &tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pnames = (char *) calloc(nchvdistr3,NAME_LENGTH);
+                    if (pnames != NULL) {
+                      size = nchvdistr3*NAME_LENGTH;
+                      ret2 = db_get_data(hDB,tkey,(void *)pnames,&size,TID_STRING);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                            "ERROR Reading Settings Names of hvdistr3 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Allocating array to hold "
+                                              "Names of hvdistr3 channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                          "ERROR Finding Settings/Names of hvdistr3 channels");
+                    ret1 = ret2;
+                  }
+
+                  if (ret1 == CM_SUCCESS) {
+
+                    mon_hvdistr3_active = TRUE;
+
+                    /* write info about TC device */
+                    sprintf(tempstr,"!");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!D  Device: hvdistr3,   %d channels",nchvdistr3);
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!F       Channel : %-20.20s : Demand [V]",
+                                    "Name");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    for (i=0;i<nchvdistr3;i++) {
+                      (*(pmondev->pChannels+i))->Offset = *(pvalues+i);
+                      *(pmondev->pSetpointChannels+i) = (double) *(psetpoints+i);
+                      /* copy labels */
+#ifdef MIDEBUG2
+                      printf("Name[%d] = >%s<\n",i,pnames+i*NAME_LENGTH);
+#endif
+                      strcpy((*(pmondev->pChannels+i))->Label,pnames+i*NAME_LENGTH);
+                      (*(pmondev->pChannels+i))->Nvals  = 0;
+                      (*(pmondev->pChannels+i))->Sum    = 0.0;
+                      (*(pmondev->pChannels+i))->Sum2   = 0.0;
+                      (*(pmondev->pChannels+i))->Mean   = 0.0;
+                      (*(pmondev->pChannels+i))->Devn   = 0.0;
+
+                      /* log info about labels */
+                      sprintf(tempstr,"!C            %2.2d : %-20.20s : %G",i,
+                              (*(pmondev->pChannels+i))->Label,
+                              *(pmondev->pSetpointChannels+i));
+                      mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+                    }
+
+                    *(smon.pDevices+nmdevs) = pmondev;
+                    nmdevs++;
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR During hvdistr3 device init");
+                    mon_free_device(pmondev);
+                  }
+
+                  if (pvalues    != NULL) free(pvalues);
+                  if (psetpoints != NULL) free(psetpoints);
+                  if (pnames     != NULL) free(pnames);
+
+                } else {
+                  cm_msg(MERROR,"mon_do","ERROR Allocating MonDevRec for hvdistr3");
+                }
+              } /* any hvdistr3 channels? */
+
+              /* any hvdistr4 channels? */
+              if (nchvdistr4 > 0) {
+
+                /* allocate data for hvdistr4 */
+                pmondev = (MonDevicePtr) calloc(1,sizeof(MonDeviceRec));
+                if (pmondev != NULL) {
+                  float *pvalues;
+                  float *psetpoints;
+                  char  *pnames;
+                  INT   size,ret1,ret2;
+
+                  ret1 = CM_SUCCESS;
+
+                  pvalues    = NULL;
+                  psetpoints = NULL;
+                  pnames     = NULL;
+
+                  strcpy(pmondev->Name,"hvdistr4");
+                  pmondev->Nchans = nchvdistr4;
+
+                  pmondev->pChannels =
+                    (MonChannelPtr *) calloc(nchvdistr4,sizeof(MonChannelPtr));
+                  if (pmondev->pChannels != NULL) {
+                    for (i=0;i<nchvdistr4;i++) {
+                      *(pmondev->pChannels+i) =
+                        (MonChannelPtr) calloc(1,sizeof(MonChannelRec));
+                      if (*(pmondev->pChannels+i) == NULL) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Allocating MonChannelRec for channel %d",i);
+                        ret1 = SS_NO_MEMORY;
+                      }
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR Allocating array of MonChannelPtr");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  pmondev->pSetpointChannels=(double *)calloc(nchvdistr4,sizeof(double));
+                  if (pmondev->pSetpointChannels == NULL) {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Allocating array to hold Setpoint of channels");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  /* read Variables/Measured */
+                  ret2=db_find_key(hDB,0,"/Equipment/hvdistr4/Variables/Measured",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pvalues = (float *) calloc(nchvdistr4,sizeof(float));
+                    if (pvalues != NULL) {
+                      size = nchvdistr4*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)pvalues,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Reading Measured Variable of hvdistr4 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                             "ERROR Allocating array to hold Measured of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                "ERROR Finding Measured Variable of hvdistr4 channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Variables/Demand */
+                  ret2=db_find_key(hDB,0,"/Equipment/hvdistr4/Variables/Demand",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    psetpoints = (float *) calloc(nchvdistr4,sizeof(float));
+                    if (psetpoints != NULL) {
+                      size = nchvdistr4*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)psetpoints,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                                 "ERROR Reading Demand Variable of hvdistr4 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                                 "ERROR Allocating array to hold Demand of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                 "ERROR Finding Demand Variable of hvdistr4 channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Settings/Names */
+                  ret2 = db_find_key(hDB,0,"/Equipment/hvdistr4/Settings/Names",
+                                           &tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pnames = (char *) calloc(nchvdistr4,NAME_LENGTH);
+                    if (pnames != NULL) {
+                      size = nchvdistr4*NAME_LENGTH;
+                      ret2 = db_get_data(hDB,tkey,(void *)pnames,&size,TID_STRING);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                            "ERROR Reading Settings Names of hvdistr4 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Allocating array to hold "
+                                              "Names of hvdistr4 channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                          "ERROR Finding Settings/Names of hvdistr4 channels");
+                    ret1 = ret2;
+                  }
+
+                  if (ret1 == CM_SUCCESS) {
+
+                    mon_hvdistr4_active = TRUE;
+
+                    /* write info about hvdistr4 device */
+                    sprintf(tempstr,"!");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!D  Device: hvdistr4,   %d channels",nchvdistr4);
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!F       Channel : %-20.20s : Demand [V]",
+                                    "Name");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    for (i=0;i<nchvdistr4;i++) {
+                      (*(pmondev->pChannels+i))->Offset = *(pvalues+i);
+                      *(pmondev->pSetpointChannels+i) = (double) *(psetpoints+i);
+                      /* copy labels */
+#ifdef MIDEBUG2
+                      printf("Name[%d] = >%s<\n",i,pnames+i*NAME_LENGTH);
+#endif
+                      strcpy((*(pmondev->pChannels+i))->Label,pnames+i*NAME_LENGTH);
+                      (*(pmondev->pChannels+i))->Nvals  = 0;
+                      (*(pmondev->pChannels+i))->Sum    = 0.0;
+                      (*(pmondev->pChannels+i))->Sum2   = 0.0;
+                      (*(pmondev->pChannels+i))->Mean   = 0.0;
+                      (*(pmondev->pChannels+i))->Devn   = 0.0;
+
+                      /* log info about labels */
+                      sprintf(tempstr,"!C            %2.2d : %-20.20s : %G",i,
+                              (*(pmondev->pChannels+i))->Label,
+                              *(pmondev->pSetpointChannels+i));
+                      mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+                    }
+
+                    *(smon.pDevices+nmdevs) = pmondev;
+                    nmdevs++;
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR During hvdistr4 device init");
+                    mon_free_device(pmondev);
+                  }
+
+                  if (pvalues    != NULL) free(pvalues);
+                  if (psetpoints != NULL) free(psetpoints);
+                  if (pnames     != NULL) free(pnames);
+
+                } else {
+                  cm_msg(MERROR,"mon_do","ERROR Allocating MonDevRec for hvdistr4");
+                }
+              } /* any hvdistr4 channels? */
+
+              /* any lckinamp0 channels? */
+              if (ncliamp0 > 0) {
+
+                /* allocate data for lckinamp0 */
+                pmondev = (MonDevicePtr) calloc(1,sizeof(MonDeviceRec));
+                if (pmondev != NULL) {
+                  float *pvalues;
+                  char  *pnames;
+                  INT   size,ret1,ret2;
+
+                  ret1 = CM_SUCCESS;
+
+                  pvalues    = NULL;
+                  pnames     = NULL;
+
+                  strcpy(pmondev->Name,"lckinamp0");
+                  pmondev->Nchans = ncliamp0;
+
+                  pmondev->pChannels =
+                    (MonChannelPtr *) calloc(ncliamp0,sizeof(MonChannelPtr));
+                  if (pmondev->pChannels != NULL) {
+                    for (i=0;i<ncliamp0;i++) {
+                      *(pmondev->pChannels+i) =
+                        (MonChannelPtr) calloc(1,sizeof(MonChannelRec));
+                      if (*(pmondev->pChannels+i) == NULL) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Allocating MonChannelRec for channel %d",i);
+                        ret1 = SS_NO_MEMORY;
+                      }
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR Allocating array of MonChannelPtr");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  /* read Variables/Measured */
+                  ret2=db_find_key(hDB,0,"/Equipment/lckinamp0/Variables/Input",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pvalues = (float *) calloc(41,sizeof(float));
+                    if (pvalues != NULL) {
+                      size = 41*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)pvalues,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Reading Input Variable of lckinamp0 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                             "ERROR Allocating array to hold Input of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                "ERROR Finding Input Variable of lckinamp0 channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Settings/Names */
+                  ret2 = db_find_key(hDB,0,"/Equipment/lckinamp0/Settings/Names Input",
+                                           &tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pnames = (char *) calloc(41,NAME_LENGTH);
+                    if (pnames != NULL) {
+                      size = 41*NAME_LENGTH;
+                      ret2 = db_get_data(hDB,tkey,(void *)pnames,&size,TID_STRING);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                            "ERROR Reading Settings Names Input of lckinamp0 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Allocating array to hold "
+                                              "Names Input of lckinamp0 channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                          "ERROR Finding Settings/Names Input of lckinamp0 channels");
+                    ret1 = ret2;
+                  }
+
+                  if (ret1 == CM_SUCCESS) {
+
+                    mon_lckinamp0_active = TRUE;
+
+                    /* write info about lockin amplifier device */
+                    sprintf(tempstr,"!");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!D  Device: lckinamp0, %d channels",ncliamp0);
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!F       Channel : %-20.20s ", "Label");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    for (i=0;i<ncliamp0;i++) {
+
+                      /* use readout value as offset */
+                      /* NOTE: INIT must therefore be called from BEGIN_RUN */
+                   
+                      if (i < 10) { // only first 10 channels monitored
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+i);
+
+                        /* no setpoint */
+
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        printf("%d: Name[%d] = >%s<\n",i,i,pnames+i*NAME_LENGTH);
+#endif
+                       strcpy((*(pmondev->pChannels+i))->Label,pnames+i*NAME_LENGTH);
+                      } else {
+                        // NIY error used lckinamp0 channel index is out of range
+                      }
+
+                      (*(pmondev->pChannels+i))->Nvals  = 0;
+                      (*(pmondev->pChannels+i))->Sum    = 0.0;
+                      (*(pmondev->pChannels+i))->Sum2   = 0.0;
+                      (*(pmondev->pChannels+i))->Mean   = 0.0;
+                      (*(pmondev->pChannels+i))->Devn   = 0.0;
+
+                      /* log info about labels */
+                      sprintf(tempstr,"!C            %2.2d : %-20.20s ",i,
+                              (*(pmondev->pChannels+i))->Label);
+                      mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+                    }
+
+                    *(smon.pDevices+nmdevs) = pmondev;
+                    nmdevs++;
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR During lckinamp0 device init");
+                    mon_free_device(pmondev);
+                  }
+
+                  if (pvalues    != NULL) free(pvalues);
+                  if (pnames     != NULL) free(pnames);
+
+                } else {
+                  cm_msg(MERROR,"mon_do","ERROR Allocating MonDevRec for lckinamp0");
+                }
+              } /* any lckinamp0 channels? */
+
+              /* any lckinamp1 channels? */
+              if (ncliamp1 > 0) {
+
+                /* allocate data for lckinamp1 */
+                pmondev = (MonDevicePtr) calloc(1,sizeof(MonDeviceRec));
+                if (pmondev != NULL) {
+                  float *pvalues;
+                  char  *pnames;
+                  INT   size,ret1,ret2;
+
+                  ret1 = CM_SUCCESS;
+
+                  pvalues    = NULL;
+                  pnames     = NULL;
+
+                  strcpy(pmondev->Name,"lckinamp1");
+                  pmondev->Nchans = ncliamp1;
+
+                  pmondev->pChannels =
+                    (MonChannelPtr *) calloc(ncliamp1,sizeof(MonChannelPtr));
+                  if (pmondev->pChannels != NULL) {
+                    for (i=0;i<ncliamp1;i++) {
+                      *(pmondev->pChannels+i) =
+                        (MonChannelPtr) calloc(1,sizeof(MonChannelRec));
+                      if (*(pmondev->pChannels+i) == NULL) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Allocating MonChannelRec for channel %d",i);
+                        ret1 = SS_NO_MEMORY;
+                      }
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR Allocating array of MonChannelPtr");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  /* read Variables/Measured */
+                  ret2=db_find_key(hDB,0,"/Equipment/lckinamp1/Variables/Input",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pvalues = (float *) calloc(41,sizeof(float));
+                    if (pvalues != NULL) {
+                      size = 41*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)pvalues,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Reading Input Variable of lckinamp1 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                             "ERROR Allocating array to hold Input of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                "ERROR Finding Input Variable of lckinamp1 channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Settings/Names */
+                  ret2 = db_find_key(hDB,0,"/Equipment/lckinamp1/Settings/Names Input",
+                                           &tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pnames = (char *) calloc(41,NAME_LENGTH);
+                    if (pnames != NULL) {
+                      size = 41*NAME_LENGTH;
+                      ret2 = db_get_data(hDB,tkey,(void *)pnames,&size,TID_STRING);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                            "ERROR Reading Settings Names Input of lckinamp1 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Allocating array to hold "
+                                              "Names Input of lckinamp1 channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                          "ERROR Finding Settings/Names Input of lckinamp1 channels");
+                    ret1 = ret2;
+                  }
+
+                  if (ret1 == CM_SUCCESS) {
+
+                    mon_lckinamp1_active = TRUE;
+
+                    /* write info about lockin amplifier device */
+                    sprintf(tempstr,"!");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!D  Device: lckinamp1, %d channels",ncliamp1);
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!F       Channel : %-20.20s ", "Label");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    for (i=0;i<ncliamp1;i++) {
+
+                      /* use readout value as offset */
+                      /* NOTE: INIT must therefore be called from BEGIN_RUN */
+                   
+                      if (i < 10) { // only first 10 channels monitored
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+i);
+
+                        /* no setpoint */
+
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        printf("%d: Name[%d] = >%s<\n",i,i,pnames+i*NAME_LENGTH);
+#endif
+                       strcpy((*(pmondev->pChannels+i))->Label,pnames+i*NAME_LENGTH);
+                      } else {
+                        // NIY error used lckinamp1 channel index is out of range
+                      }
+
+                      (*(pmondev->pChannels+i))->Nvals  = 0;
+                      (*(pmondev->pChannels+i))->Sum    = 0.0;
+                      (*(pmondev->pChannels+i))->Sum2   = 0.0;
+                      (*(pmondev->pChannels+i))->Mean   = 0.0;
+                      (*(pmondev->pChannels+i))->Devn   = 0.0;
+
+                      /* log info about labels */
+                      sprintf(tempstr,"!C            %2.2d : %-20.20s ",i,
+                              (*(pmondev->pChannels+i))->Label);
+                      mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+                    }
+
+                    *(smon.pDevices+nmdevs) = pmondev;
+                    nmdevs++;
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR During lckinamp1 device init");
+                    mon_free_device(pmondev);
+                  }
+
+                  if (pvalues    != NULL) free(pvalues);
+                  if (pnames     != NULL) free(pnames);
+
+                } else {
+                  cm_msg(MERROR,"mon_do","ERROR Allocating MonDevRec for lckinamp1");
+                }
+              } /* any lckinamp1 channels? */
+
+              /* any lckinamp2 channels? */
+              if (ncliamp2 > 0) {
+
+                /* allocate data for lckinamp2 */
+                pmondev = (MonDevicePtr) calloc(1,sizeof(MonDeviceRec));
+                if (pmondev != NULL) {
+                  float *pvalues;
+                  char  *pnames;
+                  INT   size,ret1,ret2;
+
+                  ret1 = CM_SUCCESS;
+
+                  pvalues    = NULL;
+                  pnames     = NULL;
+
+                  strcpy(pmondev->Name,"lckinamp2");
+                  pmondev->Nchans = ncliamp2;
+
+                  pmondev->pChannels =
+                    (MonChannelPtr *) calloc(ncliamp2,sizeof(MonChannelPtr));
+                  if (pmondev->pChannels != NULL) {
+                    for (i=0;i<ncliamp2;i++) {
+                      *(pmondev->pChannels+i) =
+                        (MonChannelPtr) calloc(1,sizeof(MonChannelRec));
+                      if (*(pmondev->pChannels+i) == NULL) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Allocating MonChannelRec for channel %d",i);
+                        ret1 = SS_NO_MEMORY;
+                      }
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR Allocating array of MonChannelPtr");
+                    ret1 = SS_NO_MEMORY;
+                  }
+
+                  /* read Variables/Measured */
+                  ret2=db_find_key(hDB,0,"/Equipment/lckinamp2/Variables/Input",&tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pvalues = (float *) calloc(41,sizeof(float));
+                    if (pvalues != NULL) {
+                      size = 41*sizeof(float);
+                      ret2 = db_get_data(hDB,tkey,(void *)pvalues,&size,TID_FLOAT);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                               "ERROR Reading Input Variable of lckinamp2 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                             "ERROR Allocating array to hold Input of channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                                "ERROR Finding Input Variable of lckinamp2 channels");
+                    ret1 = ret2;
+                  }
+
+                  /* read Settings/Names */
+                  ret2 = db_find_key(hDB,0,"/Equipment/lckinamp2/Settings/Names Input",
+                                           &tkey);
+                  if (ret2 == CM_SUCCESS) {
+                    pnames = (char *) calloc(41,NAME_LENGTH);
+                    if (pnames != NULL) {
+                      size = 41*NAME_LENGTH;
+                      ret2 = db_get_data(hDB,tkey,(void *)pnames,&size,TID_STRING);
+                      if (ret2 != CM_SUCCESS) {
+                        cm_msg(MERROR,"mon_do",
+                            "ERROR Reading Settings Names Input of lckinamp2 channels");
+                        ret1 = ret2;
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Allocating array to hold "
+                                              "Names Input of lckinamp2 channels");
+                      ret1 = SS_NO_MEMORY;
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                          "ERROR Finding Settings/Names Input of lckinamp2 channels");
+                    ret1 = ret2;
+                  }
+
+                  if (ret1 == CM_SUCCESS) {
+
+                    mon_lckinamp2_active = TRUE;
+
+                    /* write info about lockin amplifier device */
+                    sprintf(tempstr,"!");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!D  Device: lckinamp2, %d channels",ncliamp0);
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    sprintf(tempstr,"!F       Channel : %-20.20s ", "Label");
+                    mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+                    for (i=0;i<ncliamp2;i++) {
+
+                      /* use readout value as offset */
+                      /* NOTE: INIT must therefore be called from BEGIN_RUN */
+                   
+                      if (i < 10) { // only first 10 channels monitored
+                        (*(pmondev->pChannels+i))->Offset = *(pvalues+i);
+
+                        /* no setpoint */
+
+                        /* copy labels */
+#ifdef MIDEBUG2
+                        printf("%d: Name[%d] = >%s<\n",i,i,pnames+i*NAME_LENGTH);
+#endif
+                       strcpy((*(pmondev->pChannels+i))->Label,pnames+i*NAME_LENGTH);
+                      } else {
+                        // NIY error used lckinamp2 channel index is out of range
+                      }
+
+                      (*(pmondev->pChannels+i))->Nvals  = 0;
+                      (*(pmondev->pChannels+i))->Sum    = 0.0;
+                      (*(pmondev->pChannels+i))->Sum2   = 0.0;
+                      (*(pmondev->pChannels+i))->Mean   = 0.0;
+                      (*(pmondev->pChannels+i))->Devn   = 0.0;
+
+                      /* log info about labels */
+                      sprintf(tempstr,"!C            %2.2d : %-20.20s ",i,
+                              (*(pmondev->pChannels+i))->Label);
+                      mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+                    }
+
+                    *(smon.pDevices+nmdevs) = pmondev;
+                    nmdevs++;
+                  } else {
+                    cm_msg(MERROR,"mon_do","ERROR During lckinamp2 device init");
+                    mon_free_device(pmondev);
+                  }
+
+                  if (pvalues    != NULL) free(pvalues);
+                  if (pnames     != NULL) free(pnames);
+
+                } else {
+                  cm_msg(MERROR,"mon_do","ERROR Allocating MonDevRec for lckinamp2");
+                }
+              } /* any lckinamp2 channels? */
+
+              sprintf(tempstr,"!");
+              mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+              sprintf(tempstr,"!EOB");
+              mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+              sprintf(tempstr,"!");
+              mon_file_text(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+              /* check number of devices and number of initialised devices */
+              if (nmdevs != smon.Ndevs)
+                cm_msg(MERROR,"mon_do",
+                       "Number of found devices %d in /Equipment/ <> number of initiali"
+                       "sed devices %d", smon.Ndevs,nmdevs);
+
+              /* enable statistics here to get an average value
+               * even if a run is not started */
+              mon_do_statistics = TRUE;
+
+            } else {
+              cm_msg(MERROR,"mon_do","ERROR Allocating array of MonDevicePtr");
+            }
+          } else {
+            if (n_reg_devices > 0)
+              cm_msg(MLOG,"mon_do","Nothing to monitor or Equipment not found?");
+            else
+              cm_msg(MLOG,"mon_do","Nothing to monitor?");
+          }
+        } else {
+          cm_msg(MERROR,"mon_do","ERROR Getting ODB key /Equipment ");
+        }
+
+    /* -- FREE */
+      } else if (strcmp(cmd,"FREE") == 0) {
+
+        if ((smon.Ndevs > 0) && (smon.pDevices != NULL)) {
+          INT idev;
+
+          /* for all devices */
+          for (idev=0; idev < smon.Ndevs; idev++) {
+
+            mon_free_device(*(smon.pDevices+idev));
+            *(smon.pDevices+idev) = NULL;
+
+          } /* for all devices */
+
+        }
+
+        if (smon.pDevices != NULL) free(smon.pDevices);
+
+        smon.Ndevs    = 0;
+        smon.pDevices = NULL;
+
+    /* -- MON_INIT */
+      } else if (strcmp(cmd,"MON_INIT") == 0) {
+
+        if ((icmd != NULL) && (strcmp(icmd,"MON_INIT")!=0)) {
+          sprintf(tempstr,"Monitor restart due to %s.", icmd);
+          mon_file_comment(cur_year,cur_month,cur_day,tempstr,runnumber);
+        }
+
+        if ((smon.Ndevs != 0) && (smon.pDevices != NULL))
+          mon_do("FREE",runnumber,runstate,"MON_INIT");
+
+        if ((smon.Ndevs == 0) || (smon.pDevices == NULL))
+          mon_do("INIT",runnumber,runstate,"MON_INIT");
+
+        mon_file_comment(cur_year,cur_month,cur_day,"Monitor init.",runnumber);
+
+   /* -- MON_EXIT */
+      } else if (strcmp(cmd,"MON_EXIT") == 0) {
+
+        /* disable calculation of mean & std deviation */
+        mon_do_statistics = FALSE;
+
+        /* free mon allocations */
+        mon_do("FREE",runnumber,runstate,"MON_EXIT");
+
+        mon_file_comment(cur_year,cur_month,cur_day,"Monitor exit.",runnumber);
+
+   /* -- BEGIN_RUN */
+      } else if (strcmp(cmd,"BEGIN_RUN") == 0) {
+
+        /* write (old) statistics to mon file */
+        if ((smon.pDevices != NULL) && (smon.Ndevs>0)) {
+          sprintf(tempstr,"Statistics due to begin of run %d.",runnumber);
+          mon_file_comment(cur_year,cur_month,cur_day,tempstr,-1);
+          mon_file_statistics(cur_year,cur_month,cur_day,&smon,-1);
+        }
+
+        /* set start time */
+        time(&start_of_run_time);
+
+        if ((icmd != NULL) && (strcmp(icmd,"MON_INIT")==0))
+          sprintf(tempstr,"Begin of run %d due to MON_INIT.",runnumber);
+        else
+          sprintf(tempstr,"Begin of run %d.",runnumber);
+        mon_file_comment(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+        /* write run title information to file */
+        mon_file_title(cur_year,cur_month,cur_day,runnumber);
+
+        /* free monitor data */
+        if ((smon.Ndevs != 0) && (smon.pDevices != NULL))
+          mon_do("FREE",runnumber,runstate,"BEGIN_RUN");
+
+        /* initialise monitor data */
+        if ((smon.Ndevs == 0) || (smon.pDevices == NULL))
+          mon_do("INIT",runnumber,runstate,"BEGIN_RUN");
+
+        /* init statistics */
+        if ((smon.Ndevs > 0) && (smon.pDevices != NULL)) {
+          INT idev;
+          MonDevicePtr pmondev;
+
+          /* for all devices */
+          for (idev=0; idev < smon.Ndevs; idev++) {
+
+            pmondev = *(smon.pDevices+idev);
+
+            if ((pmondev != NULL)&&(pmondev->Nchans>0)) {
+              INT i;
+              MonChannelPtr pchan;
+
+              /* for all channels in device */
+              for (i=0;i<pmondev->Nchans;i++) {
+                if ((pmondev->pChannels!=NULL) &&
+                    (*(pmondev->pChannels+i) != NULL)) {
+                  pchan = *(pmondev->pChannels+i);
+                  pchan->Nvals  = 0;
+               /* pchan->Offset = 0.0; already initialised by INIT */
+                  pchan->Sum    = 0.0;
+                  pchan->Sum2   = 0.0;
+                  pchan->Mean   = 0.0;
+                  pchan->Devn   = 0.0;
+                }
+                if ((pmondev->pRawChannels!=NULL) &&
+                    (*(pmondev->pRawChannels+i) != NULL)){
+                  pchan = *(pmondev->pRawChannels+i);
+                  pchan->Nvals  = 0;
+               /* pchan->Offset = 0.0; already initialised by INIT */
+                  pchan->Sum    = 0.0;
+                  pchan->Sum2   = 0.0;
+                  pchan->Mean   = 0.0;
+                  pchan->Devn   = 0.0;
+                }
+
+              } /* for all channels in device */
+
+            }
+          } /* for all devices */
+
+        }
+
+        /* enable calculation of mean & std deviation */
+        mon_do_statistics = TRUE;
+
+    /* -- END_RUN */
+      } else if (strcmp(cmd,"END_RUN") == 0) {
+
+        /* disable calculation of mean & std deviation
+         * is not done here in order to be able to get averages between runs */
+        mon_do_statistics = TRUE; /* enable, if PAUSE was previously called */
+
+        if ((icmd != NULL) && (strcmp(icmd,"MON_EXIT")==0)) {
+          if (start_of_run_time != 0)
+            sprintf(tempstr,"End of run statistics %d due to MON_EXIT.",
+                    runnumber);
+          else
+            sprintf(tempstr,"Statistics due to MON_EXIT.");
+        } else
+          sprintf(tempstr,"End of run %d.",runnumber);
+        mon_file_comment(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+        /* write run title information */
+        mon_file_title(cur_year,cur_month,cur_day,runnumber);
+
+        /* write statistics to files */
+        mon_file_statistics(cur_year,cur_month,cur_day,&smon,runnumber);
+
+        /* reset start of run to zero */
+        start_of_run_time = 0;
+
+    /* -- PAUSE_RUN */
+      } else if (strcmp(cmd,"PAUSE_RUN") == 0) {
+
+        /* disable calculation of mean & std deviation */
+        mon_do_statistics = FALSE;
+
+        sprintf(tempstr,"Pausing run %d.",runnumber);
+        mon_file_comment(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+        /* write statistics to files */
+        mon_file_statistics(cur_year,cur_month,cur_day,&smon,runnumber);
+
+    /* -- RESUME_RUN */
+      } else if (strcmp(cmd,"RESUME_RUN") == 0) {
+
+        /* enable calculation of mean & std deviation */
+        mon_do_statistics = TRUE;
+
+        sprintf(tempstr,"Continuing run %d.",runnumber);
+        mon_file_comment(cur_year,cur_month,cur_day,tempstr,runnumber);
+
+    /* -- LOOP */
+      } else if (strcmp(cmd,"LOOP") == 0) {
+        INT          idev,tcstate,dvmstate,ltc1state,ls3360state,ls3361state,
+                     heliox0state,variox0state,dmm270x1state,hvdistr3state,
+                     hvdistr4state,liamp0state,liamp1state,liamp2state;
+        INT          nctc,ncdvm,ncltc1,ncls3360,ncls3361,ncheliox0,ncvariox0,ncdmm270x1,
+                     nchvdistr3,nchvdistr4,ncliamp0,ncliamp1,ncliamp2;
+        MonDevicePtr pmondev;
+        HNDLE        tkey;
+        INT          size,i;
+        char         omondevs[LIST_LENGTH];
+        BOOL         changed,tchandled,dvmhandled,ltc1handled,ls3360handled,
+                     ls3361handled,heliox0handled,variox0handled,dmm270x1handled,
+                     hvdistr3handled,hvdistr4handled,liamp0handled,liamp1handled,
+                     liamp2handled;
+
+        changed = FALSE;
+        n_mon_devices = 0;
+        gnchans = 0;
+        strncpy(omondevs,gmondevs,LIST_LENGTH);
+        gmondevs[0] = '\0';
+        tchandled = dvmhandled = ltc1handled = ls3360handled = ls3361handled =
+        heliox0handled = variox0handled = dmm270x1handled = hvdistr3handled = 
+        hvdistr4handled = liamp0handled = liamp1handled = liamp2handled = FALSE;
+
+        /* get state of TC */
+        if (mon_tc_enabled) {
+          if (db_get_int(hDB,"/Equipment/TC/Settings/Devices/TC/State",
+                         &tcstate,"TC state") != DB_SUCCESS) tcstate = -1;
+
+          if (db_get_int(hDB,"/Equipment/TC/Settings/Channels/TC",&nctc,
+                    "Number of TC channels") != CM_SUCCESS) nctc = -1;
+        } else {
+          tcstate = -1; nctc = -1;
+        }
+#ifdef MIDEBUG
+        printf("TC state = %d, Number of channels = %d\n",tcstate,nctc);
+#endif
+
+        if ((tcstate != 1)||(tcstate == 0)||(nctc == -1)) tchandled = TRUE;
+
+        /* get state of DVM */
+        if (mon_dvm_enabled) {
+          if (db_get_int(hDB,"/Equipment/DVM/Settings/Devices/DVM/State",
+                         &dvmstate,"DVM state") != DB_SUCCESS) dvmstate = -1;
+
+          if (db_get_int(hDB,"/Equipment/DVM/Settings/Channels/DVM",&ncdvm,
+                         "Number of DVM channels") != CM_SUCCESS) ncdvm = -1;
+        } else {
+          dvmstate = -1; ncdvm = -1;
+        }
+#ifdef MIDEBUG
+        printf("DVM state = %d, Number of channels = %d\n",dvmstate,ncdvm);
+#endif
+        if ((dvmstate == -1)||(dvmstate == 0)||(ncdvm == -1)) dvmhandled = TRUE;
+
+        if (mon_ltc1_enabled) {
+          ltc1state = 1; ncltc1 = 4;
+        } else {
+          ltc1state = -1; ncltc1 = -1;
+          ltc1handled = TRUE;
+        }
+#ifdef MIDEBUG
+        printf("ltc1 state = %d, Number of channels = %d\n",ltc1state,ncltc1);
+#endif
+        if (mon_ls3360_enabled) {
+          ls3360state = 1; ncls3360 = 6;
+        } else {
+          ls3360state = -1; ncls3360 = -1;
+          ls3360handled = TRUE;
+        }
+#ifdef MIDEBUG
+        printf("ls3360 state = %d, Number of channels = %d\n",ls3360state,ncls3360);
+#endif
+        if (mon_ls3361_enabled) {
+          ls3361state = 1; ncls3361 = 6;
+        } else {
+          ls3361state = -1; ncls3361 = -1;
+          ls3361handled = TRUE;
+        }
+#ifdef MIDEBUG
+        printf("ls3361 state = %d, Number of channels = %d\n",ls3361state,ncls3361);
+#endif
+        if (mon_heliox0_enabled) {
+          heliox0state = 1;
+          ncheliox0 = 5;
+        } else {
+          heliox0state = -1; ncheliox0 = -1;
+          heliox0handled = TRUE;
+        }
+#ifdef MIDEBUG
+        printf("heliox0 state = %d, Number of channels = %d\n",heliox0state,ncheliox0);
+#endif
+        if (mon_variox0_enabled) {
+          variox0state = 1;
+          ncvariox0 = 2;
+        } else {
+          variox0state = -1; ncvariox0 = -1;
+          variox0handled = TRUE;
+        }
+#ifdef MIDEBUG
+        printf("variox0 state = %d, Number of channels = %d\n",variox0state,ncvariox0);
+#endif
+        if (mon_dmm270x1_enabled) {
+          ncdmm270x1 = dmm270x1_get_channellist(FALSE);
+          if (ncdmm270x1 < 0) {
+            dmm270x1state = -1; ncdmm270x1 = -1;
+            dmm270x1handled = TRUE;
+          } else
+            dmm270x1state = 1;
+        } else {
+          dmm270x1state = -1; ncdmm270x1 = -1;
+          dmm270x1handled = TRUE;
+        }
+#ifdef MIDEBUG
+        printf("dmm270x1 state = %d, Number of channels = %d\n",dmm270x1state,
+               ncdmm270x1);
+#endif
+        if (mon_hvdistr3_enabled) {
+          HNDLE t1key;
+          KEY tskey;
+
+          hvdistr3state = 1; nchvdistr3 = 0;
+          if (db_find_key(hDB, 0, "/Equipment/hvdistr3/Variables/Measured", &t1key)
+                  == DB_SUCCESS){
+            if (db_get_key(hDB, t1key, &tskey) == DB_SUCCESS) {
+              if (tskey.num_values >= 1) nchvdistr3 = tskey.num_values;
+            } else {
+                cm_msg(MLOG,"mon_do","ODB Key /Equipment/hvdistr3/Variables/Measured "
+                                     "ERROR reading KEY info");
+            }
+          } else {
+            cm_msg(MLOG,"mon_do","ODB Key /Equipment/hvdistr3/Variables/Measured "
+                                 "not found");
+          }
+
+        } else {
+          hvdistr3state = -1; nchvdistr3 = -1;
+          hvdistr3handled = TRUE;
+        }
+#ifdef MIDEBUG
+        printf("hvdistr3 state= %d, Number of channels = %d\n",hvdistr3state,nchvdistr3);
+#endif
+        if (mon_hvdistr4_enabled) {
+          HNDLE t1key;
+          KEY tskey;
+
+          hvdistr4state = 1; nchvdistr4 = 6;
+           if (db_find_key(hDB, 0, "/Equipment/hvdistr4/Variables/Measured", &t1key)
+                  == DB_SUCCESS){
+            if (db_get_key(hDB, t1key, &tskey) == DB_SUCCESS) {
+              if (tskey.num_values >= 1) nchvdistr4 = tskey.num_values;
+            } else {
+                cm_msg(MLOG,"mon_do","ODB Key /Equipment/hvdistr4/Variables/Measured "
+                                     "ERROR reading KEY info");
+            }
+          } else {
+            cm_msg(MLOG,"mon_do","ODB Key /Equipment/hvdistr4/Variables/Measured "
+                                 "not found");
+          }
+        } else {
+          hvdistr4state = -1; nchvdistr4 = -1;
+          hvdistr4handled = TRUE;
+        }
+#ifdef MIDEBUG
+        printf("hvdistr4 state= %d, Number of channels = %d\n",hvdistr4state,nchvdistr4);
+#endif
+        if (mon_lckinamp0_enabled) {
+          liamp0state = 1; ncliamp0 = 10;
+        } else {
+          liamp0state = -1; ncliamp0 = -1;
+          liamp0handled = TRUE;
+        }
+        if (mon_lckinamp1_enabled) {
+          liamp1state = 1; ncliamp1 = 10;
+        } else {
+          liamp1state = -1; ncliamp1 = -1;
+          liamp1handled = TRUE;
+        }
+        if (mon_lckinamp2_enabled) {
+          liamp2state = 1; ncliamp2 = 10;
+        } else {
+          liamp2state = -1; ncliamp2 = -1;
+          liamp2handled = TRUE;
+        }
+
+        if (smon.pDevices != NULL) {
+
+          /* read values from ODB /Equipment/ and do statistics (if enabled) */
+          for (idev=0; idev < smon.Ndevs; idev++) {
+            pmondev = *(smon.pDevices+idev);
+            if (pmondev == NULL) continue;
+
+#ifdef MIDEBUG
+            printf("device name = >%s<\n",pmondev->Name);
+#endif
+            /* process TC */
+            if        (strcmp(pmondev->Name,"TC") == 0) {
+
+              tchandled = TRUE;
+              if (mon_tc_enabled && (nctc == pmondev->Nchans)) {
+                if (tcstate == 1) {
+                  DWORD tdelta;
+                  float *pvalues;
+
+                  pvalues = NULL;
+
+                  /* read Variables/Measured */
+                  if (db_find_key(hDB,0,"/Equipment/TC/Variables/Measured",&tkey)
+                     == CM_SUCCESS) {
+
+                    if (db_get_key_time(hDB,tkey,&tdelta) == DB_SUCCESS) {
+
+#ifdef MIDEBUG2
+                      printf(" TC delta = %d\n",tdelta);
+#endif
+                      /* only updated values,
+                       * if values were updated in interval */
+                      if (tdelta > smon.Interval+1000) /* avoid integer overflow */ 
+                        tdelta = smon.Interval/1000+3;
+
+                      if ((INT)tdelta*1000 <= smon.Interval+1000) {
+
+                        pvalues = (float *) calloc(pmondev->Nchans,sizeof(float));
+                        if (pvalues != NULL) {
+                          size = pmondev->Nchans*sizeof(float);
+                          if (db_get_data(hDB,tkey,(void *)pvalues,&size,TID_FLOAT)
+                            == CM_SUCCESS){
+
+                            n_mon_devices++;
+                            gnchans += pmondev->Nchans;
+                            strcat(gmondevs,"TC ");
+
+                            /* write channels to log file */
+                            mon_file_channels(cur_year,cur_month,cur_day,runnumber,"TC",
+                                          pmondev->Nchans,pvalues,NULL);
+
+                            /* do monitor statistics */
+                            if (mon_do_statistics) {
+                              for (i=0;i<pmondev->Nchans;i++) {
+                                if (*(pvalues+i) != -1.f)
+                                  mon_chan_statistics(*(pmondev->pChannels+i),
+                                                      *(pvalues+i));
+                              }
+                              /* TC special case */
+                              /* periodically write mean and std deviation to
+                                 /musr/td_musr/runinfo  */
+#define TEMPLISTSTR 50 /* size of temperature list for title is limited for PSI format */
+                              if (ss_millitime() - mon_last_title > smon.Interval) {
+                                char tempstr1[20];
+                                INT j;
+
+                                if (pmondev->pChannels != NULL) {
+                                  if (db_find_key(hDB,0,
+                                    "/Musr/Td_musr/runinfo/meantemp",&tkey)
+                                    == CM_SUCCESS) {
+                                    tempstr[0] = '\0';
+                                    for (i=0,j=0;i<pmondev->Nchans;i++) {
+                                      if (j==4) break;
+                                      if (*(pmondev->pChannels+i) != NULL) {
+                                        sprintf(tempstr1,"%G ",
+                                          (*(pmondev->pChannels+i))->Mean);
+                                        strcat(tempstr,tempstr1);
+                                        j++;
+                                      }
+                                    }
+                                    if (j<4) {
+                                      for(i=j;i<4;i++)
+                                        strcat(tempstr,"0.0 ");
+                                    }
+                                    tempstr[TEMPLISTSTR-1] = '\0';
+                                    if (strlen(tempstr) > 0) {
+
+                                      db_set_data(hDB,tkey,tempstr,
+                                               strlen(tempstr)+1,1,TID_STRING);
+                                    }
+                                  }
+                                  if (db_find_key(hDB,0,
+                                    "/Musr/Td_musr/runinfo/tempdev",&tkey)
+                                    == CM_SUCCESS) {
+                                    tempstr[0] = '\0';
+                                    for (i=0,j=0;i<pmondev->Nchans;i++) {
+                                      if (j==4) break;
+                                      if (*(pmondev->pChannels+i) != NULL) {
+                                        sprintf(tempstr1,"%G ",
+                                          (*(pmondev->pChannels+i))->Devn);
+                                        strcat(tempstr,tempstr1);
+                                        j++;
+                                      }
+                                    }
+                                    if (j<4) {
+                                      for(i=j;i<4;i++)
+                                        strcat(tempstr,"0.0 ");
+                                    }
+                                    tempstr[TEMPLISTSTR-1] = '\0';
+                                    if (strlen(tempstr) > 0) {
+
+                                      db_set_data(hDB,tkey,tempstr,
+                                               strlen(tempstr)+1,1,TID_STRING);
+                                    }
+                                  }
+                                }
+                                mon_last_title = ss_millitime();
+                              }
+                              /* NIY periodically verify Settings/Names */
+                            }
+
+                          } else {
+                            cm_msg(MERROR,"mon_do","ERROR Reading Measured Variables");
+                          }
+                          free(pvalues);
+                          pvalues = NULL;
+
+                        } else {
+                          cm_msg(MERROR,"mon_do","ERROR Allocating Measured values");
+                        }
+#ifdef MIDEBUG
+                      } else {
+                        printf("TC not updated in interval!\n");
+#endif
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do",
+                      "ERROR Getting update delta of Variables/Measured of TC channels");
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Finding Variables/Measured of TC channels");
+                  }
+
+                } else {
+                  if ((tcstate != 0) && (tcstate != -1))
+                   cm_msg(MLOG,"mon_do","ERROR invalid state (%d) of TC device",tcstate);
+                  /* RA95 12-AUG-2004 prevent monitor init when device falls off */
+                  /* changed = TRUE; */
+                }
+              } else {
+                if (mon_tc_enabled) changed = TRUE;
+              }
+
+            } else if (strcmp(pmondev->Name,"DVM") == 0) {
+
+              dvmhandled = TRUE;
+
+              if (mon_dvm_enabled && (pmondev->Nchans == ncdvm)) {
+
+                if (dvmstate == 1) {
+                  DWORD tdelta;
+                  float *pvalues,*prawvalues;
+
+                  pvalues = prawvalues = NULL;
+
+                  /* read Variables/Measured */
+                  if (db_find_key(hDB,0,"/Equipment/DVM/Variables/Measured",&tkey)
+                    == CM_SUCCESS) {
+
+                    if (db_get_key_time(hDB,tkey,&tdelta) == DB_SUCCESS) {
+
+#ifdef MIDEBUG2
+                      printf(" DVM delta = %d\n",tdelta);
+#endif
+                      /* only updated values,
+                       * if values were updated in interval */
+                      if (tdelta > smon.Interval+1000) /* avoid integer overflow */ 
+                        tdelta = smon.Interval/1000+3;
+
+                      if ((INT)tdelta*1000 <= smon.Interval+1000) {
+
+                        pvalues = (float *) calloc(pmondev->Nchans,sizeof(float));
+                        if (pvalues != NULL) {
+                          size = pmondev->Nchans*sizeof(float);
+                          if (db_get_data(hDB,tkey,(void *)pvalues,&size,TID_FLOAT)
+                            == CM_SUCCESS){
+
+                            /* read Variables/RawMeasured */
+                            if (db_find_key(hDB,0,
+                              "/Equipment/DVM/Variables/RawMeasured",&tkey)
+                              == CM_SUCCESS) {
+
+                              prawvalues =
+                                (float *) calloc(pmondev->Nchans,sizeof(float));
+                              if (prawvalues != NULL) {
+                                size = pmondev->Nchans*sizeof(float);
+                                if (db_get_data(hDB,tkey,(void *)prawvalues,&size,
+                                    TID_FLOAT) == CM_SUCCESS){
+
+                                  n_mon_devices++;
+                                  gnchans += pmondev->Nchans;
+                                  strcat(gmondevs,"DVM ");
+
+                                  /* write channels to log file */
+                                  mon_file_channels(cur_year,cur_month,cur_day,
+                                    runnumber,"DVM",pmondev->Nchans,pvalues,prawvalues);
+
+                                  /* do monitor statistics */
+                                  if (mon_do_statistics) {
+                                    for (i=0;i<pmondev->Nchans;i++) {
+                                      mon_chan_statistics(*(pmondev->pChannels+i),
+                                                          *(pvalues+i));
+                                      mon_chan_statistics(*(pmondev->pRawChannels+i),
+                                                          *(prawvalues+i));
+                                    }
+                                    /* NIY periodically verify Settings/Names */
+                                  }
+
+                                } else {
+                                  cm_msg(MERROR,"mon_do",
+                                                "ERROR Reading Measured Variables");
+                                }
+
+                                free(prawvalues);
+                                prawvalues = NULL;
+
+                              } else {
+                                cm_msg(MERROR,"mon_do",
+                                  "ERROR Allocating Measured values");
+                              }
+
+                            } else {
+                              cm_msg(MERROR,"mon_do","ERROR Finding Variables/Measured"
+                                                     " of DVM channels");
+                            }
+
+                          } else {
+                            cm_msg(MERROR,"mon_do","ERROR Reading Measured Variables");
+                          }
+
+                          free(pvalues);
+                          pvalues = NULL;
+
+                        } else {
+                          cm_msg(MERROR,"mon_do","ERROR Allocating Measured values");
+                        }
+#ifdef MIDEBUG
+                      } else {
+                        printf("DVM not updated in interval!\n");
+#endif
+                      }
+                    } else {
+                      cm_msg(MERROR,"mon_do","ERROR Getting update delta of "
+                                             "Variables/Measured of DVM channels");
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Finding Variables/Measured of DVM channels");
+                  }
+
+                } else {
+                  if ((dvmstate != -1) && (dvmstate != 0))
+                    cm_msg(MLOG,"mon_do","ERROR invalid state (%d) of DVM device",
+                           dvmstate);
+                  /* RA95 12-AUG-2004 prevent monitor init when device falls off */
+                     /* changed = TRUE; */
+                }
+              } else {
+                if (mon_dvm_enabled) changed = TRUE;
+              }
+
+            /* process templtc0 */
+            } else if (strcmp(pmondev->Name,"templtc0") == 0) {
+
+              ltc1handled = TRUE;
+              if (mon_ltc1_enabled && (ncltc1 == pmondev->Nchans)) {
+                if (ltc1state == 1) {
+                  DWORD tdelta;
+                  float *pvalues,*pvalues1;
+
+                  pvalues = pvalues1 = NULL;
+
+                  /* read Variables/Input */
+                  if (db_find_key(hDB,0,"/Equipment/templtc0/Variables/Input",&tkey)
+                     == CM_SUCCESS) {
+
+                    if (db_get_key_time(hDB,tkey,&tdelta) == DB_SUCCESS) {
+
+#ifdef MIDEBUG2
+                      printf(" templtc0 delta = %d\n",tdelta);
+#endif
+                      /* only updated values,
+                       * if values were updated in interval */
+                      if (tdelta > smon.Interval+1000) /* avoid integer overflow */ 
+                        tdelta = smon.Interval/1000+3;
+
+                      if ((INT)tdelta*1000 <= smon.Interval+1000) {
+
+                        pvalues = (float *) calloc(pmondev->Nchans,sizeof(float));
+                        pvalues1 = (float *) calloc(36,sizeof(float));
+                        if ((pvalues != NULL) && (pvalues1 != NULL)) {
+                          size = 36*sizeof(float);
+                          if (db_get_data(hDB,tkey,(void *)pvalues1,&size,TID_FLOAT)
+                            == CM_SUCCESS){
+
+                            n_mon_devices++;
+                            gnchans += pmondev->Nchans;
+                            strcat(gmondevs,"templtc0 ");
+
+                            *(pvalues+0) = *(pvalues1+0); // take sensor_1 temperature
+                            *(pvalues+1) = *(pvalues1+1); // take sensor_2
+                            if (*(pvalues1+10) != 3.0f) {  // not no heater sensor?
+                              *(pvalues+2) = *(pvalues1+11); // take heater temperature
+                            } else {
+                              *(pvalues+2) = -1.f;         // unknown heater temperature
+                            }
+                            if (*(pvalues1+18) != 3.0f) {  // not no analog sensor
+                              *(pvalues+3) = *(pvalues1+19); // take analog temperature
+                            } else {
+                              *(pvalues+3) = -1.f;         // unknown analog temperature
+                            }
+
+                            /* write channels to log file */
+                            mon_file_channels(cur_year,cur_month,cur_day,runnumber,
+                                "templtc0", pmondev->Nchans,pvalues,NULL);
+
+                            /* do monitor statistics */
+                            if (mon_do_statistics) {
+                              for (i=0;i<pmondev->Nchans;i++) {
+                                if (*(pvalues+i) != -1.f)
+                                  mon_chan_statistics(*(pmondev->pChannels+i),
+                                                      *(pvalues+i));
+                              }
+#ifdef templtc_title
+                              /* templtc0 special case */
+                              /* periodically write mean and std deviation to
+                                 /musr/td_musr/runinfo  */
+#define TEMPLISTSTR   50      /* size of temperature list for title is limited for PSI format */
+                              if (ss_millitime() - mon_last_title > smon.Interval) {
+                                char tempstr1[20];
+                                INT j;
+
+                                if (pmondev->pChannels != NULL) {
+                                  if (db_find_key(hDB,0,
+                                    "/Musr/Td_musr/runinfo/meantemp",&tkey)
+                                    == CM_SUCCESS) {
+                                    tempstr[0] = '\0';
+                                    for (i=0,j=0;i<pmondev->Nchans;i++) {
+                                      if (j==4) break;
+                                      if (*(pmondev->pChannels+i) != NULL) {
+                                        sprintf(tempstr1,"%G ",
+                                          (*(pmondev->pChannels+i))->Mean);
+                                        strcat(tempstr,tempstr1);
+                                        j++;
+                                      }
+                                    }
+                                    if (j<4) {
+                                      for(i=j;i<4;i++)
+                                        strcat(tempstr,"0.0 ");
+                                    }
+                                    tempstr[TEMPLISTSTR-1] = '\0';
+                                    if (strlen(tempstr) > 0) {
+
+                                      db_set_data(hDB,tkey,tempstr,
+                                               strlen(tempstr)+1,1,TID_STRING);
+                                    }
+                                  }
+                                  if (db_find_key(hDB,0,
+                                    "/Musr/Td_musr/runinfo/tempdev",&tkey)
+                                    == CM_SUCCESS) {
+                                    tempstr[0] = '\0';
+                                    for (i=0,j=0;i<pmondev->Nchans;i++) {
+                                      if (j==4) break;
+                                      if (*(pmondev->pChannels+i) != NULL) {
+                                        sprintf(tempstr1,"%G ",
+                                          (*(pmondev->pChannels+i))->Devn);
+                                        strcat(tempstr,tempstr1);
+                                        j++;
+                                      }
+                                    }
+                                    if (j<4) {
+                                      for(i=j;i<4;i++)
+                                        strcat(tempstr,"0.0 ");
+                                    }
+                                    tempstr[TEMPLISTSTR-1] = '\0';
+                                    if (strlen(tempstr) > 0) {
+
+                                      db_set_data(hDB,tkey,tempstr,
+                                               strlen(tempstr)+1,1,TID_STRING);
+                                    }
+                                  }
+                                }
+                                mon_last_title = ss_millitime();
+                              }
+#endif  /* #ifdef templtc_title */
+                              /* NIY periodically verify Settings/Names */
+                            }
+
+                          } else {
+                            cm_msg(MERROR,"mon_do","ERROR Reading Input Variables");
+                          }
+                          free(pvalues);
+                          pvalues = NULL;
+                          free(pvalues1);
+                          pvalues1 = NULL;
+
+                        } else {
+                          cm_msg(MERROR,"mon_do","ERROR Allocating Input values");
+                          if (pvalues != NULL) {
+                            free(pvalues);
+                            pvalues = NULL;
+                          }
+                          if (pvalues1 != NULL) {
+                            free(pvalues1);
+                            pvalues1 = NULL;
+                          }
+                        }
+#ifdef MIDEBUG
+                      } else {
+                        printf("templtc0 not updated in interval!\n");
+#endif
+                      }
+
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Getting update delta of "
+                                              "Variables/Input of templtc0 channels");
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Finding Variables/Input of templtc0 channels");
+                  }
+
+                } else {
+                  if ((ltc1state != 0) && (ltc1state != -1))
+                    cm_msg(MLOG,"mon_do","ERROR invalid state (%d) of templtc0 device",
+                                         ltc1state);
+                  /* RA95 12-AUG-2004 prevent monitor init when device falls off */
+                  /* changed = TRUE; */
+                }
+              } else {
+                if (mon_ltc1_enabled) changed = TRUE;
+              }
+
+            /* process templs3360 */
+            } else if (strcmp(pmondev->Name,"templs3360") == 0) {
+
+              ls3360handled = TRUE;
+              if (mon_ls3360_enabled && (ncls3360 == pmondev->Nchans)) {
+                if (ls3360state == 1) {
+                  DWORD tdelta;
+                  float *pvalues,*pvalues1;
+
+                  pvalues = pvalues1 = NULL;
+
+                  /* read Variables/Input */
+                  if (db_find_key(hDB,0,"/Equipment/templs3360/Variables/Input",&tkey)
+                     == CM_SUCCESS) {
+
+                    if (db_get_key_time(hDB,tkey,&tdelta) == DB_SUCCESS) {
+
+#ifdef MIDEBUG2
+                      printf(" templs3360 delta = %d\n",tdelta);
+#endif
+                      /* only updated values,
+                       * if values were updated in interval */
+                      if (tdelta > smon.Interval+1000) /* avoid integer overflow */ 
+                        tdelta = smon.Interval/1000+3;
+
+                      if ((INT)tdelta*1000 <= smon.Interval+1000) {
+
+                        pvalues = (float *) calloc(pmondev->Nchans,sizeof(float));
+                        pvalues1 = (float *) calloc(60,sizeof(float));
+                        if ((pvalues != NULL) && (pvalues1 != NULL)) {
+                          size = 60*sizeof(float);
+                          if (db_get_data(hDB,tkey,(void *)pvalues1,&size,TID_FLOAT)
+                            == CM_SUCCESS){
+
+                            n_mon_devices++;
+                            gnchans += pmondev->Nchans;
+                            strcat(gmondevs,"templs3360 ");
+
+                            *(pvalues+0) = *(pvalues1+0); // take sensor_A temperature
+                            *(pvalues+1) = *(pvalues1+1); // take sensor_B
+                            *(pvalues+2) = *(pvalues1+2); // take sensor_C
+                            *(pvalues+3) = *(pvalues1+3); // take sensor_D
+                            if (*(pvalues1+9) > 0.0f) {  // not no heater1 sensor?
+                              *(pvalues+4) = *(pvalues1+39); // take heater1 temperature
+                            } else {
+                              *(pvalues+4) = -1.f;         // unknown heater1 temperature
+                            }
+                            if (*(pvalues1+18) > 0.0f) {  // not no heater2 sensor
+                              *(pvalues+5) = *(pvalues1+40); // take heater2 temperature
+                            } else {
+                              *(pvalues+5) = -1.f;         // unknown heater2 temperature
+                            }
+
+                            /* write channels to log file */
+                            mon_file_channels(cur_year,cur_month,cur_day,runnumber,
+                                "templs3360", pmondev->Nchans,pvalues,NULL);
+
+                            /* do monitor statistics */
+                            if (mon_do_statistics) {
+                              for (i=0;i<pmondev->Nchans;i++) {
+                                if (*(pvalues+i) != -1.f)
+                                  mon_chan_statistics(*(pmondev->pChannels+i),
+                                                      *(pvalues+i));
+                              }
+                              /* NIY periodically verify Settings/Names */
+                            }
+
+                          } else {
+                            cm_msg(MERROR,"mon_do","ERROR Reading Input Variables");
+                          }
+                          free(pvalues);
+                          pvalues = NULL;
+                          free(pvalues1);
+                          pvalues1 = NULL;
+
+                        } else {
+                          cm_msg(MERROR,"mon_do","ERROR Allocating Input values");
+                          if (pvalues != NULL) {
+                            free(pvalues);
+                            pvalues = NULL;
+                          }
+                          if (pvalues1 != NULL) {
+                            free(pvalues1);
+                            pvalues1 = NULL;
+                          }
+                        }
+#ifdef MIDEBUG
+                      } else {
+                        printf("templs3360 not updated in interval!\n");
+#endif
+                      }
+
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Getting update delta of "
+                                              "Variables/Input of templs3360 channels");
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Finding Variables/Input of templs3360 channels");
+                  }
+
+                } else {
+                  if ((ls3360state != 0) && (ls3360state != -1))
+                    cm_msg(MLOG,"mon_do","ERROR invalid state (%d) of templs3360 device",
+                                         ls3360state);
+                  /* RA95 12-AUG-2004 prevent monitor init when device falls off */
+                  /* changed = TRUE; */
+                }
+              } else {
+                if (mon_ls3360_enabled) changed = TRUE;
+              }
+
+            /* process templs3361 */
+            } else if (strcmp(pmondev->Name,"templs3361") == 0) {
+#ifdef MIDEBUG
+              printf("    processing templs3361: mon_ls3361_enabled = %d, ncls3361 = %d,"
+                     " pmondev->Nchans=%d\n", mon_ls3361_enabled, ncls3361,
+                     pmondev->Nchans);
+#endif
+              ls3361handled = TRUE;
+              if (mon_ls3361_enabled && (ncls3361 == pmondev->Nchans)) {
+#ifdef MIDEBUG
+                printf("    ls3361state = %d\n",ls3361state);
+#endif
+                if (ls3361state == 1) {
+                  DWORD tdelta;
+                  float *pvalues,*pvalues1;
+
+                  pvalues = pvalues1 = NULL;
+
+                  /* read Variables/Input */
+                  if (db_find_key(hDB,0,"/Equipment/templs3361/Variables/Input",&tkey)
+                     == CM_SUCCESS) {
+
+                    if (db_get_key_time(hDB,tkey,&tdelta) == DB_SUCCESS) {
+
+#ifdef MIDEBUG2
+                      printf(" templs3361 delta = %d\n",tdelta);
+#endif
+                      /* only updated values,
+                       * if values were updated in interval */
+                      if (tdelta > smon.Interval+1000) /* avoid integer overflow */ 
+                        tdelta = smon.Interval/1000+3;
+
+                      if ((INT)tdelta*1000 <= smon.Interval+1000) {
+
+                        pvalues = (float *) calloc(pmondev->Nchans,sizeof(float));
+                        pvalues1 = (float *) calloc(60,sizeof(float));
+                        if ((pvalues != NULL) && (pvalues1 != NULL)) {
+                          size = 60*sizeof(float);
+                          if (db_get_data(hDB,tkey,(void *)pvalues1,&size,TID_FLOAT)
+                            == CM_SUCCESS){
+
+                            n_mon_devices++;
+                            gnchans += pmondev->Nchans;
+                            strcat(gmondevs,"templs3361 ");
+
+                            *(pvalues+0) = *(pvalues1+0); // take sensor_A temperature
+                            *(pvalues+1) = *(pvalues1+1); // take sensor_B
+                            *(pvalues+2) = *(pvalues1+2); // take sensor_C
+                            *(pvalues+3) = *(pvalues1+3); // take sensor_D
+                            if (*(pvalues1+9) > 0.0f) {  // not no heater1 sensor?
+                              *(pvalues+4) = *(pvalues1+39); // take heater1 temperature
+                            } else {
+                              *(pvalues+4) = -1.f;         // unknown heater1 temperature
+                            }
+                            if (*(pvalues1+18) > 0.0f) {  // not no heater2 sensor
+                              *(pvalues+5) = *(pvalues1+40); // take heater2 temperature
+                            } else {
+                              *(pvalues+5) = -1.f;         // unknown heater2 temperature
+                            }
+
+                            /* write channels to log file */
+                            mon_file_channels(cur_year,cur_month,cur_day,runnumber,
+                                            "templs3361", pmondev->Nchans,pvalues,NULL);
+
+                            /* do monitor statistics */
+                            if (mon_do_statistics) {
+                              for (i=0;i<pmondev->Nchans;i++) {
+                                if (*(pvalues+i) != -1.f)
+                                  mon_chan_statistics(*(pmondev->pChannels+i),
+                                                      *(pvalues+i));
+                              }
+                              /* NIY periodically verify Settings/Names */
+                            }
+
+                          } else {
+                            cm_msg(MERROR,"mon_do","ERROR Reading Input Variables");
+                          }
+                          free(pvalues); pvalues = NULL;
+                          free(pvalues1); pvalues1 = NULL;
+
+                        } else {
+                          cm_msg(MERROR,"mon_do","ERROR Allocating Input values");
+                          if (pvalues != NULL) {
+                            free(pvalues); pvalues = NULL;
+                          }
+                          if (pvalues1 != NULL) {
+                            free(pvalues1); pvalues1 = NULL;
+                          }
+                        }
+#ifdef MIDEBUG
+                      } else {
+                        printf("templs3361 not updated in interval!\n");
+#endif
+                      }
+
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Getting update delta of "
+                                              "Variables/Input of templs3361 channels");
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Finding Variables/Input of templs3361 channels");
+                  }
+
+                } else {
+                  if ((ls3361state != 0) && (ls3361state != -1))
+                    cm_msg(MLOG,"mon_do","ERROR invalid state (%d) of templs3361 device",
+                                         ls3361state);
+                  /* RA95 12-AUG-2004 prevent monitor init when device falls off */
+                  /* changed = TRUE; */
+                }
+              } else {
+                if (mon_ls3361_enabled) changed = TRUE;
+              }
+
+            /* process heliox0 */
+            } else if (strcmp(pmondev->Name,"heliox0") == 0) {
+              INT tstatus;
+#ifdef MIDEBUG
+              printf("    processing heliox0: mon_heliox0_enabled = %d, "
+                     "ncheliox0 = %d, pmondev->Nchans=%d\n", mon_heliox0_enabled,
+                     ncheliox0, pmondev->Nchans);
+#endif
+              heliox0handled = TRUE;
+              if (mon_heliox0_enabled && (ncheliox0 == pmondev->Nchans)) {
+#ifdef MIDEBUG
+                printf("    heliox0state = %d\n",heliox0state);
+#endif
+                if (heliox0state == 1) {
+                  DWORD tdelta;
+                  float *pvalues,*pvalues1;
+
+                  pvalues = pvalues1 = NULL;
+
+                  /* read Variables/Input */
+                  tstatus = db_find_key(hDB,0,"/Equipment/heliox0/Variables/Input",
+                                          &tkey);
+                  if (tstatus == CM_SUCCESS) {
+
+                    if (db_get_key_time(hDB,tkey,&tdelta) == DB_SUCCESS) {
+
+#ifdef MIDEBUG2
+                      printf(" heliox0 delta = %d\n",tdelta);
+#endif
+                      /* only updated values,
+                       * if values were updated in interval */
+                      if (tdelta > smon.Interval+1000) /* avoid integer overflow */ 
+                        tdelta = smon.Interval/1000+3;
+
+                      if ((INT)tdelta*1000 <= smon.Interval+1000) {
+
+                        pvalues = (float *) calloc(pmondev->Nchans,sizeof(float));
+                        pvalues1 = (float *) calloc(44,sizeof(float)); // changed from 43 to 44 RA36 08-AUG-2023
+                        if ((pvalues != NULL) && (pvalues1 != NULL)) {
+                          size = 44*sizeof(float);
+                          if (db_get_data(hDB,tkey,(void *)pvalues1,&size,TID_FLOAT)
+                            == CM_SUCCESS){
+
+                            n_mon_devices++;
+                            gnchans += pmondev->Nchans;
+                            strcat(gmondevs,"heliox0 ");
+
+                            *(pvalues+0) = *(pvalues1+10); // take HelioxX
+                            *(pvalues+1) = *(pvalues1+ 0); // take Variox
+                            *(pvalues+2) = *(pvalues1+24); // take HeHigh
+                            *(pvalues+3) = *(pvalues1+31); // take HeLow
+                            *(pvalues+4) = *(pvalues1+17); // take Sorb
+
+                            /* write channels to log file */
+                            mon_file_channels(cur_year,cur_month,cur_day,runnumber,
+                                            "heliox0", pmondev->Nchans,pvalues,NULL);
+
+                            /* do monitor statistics */
+                            if (mon_do_statistics) {
+                              for (i=0;i<pmondev->Nchans;i++) {
+                                if (*(pvalues+i) != -1.f)
+                                  mon_chan_statistics(*(pmondev->pChannels+i),
+                                                      *(pvalues+i));
+                              }
+                              /* NIY periodically verify Settings/Names */
+                            }
+
+                          } else {
+                            cm_msg(MERROR,"mon_do","ERROR Reading Input Variables");
+                          }
+                          free(pvalues); pvalues = NULL;
+                          free(pvalues1); pvalues1 = NULL;
+
+                        } else {
+                          cm_msg(MERROR,"mon_do","ERROR Allocating Input values");
+                          if (pvalues != NULL) {
+                            free(pvalues); pvalues = NULL;
+                          }
+                          if (pvalues1 != NULL) {
+                            free(pvalues1); pvalues1 = NULL;
+                          }
+                        }
+#ifdef MIDEBUG
+                      } else {
+                        printf("heliox0 not updated in interval!\n");
+#endif
+                      }
+
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Getting update delta of "
+                                              "Variables/Input of heliox0 channels");
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Finding Variables/Input of heliox0 channels");
+                  }
+
+                } else {
+                  if ((heliox0state != 0) && (heliox0state != -1))
+                    cm_msg(MLOG,"mon_do","ERROR invalid state (%d) of mercury iTC "
+                                         "heliox0", heliox0state);
+                  /* RA95 12-AUG-2004 prevent monitor init when device falls off */
+                  /* changed = TRUE; */
+                }
+              } else {
+                if (mon_heliox0_enabled) changed = TRUE;
+              }
+
+            /* process variox0 */
+            } else if (strcmp(pmondev->Name,"variox0") == 0) {
+              INT tstatus;
+#ifdef MIDEBUG
+              printf("    processing variox0: mon_variox0_enabled = %d, "
+                     "ncvariox0 = %d, pmondev->Nchans=%d\n", mon_variox0_enabled,
+                     ncvariox0, pmondev->Nchans);
+#endif
+              variox0handled = TRUE;
+              if (mon_variox0_enabled && (ncvariox0 == pmondev->Nchans)) {
+#ifdef MIDEBUG
+                printf("    variox0state = %d\n",variox0state);
+#endif
+                if (variox0state == 1) {
+                  DWORD tdelta;
+                  float *pvalues,*pvalues1;
+
+                  pvalues = pvalues1 = NULL;
+
+                  /* read Variables/Input */
+                  tstatus = db_find_key(hDB,0,"/Equipment/variox0/Variables/Input",
+                                          &tkey);
+                  if (tstatus == CM_SUCCESS) {
+
+                    if (db_get_key_time(hDB,tkey,&tdelta) == DB_SUCCESS) {
+
+#ifdef MIDEBUG2
+                      printf(" variox0 delta = %d\n",tdelta);
+#endif
+                      /* only updated values,
+                       * if values were updated in interval */
+                      if (tdelta > smon.Interval+1000) /* avoid integer overflow */ 
+                        tdelta = smon.Interval/1000+3;
+
+                      if ((INT)tdelta*1000 <= smon.Interval+1000) {
+
+                        pvalues = (float *) calloc(pmondev->Nchans,sizeof(float));
+                        pvalues1 = (float *) calloc(36,sizeof(float));
+                        if ((pvalues != NULL) && (pvalues1 != NULL)) {
+                          size = 36*sizeof(float);
+                          if (db_get_data(hDB,tkey,(void *)pvalues1,&size,TID_FLOAT)
+                            == CM_SUCCESS){
+
+                            n_mon_devices++;
+                            gnchans += pmondev->Nchans;
+                            strcat(gmondevs,"variox0 ");
+
+                            *(pvalues+0) = *(pvalues1+ 0); // take Variox
+                            *(pvalues+1) = *(pvalues1+11); // take Sample
+
+                            /* write channels to log file */
+                            mon_file_channels(cur_year,cur_month,cur_day,runnumber,
+                                            "variox0", pmondev->Nchans,pvalues,NULL);
+
+                            /* do monitor statistics */
+                            if (mon_do_statistics) {
+                              for (i=0;i<pmondev->Nchans;i++) {
+                                if (*(pvalues+i) != -1.f)
+                                  mon_chan_statistics(*(pmondev->pChannels+i),
+                                                      *(pvalues+i));
+                              }
+                              /* NIY periodically verify Settings/Names */
+                            }
+
+                          } else {
+                            cm_msg(MERROR,"mon_do","ERROR Reading Input Variables");
+                          }
+                          free(pvalues); pvalues = NULL;
+                          free(pvalues1); pvalues1 = NULL;
+
+                        } else {
+                          cm_msg(MERROR,"mon_do","ERROR Allocating Input values");
+                          if (pvalues != NULL) {
+                            free(pvalues); pvalues = NULL;
+                          }
+                          if (pvalues1 != NULL) {
+                            free(pvalues1); pvalues1 = NULL;
+                          }
+                        }
+#ifdef MIDEBUG
+                      } else {
+                        printf("variox0 not updated in interval!\n");
+#endif
+                      }
+
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Getting update delta of "
+                                              "Variables/Input of variox0 channels");
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Finding Variables/Input of variox0 channels");
+                  }
+
+                } else {
+                  if ((variox0state != 0) && (variox0state != -1))
+                    cm_msg(MLOG,"mon_do","ERROR invalid state (%d) of mercury iTC "
+                                         "variox0", variox0state);
+                  /* RA95 12-AUG-2004 prevent monitor init when device falls off */
+                  /* changed = TRUE; */
+                }
+              } else {
+                if (mon_variox0_enabled) changed = TRUE;
+              }
+
+            /* process dmm270x1 */
+            } else if (strcmp(pmondev->Name,"dmm270x1") == 0) {
+#ifdef MIDEBUG
+              printf("    processing dmm270x1: mon_dmm270x1_enabled = %d, ncdmm270x1 = "
+                     "%d, pmondev->Nchans=%d\n", mon_dmm270x1_enabled, ncdmm270x1,
+                     pmondev->Nchans);
+#endif
+              dmm270x1handled = TRUE;
+              if (mon_dmm270x1_enabled && (ncdmm270x1 == pmondev->Nchans)) {
+#ifdef MIDEBUG
+                printf("    dmm270x1state = %d\n",dmm270x1state);
+#endif
+                if (dmm270x1state == 1) {
+                  DWORD tdelta;
+                  float *pvalues,*pvalues1;
+
+                  pvalues = pvalues1 = NULL;
+
+                  /* read Variables/Measured */
+                  if (db_find_key(hDB,0,"/Equipment/dmm270x1/Variables/Measured",&tkey)
+                     == CM_SUCCESS) {
+
+                    if (db_get_key_time(hDB,tkey,&tdelta) == DB_SUCCESS) {
+
+#ifdef MIDEBUG2
+                      printf(" dmm2701x1 delta = %d\n",tdelta);
+#endif
+                      /* only updated values,
+                       * if values were updated in interval */
+                      if (tdelta > smon.Interval+1000) /* avoid integer overflow */ 
+                        tdelta = smon.Interval/1000+3;
+
+                      if ((INT)tdelta*1000 <= smon.Interval+1000) {
+
+                        pvalues = (float *) calloc(pmondev->Nchans,sizeof(float));
+                        pvalues1 = (float *) calloc(22,sizeof(float));
+                        if ((pvalues != NULL) && (pvalues1 != NULL)) {
+                          size = 22*sizeof(float);
+                          if (db_get_data(hDB,tkey,(void *)pvalues1,&size,TID_FLOAT)
+                                                                        == CM_SUCCESS){
+                            INT ichan;
+
+                            n_mon_devices++;
+                            gnchans += pmondev->Nchans;
+                            strcat(gmondevs,"dmm270x1 ");
+
+                            ichan = -1;
+                            for (i=0;i<pmondev->Nchans;i++) {
+                              /* find next used channel */
+                              for (ichan+=1; ichan < 22; ichan++) {
+                                if (dmm270x1_channel_used[ichan] != 0)
+                                break;
+                              }
+
+                              if (ichan < 22) {
+                                *(pvalues+i) = *(pvalues1+ichan); //
+                              }
+                            }
+
+                            /* write channels to log file */
+                            mon_file_channels(cur_year,cur_month,cur_day,runnumber,
+                                            "dmm270x1", pmondev->Nchans,pvalues,NULL);
+
+                            /* do monitor statistics */
+                            if (mon_do_statistics) {
+                              for (i=0;i<pmondev->Nchans;i++) {
+                                /* if (*(pvalues+i) != -1.f) take all */
+                                  mon_chan_statistics(*(pmondev->pChannels+i),
+                                                      *(pvalues+i));
+                              }
+                              /* NIY periodically verify Settings/Names */
+                            }
+
+                          } else {
+                            cm_msg(MERROR,"mon_do","ERROR Reading Measured values");
+                          }
+                          free(pvalues); pvalues = NULL;
+                          free(pvalues1); pvalues1 = NULL;
+
+                        } else {
+                          cm_msg(MERROR,"mon_do","ERROR Allocating Measured values");
+                          if (pvalues != NULL) {
+                            free(pvalues); pvalues = NULL;
+                          }
+                          if (pvalues1 != NULL) {
+                            free(pvalues1); pvalues1 = NULL;
+                          }
+                        }
+#ifdef MIDEBUG
+                      } else {
+                        printf("dmm270x1 not updated in interval!\n");
+#endif
+                      }
+
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Getting update delta of "
+                                              "Variables/Measured of dmm270x1 channels");
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Finding Variables/Measured of dmm270x1 channels");
+                  }
+
+                } else {
+                  if ((dmm270x1state != 0) && (dmm270x1state != -1))
+                    cm_msg(MLOG,"mon_do","ERROR invalid state (%d) of dmm270x1 device",
+                                         dmm270x1state);
+                  /* RA95 12-AUG-2004 prevent monitor init when device falls off */
+                  /* changed = TRUE; */
+                }
+              } else {
+                if (mon_dmm270x1_enabled) changed = TRUE;
+              }
+
+            /* process hvdistr3 */
+            } else if (strcmp(pmondev->Name,"hvdistr3") == 0) {
+
+              hvdistr3handled = TRUE;
+              if (mon_hvdistr3_enabled && (nchvdistr3 == pmondev->Nchans)) {
+                if (hvdistr3state == 1) {
+                  DWORD tdelta;
+                  float *pvalues;
+
+                  pvalues = NULL;
+
+                  /* read Variables/Measured */
+                  if (db_find_key(hDB,0,"/Equipment/hvdistr3/Variables/Measured",&tkey)
+                     == CM_SUCCESS) {
+
+                    if (db_get_key_time(hDB,tkey,&tdelta) == DB_SUCCESS) {
+
+#ifdef MIDEBUG2
+                      printf(" hvdistr3 delta = %d\n",tdelta);
+#endif
+                      /* only updated values,
+                       * if values were updated in interval */
+                      if (tdelta > smon.Interval+1000) /* avoid integer overflow */ 
+                        tdelta = smon.Interval/1000+3;
+
+//                    if ((INT)tdelta*1000 <= smon.Interval+1000) {
+                      if (TRUE) {
+                        pvalues = (float *) calloc(pmondev->Nchans,sizeof(float));
+                        if (pvalues != NULL) {
+                          size = pmondev->Nchans*sizeof(float);
+                          if (db_get_data(hDB,tkey,(void *)pvalues,&size,TID_FLOAT)
+                            == CM_SUCCESS){
+
+                            n_mon_devices++;
+                            gnchans += pmondev->Nchans;
+                            strcat(gmondevs,"hvdistr3 ");
+
+                            /* write channels to log file */
+                            mon_file_channels(cur_year,cur_month,cur_day,runnumber,
+                                "hvdistr3", pmondev->Nchans,pvalues,NULL);
+
+                            /* do monitor statistics */
+                            if (mon_do_statistics) {
+                              for (i=0;i<pmondev->Nchans;i++) {
+                                /* if (*(pvalues+i) != -1.f) take all */
+                                  mon_chan_statistics(*(pmondev->pChannels+i),
+                                                      *(pvalues+i));
+                              }
+                              /* NIY periodically verify Settings/Names */
+                            }
+
+                          } else {
+                            cm_msg(MERROR,"mon_do","ERROR Reading Measured Variables");
+                          }
+                          free(pvalues);
+                          pvalues = NULL;
+
+                        } else {
+                          cm_msg(MERROR,"mon_do","ERROR Allocating Measured values");
+                        }
+#ifdef MIDEBUG
+                      } else {
+                        printf("hvdistr3 not updated in interval!\n");
+#endif
+                      }
+
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Getting update delta of "
+                                              "Variables/Measured of hvdistr3 channels");
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Finding Variables/Measured of hvdistr3 channels");
+                  }
+
+                } else {
+                  if ((hvdistr3state != 0) && (hvdistr3state != -1))
+                    cm_msg(MLOG,"mon_do","ERROR invalid state (%d) of hvdistr3 device",
+                                         hvdistr3state);
+                  /* RA95 12-AUG-2004 prevent monitor init when device falls off */
+                  /* changed = TRUE; */
+                }
+              } else {
+                if (mon_hvdistr3_enabled) changed = TRUE;
+              }
+
+            /* process hvdistr4 */
+            } else if (strcmp(pmondev->Name,"hvdistr4") == 0) {
+
+              hvdistr4handled = TRUE;
+              if (mon_hvdistr4_enabled && (nchvdistr4 == pmondev->Nchans)) {
+                if (hvdistr4state == 1) {
+                  DWORD tdelta;
+                  float *pvalues;
+
+                  pvalues = NULL;
+
+                  /* read Variables/Measured */
+                  if (db_find_key(hDB,0,"/Equipment/hvdistr4/Variables/Measured",&tkey)
+                     == CM_SUCCESS) {
+
+                    if (db_get_key_time(hDB,tkey,&tdelta) == DB_SUCCESS) {
+
+#ifdef MIDEBUG2
+                      printf(" hvdistr4 delta = %d\n",tdelta);
+#endif
+                      /* only updated values,
+                       * if values were updated in interval */
+                      if (tdelta > smon.Interval+1000) /* avoid integer overflow */ 
+                        tdelta = smon.Interval/1000+3;
+
+//                    if ((INT)tdelta*1000 <= smon.Interval+1000) {
+                      if (TRUE) {
+
+                        pvalues = (float *) calloc(pmondev->Nchans,sizeof(float));
+                        if (pvalues != NULL) {
+                          size = pmondev->Nchans*sizeof(float);
+                          if (db_get_data(hDB,tkey,(void *)pvalues,&size,TID_FLOAT)
+                            == CM_SUCCESS){
+
+                            n_mon_devices++;
+                            gnchans += pmondev->Nchans;
+                            strcat(gmondevs,"hvdistr4 ");
+
+                            /* write channels to log file */
+                            mon_file_channels(cur_year,cur_month,cur_day,runnumber,
+                                "hvdistr4", pmondev->Nchans,pvalues,NULL);
+
+                            /* do monitor statistics */
+                            if (mon_do_statistics) {
+                              for (i=0;i<pmondev->Nchans;i++) {
+                                /* if (*(pvalues+i) != -1.f) take all */
+                                  mon_chan_statistics(*(pmondev->pChannels+i),
+                                                      *(pvalues+i));
+                              }
+                              /* NIY periodically verify Settings/Names */
+                            }
+
+                          } else {
+                            cm_msg(MERROR,"mon_do","ERROR Reading Measured Variables");
+                          }
+                          free(pvalues);
+                          pvalues = NULL;
+
+                        } else {
+                          cm_msg(MERROR,"mon_do","ERROR Allocating Measured values");
+                        }
+#ifdef MIDEBUG
+                      } else {
+                        printf("hvdistr4 not updated in interval!\n");
+#endif
+                      }
+
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Getting update delta of "
+                                              "Variables/Measured of hvdistr4 channels");
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Finding Variables/Measured of hvdistr4 channels");
+                  }
+
+                } else {
+                  if ((hvdistr4state != 0) && (hvdistr4state != -1))
+                    cm_msg(MLOG,"mon_do","ERROR invalid state (%d) of hvdistr4 device",
+                                         hvdistr4state);
+                  /* RA95 12-AUG-2004 prevent monitor init when device falls off */
+                  /* changed = TRUE; */
+                }
+              } else {
+                if (mon_hvdistr4_enabled) changed = TRUE;
+              }
+
+            /* process lckinamp0 */
+            } else if (strcmp(pmondev->Name,"lckinamp0") == 0) {
+#ifdef MIDEBUG
+              printf("    processing lckinamp0: mon_lckinamp0_enabled = %d, ncliamp0 = "
+                     "%d, pmondev->Nchans=%d\n", mon_lckinamp0_enabled, ncliamp0,
+                     pmondev->Nchans);
+#endif
+              liamp0handled = TRUE;
+              if (mon_lckinamp0_enabled && (ncliamp0 == pmondev->Nchans)) {
+#ifdef MIDEBUG
+                printf("    liamp0state = %d\n",liamp0state);
+#endif
+                if (liamp0state == 1) {
+                  DWORD tdelta;
+                  float *pvalues,*pvalues1;
+
+                  pvalues = pvalues1 = NULL;
+
+                  /* read Variables/Measured */
+                  if (db_find_key(hDB,0,"/Equipment/lckinamp0/Variables/Input",&tkey)
+                     == CM_SUCCESS) {
+
+                    if (db_get_key_time(hDB,tkey,&tdelta) == DB_SUCCESS) {
+
+#ifdef MIDEBUG2
+                      printf(" lckinamp0 delta = %d\n",tdelta);
+#endif
+                      /* only updated values,
+                       * if values were updated in interval */
+                      if (tdelta > smon.Interval+1000) /* avoid integer overflow */ 
+                        tdelta = smon.Interval/1000+3;
+
+                      if ((INT)tdelta*1000 <= smon.Interval+1000) {
+//TESTTEST            if (TRUE) {
+                        pvalues = (float *) calloc(pmondev->Nchans,sizeof(float));
+                        pvalues1 = (float *) calloc(41,sizeof(float));
+                        if ((pvalues != NULL) && (pvalues1 != NULL)) {
+                          size = 41*sizeof(float);
+                          if (db_get_data(hDB,tkey,(void *)pvalues1,&size,TID_FLOAT)
+                                                                        == CM_SUCCESS){
+
+                            n_mon_devices++;
+                            gnchans += pmondev->Nchans;
+                            strcat(gmondevs,"lckinamp0 ");
+
+                            for (i=0;i<pmondev->Nchans;i++) {
+                              if (i < 10) { // only handle the first 10 Input channels
+                                *(pvalues+i) = *(pvalues1+i);
+                              }
+                            }
+
+                            /* write channels to log file */
+                            mon_file_channels(cur_year,cur_month,cur_day,runnumber,
+                                            "lckinamp0", pmondev->Nchans,pvalues,NULL);
+
+                            /* do monitor statistics */
+                            if (mon_do_statistics) {
+                              for (i=0;i<pmondev->Nchans;i++) {
+                                /* if (*(pvalues+i) != -1.f) take all */
+                                  mon_chan_statistics(*(pmondev->pChannels+i),
+                                                      *(pvalues+i));
+                              }
+                              /* NIY periodically verify Settings/Names */
+                            }
+
+                          } else {
+                            cm_msg(MERROR,"mon_do","ERROR Reading Measured values");
+                          }
+                          free(pvalues); pvalues = NULL;
+                          free(pvalues1); pvalues1 = NULL;
+
+                        } else {
+                          cm_msg(MERROR,"mon_do","ERROR Allocating Measured values");
+                          if (pvalues != NULL) {
+                            free(pvalues); pvalues = NULL;
+                          }
+                          if (pvalues1 != NULL) {
+                            free(pvalues1); pvalues1 = NULL;
+                          }
+                        }
+#ifdef MIDEBUG
+                      } else {
+                        printf("lckinamp0 not updated in interval!\n");
+#endif
+                      }
+
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Getting update delta of "
+                                            "Variables/Input of lckinamp0 channels");
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Finding Variables/Input of lckinamp0 channels");
+                  }
+
+                } else {
+                  if ((liamp0state != 0) && (liamp0state != -1))
+                    cm_msg(MLOG,"mon_do","ERROR invalid state (%d) of lckinamp0 device",
+                                         liamp0state);
+                  /* RA95 12-AUG-2004 prevent monitor init when device falls off */
+                  /* changed = TRUE; */
+                }
+              } else {
+                if (mon_lckinamp0_enabled) changed = TRUE;
+              }
+
+            /* process lckinamp1 */
+            } else if (strcmp(pmondev->Name,"lckinamp1") == 0) {
+#ifdef MIDEBUG
+              printf("    processing lckinamp1: mon_lckinamp1_enabled = %d, ncliamp1 = "
+                     "%d, pmondev->Nchans=%d\n", mon_lckinamp1_enabled, ncliamp1,
+                     pmondev->Nchans);
+#endif
+              liamp1handled = TRUE;
+              if (mon_lckinamp1_enabled && (ncliamp1 == pmondev->Nchans)) {
+#ifdef MIDEBUG
+                printf("    liamp1state = %d\n",liamp1state);
+#endif
+                if (liamp1state == 1) {
+                  DWORD tdelta;
+                  float *pvalues,*pvalues1;
+
+                  pvalues = pvalues1 = NULL;
+
+                  /* read Variables/Measured */
+                  if (db_find_key(hDB,0,"/Equipment/lckinamp1/Variables/Input",&tkey)
+                     == CM_SUCCESS) {
+
+                    if (db_get_key_time(hDB,tkey,&tdelta) == DB_SUCCESS) {
+
+#ifdef MIDEBUG2
+                      printf(" lckinamp1 delta = %d\n",tdelta);
+#endif
+                      /* only updated values,
+                       * if values were updated in interval */
+                      if (tdelta > smon.Interval+1000) /* avoid integer overflow */ 
+                        tdelta = smon.Interval/1000+3;
+
+                      if ((INT)tdelta*1000 <= smon.Interval+1000) {
+//TESTTEST            if (TRUE) {
+
+                        pvalues = (float *) calloc(pmondev->Nchans,sizeof(float));
+                        pvalues1 = (float *) calloc(41,sizeof(float));
+                        if ((pvalues != NULL) && (pvalues1 != NULL)) {
+                          size = 41*sizeof(float);
+                          if (db_get_data(hDB,tkey,(void *)pvalues1,&size,TID_FLOAT)
+                                                                        == CM_SUCCESS){
+
+                            n_mon_devices++;
+                            gnchans += pmondev->Nchans;
+                            strcat(gmondevs,"lckinamp1 ");
+
+                            for (i=0;i<pmondev->Nchans;i++) {
+                              if (i < 10) { // only handle the first 10 Input channels
+                                *(pvalues+i) = *(pvalues1+i);
+                              }
+                            }
+
+                            /* write channels to log file */
+                            mon_file_channels(cur_year,cur_month,cur_day,runnumber,
+                                            "lckinamp1", pmondev->Nchans,pvalues,NULL);
+
+                            /* do monitor statistics */
+                            if (mon_do_statistics) {
+                              for (i=0;i<pmondev->Nchans;i++) {
+                                /* if (*(pvalues+i) != -1.f) take all */
+                                  mon_chan_statistics(*(pmondev->pChannels+i),
+                                                      *(pvalues+i));
+                              }
+                              /* NIY periodically verify Settings/Names */
+                            }
+
+                          } else {
+                            cm_msg(MERROR,"mon_do","ERROR Reading Measured values");
+                          }
+                          free(pvalues); pvalues = NULL;
+                          free(pvalues1); pvalues1 = NULL;
+
+                        } else {
+                          cm_msg(MERROR,"mon_do","ERROR Allocating Measured values");
+                          if (pvalues != NULL) {
+                            free(pvalues); pvalues = NULL;
+                          }
+                          if (pvalues1 != NULL) {
+                            free(pvalues1); pvalues1 = NULL;
+                          }
+                        }
+#ifdef MIDEBUG
+                      } else {
+                        printf("lckinamp1 not updated in interval!\n");
+#endif
+                      }
+
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Getting update delta of "
+                                            "Variables/Input of lckinamp1 channels");
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Finding Variables/Input of lckinamp1 channels");
+                  }
+
+                } else {
+                  if ((liamp1state != 0) && (liamp1state != -1))
+                    cm_msg(MLOG,"mon_do","ERROR invalid state (%d) of lckinamp1 device",
+                                         liamp1state);
+                  /* RA95 12-AUG-2004 prevent monitor init when device falls off */
+                  /* changed = TRUE; */
+                }
+              } else {
+                if (mon_lckinamp1_enabled) changed = TRUE;
+              }
+
+            /* process lckinamp2 */
+            } else if (strcmp(pmondev->Name,"lckinamp2") == 0) {
+#ifdef MIDEBUG
+              printf("    processing lckinamp2: mon_lckinamp2_enabled = %d, ncliamp2 = "
+                     "%d, pmondev->Nchans=%d\n", mon_lckinamp2_enabled, ncliamp2,
+                     pmondev->Nchans);
+#endif
+              liamp2handled = TRUE;
+              if (mon_lckinamp2_enabled && (ncliamp2 == pmondev->Nchans)) {
+#ifdef MIDEBUG
+                printf("    liamp2state = %d\n",liamp2state);
+#endif
+                if (liamp2state == 1) {
+                  DWORD tdelta;
+                  float *pvalues,*pvalues1;
+
+                  pvalues = pvalues1 = NULL;
+
+                  /* read Variables/Measured */
+                  if (db_find_key(hDB,0,"/Equipment/lckinamp2/Variables/Input",&tkey)
+                     == CM_SUCCESS) {
+
+                    if (db_get_key_time(hDB,tkey,&tdelta) == DB_SUCCESS) {
+
+#ifdef MIDEBUG2
+                      printf(" lckinamp2 delta = %d\n",tdelta);
+#endif
+                      /* only updated values,
+                       * if values were updated in interval */
+                      if (tdelta > smon.Interval+1000) /* avoid integer overflow */ 
+                        tdelta = smon.Interval/1000+3;
+
+                      if ((INT)tdelta*1000 <= smon.Interval+1000) {
+//TESTTEST            if (TRUE) {
+
+                        pvalues = (float *) calloc(pmondev->Nchans,sizeof(float));
+                        pvalues1 = (float *) calloc(41,sizeof(float));
+                        if ((pvalues != NULL) && (pvalues1 != NULL)) {
+                          size = 41*sizeof(float);
+                          if (db_get_data(hDB,tkey,(void *)pvalues1,&size,TID_FLOAT)
+                                                                        == CM_SUCCESS){
+
+                            n_mon_devices++;
+                            gnchans += pmondev->Nchans;
+                            strcat(gmondevs,"lckinamp2 ");
+
+                            for (i=0;i<pmondev->Nchans;i++) {
+                              if (i < 10) { // only handle the first 10 Input channels
+                                *(pvalues+i) = *(pvalues1+i);
+                              }
+                            }
+
+                            /* write channels to log file */
+                            mon_file_channels(cur_year,cur_month,cur_day,runnumber,
+                                            "lckinamp2", pmondev->Nchans,pvalues,NULL);
+
+                            /* do monitor statistics */
+                            if (mon_do_statistics) {
+                              for (i=0;i<pmondev->Nchans;i++) {
+                                /* if (*(pvalues+i) != -1.f) take all */
+                                  mon_chan_statistics(*(pmondev->pChannels+i),
+                                                      *(pvalues+i));
+                              }
+                              /* NIY periodically verify Settings/Names */
+                            }
+
+                          } else {
+                            cm_msg(MERROR,"mon_do","ERROR Reading Input values");
+                          }
+                          free(pvalues); pvalues = NULL;
+                          free(pvalues1); pvalues1 = NULL;
+
+                        } else {
+                          cm_msg(MERROR,"mon_do","ERROR Allocating Input values");
+                          if (pvalues != NULL) {
+                            free(pvalues); pvalues = NULL;
+                          }
+                          if (pvalues1 != NULL) {
+                            free(pvalues1); pvalues1 = NULL;
+                          }
+                        }
+#ifdef MIDEBUG
+                      } else {
+                        printf("lckinamp2 not updated in interval!\n");
+#endif
+                      }
+
+                    } else {
+                      cm_msg(MERROR,"mon_do", "ERROR Getting update delta of "
+                                            "Variables/Input of lckinamp2 channels");
+                    }
+                  } else {
+                    cm_msg(MERROR,"mon_do",
+                           "ERROR Finding Variables/Input of lckinamp2 channels");
+                  }
+
+                } else {
+                  if ((liamp2state != 0) && (liamp2state != -1))
+                    cm_msg(MLOG,"mon_do","ERROR invalid state (%d) of lckinamp2 device",
+                                         liamp2state);
+                  /* RA95 12-AUG-2004 prevent monitor init when device falls off */
+                  /* changed = TRUE; */
+                }
+              } else {
+                if (mon_lckinamp2_enabled) changed = TRUE;
+              }
+
+            // now all monitored devices should be handled
+            } else {
+              cm_msg(MERROR,"mon_do","ERROR device %s may not be processed",
+                     pmondev->Name);
+            }
+
+          } /* for all devices in smon */
+        } /* smon.pDevices != NULL ? */
+
+        /* get monitor setup information about monitored devices from ODB */
+        mon_device_list();
+
+        /* mark devices that are not enabled as handled */
+        if (!mon_tc_enabled)        tchandled       = TRUE;
+        if (!mon_dvm_enabled)       dvmhandled      = TRUE;
+        if (!mon_ltc1_enabled)      ltc1handled     = TRUE;
+        if (!mon_ls3360_enabled)    ls3360handled   = TRUE;
+        if (!mon_ls3361_enabled)    ls3361handled   = TRUE;
+        if (!mon_heliox0_enabled)   heliox0handled  = TRUE;
+        if (!mon_variox0_enabled)   variox0handled  = TRUE;
+        if (!mon_dmm270x1_enabled)  dmm270x1handled = TRUE;
+        if (!mon_hvdistr3_enabled)  hvdistr3handled = TRUE;
+        if (!mon_hvdistr4_enabled)  hvdistr4handled = TRUE;
+        if (!mon_lckinamp0_enabled) liamp0handled   = TRUE;
+        if (!mon_lckinamp1_enabled) liamp1handled   = TRUE;
+        if (!mon_lckinamp2_enabled) liamp2handled   = TRUE;
+
+#ifdef MIDEBUG1
+        if (changed)           printf("Setup changed\n");
+        if (!dvmhandled)       printf("DVM        not handled\n");
+        if (!tchandled)        printf("TC         not handled\n");
+        if (!ltc1handled)      printf("templtc0   not handled\n");
+        if (!ls3360handled)    printf("templs3360 not handled\n");
+        if (!ls3361handled)    printf("templs3361 not handled\n");
+        if (!heliox0handled)   printf("heliox0    not handled\n");
+        if (!variox0handled)   printf("variox0    not handled\n");
+        if (!dmm270x1handled)  printf("dmm270x1   not handled\n");
+        if (!hvdistr3handled)  printf("hvdistr3   not handled\n");
+        if (!hvdistr4handled)  printf("hvdistr4   not handled\n");
+        if (!liamp0handled)    printf("lckinamp0  not handled\n");
+        if (!liamp1handled)    printf("lckinamp1  not handled\n");
+        if (!liamp2handled)    printf("lckinamp2  not handled\n");
+#endif
+
+      //if ((changed)||/*(!dvmhandled)||(!tchandled)||(!ltc1handled)||*/
+      //    /*(!ls3360handled)||*/(!ls3361handled)/*||(!dmm270x1handled)||*/
+      //    /*(!hvdistr3handled)||(!hvdistr4handled)*/
+      //    /*(!liamp0handled)||(!liamp1handled)||(!liamp2handled)*/
+      //    )
+      //  ; // NIY mon_do("MON_INIT",runnumber,runstate,"ODB_CHANGE");
+
+        if (changed) {
+          cm_msg(MLOG,"","MON_INIT due to ODB_CHANGE (Device List or Device channels)");
+          mon_do("MON_INIT",runnumber,runstate,"ODB_CHANGE");
+        }
+
+        if (strcmp(gmondevs,omondevs) != 0) {
+          mon_active_list(gmondevs);
+        }
+
+      /* any other command */
+      } else {
+        cm_msg(MERROR,"mon_do","Unknown command %s",cmd);
+      }
+    } else {
+      cm_msg(MERROR,"mon_do",
+             "NULL pointer to command or empty string supplied as command");
+    }
+  } else {
+    cm_msg(MERROR,"mon_do","Getting current localtime");
+  }
+
+#ifdef MIDEBUG
+  printf("<< mon_do(%s)\n",(cmd==NULL)?"NULL":cmd);
+#endif
+  return status;
+}
+
+/*------------------------------------------------------------------*/
+/*! \example mon_output.exa
+ */
+
+/*********************************************************************\
+
+EXAMPLES
+========
+
+daily monitor log file
+----------------------
+
+!M File = 2003_11_19.mon
+!
+! Record format is :
+!
+!  <time>\<device>\<n_vals>\<val1> ... \[<raw1> ...\]
+!
+!
+!D  Device: TC, 2 channels
+!F       Channel : Label                : Setpoint [K]
+!C            00 : Sensor 1             : 1
+!C            01 : Sensor 2             : 1.1
+!
+!D  Device: DVM, 2 channels
+!F       Channel : Label
+!C            00 : Test   1
+!C            01 : Input  1
+!
+!EOB
+!I 19-NOV-2003 14:08:27 : Monitor init.
+14:08:34\TC\2\0.998 0.057\
+14:08:34\DVM\2\-1.08057 -274.224\-1.08057 -1.07361\
+14:08:44\TC\2\0.997 0.057\
+
+:
+
+23:59:51\DVM\2\-0.596791 -274.292\-0.632656 -1.1421\
+!I 19-NOV-2003 23:59:59 : End of day.
+
+
+run specific monitor log file
+-----------------------------
+
+!R File = run_9936.mon
+!
+! Record format is :
+!
+!  <delta_time>\<device>\<n_vals>\<val1> ... \[<raw1> ...\]
+!    <delta_time> = [dd ]hh:mm:ss
+!
+!I 19-NOV-2003 14:08:27 : Begin of run 9936 due to MON_INIT.
+!
+!D  Device: TC, 2 channels
+!F       Channel : Label                : Setpoint [K]
+!C            00 : Sensor 1             : 1
+!C            01 : Sensor 2             : 1.1
+!
+!D  Device: DVM, 2 channels
+!F       Channel : Label
+!C            00 : Test   1
+!C            01 : Input  1
+!
+!EOB
+00:00:07\TC\2\0.998 0.057\
+00:00:07\DVM\2\-1.08057 -274.224\-1.08057 -1.07361\
+00:00:17\TC\2\0.997 0.0577\
+
+:
+
+00:46:06\TC\2\0.993 0.057\
+00:46:07\DVM\2\-0.589796 -274.291\-0.626096 -1.14061\
+!I 19-NOV-2003 16:13:40 : End of run 9936.
+!
+!D  Device: TC, 2 channels
+!S  0 : Sensor 1             : 161 : 0.996702 0.0041176 :
+!S  1 : Sensor 2             : 161 : 0.057 0 :
+!
+!D  Device: DVM, 2 channels
+!S  0 : Test   1             : 161 : -0.541151 0.441294 : -0.554817 0.441454 :
+!S  1 : Input  1             : 161 : -273.73 0.448649 : -0.580054 0.44865 :
+!
+!EOS
+
+Identifiers and data format
+---------------------------
+
+!M       =   header info : daily monitor log file
+
+!R       =   header info : run specific monitor log file (delta time)
+
+!D  Device: <name>, <number> channels    = Device name and number of channels
+!F       Channel : Label                 = Channel fields
+!C     <channel> : <label>               = Channel information (number, label)
+or including setpoint field
+!F       Channel : Label                : Setpoint [K]
+!C     <channel> : <label>              : <setpoint>
+!EOB
+
+!D  Device: <name>, <number> channels
+!S  <ch> : <label>           : <nvals> : <mean> <std dev> : = channel statistic
+or including raw readouts (before calibration and/or scaling)
+!S  <ch> : <label>           : <nvals> : <mean> <std dev> : <mean raw> <std raw>
+!EOS
+
+!I dd-MON-yyyy hh:mm:ss : <Information>
+                          Monitor init.
+                          Begin of run NNNN.
+                          Begin of run NNNN due to MON_INIT.
+                          Pausing run NNNN.
+                          Continuing run NNNN.
+                          End of run NNNN.
+                          End of run statistics NNNN due to MON_EXIT.
+                          Statistics due to MON_EXIT.
+                          Statistics due to end of day.
+                          Statistics due to start of new day.
+                          End of day.
+                          Monitor exit.
+
+Device readout for monitor log files is
+
+<time>\<device>\<n_vals>\<val1> ... \[<raw1> ...\]
+
+or for run specific log files
+
+<delta_time>\<device>\<n_vals>\<val1> ... \[<raw1> ...\]
+<delta_time> = [dd ]hh:mm:ss since start of run or monitor start.
+
+\********************************************************************/
+
+/*------------------------------------------------------------------*/
+/* EOF mon_do.c */
diff --git a/frontend/musr_midas.cxx b/frontend/musr_midas.cxx
new file mode 100644
index 0000000..2069973
--- /dev/null
+++ b/frontend/musr_midas.cxx
@@ -0,0 +1,1881 @@
+/* ==================================================================== */
+
+  /*
+   *  +--------------------------------------------------------------+
+   *  |                     Paul Scherrer Institut                   |
+   *  |                       Computing Division                     |
+   *  |                                                              |
+   *  | This software may be used freely by non-profit organizations.|
+   *  | It may be copied provided that the name of P.S.I. and of the |
+   *  | author is included. Neither P.S.I. nor the author assume any |
+   *  | responsibility for the use of this software outside of P.S.I.|
+   *  +--------------------------------------------------------------+
+   *
+   *  Project  . . . . . . . . . . :  Musr support software
+   *  Component/Facility . . . . . :  Midas for muSR DAQ/slow control
+   *  File Name  . . . . . . . . . :  musr_midas.c
+   *  Title  . . . . . . . . . . . :
+   *  Abstract . . . . . . . . . . :  contains muSR specific extensions of Midas.
+   *  Author . . . . . . . . . . . :  RA95 (extracted from ptantmusr.c)
+   *  Date of creation . . . . . . :  26-JUN-2000
+   *
+   *
+   *  Date        Name        Modification
+   *
+   *  -----------------------------------------------------------------
+   *  21-AUG-2000 RA95        current_frontendpath() modified : check_fename flag
+   *                          module now independent of musr_fe.h
+   *  28-NOV-2000 RA95        get_string now eliminates trailing blanks
+   *  18-DEC-2000 RA95        get_char adapted for OS_VMS
+   *  26-APR-2001 RA95        TRIM, COMPRESS & COLLAPSE in get_string
+   *  14-SEP-2001 RA95        get_float, get_double, OMIT_ODB added
+   *  29-OCT-2001 RA95        strtime added
+   *  28-MAY-2002 RA95        get_string & get_char adapted for OS_SOLARIS, OS_OSF1, 
+   *                          OS_LINUX
+   *  30-OCT-2003 RA95        current_runnumber & current_runstate modified
+   *                          to avoid setting undefined ODB key
+   *  30-OCT-2003 RA95        ReportEvent() call : message string parameter
+   *                          modified
+   *  12-JUL-2004 RA35        Update from 1.8.3 to 1.9.3
+   *  06-AUG-2004 RA35        #ifndef OMIT_MUSR_FE  to avoid undefined LogMessageToODB,
+   *                          current_runnumber & current_runstate
+   *  03-SEP-2004 RA35        modified get_string
+   *  18-NOV-2004 RA35        free_inbuf()
+   *  02-MAY-2005 RA36        client_in_list()
+   *  24-JUN-2005 RA36        client_in_list() BUGFIX
+   *  28-JUN-2005 RA36        client_in_list_reset()
+   *  05-MAY-2016 RA36        replaced FILENAME_MAX by MAX_STRING_LENGTH or MAX_ODB_PATH
+   *  15-MAY-2016 RA36        modified db_set_string to set key.item_size instead of
+   *                          strlen(string)+1 as data size
+   *  15-MAY-2016 RA36        LogMessage now calls cm_msg(MLOG,"",message) when 
+   *                          OMIT_MUSR_FE is #defined
+   */
+
+/* --------------------------------------------------------------------- */
+/* #define MIDEBUG */
+/* #define MIDEBUG1 */
+ 
+/* #define MIDEBUGM1  */  /* debug Midas          function                  */
+ 
+/* #define MIDEBUGM2  */  /* debug Midas          info                      */
+
+/* --------------------------------------------------------------------- */
+
+#include "midas.h"
+#include "msystem.h"
+#include "musr_midas.h"
+
+/* --------------------------------------------------------------------- */
+/* external variables and functions specified by the main program or another
+ * module
+ */
+
+#ifndef OMIT_ODB                /* omit ODB specific part */
+
+extern BOOL connected;          /* connection flag */
+
+#ifndef OMIT_MUSR_FE
+extern INT LogMessageToODB(char *, INT);        /* write message to ODB e.g. msg */
+extern INT update_runnumber(INT);
+extern INT update_runstate(INT);
+#endif
+
+/* --------------------------------------------------------------------- */
+static char sstrtmp[MAX_STRING_LENGTH];      /* temporary string */
+/* --------------------------------------------------------------------- */
+
+INT db_get_int(INT, char *, INT *, char *);
+INT db_set_int(INT, char *, INT, char *);
+INT db_get_bool(INT, char *, BOOL *, char *);
+INT db_set_bool(INT, char *, BOOL, char *);
+INT db_get_string(INT, char *, char *, INT, char *);
+INT db_set_string(INT, char *, char *, char *);
+
+void LogMessage(char *, INT, BOOL);
+
+INT current_runnumber(HNDLE, INT *);
+INT current_runstate(HNDLE, INT *);
+INT current_frontendpath(HNDLE, char *, char *, char *, char *, char *, BOOL);
+INT frontend_allowed(HNDLE, char *);
+
+#ifdef OBSOLETE_CODE
+INT client_in_list(HNDLE);
+INT client_in_list_reset(void);
+#endif
+
+#endif                          /* OMIT_ODB */
+
+INT elapsed_time(void);
+
+#ifndef DATESTR
+#define DATESTR 12
+#endif
+#ifndef TIMESTR
+#define TIMESTR 9
+#endif
+
+INT cur_date_time(char *, char *);
+char *strtime(INT, char *);
+
+INT get_int(char *, int, int, int *);
+INT get_uint(char *, unsigned int, unsigned int, unsigned int *);
+INT get_char(char *, char *, int, char *);
+INT get_string(char *, int, int, char *);
+INT get_float(char *, float, float, float *);
+INT get_double(char *, double, double, double *);
+INT free_inbuf(void);
+
+/*------------------------------------------------------------------*/
+#ifndef OMIT_ODB                /* omit ODB specific part */
+
+INT db_get_int(INT hDB, char *odbkey, INT * pkeyint, char *typestr)
+{
+
+/********************************************************************\
+
+  Routine:          db_get_int
+
+  Purpose:          Return int value of ODB key if key is found
+
+  Input:            odbkey   : key name (including path)
+                    typestr  : additional information about key
+
+  Output:           *pkeyint : int value of ODB key
+
+  Function return value:
+    CM_SUCCESS      Successful completion
+    CM_SET_ERROR    NULL pointer
+    ODB_...         Error returned by db_find_key, db_get_key
+
+\********************************************************************/
+
+   INT status;
+   INT size;
+   HNDLE tkey;
+
+#ifdef MIDEBUGM1
+   printf(">>> db_get_int\n key=%s, %s\n", odbkey, typestr);
+#endif
+   status = CM_SET_ERROR;
+   if ((odbkey != NULL) && (pkeyint != NULL)) {
+      if ((status = db_find_key(hDB, 0, odbkey, &tkey)) != DB_SUCCESS) {
+         snprintf(sstrtmp, MAX_STRING_LENGTH, "ERROR Finding ODB key %s (%s)", odbkey,
+                 typestr ? typestr : "?");
+         ErrorLog(sstrtmp, status);
+         return status;
+      }
+      *pkeyint = 0;
+      size = sizeof(INT);
+#ifdef MIDEBUGM2
+      printf("calling db_get_value\n");
+#endif
+      if ((status =
+           db_get_value(hDB, 0, odbkey, pkeyint, &size, TID_INT, FALSE)) != DB_SUCCESS) {
+         snprintf(sstrtmp,MAX_STRING_LENGTH,"ERROR Reading ODB key int value of %s (%s)",
+                  odbkey, typestr ? typestr : "?");
+         ErrorLog(sstrtmp, status);
+         return status;
+      }
+#ifdef MIDEBUGM2
+      printf("size=%d\n", size);
+#endif
+      status = SUCCESS;
+   } else {
+      if (odbkey == NULL)
+         ErrorLog("ERROR db_get_int NULL pointer supplied as ODB path!", 0);
+      if (pkeyint == NULL)
+         ErrorLog("ERROR db_get_int NULL pointer supplied as return " "parameter!", 0);
+   }
+#ifdef MIDEBUGM1
+   printf("<<< db_get_int : %d\n", *pkeyint);
+#endif
+
+   return status;
+}
+
+/*------------------------------------------------------------------*/
+
+INT db_set_int(INT hDB, char *odbkey, INT keyint, char *typestr)
+{
+
+/********************************************************************\
+
+  Routine:          db_set_int
+
+  Purpose:          Set (update) int value of ODB key if key is found in ODB
+
+  Input:            odbkey   : key name (including path)
+                    typestr  : additional information about key
+                    keyint   : new int value of ODB key
+
+  Function return value:
+    CM_SUCCESS      Successful completion
+    CM_SET_ERROR    NULL pointer
+    ODB_...         Error returned by db_find_key, db_get_key
+
+\********************************************************************/
+
+   INT status;
+   HNDLE tkey;
+
+#ifdef MIDEBUGM1
+   printf(">>> db_set_int %s, %s = %d\n", odbkey, typestr, keyint);
+#endif
+   status = CM_SET_ERROR;
+   if (odbkey != NULL) {
+      if ((status = db_find_key(hDB, 0, odbkey, &tkey)) != DB_SUCCESS) {
+         snprintf(sstrtmp, MAX_STRING_LENGTH, "ERROR Finding ODB key %s (%s)", odbkey,
+                 typestr ? typestr : "?");
+         ErrorLog(sstrtmp, status);
+         return status;
+      }
+#ifdef MIDEBUGM2
+      printf("calling db_set_value\n");
+#endif
+      if ((status =
+           db_set_value(hDB, 0, odbkey, &keyint, sizeof(INT), 1,
+                        TID_INT)) != DB_SUCCESS) {
+         snprintf(sstrtmp, MAX_STRING_LENGTH, "ERROR Writing ODB key int value %s (%s)",
+                  odbkey, typestr ? typestr : "?");
+         ErrorLog(sstrtmp, status);
+         return status;
+      }
+      status = SUCCESS;
+   } else
+      ErrorLog("ERROR db_set_int NULL pointer supplied as ODB path!", 0);
+
+#ifdef MIDEBUGM1
+   printf("<<< db_set_int \n");
+#endif
+   return status;
+}
+
+/*------------------------------------------------------------------*/
+
+INT db_get_bool(INT hDB, char *odbkey, BOOL * pkeybool, char *typestr)
+{
+
+/********************************************************************\
+
+  Routine:          db_get_bool
+
+  Purpose:          Return bool value of ODB key if key is found
+
+  Input:            odbkey    : key name (including path)
+                    typestr   : additional information about key
+
+  Output:           *pkeybool : bool value of ODB key
+
+  Function return value:
+    CM_SUCCESS      Successful completion
+    CM_SET_ERROR    NULL pointer
+    ODB_...         Error returned by db_find_key, db_get_key
+
+\********************************************************************/
+
+   INT status;
+   INT size;
+   HNDLE tkey;
+
+#ifdef MIDEBUGM1
+   printf(">>> db_get_bool\n %s, %s\n", odbkey, typestr);
+#endif
+   status = CM_SET_ERROR;
+   if ((odbkey != NULL) && (pkeybool != NULL)) {
+      if ((status = db_find_key(hDB, 0, odbkey, &tkey)) != DB_SUCCESS) {
+         snprintf(sstrtmp, MAX_STRING_LENGTH, "ERROR Finding ODB key %s (%s)", odbkey,
+                 typestr ? typestr : "?");
+         ErrorLog(sstrtmp, status);
+         return status;
+      }
+      *pkeybool = 0;
+      size = sizeof(INT);
+      if ((status =
+           db_get_value(hDB, 0, odbkey, pkeybool, &size, TID_BOOL,
+                        FALSE)) != DB_SUCCESS) {
+         snprintf(sstrtmp, MAX_STRING_LENGTH, "ERROR Reading ODB key bool value of %s "
+                  "(%s)", odbkey, typestr ? typestr : "?");
+         ErrorLog(sstrtmp, status);
+         return status;
+      }
+#ifdef MIDEBUGM2
+      printf("size=%d\n", size);
+#endif
+      status = SUCCESS;
+   } else {
+      if (odbkey == NULL)
+         ErrorLog("ERROR db_get_bool NULL pointer supplied as ODB path!", 0);
+      if (pkeybool == NULL)
+         ErrorLog("ERROR db_get_bool NULL pointer supplied as return " "parameter!", 0);
+   }
+#ifdef MIDEBUGM1
+   printf("<<< db_get_bool %d\n", *pkeybool);
+#endif
+   return status;
+}
+
+/*------------------------------------------------------------------*/
+
+INT db_set_bool(INT hDB, char *odbkey, BOOL keybool, char *typestr)
+{
+
+/********************************************************************\
+
+  Routine:       db_set_bool
+
+  Purpose:       Set (update) bool value of ODB key if key is found in ODB
+
+  Input:         odbkey   : key name (including path)
+                 typestr  : additional information about key
+                 keybool  : new bool value of ODB key
+
+  Function return value:
+    CM_SUCCESS   Successful completion
+    CM_SET_ERROR NULL pointer
+    ODB_...      Error returned by db_find_key, db_get_key
+
+\********************************************************************/
+
+   INT status;
+   HNDLE tkey;
+
+#ifdef MIDEBUGM1
+   printf(">>> db_set_bool %s, %s = %d\n", odbkey, typestr, keybool);
+#endif
+   status = CM_SET_ERROR;
+   if (odbkey != NULL) {
+      if ((status = db_find_key(hDB, 0, odbkey, &tkey)) != DB_SUCCESS) {
+         snprintf(sstrtmp, MAX_STRING_LENGTH, "ERROR Finding ODB key %s (%s)", odbkey,
+                 typestr ? typestr : "?");
+         ErrorLog(sstrtmp, status);
+         return status;
+      }
+#ifdef MIDEBUGM2
+      printf("calling db_set_value\n");
+#endif
+      if ((status = db_set_value(hDB, 0, odbkey, &keybool, sizeof(BOOL), 1, TID_BOOL)) !=
+          DB_SUCCESS) {
+         snprintf(sstrtmp, MAX_STRING_LENGTH, "ERROR Writing %s (%s) as bool ODB key", 
+                  odbkey, typestr ? typestr : "?");
+         ErrorLog(sstrtmp, status);
+         return status;
+      }
+      status = SUCCESS;
+   } else
+      ErrorLog("ERROR db_set_bool NULL pointer supplied as ODB path!", 0);
+
+#ifdef MIDEBUGM1
+   printf("<<< db_set_bool \n");
+#endif
+   return status;
+}
+
+/*------------------------------------------------------------------*/
+
+INT db_get_string(INT hDB, char *odbkey, char *pkeystr, INT strsize, char *typestr)
+{
+/********************************************************************\
+
+  Routine:       db_get_string
+
+  Purpose:       Return string value of ODB key if key is found
+
+  Input:         odbkey   : key name (including path)
+                 strsize  : max length of string
+                 typestr  : additional information about key
+
+  Output:        *pkeystr : string value of ODB key
+
+  Function return value:
+    CM_SUCCESS   Successful completion
+    CM_SET_ERROR NULL pointer
+    ODB_...      Error returned by db_find_key, db_get_key
+
+\********************************************************************/
+
+   INT status;
+   INT size;
+   HNDLE tkey;
+
+#ifdef MIDEBUGM1
+   printf(">>> db_get_string\n %s, size=%d, %s\n", odbkey, strsize, typestr);
+#endif
+   status = CM_SET_ERROR;
+   if ((odbkey != NULL) && (pkeystr != NULL) && (strsize > 0)) {
+      if ((status = db_find_key(hDB, 0, odbkey, &tkey)) != DB_SUCCESS) {
+         snprintf(sstrtmp, MAX_STRING_LENGTH, "ERROR Finding ODB key %s (%s)", odbkey,
+                 typestr ? typestr : "?");
+         ErrorLog(sstrtmp, status);
+         return status;
+      }
+      *pkeystr = '\0';
+      size = strsize;
+      if ((status =
+           db_get_value(hDB, 0, odbkey, (void *) pkeystr, &size, TID_STRING,
+                        FALSE)) != DB_SUCCESS) {
+         snprintf(sstrtmp, MAX_STRING_LENGTH, "ERROR Reading ODB key string value %s "
+                                              "(%s)", odbkey, typestr ? typestr : "?");
+         ErrorLog(sstrtmp, status);
+         return status;
+      }
+#ifdef MIDEBUGM2
+      printf("pkeystr=%s, size = %d, strlen = %d\n", pkeystr, size, strlen(pkeystr));
+#endif
+      status = SUCCESS;
+   } else {
+      if (odbkey == NULL)
+         ErrorLog("ERROR db_get_string : NULL pointer supplied as ODB " "path!", 0);
+      if (pkeystr == NULL)
+         ErrorLog("ERROR db_get_string : NULL pointer supplied as return "
+                  "parameter!", 0);
+      if (strsize <= 0)
+         ErrorLog("ERROR db_get_string Invalid string size!", 0);
+   }
+#ifdef MIDEBUGM1
+   printf("<<< db_get_string %s\n", pkeystr);
+#endif
+   return status;
+}
+
+/*------------------------------------------------------------------*/
+
+INT db_set_string(INT hDB, char *odbkey, char *keystr, char *typestr)
+{
+
+/********************************************************************\
+
+  Routine:       db_set_string
+
+  Purpose:       Set (update) string value of ODB key if key is found in ODB
+
+  Input:         odbkey   : key name (including path)
+                 typestr  : additional information about key
+                 keystr   : new string value of ODB key
+
+  Function return value:
+    CM_SUCCESS   Successful completion
+    CM_SET_ERROR NULL pointer
+    ODB_...      Error returned by db_find_key, db_get_key
+
+\********************************************************************/
+
+   INT status;
+   HNDLE tkey;
+
+#ifdef MIDEBUGM1
+   printf(">>> db_set_string %s, %s = %s\n", odbkey, typestr, keystr);
+#endif
+   status = CM_SET_ERROR;
+   if ((odbkey != NULL) && (keystr != NULL)) {
+      KEY key;
+      if ((status = db_find_key(hDB, 0, odbkey, &tkey)) != DB_SUCCESS) {
+         snprintf(sstrtmp, MAX_STRING_LENGTH, "ERROR Finding ODB key %s (%s)", odbkey,
+                 typestr ? typestr : "?");
+         ErrorLog(sstrtmp, status);
+         return status;
+      }
+#ifdef MIDEBUGM2
+      printf("calling db_get_key\n");
+#endif
+      if ((status = db_get_key(hDB, tkey, &key)) != DB_SUCCESS) {
+         snprintf(sstrtmp, MAX_STRING_LENGTH, "ERROR Reading ODB key %s (%s) KEY info", 
+                  odbkey, typestr ? typestr : "?");
+         ErrorLog(sstrtmp, status);
+         return status;
+      }
+#ifdef MIDEBUGM2
+      printf("calling db_set_value\n");
+#endif
+      /* BUG FIX RA36 15-MAY-2016 if strlen+1 <= keysize use keysize */
+      if (strlen(keystr)+1 <= key.item_size) {
+        status = db_set_value(hDB, 0, odbkey, keystr, key.item_size, 1, TID_STRING);
+      } else {
+        /* initial code was always setting strlen(keystr)+1 */
+        status = db_set_value(hDB, 0, odbkey, keystr, strlen(keystr)+1, 1, TID_STRING);
+        printf("WARNING db_set_string(%s) string_length+1 (%d) is larger than item "
+               "size %d\n", odbkey, (INT) strlen(keystr)+1, key.item_size);
+      } 
+      if (status != DB_SUCCESS) {
+         snprintf(sstrtmp, MAX_STRING_LENGTH, "ERROR Writing ODB key string value %s "
+                  "(%s)", odbkey, typestr ? typestr : "?");
+         ErrorLog(sstrtmp, status);
+         return status;
+      }
+      status = SUCCESS;
+   } else {
+     if (odbkey == NULL)
+      ErrorLog("ERROR db_set_string : NULL pointer supplied as ODB path!", 0);
+     if (keystr == NULL)
+      ErrorLog("ERROR db_set_string : NULL pointer supplied as ODB string to set!", 0);
+   }
+#ifdef MIDEBUGM1
+   printf("<<< db_set_string \n");
+#endif
+   return status;
+}
+
+/*------------------------------------------------------------------*/
+
+void LogMessage(char *message, INT status, BOOL exitflag)
+{
+
+/********************************************************************\
+
+  Routine:       LogMessage
+
+  Purpose:       Propagate error and informational messages to log devices
+
+  Input:         message  : message string
+                 status   : error status
+                 exitflag : if True program is terminated
+
+  Output:
+
+  Function return value:    none
+
+\********************************************************************/
+
+#ifdef MIDEBUG1
+   printf(">>>LogMessage\n");
+#endif
+   /* valid message ? */
+   if ((message != NULL) && (strlen(message) > 0)) {
+
+#ifdef MIDEBUG2
+      /* write to stdout */
+      if (status != 0)
+         printf("%s, status = %d, exitflag = %d\n", message, status, exitflag);
+      else
+         printf("%s, exitflag = %d\n", message,exitflag);
+#endif
+
+#ifdef MIDEBUG
+#ifndef DATESTR
+#define DATESTR 12
+#endif
+#ifndef TIMESTR
+#define TIMESTR 9
+#endif
+      /* log to midas_debug.log in current working directory */
+      {
+         FILE *logfile;
+         char date[DATESTR], time[TIMESTR];
+         if ((logfile = fopen("midas_debug.log", "a+")) != NULL) {
+            cur_date_time(date, time);
+            if (exitflag) 
+              if (status != 0) {
+                fprintf(logfile, "%s %s : %s, status = %d, EXITFLAG\n", date, time, 
+                                                                        message, status);
+              } else {
+                fprintf(logfile, "%s %s : %s EXITFLAG\n", date, time, message);
+              }
+            else
+              if (status != 0) {
+                fprintf(logfile, "%s %s : %s, status = %d\n", date, time, message, 
+                                                              status);
+              } else {
+                fprintf(logfile, "%s %s : %s\n", date, time, message);
+              }
+            fclose(logfile);
+         }
+      }
+#endif
+
+#ifndef OMIT_MUSR_FE
+      /* copy error message to frontend's section of ODB and midas.log  on back end */
+      if (connected)
+         LogMessageToODB(message, status);
+#else
+      /* if (connected) */
+        cm_msg(MLOG,"","LogMessage: %s",message);
+#endif
+
+#ifdef OS_WINNT
+      /* on Windows NT, write error information, only, into the application log file */
+      if ((strlen(message) > 5) && (strstr(message, "ERROR") != NULL)) {
+         HANDLE eventsource;
+
+         if ((eventsource = RegisterEventSource(NULL, "Midas")) != NULL) {
+            char *pts[1];
+            pts[0] = message;   /* RA95 30-OCT-2003 */
+
+            /* ReportEvent to Windows NT EventLogger */
+            if (ReportEvent(eventsource,        /* event handle                   */
+                            EVENTLOG_ERROR_TYPE,        /* event type             */
+                            0,  /* event category                         */
+                            status,     /* event ID                               */
+                            NULL,       /* user security identifier               */
+                            1,  /* number of strings to merge             */
+                            0,  /* number of event specific bytes         */
+                            pts,        /* array of strings to merge with message */
+                            NULL        /* address of binary data                 */
+                ) == 0) {
+               DWORD rete;
+               rete = GetLastError();
+
+               printf("ERROR ReportEvent failed! Error code = %d\n", rete);
+            }
+            DeregisterEventSource(eventsource);
+         } else
+            printf("ERROR returned by RegisterEventSource\n");
+      }
+#endif
+
+   }
+
+   /* is exitflag set? */
+   if (exitflag) {
+      if (connected)
+         cm_disconnect_experiment();
+      connected = FALSE;
+#ifdef MIDEBUG
+      printf("<<<LogMessage -> Exit\n");
+#endif
+      exit(1);
+   }
+#ifdef MIDEBUG1
+   printf("<<<LogMessage\n");
+#endif
+}
+
+/*------------------------------------------------------------------*/
+
+INT current_runnumber(HNDLE hDB, INT * runnumber)
+{
+/********************************************************************\
+
+  Routine:       current_runnumber
+
+  Purpose:       Get run number from ODB and change global run_number if changed
+
+  Input:         hDB        : ODB handle
+
+  Output:        *runnumber : run number
+
+  Function return value:
+    CM_SUCCESS   Successful completion
+
+\********************************************************************/
+   INT status;
+   INT size;
+   INT currun;
+   status = SUCCESS;
+
+#ifdef MIDEBUGM1
+   printf(">>>current_runnumber\n");
+#endif
+
+   /* avoid setting an invalid run number if the key is not present
+    * NOTE: Midas sets the value when db_get_value is called on a missing
+    *       ODB key.
+    */
+   if (runnumber == NULL) {
+      HNDLE tkey;
+      INT itry;
+
+      itry = 0;
+
+    find_again:
+      itry++;
+
+      if ((status = db_find_key(hDB, 0, "/Runinfo/Run number", &tkey)) != DB_SUCCESS) {
+         ErrorLog("ERROR finding key /Runinfo/Run number", status);
+         if (itry < 3)
+            goto find_again;
+
+         ErrorLog("Too many errors finding key /Runinfo/Run number", status);
+         return status;
+      } else {
+         currun = 0;            /* set an invalid run number */
+      }
+   } else {
+      currun = *runnumber;      /* if ODB variable is not defined set current value */
+   }
+
+   /* get current run number from ODB */
+   size = sizeof(currun);
+   if ((status =
+        db_get_value(hDB, 0, "/Runinfo/Run number", &currun, &size, TID_INT,
+                     FALSE)) != SUCCESS) {
+      ErrorLog("ERROR Reading /Runinfo/Run number", status);
+      return status;
+   }
+#ifdef MIDEBUGM1
+   printf("run number = %d\n", currun);
+#endif
+
+   /* update run_number */
+   if ((runnumber == NULL) || (*runnumber == 0) || (currun != *runnumber)) {
+#ifndef OMIT_MUSR_FE
+      update_runnumber(currun);
+#endif
+      if (runnumber != NULL)
+         *runnumber = currun;
+   }
+#ifdef MIDEBUGM1
+   printf("<<<current_runnumber\n");
+#endif
+   return status;
+}
+
+/*------------------------------------------------------------------*/
+
+INT current_runstate(HNDLE hDB, INT * runstate)
+{
+
+/********************************************************************\
+
+  Routine:       current_runstate
+
+  Purpose:       Get run state from ODB and change global run_state if changed
+
+  Input:         hDB       : ODB handle
+
+  Output:        *runstate : run state
+
+  Function return value:
+    CM_SUCCESS   Successful completion
+
+\********************************************************************/
+   INT status;
+   INT size;
+   INT curstate;
+   status = SUCCESS;
+
+#ifdef MIDEBUGM1
+   printf(">>>current_runstate\n");
+#endif
+
+   /* avoid setting an invalid run state if the key is not present
+    * NOTE: Midas sets the value when db_get_value is called on a missing
+    *       ODB key.
+    */
+   if (runstate == NULL) {
+      HNDLE tkey;
+      INT itry;
+
+      itry = 0;
+
+    find_again:
+      itry++;
+
+      if ((status = db_find_key(hDB, 0, "/Runinfo/State", &tkey)) != DB_SUCCESS) {
+         ErrorLog("ERROR finding key /Runinfo/State", status);
+         if (itry < 3)
+            goto find_again;
+
+         ErrorLog("Too many errors finding key /Runinfo/State", status);
+         return status;
+      } else {
+         curstate = 0;          /* set an invalid run state */
+      }
+   } else {
+      curstate = *runstate;     /* if ODB variable is not defined set current value */
+   }
+
+   /* get current run state from ODB */
+   size = sizeof(curstate);
+   curstate = STATE_STOPPED;
+   if ((status =
+        db_get_value(hDB, 0, "/Runinfo/State", &curstate, &size, TID_INT,
+                     FALSE)) != SUCCESS) {
+      ErrorLog("ERROR Reading /Runinfo/State", status);
+      return status;
+   }
+#ifdef MIDEBUGM1
+   printf("run state = %d\n", curstate);
+#endif
+
+   /* update run_state */
+   if ((runstate == NULL) || (*runstate == 0) || (curstate != *runstate)) {
+#ifndef OMIT_MUSR_FE
+      update_runstate(curstate);
+#endif
+      if (runstate != NULL)
+         *runstate = curstate;
+   }
+#ifdef MIDEBUGM1
+   printf("<<<current_runstate\n");
+#endif
+   return status;
+}
+
+/*------------------------------------------------------------------*/
+
+  /* -- find front end subkey in ODB -- */
+INT current_frontendpath(HNDLE hDB, char *odbpath, char *frontend_name, char *fetype,
+                         char *exptype, char *expgroup, BOOL check_fename)
+{
+
+/********************************************************************\
+
+  Routine:       current_frontendpath
+
+  Purpose:       Return front end path specified by FE_NAME, FE_TYPE,
+                 EXP_NAME and EXP_GROUP in the sequence
+                 /$(exp_group)/$(exp_type)/$(equipment)/$(fe_type)/$(fe_name)/
+
+  Input:         FE_NAME,FE_TYPE,EXP_NAME,EXP_GROUP : front end settings from setup file
+
+  Output:        *odbpath  : ODB path of front end
+
+  Function return value:
+    CM_SUCCESS   Successful completion
+
+\********************************************************************/
+   INT status;
+   INT size;
+   HNDLE tkey;
+   char odbtmp[MAX_ODB_PATH], tkeystr[MAX_STRING_LENGTH];
+
+#ifdef MIDEBUGM1
+   printf(">>>current_frontendpath\n");
+#endif
+   status = SUCCESS;
+
+   /* all parameter as expected? */
+   if ((frontend_name == NULL) || (strlen(frontend_name) <= 0) || (fetype == NULL) ||
+       (strlen(fetype) <= 0) || (exptype == NULL) || (strlen(exptype) <= 0) ||
+       (expgroup == NULL) || (strlen(expgroup) <= 0) || (odbpath == NULL)) {
+
+      if (check_fename && ((frontend_name == NULL) || (strlen(frontend_name) <= 0))) {
+         sprintf(sstrtmp, "ERROR in current_frontendpath : Invalid frontend_name!");
+         ErrorTerminate(sstrtmp, 0);
+      }
+      if ((fetype == NULL) || (strlen(fetype) <= 0)) {
+         sprintf(sstrtmp, "ERROR in current_frontendpath : Invalid frontend type!");
+         ErrorTerminate(sstrtmp, 0);
+      }
+      if ((exptype == NULL) || (strlen(exptype) <= 0)) {
+         sprintf(sstrtmp, "ERROR in current_frontendpath : Invalid experiment type!");
+         ErrorTerminate(sstrtmp, 0);
+      }
+      if ((expgroup == NULL) || (strlen(expgroup) <= 0)) {
+         sprintf(sstrtmp, "ERROR in current_frontendpath : Invalid experiment group!");
+         ErrorTerminate(sstrtmp, 0);
+      }
+      if (odbpath == NULL) {
+         sprintf(sstrtmp, "ERROR in current_frontendpath : NULL pointer to ODB path!");
+         ErrorTerminate(sstrtmp, 0);
+      }
+   }
+
+   /* does key for experiment group exist? */
+   snprintf(odbtmp, MAX_ODB_PATH, "/%s", expgroup);
+#ifdef MIDEBUGM1
+   printf("odbtmp = %s\n", odbtmp);
+#endif
+   if ((status = db_find_key(hDB, 0, odbtmp, &tkey)) != DB_SUCCESS) {
+      snprintf(sstrtmp, MAX_STRING_LENGTH, "ERROR Finding %s key (experiment group)", 
+               odbtmp);
+      ErrorLog(sstrtmp, status);
+      if (status == DB_INVALID_HANDLE)
+         status = SS_ABORT;
+      return status;
+   }
+   snprintf(odbpath, MAX_ODB_PATH, "/%s/", expgroup);
+
+   /* get experiment type of experiment group */
+   snprintf(odbtmp, MAX_ODB_PATH, "%sexp_type", odbpath);
+#ifdef MIDEBUGM1
+   printf("odbtmp = %s\n", odbtmp);
+#endif
+   if ((status = db_get_string(hDB, odbtmp, tkeystr, sizeof(tkeystr), "exp_type")) !=
+       CM_SUCCESS)
+      return status;
+#ifdef MIDEBUGM1
+   printf("tkeystr = %s\n", tkeystr);
+#endif
+
+   /* exp_type from setup identical to ODB exp_type? */
+   if (!equal_ustring(tkeystr, exptype)) {
+      snprintf(sstrtmp, MAX_STRING_LENGTH, "ERROR experiment type %s in setup != %s "
+               "in ODB", exptype, tkeystr);
+      ErrorLog(sstrtmp, 0);
+      return 0;
+   }
+   strcat(odbpath, tkeystr);
+
+   /* get current equipment $(/$(exp_group)/$(exp_type)/equipment) */
+   strcpy(odbtmp, odbpath);
+   strcat(odbtmp, "/equipment");
+#ifdef MIDEBUGM1
+   printf("odbtmp = %s\n", odbtmp);
+#endif
+   if ((status = db_get_string(hDB, odbtmp, tkeystr, sizeof(tkeystr), "equipment")) !=
+       CM_SUCCESS)
+      return status;
+#ifdef MIDEBUGM1
+   printf("tkeystr = %s\n", tkeystr);
+#endif
+
+
+   /* /$(exp_group)/$(exp_type)/$(equipment)/$(fe_type)/ */
+   strcat(odbpath, "/");
+   strcat(odbpath, tkeystr);
+   strcat(odbpath, "/");
+   strcat(odbpath, fetype);
+   strcat(odbpath, "/");
+
+   /* get key value $(/$(exp_group)/$(exp_type)/$(equipment)/$(fe_type)/$(fe_type)) */
+   strcpy(odbtmp, odbpath);
+   strcat(odbtmp, fetype);
+#ifdef MIDEBUGM1
+   printf("odbtmp = %s\n", odbtmp);
+#endif
+
+   if ((status =
+        db_get_string(hDB, odbtmp, tkeystr, sizeof(tkeystr), fetype)) != CM_SUCCESS)
+      return status;
+
+#ifdef MIDEBUGM1
+   printf("tkeystr = %s\n", tkeystr);
+#endif
+
+   /* front_end name from setup identical to $(...../$(fe_type)/$(fe_type))? */
+   if (check_fename && (!equal_ustring(tkeystr, frontend_name))) {
+      snprintf(sstrtmp, MAX_STRING_LENGTH, "ERROR frontend name %s in setup file != %s "
+               "in ODB", frontend_name, tkeystr);
+      ErrorLog(sstrtmp, 0);
+      return 0;
+   }
+
+   /* path is /$(exp_group)/$(exp_type)/$(equipment)/$(fe_type)/$(fe_name) */
+   strcat(odbpath, tkeystr);
+   strcpy(odbtmp, odbpath);
+   if ((status = db_find_key(hDB, 0, odbtmp, &tkey)) != DB_SUCCESS) {
+      snprintf(sstrtmp, MAX_STRING_LENGTH,"ERROR Finding %s key (ODB directory)",odbtmp);
+      ErrorLog(sstrtmp, status);
+      return status;
+   }
+
+   /* final path is /$(exp_group)/$(exp_type)/$(equipment)/$(fe_type)/$(fe_name)/ */
+   strcat(odbpath, "/");
+
+#ifdef MIDEBUGM1
+   printf("odbpath = %s\n", odbpath);
+#endif
+
+#ifdef MIDEBUGM1
+   printf("<<<current_frontendpath\n");
+#endif
+   return status;
+}
+
+/*------------------------------------------------------------------*/
+
+INT frontend_allowed(HNDLE hDB, char *odbpath)
+{
+
+/********************************************************************\
+
+  Routine:       frontend_allowed
+
+  Purpose:       compare value of host key in odbpath with front end host name
+
+  Input:         hDB        : ODB handle
+                 *odbpath   : front end specific ODB path
+  Output:
+
+  Function return value:
+    CM_SUCCESS      Successful completion frontend is allowed
+    FE_ERR_DISABLED         Front end is not allowed
+
+\********************************************************************/
+   INT status;
+   INT size;
+   HNDLE tkey;
+   char odbtmp[MAX_ODB_PATH], tkeystr[MAX_STRING_LENGTH];
+   char hostname[MAX_STRING_LENGTH];
+
+#ifdef MIDEBUGM1
+   printf(">>>frontend_allowed\n");
+#endif
+   if ((odbpath == NULL) || (strlen(odbpath) <= 4)) {
+      sprintf(sstrtmp, "ERROR in frontend_allowed : Invalid ODB path");
+      ErrorTerminate(sstrtmp, 0);
+   }
+
+   if ((status = gethostname(hostname, MAX_STRING_LENGTH)) == 0) {
+      char *phostname;
+
+#ifdef MIDEBUGM1
+      printf("hostname = %s \n", hostname);
+#endif
+
+      /* truncate full domain name to get host name */
+      if ((phostname = strstr(hostname, ".")) != NULL)
+         *phostname = '\0';
+
+      /* get value of host key */
+      snprintf(odbtmp, MAX_ODB_PATH, "%shost", odbpath);
+#ifdef MIDEBUGM1
+      printf("odbtmp = %s\n", odbtmp);
+#endif
+      if ((status =
+           db_get_string(hDB, odbtmp, tkeystr, sizeof(tkeystr), "host")) != CM_SUCCESS)
+         return status;
+
+#ifdef MIDEBUGM1
+      printf("tkeystr = %s\n", tkeystr);
+#endif
+
+      if (!equal_ustring(tkeystr, hostname)) {
+         snprintf(sstrtmp, MAX_STRING_LENGTH, "ERROR host name %s is not identical "
+                  "with allowed host name %s in ODB", hostname, tkeystr);
+         status = FE_ERR_DISABLED;
+         ErrorLog(sstrtmp, status);
+         return status;
+      }
+   } else {
+      sprintf(sstrtmp, "ERROR returned by gethostname");
+      ErrorLog(sstrtmp, status);
+   }
+#ifdef MIDEBUGM1
+   printf("<<<frontend_allowed\n");
+#endif
+   return status;
+}
+
+/*------------------------------------------------------------------*/
+
+#ifdef OBSOLETE_CODE
+
+DWORD _last_client_in_list_call = 0;
+char _last_client_entry[MAX_STRING_LENGTH];
+
+INT client_in_list_reset()
+{
+/********************************************************************\
+
+  Routine:       client_in_list_reset
+
+  Purpose:       reset global variables used by client_in_list
+
+  Input:         NONE
+  Output:        NONE
+
+  Function return value:
+    CM_SUCCESS      Successful completion
+
+\********************************************************************/
+   _last_client_in_list_call = 0;
+   _last_client_entry[0] = '\0';
+   return CM_SUCCESS;
+}
+
+INT client_in_list(HNDLE hDB)
+{
+/********************************************************************\
+
+  Routine:       client_in_list
+
+  Purpose:       check if this pid is still in the /System/Clients ODB path
+
+  Input:         hDB        : ODB handle
+  Output:
+
+  Function return value:
+    CM_SUCCESS      Successful completion (pid sub directory is still existing)
+    SS_ABORT        Client pid is not in list anymore 
+
+\********************************************************************/
+   INT status;
+   DWORD tdiff;
+
+   status = CM_SUCCESS;
+
+   if (_last_client_in_list_call == 0) {
+      HNDLE kclient;
+      KEY clkey;
+
+      cm_get_experiment_database(&hDB, &kclient);
+      if ((status = db_get_key(hDB, kclient, &clkey)) != DB_SUCCESS) {
+         cm_msg(MERROR, "client_in_list", "ERROR %d client entry not "
+                "present in ODB", status);
+         _last_client_entry[0] = '\0';
+      } else {
+         cm_msg(MLOG, "", "client name = %s", clkey.name);
+         snprintf(_last_client_entry, MAX_STRING_LENGTH, "/System/Clients/%s", 
+                  clkey.name);
+         cm_set_watchdog_params(TRUE, 120000);
+      }
+      _last_client_in_list_call = ss_millitime();
+
+   }
+
+   if ((_last_client_in_list_call != 0) &&
+       (ss_millitime() > _last_client_in_list_call) &&
+       ((ss_millitime() - _last_client_in_list_call) > 60000)) {
+      HNDLE hkey;
+
+      if (strlen(_last_client_entry) > 0) {
+        if ((status = db_find_key(hDB, 0, _last_client_entry, &hkey)) != DB_SUCCESS) {
+           cm_msg(MERROR, "client_in_list", "ERROR %d client entry %s not "
+                  "present in ODB", status, _last_client_entry);
+           status = SS_ABORT;
+           _last_client_in_list_call = 0; /* reset to enable retry */
+        } else {
+           _last_client_in_list_call = ss_millitime();
+        }
+      } else {
+        _last_client_in_list_call = 0; /* reset to enable retry */
+      }
+   }
+
+   return status;
+}
+#endif /* OBSOLETE_CODE */
+
+/*------------------------------------------------------------------*/
+#endif                          /* OMIT_ODB */
+
+/*------------------------------------------------------------------*/
+#ifdef OS_WINNT
+struct _timeb gElapsedTime = { 0, 0 }; /* elapsed time since last calling elapsed_time */
+#elif defined(OS_VMS)
+struct timeb gElapsedTime = { 0, 0 };  /* elapsed time since last calling elapsed_time */
+#elif defined(OS_UNIX)
+struct timeb gElapsedTime = { 0, 0 };  /* elapsed time since last calling elapsed_time */
+#endif
+
+INT elapsed_time(void)
+{
+/********************************************************************\
+
+  Routine:       elapsed_time
+
+  Purpose:       return the time passed [msec] since this function was last called
+
+  Input:         none
+
+  Output:        none
+
+  Function return value:
+    INT          Elapsed time in msec
+
+\********************************************************************/
+   INT retval;
+
+#ifdef OS_WINNT
+   struct _timeb curtime;
+   _ftime(&curtime);
+#elif defined(OS_VMS)
+   struct timeb curtime;
+   ftime(&curtime);
+#elif defined(OS_UNIX)
+   struct timeb curtime;
+   ftime(&curtime);
+#endif
+
+#ifdef MIDEBUGM1
+   printf(">>> elapsed_time\n");
+#endif
+
+   retval = (curtime.time - gElapsedTime.time) * 1000 +
+       ((INT) curtime.millitm - (INT) gElapsedTime.millitm);
+   gElapsedTime.time = curtime.time;
+   gElapsedTime.millitm = curtime.millitm;
+
+#ifdef MIDEBUGM1
+   printf("<<< elapsed_time\n");
+#endif
+   return retval;
+}
+
+/*------------------------------------------------------------------*/
+
+char *Months[12] =
+    { "JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV",
+   "DEC"
+};
+
+INT cur_date_time(char *datestring, char *timestring)
+{
+/********************************************************************\
+
+  Routine:       cur_date_time
+
+  Purpose:       Return current date and/or time
+
+  Input:         none
+
+  Output:        *datestring : date as dd-MMM-yyyy
+                 *timestring : time as hh:mm:ss
+
+  Function return value:
+    CM_SUCCESS   Successful completion
+
+\********************************************************************/
+   INT retval;
+   time_t ti;
+   struct tm *lt;
+
+#ifdef MIDEBUGM1
+   printf(">>> cur_date_time\n");
+#endif
+   retval = CM_SET_ERROR;
+
+   time(&ti);
+   if ((lt = localtime(&ti)) != NULL) {
+      if (datestring != NULL)
+         snprintf(datestring, DATESTR, "%2.2d-%3.3s-%2.2d", lt->tm_mday,
+                 Months[lt->tm_mon], lt->tm_year + 1900);
+      if (timestring != NULL)
+         snprintf(timestring, TIMESTR, "%2.2d:%2.2d:%2.2d", lt->tm_hour, lt->tm_min, 
+                                                            lt->tm_sec);
+      retval = SUCCESS;
+   }
+#ifdef MIDEBUGM1
+   printf("<<< cur_date_time\n");
+#endif
+   return retval;
+}
+
+/*------------------------------------------------------------------*/
+char *strtime(INT timeval, char *datetimestr)
+{
+/********************************************************************\
+
+  Routine:       strtime
+
+  Purpose:       Return timval time as date and time string
+
+  Input:
+    INT          timeval        time in seconds since january 1th 1970
+    char         datetimestr    string to return date & time 
+                                (size must be at least 21 char)
+  Output:        *datetimestr : dd-MMM-yyyy hh:mm:ss
+
+  Function return value:
+    char * pointer to datetimestr
+
+\********************************************************************/
+   struct tm *st;
+
+   if (datetimestr != NULL) {
+
+      st = localtime((time_t *) & timeval);
+      if (st != NULL) {
+         snprintf(datetimestr, 25, "%2.2d-%3.3s-%4.4d %2.2d:%2.2d:%2.2d", st->tm_mday,
+                 Months[st->tm_mon], st->tm_year + 1900, st->tm_hour,
+                 st->tm_min, st->tm_sec);
+      } else
+         *datetimestr = '\0';
+   }
+   return datetimestr;
+}
+
+/*------------------------------------------------------------------*/
+
+INT get_int(char *string, int min, int max, int *ret)
+{
+/********************************************************************\
+
+  Routine:       get_int
+
+  Purpose:       get an integer from the keyboard, if (min<max) check range
+
+  Input:         string : prompt
+                 min, max : range
+                 *ret : default
+
+  Output:        *ret : returned value
+
+  Function value:
+    INT          0       FAILURE
+                 1       SUCCESS
+
+\********************************************************************/
+   INT retval;
+
+#ifdef MIDEBUGM1
+   printf(">>> get_int\n");
+#endif
+
+#define INTSTRLEN 20
+   retval = FAILURE;
+   if (ret != NULL) {
+      char intstring[INTSTRLEN];
+
+    again:
+      snprintf(&intstring[0], INTSTRLEN, "%d", *ret);
+      if ((retval = get_string(string, INTSTRLEN, TRIM | COMPRESS, &intstring[0]))) {
+         int tret;
+         if (intstring[0] != '\0')
+            sscanf(&intstring[0], "%d", &tret);
+         else
+            tret = 0;
+         if (min < max) {
+            if ((min > tret) || (tret > max)) {
+               printf("Enter a value larger or equal to %d and smaller or equal to %d!\n",
+                      min, max);
+               goto again;
+            }
+         }
+         *ret = tret;
+         retval = SUCCESS;
+      }
+   }
+#undef INTSTRLEN
+#ifdef MIDEBUGM1
+   printf("<<< get_int\n");
+#endif
+   return retval;
+}
+
+/*------------------------------------------------------------------*/
+
+INT get_uint(char *string, unsigned int min, unsigned int max, unsigned int *ret)
+{
+/********************************************************************\
+
+  Routine:       get_uint
+
+  Purpose:       get an unsigned integer from the keyboard, if (min<max) check range
+
+  Input:         string : prompt
+                 min, max : range
+                 *ret : default
+
+  Output:        *ret : returned value
+
+  Function value:
+    INT          0       FAILURE
+                 1       SUCCESS
+
+\********************************************************************/
+   INT retval;
+
+#ifdef MIDEBUGM1
+   printf(">>> get_uint\n");
+#endif
+#define INTSTRLEN 20
+   retval = FAILURE;
+   if (ret != NULL) {
+      char intstring[INTSTRLEN];
+
+    again:
+      snprintf(&intstring[0], INTSTRLEN, "%u", *ret);
+      if ((retval = get_string(string, INTSTRLEN, TRIM | COMPRESS, &intstring[0]))) {
+         unsigned int tret;
+         if (intstring[0] != '\0')
+#ifdef OS_OSF1
+            sscanf(&intstring[0], "%u", &tret);
+#else
+            sscanf(&intstring[0], "%u", &tret);
+#endif
+         else
+            tret = 0;
+         if (min < max) {
+            if ((min > tret) || (tret > max)) {
+               printf("Enter a value larger or equal to %u and smaller or equal "
+                      "to %u!\n", min, max);
+               goto again;
+            }
+         }
+         *ret = tret;
+         retval = SUCCESS;
+      }
+   }
+#undef INTSTRLEN
+#ifdef MIDEBUGM1
+   printf("<<< get_uint\n");
+#endif
+   return retval;
+}
+
+/*------------------------------------------------------------------*/
+
+INT get_float(char *string, float min, float max, float *ret)
+{
+/********************************************************************\
+
+  Routine:       get_float
+
+  Purpose:       get a float from the keyboard, if (min<max) check range
+
+  Input:         string : prompt
+                 min, max : range
+                 *ret : default
+
+  Output:        *ret : returned value
+
+  Function value:
+    INT          0       FAILURE
+                 1       SUCCESS
+
+\********************************************************************/
+   INT retval;
+
+#ifdef MIDEBUGM1
+   printf(">>> get_float\n");
+#endif
+
+#define FLOATSTRLEN 20
+   retval = FAILURE;
+   if (ret != NULL) {
+      char floatstring[FLOATSTRLEN];
+
+    again:
+      snprintf(&floatstring[0], FLOATSTRLEN, "%f", *ret);
+      if ((retval = get_string(string, FLOATSTRLEN, TRIM | COMPRESS, &floatstring[0]))) {
+         float tret;
+         if (floatstring[0] != '\0')
+            sscanf(&floatstring[0], "%f", &tret);
+         else
+            tret = 0.0;
+         if (min < max) {
+            if ((min > tret) || (tret > max)) {
+              printf("Enter a value larger or equal to %f and smaller or equal to %f!\n",
+                      min, max);
+               goto again;
+            }
+         }
+         *ret = tret;
+         retval = SUCCESS;
+      }
+   }
+#undef FLOATSTRLEN
+#ifdef MIDEBUGM1
+   printf("<<< get_float\n");
+#endif
+   return retval;
+}
+
+/*------------------------------------------------------------------*/
+INT get_double(char *string, double min, double max, double *ret)
+{
+/********************************************************************\
+
+  Routine:       get_double
+
+  Purpose:       get a double from the keyboard, if (min<max) check range
+
+  Input:         string : prompt
+                 min, max : range
+                 *ret : default
+
+  Output:        *ret : returned value
+
+  Function value:
+    INT          0       FAILURE
+                 1       SUCCESS
+
+\********************************************************************/
+   INT retval;
+
+#ifdef MIDEBUGM1
+   printf(">>> get_double\n");
+#endif
+
+#define DOUBLESTRLEN 20
+   retval = FAILURE;
+   if (ret != NULL) {
+      char doublestring[DOUBLESTRLEN];
+
+    again:
+      snprintf(&doublestring[0], DOUBLESTRLEN, "%lf", *ret);
+      if ((retval = get_string(string, DOUBLESTRLEN, TRIM|COMPRESS, &doublestring[0]))) {
+         double tret;
+         if (doublestring[0] != '\0')
+            sscanf(&doublestring[0], "%lf", &tret);
+         else
+            tret = 0.0;
+         if (min < max) {
+            if ((min > tret) || (tret > max)) {
+               printf("Enter a value larger or equal to %lf and smaller or equal to "
+                      "%lf!\n", min, max);
+               goto again;
+            }
+         }
+         *ret = tret;
+         retval = SUCCESS;
+      }
+   }
+#undef DOUBLESTRLEN
+#ifdef MIDEBUGM1
+   printf("<<< get_double\n");
+#endif
+   return retval;
+}
+
+/*------------------------------------------------------------------*/
+INT get_char(char *string, char *chars, int flags, char *ret)
+{
+/********************************************************************\
+
+  Routine:       get_char
+
+  Purpose:       get a character from the keyboard, if chars != NULL
+                 check allowed characters
+
+  Input:         string : prompt
+                 *chars : allowed characters or NULL
+                 flags  : special flags
+                 *ret   : default
+
+  Output:        *ret   : returned value
+
+  Function value:
+    INT          0       FAILURE
+                 1       SUCCESS
+
+\********************************************************************/
+   char ch;
+   char def;
+   int retint;
+   INT retval;
+
+#ifdef MIDEBUGM1
+   printf(">>> get_char\n");
+#endif
+   retval = FAILURE;
+   if (ret != NULL) {
+      def = *ret;
+    again:
+      if (string != NULL)
+         printf("%s", string);
+#ifdef OS_WINNT
+      retint = getch();
+#else
+      retint = getchar();
+#endif
+
+#if   defined(OS_WINNT)
+      if (retint == 0x00d)
+         ch = def;
+#elif defined(OS_VMS) || defined(OS_SOLARIS) || defined(OS_OSF1) || defined(OS_LINUX)
+      if (retint == 0x00a)
+         ch = def;
+#else
+      if (retint == 0x00d)
+         ch = def;
+#endif
+      else if (retint == EOF)
+         ch = def;
+      else if ((retint > 0x7f) || (retint < 0x1f))
+         ch = ' ';
+      else {
+         if ((flags & UPPERCASE) == UPPERCASE)
+            ch = toupper((char) retint);
+         else if ((flags & LOWERCASE) == LOWERCASE)
+            ch = tolower((char) retint);
+         else
+            ch = (char) retint;
+      }
+
+#if      defined(OS_WINNT)
+      printf("%c\n", ch);
+#elif defined(OS_VMS) || defined(OS_SOLARIS) || defined(OS_OSF1) || defined(OS_LINUX)
+      while ((retint != EOF) && (retint != 0x00a))
+         retint = getchar();
+#else
+      while ((retint != EOF) && (retint != 0x00d))
+         retint = getchar();
+#endif
+
+      if (chars != NULL) {
+         char *pc;
+
+         pc = chars;
+
+         while ((*pc != '\0') && (*pc != ch))
+            pc++;
+
+         if ((*pc != '\0') && (*pc == ch))
+            *ret = ch;
+         else
+            goto again;
+
+      } else
+         *ret = ch;
+
+      retval = SUCCESS;
+   }
+#ifdef MIDEBUGM1
+   printf("<<< get_char\n");
+#endif
+   return retval;
+}
+
+/*------------------------------------------------------------------*/
+
+char *_inbuf = NULL;            /* input buffer storing last input */
+
+INT free_inbuf(void)
+{
+   if (_inbuf != NULL)
+      free(_inbuf);
+   _inbuf = NULL;
+   return CM_SUCCESS;
+}
+
+/*------------------------------------------------------------------*/
+
+INT get_string(char *string, int bufsize, int flags, char *ret)
+{
+/********************************************************************\
+
+  Routine:       get_string
+
+  Purpose:       get a string from the keyboard
+
+  Input:         string  : prompt
+                 bufsize : size of return buffer
+                 flags   : special flags
+                 *ret    : default string
+
+  Output:        *ret    : returned value
+
+  Function value:
+    INT          0       FAILURE
+                 1       SUCCESS
+
+\********************************************************************/
+   char ch;
+   int ipos;
+   int retint;
+   INT retval, i, j, k;
+   char *tbuf, *ptbuf;
+   BOOL combflag;
+
+#ifdef MIDEBUGM1
+   printf(">>> get_string\n");
+#endif
+   retval = FAILURE;
+
+   combflag = FALSE;
+   tbuf = NULL;
+   if ((ret != NULL) && (bufsize > 0)) {
+      /* write string */
+      if (string != NULL) {
+         /* with default supplied? */
+         if (*ret != '\0')
+            printf("%s : [%s] ", string, ret);
+         else
+            printf("%s : ", string);
+      }
+
+      /* allocate space and process user input */
+      if ((tbuf = (char *) malloc(bufsize * sizeof(char))) != NULL) {
+         for (i = 0, ptbuf = tbuf; i < bufsize; i++)
+            *ptbuf++ = '\0';
+         ptbuf = tbuf;
+         ipos = 0;
+
+       nextchar:
+#ifdef OS_WINNT
+         retint = getch();      /* get character from console without echo */
+#else
+         retint = getchar();    /* get character from standard input */
+#endif
+       eofchar:
+         /* input terminated? */
+#if   defined(OS_WINNT)
+         if ((retint != 0x00d) && (retint != EOF)) {
+#elif defined(OS_VMS) || defined(OS_SOLARIS) || defined(OS_OSF1) || defined(OS_LINUX)
+         if ((retint != 0x00a) && (retint != EOF)) {
+#else
+         if ((retint != 0x00d) && (retint != EOF)) {
+#endif
+
+#ifdef MIDEBUGM1
+            printf(" %d ", retint);
+#endif
+#ifdef OS_WINNT
+            if (retint == 224) {
+               combflag = TRUE;
+               goto nextchar;
+            }
+#else
+            /* NIY */
+#endif
+            if (combflag) {
+               combflag = FALSE;
+#ifdef OS_WINNT
+               if (retint == 72) {
+#else
+               /* NIY */  {
+#endif
+                  if (ipos == 0) {
+                     if (_inbuf != NULL) {
+                        strcpy(tbuf, _inbuf);
+                        ptbuf = tbuf + strlen(tbuf);
+                        ipos = strlen(tbuf);
+                        printf("%s", tbuf);
+                     }
+                  }
+               }
+               goto nextchar;
+            }
+
+            /* useable ASCII character ? */
+            if (((retint > 0x1f) && (retint < 0x7f)) || (retint == 0x09)) {
+               combflag = FALSE;
+               if (retint == 0x09)
+                  retint = 0x20;        /* replace tab by space */
+               if ((flags & LOWERCASE) == LOWERCASE)
+                  ch = tolower((char) retint);
+               else if ((flags & UPPERCASE) == UPPERCASE)
+                  ch = toupper((char) retint);
+               else
+                  ch = (char) retint;
+
+               if (ipos < bufsize - 1) {
+#ifdef OS_WINNT
+                  printf("%c", ch);     /* echo input character */
+#endif
+                  *ptbuf++ = ch;
+                  *ptbuf = '\0';
+                  ipos++;
+                  goto nextchar;
+               } else
+                  printf("\nInput terminated to prevent buffer overflow\n");
+            } else {
+               /* backspace or delete ? */
+               if ((retint == 0x08) || (retint == 0x7f)) {
+                  int sof;
+
+                  *ptbuf = '\0';        /* remove delete or backspace character */
+
+                  if (*string == '\n')
+                     sof = 1;
+                  else
+                     sof = 0;
+
+                  if (*ret != '\0')     /* print header again */
+                     printf("\r%s : [%s] ", string + sof, ret);
+                  else
+                     printf("\r%s : ", string + sof);
+
+                  if (ipos != 0) {      /* remove last valid character */
+                     ptbuf--;
+                     ipos--;
+                     *ptbuf = '\0';
+                  }
+
+                  if (ipos != 0)        /* overwrite removed characters */
+                     printf("%s  ", tbuf);
+                  else
+                     printf("  ");
+
+                  if (*ret != '\0')     /* print header once more */
+                     printf("\r%s : [%s] ", string + sof, ret);
+                  else
+                     printf("\r%s : ", string + sof);
+
+                  if (ipos != 0)
+                     printf("%s", tbuf);        /* write input again */
+               }
+               goto nextchar;
+            }
+         }
+
+         /* copy changes to buffer */
+         if (ptbuf != tbuf) {
+            char *tret;
+            for (tret = ret, ptbuf = tbuf, ipos = 0; (*tret++ = *ptbuf++) != '\0';
+                 ipos++);
+
+#ifdef MIDEBUG1
+            printf(" before trim = >%s<\n", ret);
+#endif
+            /* remove leading blanks */
+            if (flags & TRIM) {
+               for (i = 0, j = 0, k = strlen(ret); i < k; i++) {
+                  if ((j == 0) && (ret[i] == ' ')) {
+                     /* do nothing */
+                  } else {
+                     if (i != j)
+                        ret[j] = ret[i];
+                     j++;
+                  }
+               }
+               ret[j] = '\0';
+            }
+#ifdef MIDEBUG1
+            printf(" after trim = >%s<\n", ret);
+#endif
+            /* remove all spaces (tabs are already converted to spaces) */
+            if (flags & COLLAPSE) {
+               for (i = 0, j = 0, k = strlen(ret); i < k; i++) {
+                  if (ret[i] == ' ') {
+                     /* do nothing */
+                  } else {
+                     if (i != j)
+                        ret[j] = ret[i];
+                     j++;
+                  }
+               }
+               ret[j] = '\0';
+            }
+#ifdef MIDEBUG1
+            printf(" after collapse = >%s<\n", ret);
+#endif
+            /* remove multiple spaces (tabs are already converted to spaces) */
+            if (flags & COMPRESS) {
+               BOOL wasspace;
+
+               wasspace = FALSE;
+               for (i = 0, j = 0, k = strlen(ret); i < k; i++) {
+                  if (ret[i] == ' ') {
+                     if (!wasspace)
+                        ret[j++] = ret[i];
+                     wasspace = TRUE;
+                  } else {
+                     if (i != j)
+                        ret[j] = ret[i];
+                     j++;
+                     wasspace = FALSE;
+                  }
+               }
+               ret[j] = '\0';
+            }
+#ifdef MIDEBUG1
+            printf(" after compress = >%s<\n", ret);
+#endif
+
+            /* fill buffer with spaces */
+            if (flags & FILLSTRING) {
+               for (; ipos < bufsize - 1; ipos++)
+                  ret[i++] = ' ';
+               ret[i] = '\0';
+
+               /* else remove trailing blanks */
+            } else {
+               i = strlen(ret);
+               while ((i >= 1) && (ret[i - 1] == ' '))
+                  ret[--i] = '\0';
+            }
+            /* copy default */
+         } else {
+            if ((ret != NULL) && (*ret != '\0'))
+               strcpy(tbuf, ret);
+         }
+#ifdef MIDEBUG1
+         printf(">%s<", ret);
+#endif
+         printf("\n");
+         retval = SUCCESS;
+      } else
+         printf("\nERROR in get_string malloc returned NULL pointer!\n");
+   }
+
+   if (_inbuf != NULL)
+      free(_inbuf);
+
+   if (tbuf != NULL)
+#ifdef OS_WINNT
+      _inbuf = tbuf;
+#else
+      free(tbuf);
+#endif
+
+#ifdef MIDEBUGM1
+   printf("<<< get_string\n");
+#endif
+   return retval;
+}
+
+/* EOF musr_midas.c------------------------------------------------ */
diff --git a/frontend/musr_midas.h b/frontend/musr_midas.h
new file mode 100644
index 0000000..46fab7b
--- /dev/null
+++ b/frontend/musr_midas.h
@@ -0,0 +1,109 @@
+/* ==================================================================== */
+
+  /*
+   *  +--------------------------------------------------------------+
+   *  |                     Paul Scherrer Institut                   |
+   *  |                       Computing Division                     |
+   *  |                                                              |
+   *  | This software may be used freely by non-profit organizations.|
+   *  | It may be copied provided that the name of P.S.I. and of the |
+   *  | author is included. Neither P.S.I. nor the author assume any |
+   *  | responsibility for the use of this software outside of P.S.I.|
+   *  +--------------------------------------------------------------+
+   *
+   *  Project  . . . . . . . . . . :  Musr support software
+   *  Component/Facility . . . . . :  Midas Front end for muSR DAQ/slow control
+   *  File Name  . . . . . . . . . :  musr_midas.h
+   *  Title  . . . . . . . . . . . :
+   *  Abstract . . . . . . . . . . :  contains muSR specific extensions of Midas.
+   *  Author . . . . . . . . . . . :  RA95 (extracted from ptantmusr.c)
+   *  Date of creation . . . . . . :  26-JUN-2000
+   *
+   *
+   *  Date        Name        Modification
+   *  -----------------------------------------------------------------
+   *  21-AUG-2000 RA95        current_frontendpath() modified, BOOL check_fename added
+   *  26-APR-2001 RA95        TRIM, COMPRESS & COLLAPSE added
+   *  14-SEP-2001 RA95        get_float, get_double, OMIT_ODB added
+   *  29-OCT-2001 RA95        strtime added
+   *  18-NOV-2004 RA35        free_inbuf()
+   *  02-MAY-2005 RA36        client_in_list() added
+   *  28-JUN-2005 RA36        client_in_list_reset() added
+   *
+   */
+
+/* --------------------------------------------------------------------- */
+
+#ifndef _MUSR_MIDAS_H_
+#define _MUSR_MIDAS_H_
+
+/* --------------------------------------------------------------------- */
+
+#include "midas.h"
+#include "msystem.h"
+
+/* --------------------------------------------------------------------- */
+
+#define FAILURE     0
+
+   /* used by get_char and get_string */
+#define NONE        0
+#define FILLSTRING  1           /* fill string with spaces */
+#define LOWERCASE   2           /* convert upper case to lower case characters */
+#define UPPERCASE   4           /* convert lower case to upper case characters */
+#define TRIM        8           /* remove trailing and leading blanks or tabs */
+#define COMPRESS   16           /* replace multiple blanks or tabs by single space */
+#define COLLAPSE   32           /* remove all spaces or tabs */
+
+/* --------------------------------------------------------------------- */
+#ifndef OMIT_ODB                /* omit ODB specific part */
+
+  /* get value from ODB, write value to ODB */
+extern INT db_get_int(INT, char *, INT *, char *);
+extern INT db_set_int(INT, char *, INT, char *);
+extern INT db_get_bool(INT, char *, BOOL *, char *);
+extern INT db_set_bool(INT, char *, BOOL, char *);
+extern INT db_get_string(INT, char *, char *, INT, char *);
+extern INT db_set_string(INT, char *, char *, char *);
+
+  /* error logging */
+extern void LogMessage(char *, INT, BOOL);
+#define ErrorTerminate(message,status) LogMessage(message,status,TRUE)
+#define ErrorLog(message,status)       LogMessage(message,status,FALSE)
+#define MessageLog(message,status)     LogMessage(message,status,FALSE)
+
+  /* run and front end specific */
+extern INT current_runnumber(HNDLE, INT *);
+extern INT current_runstate(HNDLE, INT *);
+extern INT current_frontendpath(HNDLE, char *, char *, char *, char *, char *, BOOL);
+extern INT frontend_allowed(HNDLE, char *);
+
+#ifdef OBSOLETE_CODE
+extern INT client_in_list(HNDLE);
+extern INT client_in_list_reset(void);
+#endif
+
+#endif                          /* OMIT_ODB */
+
+extern INT elapsed_time(void);
+
+  /* date and time */
+extern INT cur_date_time(char *, char *);
+#define cur_date(date) cur_date_time(date,NULL)
+#define cur_time(time) cur_date_time(NULL,time)
+extern char *strtime(INT, char *);
+
+ /* get values from keyboard */
+extern INT get_int(char *, int, int, int *);
+extern INT get_uint(char *, unsigned int, unsigned int, unsigned int *);
+extern INT get_char(char *, char *, int, char *);
+extern INT get_string(char *, int, int, char *);
+extern INT get_float(char *, float, float, float *);
+extern INT get_double(char *, double, double, double *);
+extern INT free_inbuf(void);
+
+/* --------------------------------------------------------------------- */
+
+#endif                          /* _MUSR_MIDAS_H_ */
+
+/* EOF musr_midas.h ---------------------------------------------------- */