write_summary.cxx

Go to the documentation of this file.

/********************************************************************\

  midas/experiment/nemu/write_summary.cxx

  Name:         write_summary.cxx
  Created by:   Thomas Prokscha
  Date:         21-Oct-2005

  Contents:     Program to create Nemu summary file;
                It is called at Start-of-Run and end-of-run.


\********************************************************************/

/* standard includes */
#include <cstdio>
#include <cstring>
#include <ctime>

#include "midas.h"
#include "msystem.h"

#define MAXLINE                   160
#define N_FUG                      16
#define MODERATOR_HV_CHANNEL        4
#define SAMPLE_HV_CHANNEL          15
#define SPINROTATOR_VOLTAGE_CHANNEL 2
#define SPINROTATOR_CURRENT_CHANNEL 3

// ODB structures
#include "experim.h"

// LEM specific definitions
#include "nemu_experim.h"

#define N_ELEMENTS 23
const char *odbElements[] = {"/Runinfo",
                       "/Experiment/Run Parameters",
                       "/Equipment/Trigger/Settings",
                       "/Equipment/Trigger/Vme_Statistics",
                       "/Equipment/Scaler/Settings",
                       "/Analyzer/Parameters/ScalerSumRate",
                       "/Equipment/HV/Settings",
                       "/Equipment/HV/Variables",
                       "/Equipment/HV Detectors/Settings",
                       "/Equipment/HV Detectors/Variables",
                       "/Equipment/Beamline/Settings",
                       "/Equipment/Beamline/Variables",
                       "/Equipment/ModCryo/Settings",
                       "/Equipment/ModCryo/Variables",
                       "/Equipment/SampleCryo/Settings",
                       "/Equipment/SampleCryo/Variables",
                       "/Equipment/LEMVAC/Settings",
                       "/Equipment/LEMVAC/Variables",
                       "/Equipment/SCS2001M/Variables",
                       "/Equipment/SlowControl/Variables/MEAN",
                       "/Analyzer/Parameters/TOFAnaModule",
                       "/Equipment/Danfysik_Spin_Rot/Variables",
                       "/Equipment/Omega/Variables",
 };

typedef struct{
 RUNINFO               runinfo;
 EXP_PARAM             exp_param;
 TRIGGER_SETTINGS      trigger_settings;
 VME_STATS             vme_stats;
 SCALER_SETTINGS       scaler_settings;
 SCALERSUMRATE_PARAM   scaler_param;
 HV_SETTINGS           hv_settings;
 HV_EVENT              hv_event;
 HV_DETECTORS_SETTINGS hvdet_settings;
 HV_DETECTORS_EVENT    hvdet_event;
 BEAMLINE_SETTINGS     beamline_settings;
 BEAMLINE_EVENT        beamline_event;
 MODCRYO_SETTINGS      moddy_settings;
 MODCRYO_EVENT         moddy_event;
 SAMPLECRYO_SETTINGS   sample_settings;
 SAMPLECRYO_EVENT      sample_event;
 LEMVAC_SETTINGS       lemvac_settings;
 LEMVAC_EVENT          lemvac_event;
// SCS900_EVENT          scs900_event;
 SCS2001M_EVENT        scs2001m_event;
 MEAN_BANK             mean_bank;
 TOFANAMODULE_PARAM    tof_param;
 DANFYSIK_SPIN_ROT_EVENT danfysik_spin_rot_event;
 OMEGA_EVENT           oven_omega_event;
} ODB;

ODB      odb;
void   *podb;
INFO          info;

/* other global variable */
FILE   *file;
char   sumfile[256];
char   line[MAXLINE];
HNDLE  hDB, hKey;

/* function declarations */
INT   open_odb_records(void);
INT   create_sum_filename( char *filename, const char *flag );
INT   write_sum_file(char *filename);
void  strcut(char *result, char *orgstr, char *cutstr);
INT   write_hvtrans(FILE *f);
INT   write_hvdet(FILE *f);
INT   write_trigger(FILE *f);
INT   write_beamline(FILE *f);
INT   write_env(FILE *f);
INT   write_temp(FILE *f, BOOL running);
void  write_control_room_scaler(FILE *f);
INT   write_eloss(FILE *f);
INT   write_t0(FILE *f);
INT   write_rates(FILE *f, double norm, double ip_norm, double scaler_sum, const char* label);
INT   display_scaler(FILE *f);

/*-----------------------------------------------------------------*/
INT open_odb_records(void)
/* *****************************************************************\

  Name:         open_odb_records
  Author:       Thomas Prokscha
  Date:         09-Nov-2001

  Purpose:      open odb records for later extraction of data to
                be written to the summary file

  Function value:
    DB_SUCCESS              Successful completion
    status                  in case of error: value of db_ function.

\* ****************************************************************** */
{
  INT  status, size, size1=0, i;
  char odbkey[132];

/* --------------------------------
   create /Info key and get record
   -------------------------------- */
  sprintf(odbkey, "/Info");
  db_find_key(hDB, 0, odbkey, &hKey);
  size = sizeof(info);
  status = db_get_record(hDB, hKey, &info, &size, 0);
  if ( status != DB_SUCCESS ){
        cm_msg(MERROR,"open_odb_records", "Could not open %s record.", odbkey);
        return status;
  }

  // get other records
  podb = &odb;
  for (i=0; i < N_ELEMENTS; i++){
    status = db_find_key(hDB, 0, odbElements[i], &hKey);
    if ( status != DB_SUCCESS ){
        cm_msg(MERROR,"open_odb_records", "Could not find %s key.", odbElements[i]);
        return status;
    }
    else {
      switch (i) {
        case  0: size = sizeof(RUNINFO); break;
        case  1: size = sizeof(EXP_PARAM); break;
        case  2: size = sizeof(TRIGGER_SETTINGS); break;
        case  3: size = sizeof(VME_STATS); break;
        case  4: size = sizeof(SCALER_SETTINGS); break;
        case  5: size = sizeof(SCALERSUMRATE_PARAM); break;
        case  6: size = sizeof(HV_SETTINGS); break;
        case  7: size = sizeof(HV_EVENT); break;
        case  8: size = sizeof(HV_DETECTORS_SETTINGS); break;
        case  9: size = sizeof(HV_DETECTORS_EVENT); break;
        case 10: size = sizeof(BEAMLINE_SETTINGS); break;
        case 11: size = sizeof(BEAMLINE_EVENT); break;
        case 12: size = sizeof(MODCRYO_SETTINGS); break;
        case 13: size = sizeof(MODCRYO_EVENT); break;
        case 14: size = sizeof(SAMPLECRYO_SETTINGS); break;
        case 15: size = sizeof(SAMPLECRYO_EVENT); break;
        case 16: size = sizeof(LEMVAC_SETTINGS); break;
        case 17: size = sizeof(LEMVAC_EVENT); break;
//        case 18: size = sizeof(SCS900_EVENT); break;
        case 18: size = sizeof(SCS2001M_EVENT); break;
        case 19: size = sizeof(MEAN_BANK); break;
        case 20: size = sizeof(TOFANAMODULE_PARAM); break;
        case 21: size = sizeof(DANFYSIK_SPIN_ROT_EVENT); break;
        case 22: size = sizeof(OMEGA_EVENT); break;
        default: break;
      }
//      printf("%d %d\n", i, size);
      status = db_get_record(hDB, hKey, podb, &size, 0);
      podb+=size;
      size1+=size;
      if (status != DB_SUCCESS) {
         cm_msg(MERROR,"open_odb_records", "Could not open %s record.", odbElements[i]);
         return status;
      }
    }
  }
/* printf("%d %d\n", sizeof(odb), size1);
 printf("%s\n", odb.trigger_settings.events.comment);
 printf("%s\n", odb.exp_param.comment);
 printf("%f\n", odb.danfysik_spin_rot_event.output[3]);*/
  return DB_SUCCESS;
}

/* -----------------------------------------------------------------*/
INT create_sum_filename( char *filename, const char *flag )
/* ***************************************************************** *\

  Name:         create_sum_filename
  Author:       Thomas Prokscha
  Date:         22-May-2001

  Purpose:      create filename for Run summary files of
                the Nemu experiment.
                Runs on Unix and Windows NT

  11-Sep-2001   TP:
                changed filename to ../summ/lem%02d_%04d.summ where
                %02d is replaced by the year modulo 100.

                Look for MIDAS_DATA variable ( == /data/nemu on PC3159),
                and build the filename of the summary file in the form
                MIDAS_DATA/summ/nemu_%04d.summ, where %04d is the four
                digit run number extracted from the ODB.
                If MIDAS_DATA is not defined the HOME path is taken as
                default location for the summary file. In this case a
                message is broadcasted to all MIDAS clients using cm_msg.
                The message is additionally written to the file midas.log
                (located in MIDAS_DATA/log on PC3159).

  Input:        char *flag: if flag == 'N' use current run number from ODB,
                otherwise use run number-1 (the previous run).


  Output:       char *filename, the name of the summary file


  Function value:
    SS_SUCCESS              Successful completion

\* ****************************************************************** */
{
  struct tm *tms;
  time_t now;
  char   dir[256], filebody[256];

  dir[0]   = 0;
  filebody[0] = 0;

  if ( getenv("MIDAS_DATA") ){
        strcpy(dir, getenv("MIDAS_DATA"));
        strcat(dir, DIR_SEPARATOR_STR);
        strcat(dir, "summ");
        strcat(dir, DIR_SEPARATOR_STR);
  }
  else{
#if defined (OS_UNIX)
        strcpy(dir, getenv("HOME"));
#elif defined (OS_WINNT)
        strcpy(dir, getenv("HOMEPATH"));
#endif
        strcat(dir, DIR_SEPARATOR_STR);
        cm_msg(MINFO, "create_sum_filename",
               "MIDAS_DATA path not defined, use home directory %s instead\n", dir);
  }

  time(&now);
  tms = localtime(&now);
  // tms->tm_year yields "Year - 1900"

  strcpy(filename, dir);
  if ( flag == "N")
        sprintf(filebody, "%04d/lem%02d_%04d.summ", tms->tm_year+1900,
                tms->tm_year%100, odb.runinfo.run_number);
  else
        sprintf(filebody, "%04d/lem%02d_%04d.summ", tms->tm_year+1900,
                tms->tm_year%100, odb.runinfo.run_number-1);

  strcat(filename, filebody);

  return SS_SUCCESS;
}

/* --------------------------------------------------------- */
INT write_sum_file(char *filename)
/* ***************************************************************** *\

  Name:         write_sum_filename
  Author:       Thomas Prokscha
  Date:         22-May-2001

  Purpose:      writes summary file of Nemu experiment.
                Runs on Unix and (Windows NT, not yet).

  Input:        char *filename, the name of the summary file


  Output:       None


  Function value:
    SS_SUCCESS              Successful completion
    -1                      Error opening new summary file


\* ****************************************************************** */
{
   FILE   *fprevious;
   char   beginComment[] =
          "#BUC---- B e g i n of User Comment ------ Do not edit this line";
   char   endComment[]   =
          "#EUC----   E n d   of User Comment ------ Do not edit this line";
   char   bucpattern[5] = "#BUC";
   char   eucpattern[5] = "#EUC";
   char   pattern[5], underline[MAXLINE], previousfile[256];
   char   cmd[256];
   BOOL   prevfile=FALSE, cont=FALSE, dowrite=FALSE, running=FALSE;
   int    i, len;
   INT    size;

   /* initialise */
   line[0]         = 0;
   pattern[0]      = 0;
   previousfile[0] = 0;
   cmd[0]          = 0;

   /* -----------------------------
      check if file already exists
      (that is we are at end of run...)
      -----------------------------*/
   file = fopen(filename, "r");
   if ( file != NULL){
        fclose(file);
        prevfile = TRUE;
        running  = TRUE;
        sprintf(previousfile,"%s.old", filename);
        sprintf(cmd, "cp %s %s", filename, previousfile);
        system(cmd);
        fprevious = fopen(previousfile, "r");
   }
   else{
   /* -------------------------------
      check if previous run summary file
      exists; if yes copy the user comment
      lines to the new file
      --------------------------------*/
        create_sum_filename(previousfile, "P");
        fprevious = fopen(previousfile, "r");
        if ( fprevious != NULL ){
                prevfile = TRUE;
                running  = FALSE;
        }
        else{
                prevfile = FALSE;
                running  = FALSE;
        }
   }

   /* ------------------------------
      open file in write mode
      ------------------------------*/
   file = fopen(filename, "w");
   if ( file == NULL ){ /* error opening file, return and send error message */
        cm_msg(MERROR, "write_sum_file", "Error opening summary file %s",
               filename);
        return -1;
   }

  /* ------------------------------
      write file header and comments
      ------------------------------*/
   sprintf(line, "%s Run %04d started.\n", odb.runinfo.start_time,
           odb.runinfo.run_number);
   fputs(line, file);
   
   if ( !running )
        sprintf(line, "%s Run %04d stopped.\n\n", odb.runinfo.stop_time,
                odb.runinfo.run_number-1);
   else
        sprintf(line, "%s Run %04d stopped.\n\n", odb.runinfo.stop_time,
                odb.runinfo.run_number);

   fputs(line, file);

   if ( strlen(odb.exp_param.comment) > 132 );
     odb.exp_param.comment[132] = 0;

   sprintf(line, " %s\n", odb.exp_param.comment);
   fputs(line, file);

   len = strlen(line);
   for ( i=0; i<len; i++)
        underline[i] = '=';
   underline[len] = 0;
   sprintf(line, " %s\n\n", underline);
   fputs(line, file);

   sprintf(line, "%s\n", beginComment);
   fputs(line, file);

   if ( prevfile ){
        cont   = TRUE;
        dowrite = FALSE;
        while ( cont ){
          if ( fgets(line, MAXLINE, fprevious) == NULL){
                dowrite = FALSE;
                cont = FALSE;
                break;
          }
          if ( dowrite )
                fputs(line, file);
          for ( i = 0; i<4; i++ )
                pattern[i] = line[i];
          pattern[4] = 0;
          if ( strcmp(pattern, bucpattern) == 0 )
                dowrite = TRUE;
          if ( strcmp(pattern, eucpattern) == 0 )
                cont = FALSE;
        }
        fclose(fprevious);
        if ( running )
                unlink(previousfile);
   }

   if ( !prevfile){
        sprintf(line, "\n\n%s\n\n\n", endComment);
        fputs(line, file);
   }
   else{
        sprintf(line, "\n\n\n");
        fputs(line, file);
   }
/* --------------------------------------------------

   now, header with comments are written, write other
   experiment parameters

   - transport system high voltage
   - trigger settings
   - the beamline settings
   - scaler sum and rates at the end of summary file

   --------------------------------------------------
*/
   write_trigger(file);
   write_hvtrans(file);
   write_eloss(file);
   write_t0(file);
   write_beamline(file);
   write_env(file);
   write_temp(file, running);
   write_control_room_scaler(file);
   write_hvdet(file);
   display_scaler(file);
/* --------------------------------------------------
   close file and return
   --------------------------------------------------
*/
   fclose(file);
   return SS_SUCCESS;
}
/*---------------------------------------------------------------*/
void strcut(char *result, char *orgstr, char *cutstr)
/*----------------------------------------------------

  Purpose:      look, if cutstr is at the beginning of orgstr.
                if yes, copy orgstr starting after cutstr to
                result. If not, copy orgstr to result.
                quicky version...
  -----------------------------------------------------*/
{
 int    len, j;
 char   tempstr[80];

 len = strlen(cutstr);
 strcpy(tempstr, orgstr);
 tempstr[len] = 0;
 if ( strcmp(tempstr, cutstr) == 0 ){
        j = 0;
        while ( (result[j] = orgstr[j+len]) != '\0')
                j++;
 }
 else
        strcpy(result, orgstr);
 return;
}
/*-----------------------------------------------------------------*/
INT write_hvtrans(FILE *f)
/* ---------------------------
      Transport system HVq
   ---------------------------*/
{
   INT    i;
   char   name0[32], name1[32];
   char   group[5] = "FUG%";

   sprintf(line, "\nTransport-HV:\n");
   fputs(line, f);
   sprintf(line, "===============\n");
   fputs(line, f);

// cut of FUG% if found in string
   for ( i = 0; i<N_FUG; i+=2){
        strcut(name0, odb.hv_settings.names[i], group);
        strcut(name1, odb.hv_settings.names[i+1], group);
        sprintf(line, " %15s = %8.3f   kV\t %15s = %8.3f   kV\n",
         name0, odb.hv_event.measured[i], name1, odb.hv_event.measured[i+1]);
        fputs(line, f);
   }
  // add mean of moderator and sample HV
  sprintf(line, "  Mean Moderator = %8.3f(%5.3f) kV\t     Mean Sample = %8.3f(%5.3f) kV\n",
           odb.mean_bank.moderator_hv, odb.mean_bank.var_moderator_hv,
           odb.mean_bank.sample_hv, odb.mean_bank.var_sample_hv);
  fputs(line, f);
  // add spin-rotator current
  sprintf(line, "      SR Current = %8.3f A\t\t      SR Voltage = %8.3f V\n",
           odb.danfysik_spin_rot_event.input[SPINROTATOR_CURRENT_CHANNEL],
           odb.danfysik_spin_rot_event.input[SPINROTATOR_VOLTAGE_CHANNEL]);
  fputs(line, f);
  // add spin-rotator angle
  sprintf(line, "      SR Angle   = %8.3f degree\n", info.spinrot_parameter.rotation_angle);
  fputs(line, f);

  return SS_SUCCESS;
}
/*-----------------------------------------------------------------*/
INT write_eloss(FILE *f)
/* -----------------------------------------------
      energy loss in C-foil, implantation energy
   -----------------------------------------------*/
{
  float eloss, implantation_energy;

  sprintf(line, "\nMuon Energy:\n");
  fputs(line, f);
  sprintf(line, "===============\n");
  fputs(line, f);

  eloss = info.energy_loss;
  implantation_energy = info.implantation_energy;

  sprintf(line, "     energy loss = %8.3f   keV    implantation energy = %8.3f   keV\n",
          eloss, implantation_energy);
  fputs(line, f);

  return SS_SUCCESS;
}
/*-----------------------------------------------------------------*/
INT write_t0(FILE *f)
/* -----------------------------------------------
      calculated time zeros in decay histograms
   -----------------------------------------------*/
{
  INT i;

  sprintf(line, "\nCalculated t0's:\n");
  fputs(line, f);
  sprintf(line, "===============\n");
  fputs(line, f);

  for (i=0; i<N_DECAY_HISTS; i++){
    sprintf(line, "     t0[%2d]      = %8d\n", i, info.t0_parameter.t0[i]);
    fputs(line, f);
  }
  return SS_SUCCESS;
}
/*---------------------------------------------------------------*/
INT write_trigger(FILE *f)
{
   sprintf(line,"\n ======================   E v e n t  definition   =========================\n\n");
   fputs(line,f);
   sprintf(line," Events: \n %s\n\n", odb.trigger_settings.events.comment);
   fputs(line,f);

   sprintf(line, " t0 Offset: %d\n", odb.trigger_settings.t0_offset);
   fputs(line, f);

   sprintf(line, " Event   0: %d\t     BC: %7d\t     e+: %7d\n",
     odb.trigger_settings.events.event_0_active,
     odb.trigger_settings.event_0_settings.beamcounter_active,
     odb.trigger_settings.event_0_settings.positrons_active
     );
   fputs(line,f);

   sprintf(line, " Event   1: %d\t     BC: %7d\t     e+: %7d\n",
     odb.trigger_settings.events.event_1_active,
     odb.trigger_settings.event_1_settings.beamcounter_active,
     odb.trigger_settings.event_1_settings.positrons_active
     );
   fputs(line,f);

   sprintf(line, " Event   2: %d\t     BC: %7d\t     e+:       1\n",
     odb.trigger_settings.events.event_2_active,
     odb.trigger_settings.event_2_settings.beamcounter_active
     );
   fputs(line,f);

   sprintf(line, "\n Time windows: \n");
   fputs(line,f);
   sprintf(line, " ============= \n");
   fputs(line, f);
   sprintf(line, " Event   0: Data Window: %7d, TOF BC Window: %7d, TOF BC Pileup: %7d\n",
     odb.trigger_settings.event_0_settings.data_window,
     odb.trigger_settings.tof_bc_window,
     odb.trigger_settings.tof_bc_pileup_window
     );
   fputs(line,f);

   sprintf(line, " Event   1: Data Window: %7d, TOF M2 Window: %7d, TOF M2 Pileup: %7d\n",
     odb.trigger_settings.event_1_settings.data_window,
     odb.trigger_settings.event_1_settings.tof_m2_window,
     odb.trigger_settings.event_1_settings.tof_m2_pileup_window
     );
   fputs(line,f);

   sprintf(line, " Event   1: Data Window: %7d, TOF BC Window: %7d, TOF BC Pileup: %7d\n",
     odb.trigger_settings.event_1_settings.data_window,
     odb.trigger_settings.tof_bc_window,
     odb.trigger_settings.tof_bc_pileup_window
     );
   fputs(line,f);

   sprintf(line, " Event   2: Data Window: %7d, TOF BC Window: %7d, TOF BC Pileup: %7d\n",
     odb.trigger_settings.event_2_settings.data_window,
     odb.trigger_settings.tof_bc_window,
     odb.trigger_settings.tof_bc_pileup_window
     );
   fputs(line,f);

   sprintf(line, "\n Software delays: \n");
   fputs(line,f);
   sprintf(line, " ================ \n");
   fputs(line, f);
   sprintf(line, " Event   0: MCP1  : %7d, e+: %7d\n",
     odb.trigger_settings.event_0_settings.mcp1_delay,
     odb.trigger_settings.event_0_settings.positron_delay
     );
   fputs(line,f);
   sprintf(line, " Event   1: Master: %7d, e+: %7d\n",
     odb.trigger_settings.event_1_settings.master_delay,
     odb.trigger_settings.event_1_settings.positron_delay
     );
   fputs(line,f);
   sprintf(line, " Event   2: TD    : %7d, e+: %7d\n",
     odb.trigger_settings.event_2_settings.td_delay,
     odb.trigger_settings.event_2_settings.positron_delay
     );
   fputs(line,f);


   sprintf(line, "\n Event   1: Master TD: %d, TD Active: %d, Master M2: %d, M2 Active %d\n",
     odb.trigger_settings.event_1_settings.td_master,
     odb.trigger_settings.event_1_settings.td_active,
     odb.trigger_settings.event_1_settings.mcp2_master,
     odb.trigger_settings.event_1_settings.mcp2_active
     );
   fputs(line,f);

   sprintf(line, "\n TD-MCP2 TOF cuts: \n");
   fputs(line,f);
   sprintf(line, " ================= \n");
   fputs(line, f);

   sprintf(line, " TOFcutMin  : %7.0f, TOFcutMax: %7.0f\n",
     odb.tof_param.tofm2fmin,
     odb.tof_param.tofm2fmax
     );
   fputs(line, f);
   
   sprintf(line, "\n MCP2 beamspot parameter: \n");
   fputs(line,f);
   sprintf(line, " ======================== \n");
   fputs(line, f);

   sprintf(line, " x Offset (mm)  : %7.2f, y Offset (mm): %7.2f\n",
     odb.tof_param.xoffset_mm_,
     odb.tof_param.yoffset_mm_
     );
   fputs(line, f);
   sprintf(line, " scale factor   : %7.2f, rotation angle (degree): %7.2f\n",
     odb.tof_param.scalefactor,
     odb.tof_param.rotationangle
     );
   fputs(line, f);


   return SS_SUCCESS;
}
/*---------------------------------------------------------------------*/
INT write_beamline(FILE *f)
{
   INT    i, nmax;
   char   str0[32], str1[32];
  
   sprintf(line, "\nBeamline:\n");
   fputs(line, f);
   sprintf(line, "=========");
   fputs(line, f);
   sprintf(line, "\n Beamline settings: %s\n\n", info.beamline_settings);
   fputs(line, f);
   nmax = sizeof(odb.beamline_event.measured)/4;
/*   nmax = odb.beamline_settings.channels.magnets +
          odb.beamline_settings.channels.kv61 +
          odb.beamline_settings.channels.kv62 +
          odb.beamline_settings.channels.sep61;*/
   for ( i=0; i<nmax-1; i++){
        strcpy(str0, odb.beamline_settings.names[i]);
        strcpy(str1, odb.beamline_settings.names[i+1]);
        str0[6] = 0; //truncate
        str1[6] = 0;
        sprintf(line," %s\t DAC = %5.0f  ADC = %7.3f\t %s\t DAC = %5.0f  ADC = %7.3f\n",
         str0, odb.beamline_event.demand[i], odb.beamline_event.measured[i],
         str1, odb.beamline_event.demand[i+1], odb.beamline_event.measured[i+1]);
        fputs(line, f);
        i++;
   }
   //sprintf(line, "\t\t SEP \t\t  HV = %8.1f kV\n", info.separator.hv);
   fputs(line, f);

   return SS_SUCCESS;
}

INT write_hvdet(FILE *f)
{
/*//as35
#define   N_CHANNELS 48
   INT    i, j;
   char   name[32];
   char   group[10] = "NHQ%";
   char   sign[2] = "-";
   char   *mcp[] = {"TD C Foil", "TD Front", "TD Back", "TD MCP", "MCP1", "MCP2"};
   char   *pos[] = {"L_i","L_a","T_i","T_a","R_i","R_a","B_i","B_a"};

   sprintf(line, "\nDetectors:\n");
   fputs(line, f);
   sprintf(line, "==========\n");
   fputs(line, f);

   for ( i=0; i<N_CHANNELS; i++){
        strcut(name, odb.hvdet_settings.names[i], group);
        if ( strstr(name, "%" )) continue;
        for ( j=0; j<6; j++)
        {
                if (strstr(name, mcp[j]))
                {
                        sprintf(line, "\t   %-20s\t = %8.3f   kV\n", name, odb.hvdet_event.measured[i]);
                        fputs(line, f);
                }

        }
  }
   //-------------------------
   // the detector thresholds
   //-------------------------
   sprintf(line, "\nDetector thresholds:\n");
   fputs(line, f);
   sprintf(line, "====================\n");
   fputs(line, f);

   sprintf(line, "\t\t           BcL_1 = %6.1f mV\t    BcL_2 = %6.1f mV\n", info.thresholds.bcl1, info.thresholds.bcl2);
   fputs(line, f);
   sprintf(line, "\t\t           BcL_3 = %6.1f mV\t    BcL_4 = %6.1f mV\n", info.thresholds.bcl3, info.thresholds.bcl4);
   fputs(line, f);
   sprintf(line, "\t\t           BcR_1 = %6.1f mV\t    BcR_2 = %6.1f mV\n", info.thresholds.bcr1, info.thresholds.bcr2);
   fputs(line, f);
   sprintf(line, "\t\t           BcR_3 = %6.1f mV\t    BcR_4 = %6.1f mV\n", info.thresholds.bcr3, info.thresholds.bcr4);
   fputs(line, f);
   sprintf(line, "\t\t      Pos_MCP1_I = %6.1f mV\t     MCP1 = %6.1f mV\n", info.thresholds.posmcp1i, info.thresholds.mcp1);
   fputs(line, f);
   sprintf(line, "\t\t      Pos_MCP1_O = %6.1f mV\t   MCP2_F = %6.1f mV\n", info.thresholds.posmcp1o, info.thresholds.mcp2f);
   fputs(line, f);
   sprintf(line, "\t\t          MCP2_R = %6.1f mV\t       TD = %6.1f mV\n", info.thresholds.mcp2r, info.thresholds.td);
   fputs(line, f);
   sprintf(line, "\t\t      MCP2_Anode = %6.1f mV\t                    \n", info.thresholds.mcp2anode);
   fputs(line, f);
   sprintf(line, "\t\t         Pos_LDI = %6.1f mV\t  Pos_LDO = %6.1f mV\n", info.thresholds.posldi, info.thresholds.posldo);
   fputs(line, f);
   sprintf(line, "\t\t         Pos_LUI = %6.1f mV\t  Pos_LUO = %6.1f mV\n", info.thresholds.poslui, info.thresholds.posluo);
   fputs(line, f);
   sprintf(line, "\t\t         Pos_TDI = %6.1f mV\t  Pos_TDO = %6.1f mV\n", info.thresholds.postdi, info.thresholds.postdo);
   fputs(line, f);
   sprintf(line, "\t\t         Pos_TUI = %6.1f mV\t  Pos_TUO = %6.1f mV\n", info.thresholds.postui, info.thresholds.postuo);
   fputs(line, f);
   sprintf(line, "\t\t         Pos_RDI = %6.1f mV\t  Pos_RDO = %6.1f mV\n", info.thresholds.posrdi, info.thresholds.posrdo);
   fputs(line, f);
   sprintf(line, "\t\t         Pos_RUI = %6.1f mV\t  Pos_RUO = %6.1f mV\n", info.thresholds.posrui, info.thresholds.posruo);
   fputs(line, f);
   sprintf(line, "\t\t         Pos_BDI = %6.1f mV\t  Pos_BDO = %6.1f mV\n", info.thresholds.posbdi, info.thresholds.posbdo);
   fputs(line, f);
   sprintf(line, "\t\t         Pos_BUI = %6.1f mV\t  Pos_BUO = %6.1f mV\n", info.thresholds.posbui, info.thresholds.posbuo);
   fputs(line, f);

*/
  return SS_SUCCESS;
}

/*--------------------*/
INT write_env(FILE *f)
/* **********************\
\* **********************/
{
   INT i, j, size;
   const char *press[] = {"MC_GJ ", "MC_GJ2", "TC_GJ ", "SC_GJ ", "SC_GJ2"};
   const char *xtc[]   = {"XTC_Th"};

   size = sizeof(odb.moddy_event.input)/sizeof(float);

   sprintf(line, "\nEnvironment:\n");
   fputs(line, f);
   sprintf(line, "============\n");
   fputs(line, f);

   sprintf(line,"\t LEM Setup\t\t = %s\n", info.lem_setup);
   fputs(line,f);
   sprintf(line, "\t Sample Name\t\t = %s\n", info.sample_name);
   fputs(line,f);
   sprintf(line,"\t Sample Cryo\t\t = %s\n", info.sample_cryo);
   fputs(line,f);
//   sprintf(line,"\t Zero Flux\t\t = %10.4f V\n", odb.scs900_event.input[8]);
   sprintf(line,"\t Zero Flux\t\t = %10.4f V\n", odb.scs2001m_event.input[31]);
   fputs(line,f);
   sprintf(line,"\t B Field\t\t = %10.2f G\n", info.magnetic_field);
   fputs(line,f);
   // add mean value of B field
   sprintf(line, "\t Mean B field\t\t = %10.2f(%5.2f) G\n\n", odb.mean_bank.sample_b,
           odb.mean_bank.var_sample_b);
   fputs(line, f);

   for ( i=0; i<size; i++){
        for ( j=0; j<5; j++){
                if (strstr(odb.lemvac_settings.names_input[i], press[j])){
                  sprintf(line, "\t %s\t\t\t = %8.2e mbar\n", press[j], odb.lemvac_event.input[i]);
                  fputs(line, f);
                }
        }
   }

   sprintf(line, "\n");
   fputs(line,f);

   for ( i=0; i<size; i++){
        for ( j=0; j<1; j++){
                if (strstr(odb.moddy_settings.names_input[i], xtc[j])){
                  sprintf(line, "\t %s\t\t\t = %8.2f AA\n", xtc[j], odb.moddy_event.input[i]);
                  fputs(line, f);
                }
        }
   }

   sprintf(line, "\t moderator\t\t =   %s\n", info.moderator);
   fputs(line,f);

   sprintf(line, "\t Date of Evaporation\t =   %s\n\n", info.moderatorDATE);
   fputs(line,f);

   sprintf(line, "\t Mirror horizontal\t = %6.2f degree\n", info.mirror.angle_horizontal);
   fputs(line,f);
   sprintf(line, "\t Mirror vertical\t = %6.2f mm\n", info.mirror.angle_vertical);
   fputs(line,f);
   sprintf(line, "\t Trigger horizontal\t = %6.2f degree\n", info.trigger.angle);
   fputs(line,f);
   sprintf(line, "\t Trigger vertical\t = %6.2f mm\n", info.trigger.height);
   fputs(line,f);

 return SS_SUCCESS;
}

/*--------------------*/
INT write_temp(FILE *f, BOOL running)
/* **********************\
\* **********************/
{
   INT i, j, size;
   const char *temp_mod[]     = {"ModCryo_CF_1", "ModCryo_CF_2", "ModCryo_Chimney", "ModCryo_He_Shield"};
   const char *temp_sample[]  = {"Sample_CF1", "Sample_CF2", "Sample_D0"};

   size = sizeof(odb.moddy_event.input)/sizeof(float);

   sprintf(line, "\nTemperatures:\n");
   fputs(line, f);
   sprintf(line, "============\n");
   fputs(line, f);

   for ( i=0; i<size; i++){
        for ( j=0; j<4; j++){
                if (strstr(odb.moddy_settings.names_input[i], temp_mod[j])){
                  sprintf(line, "\t %-15s\t = %8.2f   K\n", temp_mod[j], odb.moddy_event.input[i]);
                  fputs(line, f);
                }
        }
   }

   size = sizeof(odb.sample_event.input)/sizeof(float);
   for ( i=0; i<size; i++){
        for ( j=0; j<3; j++){
                if (strstr(odb.sample_settings.names_input[i], temp_sample[j])){
                  sprintf(line, "\t %-15s\t = %8.2f   K\n", temp_sample[j], odb.sample_event.input[i]);
                  fputs(line, f);
                }
        }
   }
   // add mean value of Sample 
   if (running)
    sprintf(line, "\t Mean Sample\t\t = %8.2f(%5.2f) K", odb.mean_bank.sample_t,
                   odb.mean_bank.var_sample_t);
   else{
    for ( i=0; i<size; i++){
     if (strstr(odb.sample_settings.names_input[i], temp_sample[0]))
       sprintf(line, "\t Mean Sample\t\t = %8.2f(0.00) K", odb.sample_event.input[i]);     
     }
   }
   fputs(line, f);

   // add oven temperature, Omega controller
   sprintf(line, "\n\t Oven_Omega_T1\t\t = %8.2f   K", odb.oven_omega_event.input[0]);
   fputs(line, f);
   
   sprintf(line, "\n");
   fputs(line,f);

   return SS_SUCCESS;
}

//---------------------------------------------------------------------
void write_control_room_scaler(FILE *f)
{
  sprintf(line, "\nControl Room Scalers:\n");
  fputs(line, f);
  sprintf(line, "====================\n");
  fputs(line, f);
  sprintf(line, "\t Nominal Value = %d\n", info.controlroom_scaler_info.nominal_value);
  fputs(line, f);
  sprintf(line, "\t AHPOS Date    = %s\n", info.controlroom_scaler_info.ahpos_date);
  fputs(line, f);
  sprintf(line, "\t Target        = %s\n", info.controlroom_scaler_info.target);
  fputs(line, f);
  sprintf(line, "\n");
  fputs(line,f);
}

INT display_scaler(FILE *f)
/* ***************************************************************** *\

  Name:         display_scaler
  Author:       Thomas Prokscha
  Date:         28-May-2001

  Purpose:      reads the scaler sum and rates from the ODB and
                writes them at the end of the summary file.
                Use void function disp_scaler in $MIDAS_WORK/src/scaler.c
                as template.

  Input:        FILE *f pointer to a file which already must be opened
                in write mode.

  Output:       None


  Function value:
    SS_SUCCESS              Successful completion


\* ****************************************************************** */
{
  double ssum[N_SCALER], rate, rate_perIp, bc_sum;

  INT           scal_ch, ip_ch;
  double        scal_rate, norm, ip_norm, ip_rate, tdc_life;

  const char   *state[]     = {"", "Stopped", "Paused", "Running" };
  const char   *dashline[]  =
  {"--------------------------------------------------------------------------"};
  const char   *top[]   =
  {" #  Label                  Total              Rate/mAs           Rate/s    "};
  time_t        now, difftime;
  INT           i, size;

  /* for calculating the mean rates */
  scal_ch   = odb.scaler_param.channel_norm_time;
  scal_rate = odb.scaler_param.rate_norm_time;
  ip_ch     = odb.scaler_param.ip_channel;
  ip_rate   = IpSCALE;

  sprintf(line, "\n%s\n", dashline[0]);
  fputs(line, f);

  sprintf(line, " Run Number: %10d               started at: %s\n",
           odb.runinfo.run_number, odb.runinfo.start_time);
  fputs(line, f);

  if ( odb.runinfo.state == STATE_STOPPED){
        sprintf(line, " Run State : %10s              last update: %s\n",
         state[odb.runinfo.state], odb.runinfo.stop_time);
  }
  else{
        time(&now);
        sprintf(line, " Run State : %10s              last update: %s\n",
         state[odb.runinfo.state], ctime(&now));
  }
  fputs(line, f);
  sprintf(line, "\n%s\n", top[0]);
  fputs(line, f);
  sprintf(line, "%s\n\n", dashline[0]);
  fputs(line, f);
  db_find_key(hDB, 0, "/Equipment/Scaler/Variables/SSUM", &hKey);
  size = sizeof(ssum);
  db_get_data(hDB, hKey, &ssum, &size, TID_DOUBLE);

  for (i=0 ; i<N_SCALER ; i++){
        //if ( runinfo.state == STATE_STOPPED )
        //{
      if ( ssum[i] > 1e36 || (ssum[i] < 1e-36 && ssum[i] != 0.))
        ssum[i] = -1.;  //something wrong in ODB
        norm    = ssum[scal_ch]/scal_rate;
        ip_norm = ssum[ip_ch]/ip_rate;
        if ( norm > 0. )
                rate = ssum[i]/norm;
        else
                rate = -1.;
        if ( ip_norm > 0. )
                 rate_perIp = ssum[i]/ip_norm;
        else
                 rate_perIp = -1.;

        //}
        if ( ssum[i] > 1e7 )
          sprintf(line, "%2d  %-12s %15.5e\t %13.1f %16.1f\n", i,
                  odb.scaler_settings.names_scl0[i], ssum[i], rate_perIp, rate);
        else
          sprintf(line, "%2d  %-12s %15.0f\t %13.1f %16.1f\n", i,
                  odb.scaler_settings.names_scl0[i], ssum[i], rate_perIp, rate);
        fputs(line, f);
  }
  // sum 8 beam counter segments
  bc_sum = 0.;
  for ( i=BCL1; i<=BCR4; i++ ){
        bc_sum += ssum[i];
  }
  if ( norm > 0. )
    rate = bc_sum/norm;
  else
   rate = -1.;
  if ( ip_norm > 0. )
   rate_perIp = bc_sum/ip_norm;
  else
  rate_perIp = -1.;

  if ( bc_sum > 1e7 )
        sprintf(line, "    BC-Sum: %20.5e\t %13.1f %16.1f\n", bc_sum, rate_perIp, rate);
  else
        sprintf(line, "    BC-Sum: %20.0f\t %13.1f %16.1f\n", bc_sum, rate_perIp, rate);
  fputs(line, f);

  // vme statistics
  sprintf(line, "--- vme stats ----------\n");
  fputs(line, f);

  write_rates(f, norm, ip_norm, odb.vme_stats.slowMuonEvents, " SlowMuonEvents");
  write_rates(f, norm, ip_norm, odb.vme_stats.fastMuonEvents, " FastMuonEvents");
  write_rates(f, norm, ip_norm, odb.vme_stats.readcounts, " ReadMidasEvents");
  write_rates(f, norm, ip_norm, odb.vme_stats.td_clean,   " TD-clean");
  write_rates(f, norm, ip_norm, odb.vme_stats.td_good,    " TD-good");
  write_rates(f, norm, ip_norm, odb.vme_stats.mcp1_clean, " MCP1-clean");
  write_rates(f, norm, ip_norm, odb.vme_stats.mcp1_good,  " MCP1-good");
  write_rates(f, norm, ip_norm, odb.vme_stats.mcp2_clean, " MCP2-clean");
  write_rates(f, norm, ip_norm, odb.vme_stats.mcp2_good,  " MCP2-good");

  bc_sum = 0.;
  for ( i=BCL1; i<=BCR4; i++ ){
        bc_sum += odb.vme_stats.channelCounts[i];
  }
  write_rates(f, norm, ip_norm, bc_sum,  " BC-Sum");
  write_rates(f, norm, ip_norm, odb.vme_stats.bc_clean,  " BC-clean");

  //-------------------------------
  if ( ssum[CLOCK] > 0 )
    tdc_life = (double) odb.vme_stats.channelCounts[CLOCK] / ssum[CLOCK] * 100.;
  else
    tdc_life = -1.;
  sprintf(line, " TDC LifeTime: %17.2f(%)   TDC Error counts: %15.0f\n", tdc_life, odb.vme_stats.tdc_error_counts);
  fputs(line,f);

  sprintf(line, " TDC Clock: %19.0f\n", odb.vme_stats.channelCounts[CLOCK]);
  fputs(line,f);


  sprintf(line, "%s\n", dashline[0]);
  fputs(line, f);

  if (odb.runinfo.state == STATE_STOPPED)
        difftime = odb.runinfo.stop_time_binary - odb.runinfo.start_time_binary;
  else
        difftime = now - odb.runinfo.start_time_binary;

  sprintf(line, "Elapsed time: %dh%02dm%02ds\n",
            difftime/3600, difftime%3600/60,difftime%60);
  fputs(line, f);
  sprintf(line, "\nRates are   a v e r a g e d   rates\n");
  fputs(line, f);

  return SS_SUCCESS;
}
/*-----------------------------------------------------------*/
INT write_rates(FILE *f, double norm, double ip_norm, double scaler_sum, const char* label)
/*

*/
{
 double rate, rate_perIp;

 if ( norm > 0. )
   rate = scaler_sum / norm;
 else
   rate = -1.;
 if ( ip_norm > 0. )
   rate_perIp =  scaler_sum / ip_norm;
 else
   rate_perIp = -1.;

 if ( scaler_sum > 1e7 )
   sprintf(line, "%-16s: %14.5e\t %13.1f %16.1f\n",
                 label, scaler_sum, rate_perIp, rate);
  else
   sprintf(line, "%-16s: %14.0f\t %13.1f %16.1f\n",
                 label, scaler_sum, rate_perIp, rate);
 fputs(line, f);

 return SS_SUCCESS;
}
/* ----------------------------------------------------------

   m a i n  program

   ----------------------------------------------------------
*/
main(int argc, char *argv[])
{
  INT    status, i, size;
  char   host_name[HOST_NAME_LENGTH];
  char   expt_name[HOST_NAME_LENGTH];
  char   cmd[256];
  char   printcmd[32];

  /* initialise */
  host_name[0] = 0;
  expt_name[0] = 0;
  cmd[0]       = 0;
  printcmd[0]  = 0;

  /* get default from environment variables */
  cm_get_environment (host_name, sizeof(host_name), expt_name, sizeof(expt_name));

  /* parse command line parameters */
  for ( i=1; i<argc; i++){
        if ( argv[i][0] == '-' ){
                if ( i+1 >= argc || argv[i+1][0] == '-' )
                        goto usage;
                if ( argv[i][1] == 'e' )
                        strcpy(expt_name, argv[i+1]);
                else if ( argv[i][1] == 'h' )
                        strcpy(host_name, argv[i+1]);
                else{
usage:
                        printf("\n usage: write_summary [-h Hostname] [-e Experiment]\n\n");
                        return 1;
                }
        }
  }

/* ----------------
   connect to experiment expt_name on host host_name
   ----------------
*/
  status = cm_connect_experiment(host_name, expt_name, "write_summary", NULL);
  if ( status != CM_SUCCESS)
        return status;

/* -----------------
   connect to ODB
   -----------------
*/
  cm_get_experiment_database(&hDB, NULL);

/* ------------------
   open ODB records
   ------------------
*/
  ss_sleep(500);
  status = open_odb_records();

/* -------------------------------------------------------
   do the run summary job if no odb error was encountered
   -------------------------------------------------------
*/
  if ( status == DB_SUCCESS ){
        create_sum_filename(sumfile, "N");
        write_sum_file(sumfile);
        sprintf(cmd, "emacs %s", sumfile);
        /* here we'll wait until emacs finishes */
//      system(cmd);

/* ------------------
   send summary file to default printer ?
   only for Unix/Linux at the moment
   ------------------
*/
        size = sizeof(printcmd);
        if ( db_get_value(hDB, 0, "/Programs/print summary", &printcmd, &size, TID_STRING, FALSE)
                == DB_SUCCESS && odb.runinfo.state == 1 ){ /* print only when run is stopped */
#ifdef OS_UNIX
                if ( strstr( printcmd, "print") ){
                        sprintf(cmd, "%s %s &", printcmd, sumfile);
                        system(cmd);
                }
#endif
        }
  } /* if ( status == DB_SUCCESS ) */

  cm_disconnect_experiment();

}