hv_detectors_scfe.cxx

Go to the documentation of this file.

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

  Name:         hv_detectors_scfe.cxx
  Created by:   Andreas Suter

  Contents:     Midas frontend for the detector high voltage

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

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>

#include "midas.h"
#include "mfe.h"

#include "class/hv.h"
#include "hv_nhr.h"
#include "hvr400.h"
#include "hv_scs2001_apd.h"
#include "hpx30_107.h"
#include "tcpip_rs232.h"
#include "bus/null.h"

//-- Globals -------------------------------------------------------

const char *frontend_name = "HV Detectors";
const char *frontend_file_name = __FILE__;

BOOL frontend_call_loop = TRUE;

INT display_period = 1000;

INT max_event_size = 10000;

INT max_event_size_frag = 5*1024*1024;

INT event_buffer_size = 10*10000;

// -- HV Monitoring Variables -----------------------------------------

#define LEMVAC_GAS_INLET_ON        0x80
#define LEMVAC_MC_STATUS_WORD_2    15
#define LEMVAC_TC_STATUS_WORD_2    18
#define LEMVAC_SC_STATUS_WORD_2    21
#define TD_FIRST_CH     0
#define TD_LAST_CH      3
#define MCP1_CH         4
#define MCP2_FIRST_CH   6
#define MCP2_LAST_CH    7
#define POS_MCP1_I      12
#define POS_MCP1_O      13

#define HV_TD_MAX_COUNT 30

#define HV_DETECTOR_CHANNELS 94

#define HV_DETECTOR_READ_TIME  10

HNDLE hv_detectors_hDB;
HNDLE hv_detectors_measured_hKey;

int   hv_detectors_drop_counter[HV_DETECTOR_CHANNELS];
char  hv_detectors_names[HV_DETECTOR_CHANNELS*NAME_LENGTH];
float hv_detectors_demand[HV_DETECTOR_CHANNELS];
float hv_detectors_measured[HV_DETECTOR_CHANNELS];
int   hv_td_hv_check_counter; 

// Monitoring stuff
INT hv_monitoring_enabled; 
INT hv_hvAlreadyOff;       

// Gas inlet stuff
float lemvac_in[27]; 

DWORD hv_dectector_timestamp; 

//-- Equipment list ------------------------------------------------

DEVICE_DRIVER hv_driver[] = {
  { "TD",        hv_nhr,             4,        null, DF_PRIO_DEVICE | DF_HW_RAMP | DF_REPORT_STATUS | DF_REPORT_TEMP },
  { "MCP",       hv_nhr,             4,        null, DF_PRIO_DEVICE | DF_HW_RAMP | DF_REPORT_STATUS | DF_REPORT_TEMP },
  { "PHVR400_1", hvr400,             4,        null, DF_PRIO_DEVICE | DF_HW_RAMP },
  { "PHVR400_2", hvr400,             4,        null, DF_PRIO_DEVICE | DF_HW_RAMP },
  { "PHVR400_3", hvr400,             4,        null, DF_PRIO_DEVICE | DF_HW_RAMP },
  { "NHVR400_1", hvr400,             4,        null, DF_PRIO_DEVICE | DF_HW_RAMP },
  { "NHVR400_2", hvr400,             4,        null, DF_PRIO_DEVICE | DF_HW_RAMP },
  { "HPP30_107", hpx30_107,          1, tcpip_rs232, DF_PRIO_DEVICE | DF_REPORT_STATUS | DF_REPORT_TEMP },
  { "HPN30_107", hpx30_107,          1, tcpip_rs232, DF_PRIO_DEVICE | DF_REPORT_STATUS | DF_REPORT_TEMP },
  { "HV_APD",    hv_scs2001_apd,    64,        null, DF_PRIO_DEVICE | DF_HW_RAMP },
  { "" }
};

BOOL equipment_common_overwrite = FALSE;

EQUIPMENT equipment[] = {

  { "HV Detectors",       // equipment name
   {73, 0,                // event ID, trigger mask
    "SYSTEM",             // event buffer
    EQ_SLOW,              // equipment type
    0,                    // event source
    "FIXED",              // format
    TRUE,                 // enabled
    RO_RUNNING |
    RO_TRANSITIONS,       // read when running and on transitions
    30000,                // read every 30 sec
    0,                    // stop run after this event limit
    0,                    // number of sub events
    1,                    // log history every event
    "", "", "",},
    cd_hv_read,           // readout routine
    cd_hv,                // class driver main routine
    hv_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, POINTER_T adr) {return 1;};

// -- HV monitoring routines ---------------------------------------
void hv_detectors_scfe_gas_inlet(INT hDB, INT hKey, void *dummy)
{
  char  str[128];
  int   status, ival, i;
  float value;
  HNDLE hv_hKey;

  ival = (int)lemvac_in[LEMVAC_MC_STATUS_WORD_2];
  if (ival & LEMVAC_GAS_INLET_ON) {
    // get hv demand odb key
    strcpy(str, "/Equipment/HV Detectors/Variables/Demand");
    status = db_find_key(hDB, 0, str, &hv_hKey);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "hv_detectors_scfe_gas_inlet", "hv_detectors_scfe_gas_inlet: Couldn't find %s", str);
      return;
    }

    // set all hv detector values of the moderator chamber to zero
    value = 0.0;
    // MCP1 HV
    db_set_data_index(hDB, hv_hKey, &value, sizeof(value), MCP1_CH, TID_FLOAT);
  }

  ival = (int)lemvac_in[LEMVAC_TC_STATUS_WORD_2];
  if (ival & LEMVAC_GAS_INLET_ON) {
    // get hv demand odb key
    strcpy(str, "/Equipment/HV Detectors/Variables/Demand");
    status = db_find_key(hDB, 0, str, &hv_hKey);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "hv_detectors_scfe_gas_inlet", "hv_detectors_scfe_gas_inlet: Couldn't find %s", str);
      return;
    }

    // set all hv detector values of the trigger chamber to zero
    value = 0.0;
    // Trigger HV's
    for (i=TD_FIRST_CH; i<=TD_LAST_CH; i++) {
      db_set_data_index(hDB, hv_hKey, &value, sizeof(value), i, TID_FLOAT);
    }
  }

  ival = (int)lemvac_in[LEMVAC_SC_STATUS_WORD_2];
  if (ival & LEMVAC_GAS_INLET_ON) {
    // get hv demand odb key
    strcpy(str, "/Equipment/HV Detectors/Variables/Demand");
    status = db_find_key(hDB, 0, str, &hv_hKey);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "hv_detectors_scfe_gas_inlet", "hv_detectors_scfe_gas_inlet: Couldn't find %s", str);
      return;
    }

    // set all hv detector values of the sample chamber to zero
    value = 0.0;
    // MCP2 HV's
    for (i=MCP2_FIRST_CH; i<=MCP2_LAST_CH; i++) {
      db_set_data_index(hDB, hv_hKey, &value, sizeof(value), i, TID_FLOAT);
    }
  }
}

//------------------------------------------------------------------
void hv_detectors_scfe_td_check(INT hDB, INT hKey, void *dummy)
{
  // check if the difference between the measured TD HV's are smaller 1.0kV
  if (fabs(fabs(hv_detectors_measured[TD_FIRST_CH])-fabs(hv_detectors_measured[TD_FIRST_CH+1]))>1.0)
    hv_td_hv_check_counter++;
  else if (fabs(fabs(hv_detectors_measured[TD_FIRST_CH])-fabs(hv_detectors_measured[TD_FIRST_CH+2]))>1.0)
    hv_td_hv_check_counter++;
  else if (fabs(fabs(hv_detectors_measured[TD_FIRST_CH])-fabs(hv_detectors_measured[TD_FIRST_CH+3]))>1.0)
    hv_td_hv_check_counter++;
  else if (fabs(fabs(hv_detectors_measured[TD_FIRST_CH+1])-fabs(hv_detectors_measured[TD_FIRST_CH+2]))>1.0)
    hv_td_hv_check_counter++;
  else if (fabs(fabs(hv_detectors_measured[TD_FIRST_CH+1])-fabs(hv_detectors_measured[TD_FIRST_CH+3]))>1.0)
    hv_td_hv_check_counter++;
  else if (fabs(fabs(hv_detectors_measured[TD_FIRST_CH+2])-fabs(hv_detectors_measured[TD_FIRST_CH+3]))>1.0)
    hv_td_hv_check_counter++;
  else // everything OK, reset counter
    hv_td_hv_check_counter=0;

  if (hv_td_hv_check_counter > HV_TD_MAX_COUNT) { // at least one HV is hanging
    al_trigger_alarm( "hv_detectors_scfe_td_check", "TD HV's need to be checked!!",
                      "Warning", "TD HV's need to be checked!!", AT_INTERNAL);
  }

}

//-- Frontend Init -------------------------------------------------
INT frontend_init()
{
  HNDLE hDB, hKey;
  int   i, size;
  INT   status;
  char  str[128];

  // de-register run-transition notifications
  cm_deregister_transition(TR_START);
  cm_deregister_transition(TR_STOP);
  cm_deregister_transition(TR_PAUSE);
  cm_deregister_transition(TR_RESUME);

  // init global variables
  hv_monitoring_enabled = FALSE;
  hv_hvAlreadyOff       = FALSE;

  // get ODB main handle
  cm_get_experiment_database(&hDB, NULL);

  // keep main handle to ODB
  hv_detectors_hDB = hDB;

  // hotlink lemvac input
  strcpy(str, "/Equipment/LEMVAC/Variables/Input");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_init", "hv_detectors_scfe: Couldn't find %s", str);
    return CM_SUCCESS;
  }

  status = db_open_record(hDB, hKey, &lemvac_in, sizeof(lemvac_in), MODE_READ,
                          &hv_detectors_scfe_gas_inlet, NULL);

  // init drop counters
  for (i=0; i<HV_DETECTOR_CHANNELS; i++) {
    hv_detectors_drop_counter[i] = 0;
  }

  // get HV Detector names
  strcpy(str, "/Equipment/HV Detectors/Settings/Names");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_init", "hv_detectors_scfe: Couldn't find %s", str);
    return CM_SUCCESS;
  }

  size = sizeof(hv_detectors_names);
  status = db_get_record(hDB, hKey, &hv_detectors_names, &size, 0);

  // hotlink demand detector HV's
  strcpy(str, "/Equipment/HV Detectors/Variables/Demand");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_init", "hv_detectors_scfe: Couldn't find %s", str);
    return CM_SUCCESS;
  }

  status = db_open_record(hDB, hKey, &hv_detectors_demand, sizeof(hv_detectors_demand), MODE_READ,
                          NULL, NULL);

  // hotlink measured detector HV's
  strcpy(str, "/Equipment/HV Detectors/Variables/Measured");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_init", "hv_detectors_scfe: Couldn't find %s", str);
    return CM_SUCCESS;
  }

  // keep measured key for cyclic reading in frontend loop
  hv_detectors_measured_hKey = hKey;

  hv_td_hv_check_counter = 0;

  status = db_open_record(hDB, hKey, &hv_detectors_measured, sizeof(hv_detectors_measured), MODE_READ,
                          &hv_detectors_scfe_td_check, NULL);

  // start cyclic timer for hv checks
  hv_dectector_timestamp = ss_time();

  return CM_SUCCESS;
}

//-- Frontend Exit -------------------------------------------------
INT frontend_exit()
{
  char  str[128];
  int   status;
  HNDLE hDB, hKey;

  // get ODB main handle
  cm_get_experiment_database(&hDB, NULL);

  // unlink lemvac input
  strcpy(str, "/Equipment/LEMVAC/Variables/Input");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_exit", "hv_detectors_scfe: Couldn't find %s, status=%d", str, status);
    return CM_SUCCESS;
  }
  db_close_record(hDB, hKey);

  // unlink demand HV's
  strcpy(str, "/Equipment/HV Detectors/Variables/Demand");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_exit", "hv_detectors_scfe: Couldn't find %s, status=%d", str, status);
    return CM_SUCCESS;
  }
  db_close_record(hDB, hKey);

  // unlink measured HV's
  strcpy(str, "/Equipment/HV Detectors/Variables/Measured");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_exit", "hv_detectors_scfe: Couldn't find %s, status=%d", str, status);
    return CM_SUCCESS;
  }
  db_close_record(hDB, hKey);

  return CM_SUCCESS;
}

//-- Frontend Loop -------------------------------------------------
INT frontend_loop()
{
  HNDLE hKey;
  DWORD now;
  int   size, i, status;
  float measured[HV_DETECTOR_CHANNELS], fval;
  static int offset;
  char  name[NAME_LENGTH];
  char  str[512];

  offset = -1;

  // time to read hv measured?
  now = ss_time();
  if (now - hv_dectector_timestamp > HV_DETECTOR_READ_TIME) {
    // reset timer
    hv_dectector_timestamp = now;
    // read hv measured values from ODB
    size = sizeof(measured);
    db_get_record(hv_detectors_hDB, hv_detectors_measured_hKey, &measured[0], &size, 0);
    // check if measured one is deviating too strongly from the demand
    for (i=0; i<HV_DETECTOR_CHANNELS; i++) {
      if ((hv_detectors_demand[i] != 0.0) && (fabs(fabs(hv_detectors_demand[i])-fabs(measured[i]))>0.2)) {
        hv_detectors_drop_counter[i]++;
        // check of limit is reached
        if (hv_detectors_drop_counter[i]>18) { // 3 mins HV demand != measured
          strncpy(name, &hv_detectors_names[i*NAME_LENGTH], NAME_LENGTH*sizeof(char));
          sprintf(str, "HV Detector %s: measured = %f, demand = %f, check!!",
                       name, hv_detectors_measured[i], hv_detectors_demand[i]);
          al_trigger_alarm( "hv_detectors_scfe", str, "Warning", str, AT_INTERNAL);
        }
        if ((i == POS_MCP1_I) || (i == POS_MCP1_O)) {
          // toggle offset between -1 and 1
          if (offset == 1)
            offset = -1;
          else if (offset == -1)
            offset = 1;

          strcpy(str, "/Equipment/HV Detectors/Variables/Demand");
          status = db_find_key(hv_detectors_hDB, 0, str, &hKey);
          if (status != DB_SUCCESS) {
            cm_msg(MERROR, "frontend_loop", "hv_detectors_scfe: Couldn't find %s, status=%d", str, status);
            return CM_SUCCESS;
          }

          fval = hv_detectors_demand[i] + offset*0.001;
          if (i == POS_MCP1_I) {
            status = db_set_data_index(hv_detectors_hDB, hKey, &fval, sizeof(fval), POS_MCP1_I, TID_FLOAT);
            cm_msg(MINFO, "hv_detectors_scfe", "hv_detectors_scfe: try to self-reset POS_MCP1_I HV");
          } else {
            status = db_set_data_index(hv_detectors_hDB, hKey, &fval, sizeof(fval), POS_MCP1_O, TID_FLOAT);
            cm_msg(MINFO, "hv_detectors_scfe", "hv_detectors_scfe: try to self-reset POS_MCP1_O HV");
          }
        }
      } else { // reset drop counter since readback is OK
        hv_detectors_drop_counter[i]  = 0;
      }
    }
  }

  return CM_SUCCESS;
}

//-- Begin of Run --------------------------------------------------
INT begin_of_run(INT run_number, char *error)
{
  return CM_SUCCESS;
}

//-- End of Run ----------------------------------------------------
INT end_of_run(INT run_number, char *error)
{
  return CM_SUCCESS;
}

//-- Pause Run -----------------------------------------------------
INT pause_run(INT run_number, char *error)
{
  return CM_SUCCESS;
}

//-- Resume Run ----------------------------------------------------
INT resume_run(INT run_number, char *error)
{
  return CM_SUCCESS;
}

//------------------------------------------------------------------