PLemAutoRun.cpp

Go to the documentation of this file.

/********************************************************************************************

  PLemAutoRun.cpp

*********************************************************************************************

    begin                : Andreas Suter, 2006/03/14
    modfied:             :
    copyright            : (C) 2006 by
    email                : andreas.suter@psi.ch

********************************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include <iostream>

#include <stdlib.h>
#include <unistd.h>
#include <math.h>
#include <string.h>
#include <time.h>

#include <QCoreApplication>
#include <QFile>
#include <QFileInfo>
#include <QDateTime>
#include <QStringList>
#include <QMapIterator>
#include <QElapsedTimer>
#include <QXmlStreamAttributes>
#include <QTextStream>

#include "lemAutoRun.h"
#include "PLemAutoRun.h"

// defines ------------------------------------------------------------

// Cryo related tags
#define CRYO_NO     -1    
#define CRYO_KONTI   0    
#define CRYO_LOWTEMP 1    
#define CRYO_OVEN_OMEGA 2 

// MIDAS flags
#define RUN_STOPPED 1  
#define RUN_PAUSED  2  
#define RUN_RUNNING 3  

#define BPVX         0  
#define BPVY         1  
#define BPV_CLOSE    3  
#define BPV_OPEN     2  
#define BPVX_ENABLED 0  
#define BPVX_SET     1  
#define BPVY_ENABLED 2  
#define BPVY_SET     3  
#define BPVX_STATE   25 
#define BPVY_STATE   26 
#define BPV_STATE_OPEN   5120 
#define BPV_STATE_CLOSED 3072 
#define BPV_STATE_LOCKED 2048 

#define SC_VENT_ENABLED 6 
#define SC_VENT_CMD     7 

// LS340/LS336 control commands
#define LS_CTRL_PID               1 
#define LS_CTRL_ZONE              2 
// LS340 input
#define LS340_INPUT_CF1           0 
#define LS340_INPUT_CF2           1 
#define LS340_INPUT_PRESSURE      2 
#define LS340_INPUT_HEATER        7 
#define LS340_INPUT_SETPOINT      8 
#define LS340_INPUT_PID_P         9 
#define LS340_INPUT_PID_I        10 
#define LS340_INPUT_PID_D        11 
#define LS340_INPUT_HEATER_RANGE 12 
#define LS340_INPUT_HEATER_MODE  13 
#define LS340_INPUT_RAMP         14 
// LS340 output
#define LS340_OUTPUT_REMOTE       0 
#define LS340_OUTPUT_SETPOINT     1 
#define LS340_OUTPUT_PID_P        2 
#define LS340_OUTPUT_PID_I        3 
#define LS340_OUTPUT_PID_D        4 
#define LS340_OUTPUT_HEATER_RANGE 5 
#define LS340_OUTPUT_HEATER_MODE  6 
#define LS340_OUTPUT_RAMP         7 
// LS336 input
#define LS336_INPUT_CF1           0 
#define LS336_INPUT_CF2           1 
#define LS336_INPUT_PRESSURE      4 
#define LS336_INPUT_HEATER        8 
#define LS336_INPUT_SETPOINT      9 
#define LS336_INPUT_PID_P        10 
#define LS336_INPUT_PID_I        11 
#define LS336_INPUT_PID_D        12 
#define LS336_INPUT_HEATER_RANGE 13 
#define LS336_INPUT_HEATER_MODE  14 
#define LS336_INPUT_RAMP         15 
// LS336 output
#define LS336_OUTPUT_SETPOINT     0 
#define LS336_OUTPUT_PID_P        1 
#define LS336_OUTPUT_PID_I        2 
#define LS336_OUTPUT_PID_D        3 
#define LS336_OUTPUT_HEATER_RANGE 4 
#define LS336_OUTPUT_HEATER_MODE  5 
#define LS336_OUTPUT_RAMP         6 

// Omega oven input
#define OMEGA_OVEN_INPUT_TEMP      0 
#define OMEGA_OVEN_INPUT_SETPOINT  6 
// Omega oven output
#define OMEGA_OVEN_OUTPUT_SETPOINT 0 

// NeedleValve input
#define SM_INPUT_NEEDLEVALVE     0 
// NeedleValve output
#define SM_OUTPUT_NEEDLEVALVE    0 
#define SM_MODUS_NEEDLEVALVE     1 
// Bronkhorst input
#define BH_INPUT_FLOW             0 
#define BH_INPUT_VALVE            1 
// Bronkhorst output
#define BH_OUTPUT_FLOW            0 
// Danfsik Spin Rotator Magnet Current
#define SPINT_ROT_OUTPUT_CURRENT  2 
#define SPINT_ROT_INPUT_CURRENT   3 
// Danfysik input
#define DANFYSIK_INPUT_CURRENT    3 
// Danfysik output
#define DANFYSIK_OUTPUT_CURRENT   2 
// WEW input
#define WEWL_INPUT_STATUS         0 
#define WEWL_INPUT_CURRENT        1 
#define WEWH_INPUT_STATUS         3 
#define WEWH_INPUT_CURRENT        4 
// WEW output
#define WEWL_OUTPUT_CMD           0 
#define WEWL_OUTPUT_CURRENT       1 
#define WEWH_OUTPUT_CMD           2 
#define WEWH_OUTPUT_CURRENT       3 
#define WEW_SSP_LOCK              4 
// HV FUG
#define HV_FUG_MAX_TRY            5 
#define HV_FUG_CHS               16 
#define HV_FUG_RIGHT_RODS         0 
#define HV_FUG_LEFT_RODS          1 
#define HV_FUG_LEFT_PLATE         2 
#define HV_FUG_RIGHT_PLATE        3 
#define HV_FUG_MOD                4 
#define HV_FUG_MIRROR             8 
#define HV_FUG_LENSE_2            9 
#define HV_FUG_LENSE_3           10 
#define HV_FUG_RAL               11 
#define HV_FUG_RAR               12 
#define HV_FUG_RAT               13 
#define HV_FUG_RAB               14 
#define HV_FUG_SAMPLE            15 
// HV NHQ
#define HV_NHQ_TD_FIRST           0 
#define HV_NHQ_TD_LAST            3 
#define HV_NHQ_MCP1               4 
// FOM input
#define FOM_CURRENT_MEASURED      0 
#define FOM_VOLTAGE_MEASURED      1 
#define FOM_BATTERY               2 
// FOM ouput
#define FOM_CURRENT_DEMAND        0 
#define FOM_STANDBY               1 
// Beamline KV61, KV62 indices
#define BEAMLINE_KV61_DEMAND_CH   26 
#define BEAMLINE_KV62_DEMAND_CH   28 

// web related stuff
#define HTML_LOAD        0  
#define HTML_START       1  
#define HTML_RUNNING     2  
#define HTML_STOP        3  
#define HTML_ABORTED     4  
#define HTML_ALARM       5  
#define HTML_WARMUP      6  
#define HTML_STRANGE     7  
#define HTML_PARSE_ERROR 8  
#define HTML_FATAL       9  

// TEMP parameter tags
#define TEMP_DEMAND_TEMP       0 
#define TEMP_DELTA_T           1 
#define TEMP_STABILITY_TIMEOUT 2 
#define TEMP_RAMP              3 
#define TEMP_HEATER_RANGE      4 
#define TEMP_P_PID             5 
#define TEMP_I_PID             6 
#define TEMP_D_PID             7 
#define TEMP_FLOW              8 

// autorun transition tags
#define LAR_TT_IDLE     0
#define LAR_TT_FINISHED 1
#define LAR_TT_ABORTED  2
#define LAR_TT_WARMUP   3

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// implementation of PLemAutoRunXMLParser
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//**********************************************************************
// constructor
//**********************************************************************
PLemAutoRunXMLParser::PLemAutoRunXMLParser(const QString fln, PLemAutoRun *lar)
{
  fLar = lar;

  QFile file(fln);
  if (!file.open(QFile::ReadOnly | QFile::Text) || (file.size()==0))
    return;

  fValid = parse(&file);
}

//**********************************************************************
// destructor
//**********************************************************************
PLemAutoRunXMLParser::~PLemAutoRunXMLParser()
{
}

//**********************************************************************
// parse
//**********************************************************************
bool PLemAutoRunXMLParser::parse(QIODevice *device)
{
  fXml.setDevice(device);

  bool expectChars = false;
  while (!fXml.atEnd()) {
    fXml.readNext();
    if (fXml.isStartDocument()) {
      startDocument();
    } else if (fXml.isStartElement()) {
      startElement();
      expectChars = true;
    } else if (fXml.isCharacters() && expectChars) {
      characters();
    } else if (fXml.isEndElement()) {
      endElement();
      expectChars = false;
    } else if (fXml.isEndDocument()) {
      endDocument();
    }
  }
  if (fXml.hasError()) {
    QString msg;
    msg = QString("%1 Line %2, column %3").arg(fXml.errorString()).arg(fXml.lineNumber()).arg(fXml.columnNumber());
    cm_msg(MERROR, "lemAutoRun", msg.toLatin1().data());
    cm_yield(0);
    return false;
  }

  return true;
}

//**********************************************************************
// startDocument
//**********************************************************************
bool PLemAutoRunXMLParser::startDocument()
{
  return true;
}

//**********************************************************************
// startElement
//**********************************************************************
bool PLemAutoRunXMLParser::startElement()
{
  QString qName = fXml.name().toString();
  QXmlStreamAttributes qAttr = fXml.attributes();

  if (qName == "xmlSchemaFln") {
    fKey = eXmlSchemaFln;
  } else if (qName == "xmlAutoRunFln") {
    fKey = eXmlAutoRunFln;
  } else if (qName == "xmlAutoRunValidateFln") {
    fKey = eXmlAutoRunValidateFln;
  } else if (qName == "xmlAutoRunHTML") {
    fKey = eXmlAutoRunHTML;
  } else if (qName == "enable_all") {
    fKey = eEnableAll;
  } else if (qName == "autoRunPath") {
    fKey = eAutoRunPath;
  } else if (qName == "hvSettingsPath") {
    fKey = eHvSettingsPath;
  } else if (qName == "debug") {
    fKey = eDebug;
  } else if (qName == "ignore_clients") {
    fKey = eIgnore_clients;
  } else if (qName == "ignore_alarms") {
    fKey = eIgnore_alarms;
  } else if (qName == "fug_hv_check") {
    fKey = eFugHvCheck;
  } else if (qName == "field_timeout") {
    fKey = eField_timeout;
  } else if (qName == "field_accuracy") {
    fKey = eField_accuracy;
  } else if (qName == "hv_timeout") {
    fKey = eHv_timeout;
  } else if (qName == "hv_accuracy") {
    fKey = eHv_accuracy;
  } else if (qName == "fom_current_accuracy") {
    fKey = eFOM_current_accuracy;
  } else if (qName == "wew_critical_current_ra") {
    fKey = eWEW_critical_current_ra;
  } else if (qName == "wewl_max_current") {
    fKey = eWEWL_max_current;
  } else if (qName == "wewh_max_current") {
    fKey = eWEWH_max_current;
  } else if (qName == "danfysik_max_current") {
    fKey = eDanfysik_max_current;
  } else if (qName == "trigger_events") {
    fKey = eTrigger_events;    
    setAttribute("trigger_events_odb", qAttr);
  } else if (qName == "enable_on_off_mode") {
    fKey = eEnable_OnOff_Mode;
    setAttribute("enable_on_off_mode_odb", qAttr);
  } else if (qName == "alarms") {
    fKey = eAlarms;
    setAttribute("alarms_odb", qAttr);
  } else if (qName == "alarms_td_hv_trip") {
    fKey = eAlarm_td_hv_trip;
    setAttribute("alarms_td_hv_trip_odb", qAttr);
  } else if (qName == "run_info") {
    fKey = eRun_info;
  } else if (qName == "run_comment") {
    fKey = eRun_comment;
    setAttribute("run_comment_odb", qAttr);
  } else if (qName == "tof_min") {
    fKey = eTof_min;
    setAttribute("tof_min_odb", qAttr);
  } else if (qName == "tof_max") {
    fKey = eTof_max;
    setAttribute("tof_max_odb", qAttr);
  } else if (qName == "mod_name") {
    fKey = eMod_name;
    setAttribute("mod_name_odb", qAttr);
  } else if (qName == "mod_date") {
    fKey = eMod_date;
    setAttribute("mod_date_odb", qAttr);
  } else if (qName == "lem_setup") {
    fKey = eLem_setup;
    setAttribute("lem_setup_odb", qAttr);
  } else if (qName == "sample_name") {
    fKey = eSample_name;
    setAttribute("sample_name_info_odb", qAttr);
  } else if (qName == "spin_rot_enabled") {
    fKey = eSpin_rot_enabled;
    setAttribute("spin_rot_calib_odb", qAttr);
  } else if (qName == "spin_rot_angle") {
    fKey = eSpin_rot_angle;
    setAttribute("spin_rot_angle_odb", qAttr);
  } else if (qName == "mag_param_wew") {
    fKey = eMag_param_wew;
    setAttribute("mag_param_wew_odb", qAttr);
  } else if (qName == "mag_param_bpar") {
    fKey = eMag_param_bpar;
    setAttribute("mag_param_bpar_odb", qAttr);
  } else if (qName == "setup_sample_enabled") {
    fKey = eSetup_sample_enabled;
    setAttribute("setup_sample_odb", qAttr);
  } else if (qName == "setup_wew_enabled") {
    fKey = eSetup_wew_enabled;
    setAttribute("setup_wew_odb", qAttr);
  } else if (qName == "setup_bpar_enabled") {
    fKey = eSetup_bpar_enabled;
    setAttribute("setup_bpar_odb", qAttr);
  } else if (qName == "sample_cryo") {
    fKey = eSample_cryo;
    setAttribute("sample_cryo_info_odb", qAttr);
  } else if (qName == "energy_loss_param") {
    fKey = eEnergy_loss_param;
    setAttribute("energy_loss_param_odb", qAttr);
  } else if (qName == "clients") {
    fKey = eClients;
  } else if (qName == "clients_analyzer") {
    fKey = eClients_analyzer;
    setAttribute("analyzer_fe", qAttr);
  } else if (qName == "clients_frontend") {
    fKey = eClients_frontend;
    setAttribute("vme_fe", qAttr);
  } else if (qName == "clients_tfl") {
    fKey = eClients_tfl;
    setAttribute("tfl_scfe", qAttr);
  } else if (qName == "clients_sample") {
    fKey = eClients_sample;
    setAttribute("sample_scfe", qAttr);
  } else if (qName == "clients_sample_omega") {
    fKey = eClients_sample_omega;
    setAttribute("omega_scfe", qAttr);
  } else if (qName == "clients_wew") {
    fKey = eClients_WEW;
    setAttribute("wew_scfe", qAttr);
  } else if (qName == "clients_danfysik") {
    fKey = eClients_danfysik;
    setAttribute("danfysik_scfe", qAttr);
  } else if (qName == "clients_hv") {
    fKey = eClients_hv;
    setAttribute("fug_scfe", qAttr);
  } else if (qName == "clients_lemvac") {
    fKey = eClients_lemvac;
    setAttribute("lemvac_scfe", qAttr);
  } else if (qName == "hv_demand") {
    fKey = eHv_demand;
    setAttribute("fug_eq", qAttr);
  } else if (qName == "hv_measured") {
    fKey = eHv_measured;
    setAttribute("fug_eq", qAttr);
  } else if (qName == "hv_current") {
    fKey = eHv_current;
    setAttribute("fug_eq", qAttr);
  } else if (qName == "hv_detectors_demand") {
    fKey = eHvDetector_demand;
    setAttribute("hv_detectors_eq", qAttr);
  } else if (qName == "hv_detectors_measured") {
    fKey = eHvDetector_measured;
    setAttribute("hv_detectors_eq", qAttr);
  } else if (qName == "spin_rot_mag_input") {
    fKey = eSpin_rot_mag_input;
    setAttribute("danfysik_spin_rot_eq", qAttr);
  } else if (qName == "spin_rot_mag_output") {
    fKey = eSpin_rot_mag_output;
    setAttribute("danfysik_spin_rot_eq", qAttr);
  } else if (qName == "danfysik_input") {
    fKey = eDanfysik_input;
    setAttribute("danfysik_eq", qAttr);
  } else if (qName == "danfysik_output") {
    fKey = eDanfysik_output;
    setAttribute("danfysik_eq", qAttr);
  } else if (qName == "wew_output") {
    fKey = eWEW_output;
    setAttribute("wew_eq", qAttr);
  } else if (qName == "wew_input") {
    fKey = eWEW_input;
    setAttribute("wew_eq", qAttr);
  } else if (qName == "mag_field") {
    fKey = eMag_field;
    setAttribute("magnet_field_info", qAttr);
  } else if (qName == "tfl_input") {
    fKey = eTfl_input;
    setAttribute("tfl_eq", qAttr);
  } else if (qName == "tfl_output") {
    fKey = eTfl_output;
    setAttribute("tfl_eq", qAttr);
  } else if (qName == "sample_ctrl_ch") {
    fKey = eSample_ctrl_ch;
    setAttribute("sample_eq", qAttr);
  } else if (qName == "sample_channel") {
    fKey = eSample_channel;
    setAttribute("sample_eq", qAttr);
  } else if (qName == "sample_sensor_type") {
    fKey = eSample_sensor_type;
    setAttribute("sample_eq", qAttr);
  } else if (qName == "sample_input") {
    fKey = eSample_input;
    setAttribute("sample_eq", qAttr);
  } else if (qName == "sample_output") {
    fKey = eSample_output;
    setAttribute("sample_eq", qAttr);
  } else if (qName == "sample_rawvoltage") {
    fKey = eSample_rawvoltage;
    setAttribute("sample_eq", qAttr);
  } else if (qName == "sample_bh_odb_offset_input") {
    fKey = eSample_bh_odb_offset_input;
    setAttribute("sample_eq", qAttr);
  } else if (qName == "sample_bh_odb_offset_output") {
    fKey = eSample_bh_odb_offset_output;
    setAttribute("sample_eq", qAttr);
  } else if (qName == "sample_oven_omega_input") {
    fKey = eSample_oven_omega_input;
    setAttribute("omega_eq", qAttr);
  } else if (qName == "sample_oven_omega_output") {
    fKey = eSample_oven_omega_output;
    setAttribute("omega_eq", qAttr);
  } else if (qName == "lemvac_input") {
    fKey = eLemvac_input;
    setAttribute("lemvac_eq", qAttr);
  } else if (qName == "lemvac_output") {
    fKey = eLemvac_output;
    setAttribute("lemvac_eq", qAttr);
  } else if (qName == "fom_input") {
    fKey = eFOM_input;
    setAttribute("fom_eq", qAttr);
  } else if (qName == "fom_output") {
    fKey = eFOM_output;
    setAttribute("fom_eq", qAttr);
  } else if (qName == "beamline_demand") {
    fKey = eBeamline_demand;
    setAttribute("beamline_eq", qAttr);
  }

  return true;
}

//**********************************************************************
// endElement
//**********************************************************************
bool PLemAutoRunXMLParser::endElement()
{
  fKey = eEmpty; // no key word anymore

  return true;
}

//**********************************************************************
// characters
//**********************************************************************
bool PLemAutoRunXMLParser::characters()
{
  QString str = fXml.text().toString();

  int  number;
  bool ok;

  switch (fKey) {
    case eXmlSchemaFln:
      fLar->fXMLSchemaFln = str;
      break;
    case eXmlAutoRunFln:
      fLar->fXMLAutoRunFln = str;
      break;
    case eXmlAutoRunValidateFln:
      fLar->fXMLAutoRunValidateFln = str;
      break;
    case eXmlAutoRunHTML:
      fLar->fXMLAutoRunHTML = str;
      break;
    case eEnableAll:
      if (str == "yes") {
        fLar->fEnableAll = true;
        fLar->SetEnabled("all", true);
      }
      break;
    case eAutoRunPath:
      fLar->fAutoRunPath = str;
      break;
    case eHvSettingsPath:
      fLar->fHvSettingsPath = str;
      break;
    case eDebug:
      if (str == "true")
        fLar->fDebug = true;
      else
        fLar->fDebug = false;
      break;
    case eIgnore_clients:
      if (str == "true")
        fLar->fIgnoreClients = true;
      else
        fLar->fIgnoreClients = false;
      break;
    case eIgnore_alarms:
      if (str == "true")
        fLar->fIgnoreAlarms = true;
      else
        fLar->fIgnoreAlarms = false;
      break;
    case eField_timeout:
      fLar->fFieldTimeout = str.toFloat();
      break;
    case eFugHvCheck:
      if (str == "false")
        fLar->fFugHvCheck = false;
      else
        fLar->fFugHvCheck = true;
      break;
    case eField_accuracy:
      fLar->fFieldAccuracy = str.toFloat();
      break;
    case eHv_timeout:
      fLar->fHVTimeout = str.toFloat();
      break;
    case eHv_accuracy:
      fLar->fHVAccuracy = str.toFloat();
      break;
    case eFOM_current_accuracy:
      fLar->fFOMCurrentAccuracy = str.toFloat();
      break;
    case eWEW_critical_current_ra:
      fLar->fWEWCriticalCurrentRA = str.toFloat();
      break;
    case eWEWL_max_current:
      fLar->fWEWLMaxCurrent = str.toFloat();
      break;
    case eWEWH_max_current:
      fLar->fWEWHMaxCurrent = str.toFloat();
      break;
    case eDanfysik_max_current:
      fLar->fDanfysikMaxCurrent = str.toFloat();
      break;
    case eTrigger_events:
      fLar->fTriggerEventsPath = str;
      break;
    case eEnable_OnOff_Mode:
      fLar->fEnableOnOffModePath = str;
      break;
    case eAlarms:
      fLar->fAlarmsPath = str;
      break;
    case eAlarm_td_hv_trip:
      fLar->fAlarmTdHvTripPath = str;
      break;
    case eRun_info:
      fLar->fRunInfoPath = str;
      break;
    case eRun_comment:
      fLar->fRunCommentPath = str;
      break;
    case eTof_min:
      fLar->fTofMinPath = str;
      break;
    case eTof_max:
      fLar->fTofMaxPath = str;
      break;
    case eMod_name:
      fLar->fModNamePath = str;
      break;
    case eMod_date:
      fLar->fModDatePath = str;
      break;
    case eLem_setup:
      fLar->fLemSetupPath = str;
      break;
    case eSample_name:
      fLar->fSampleNamePath = str;
      break;
    case eSpin_rot_enabled:
      fLar->fSpinRotEnabledPath = str;
      break;
    case eSpin_rot_angle:
      fLar->fSpinRotAnglePath = str;
      break;
    case eMag_param_wew:
      fLar->fMagParamWewPath = str;
      break;
    case eMag_param_bpar:
      fLar->fMagParamBparPath = str;
      break;
    case eSetup_sample_enabled:
      fLar->fSetupSampleEnabledPath = str;
      break;
    case eSetup_wew_enabled:
      fLar->fSetupWewEnabledPath = str;
      break;
    case eSetup_bpar_enabled:
      fLar->fSetupBparEnabledPath = str;
      break;
    case eSample_cryo:
      fLar->fSampleCryoPath = str;
      break;
    case eEnergy_loss_param:
      fLar->fEnergyLossParamPath = str;
      break;
    case eClients:
      fLar->fClientsPath = str;
      break;
    case eClients_analyzer:
      fLar->fAnalyzerName = str;
      break;
    case eClients_frontend:
      fLar->fFrontendName = str;
      break;
    case eClients_tfl:
      fLar->fTflFeName = str;
      break;
    case eClients_sample:
      fLar->fSampleFeName = str;
      break;
    case eClients_sample_omega:
      fLar->fSampleOvenOmegaFeName = str;
      break;
    case eClients_WEW:
      fLar->fWEWFeName = str;
      break;
    case eClients_danfysik:
      fLar->fDanfysikFeName = str;
      break;
    case eClients_hv:
      fLar->fHVFeName = str;
      break;
    case eClients_lemvac:
      fLar->fLemvacFeName = str;
      break;
    case eHv_demand:
      fLar->fHVDemandPath = str;
      break;
    case eHv_measured:
      fLar->fHVMeasuredPath = str;
      break;
    case eHv_current:
      fLar->fHVCurrentPath = str;
      break;
    case eHvDetector_demand:
      fLar->fHVDetectorDemandPath = str;
      break;
    case eHvDetector_measured:
      fLar->fHVDetectorMeasuredPath = str;
      break;
    case eSpin_rot_mag_input:
      fLar->fSpinRotMagInputPath = str;
      break;
    case eSpin_rot_mag_output:
      fLar->fSpinRotMagOutputPath = str;
      break;
    case eDanfysik_input:
      fLar->fDanfysikInputPath = str;
      break;
    case eDanfysik_output:
      fLar->fDanfysikOutputPath = str;
      break;
    case eWEW_output:
      fLar->fWEWOutputPath = str;
      break;
    case eWEW_input:
      fLar->fWEWInputPath = str;
      break;
    case eMag_field:
      fLar->fMagFieldPath = str;
      break;
    case eTfl_input:
      fLar->fTflInputPath = str;
      break;
    case eTfl_output:
      fLar->fTflOutputPath = str;
      break;
    case eSample_ctrl_ch:
      fLar->fSampleCtrlChPath = str;
      break;
    case eSample_channel:
      fLar->fSampleChannelPath = str;
      break;
    case eSample_sensor_type:
      fLar->fSampleSensorTypePath = str;
      break;
    case eSample_input:
      fLar->fSampleInputPath = str;
      break;
    case eSample_output:
      fLar->fSampleOutputPath = str;
      break;
    case eSample_rawvoltage:
      fLar->fSampleRawVoltagePath = str;
      break;
    case eSample_bh_odb_offset_input:
      number = str.toInt(&ok);
      if (ok)
        fLar->fSampleBhOdbOffsetInput = number;
      break;
    case eSample_bh_odb_offset_output:
      number = str.toInt(&ok);
      if (ok)
        fLar->fSampleBhOdbOffsetOutput = number;
      break;
    case eSample_oven_omega_input:
      fLar->fSampleOvenOmegaInputPath = str;
      break;
    case eSample_oven_omega_output:
      fLar->fSampleOvenOmegaOutputPath = str;
      break;
    case eLemvac_input:
      fLar->fLemvacInputPath = str;
      break;
    case eLemvac_output:
      fLar->fLemvacOutputPath = str;
      break;
    case eFOM_input:
      fLar->fFOMInputPath = str;
      break;
    case eFOM_output:
      fLar->fFOMOutputPath = str;
      break;
    case eBeamline_demand:
      fLar->fBeamlineDemandPath = str;
      break;
    default:
      break;
  }

  return true;
}

//**********************************************************************
// endDocument
//**********************************************************************
bool PLemAutoRunXMLParser::endDocument()
{
  QString errorMsg;

  // check if all expected input is found

  if (fLar->fXMLSchemaFln.isEmpty()) { // no XML-schema path given
    fLar->fXMLSchemaFln = "/home/nemu/nemu/lemQt5/lemAutoRun/lemAutoRun.xsd";
    errorMsg = "lemAutoRun: Couldn't find XML-schema path, will try hard-wired one (no warranty that it works): " +
               fLar->fXMLSchemaFln;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fXMLAutoRunFln.isEmpty()) { // no XML autorun sequence path is given
    fLar->fXMLAutoRunFln = "/home/nemu/nemu/lemQt5/lemAutoRun/lar_seq.xml";
    errorMsg = QString("lemAutoRun: Couldn't find XML autorun sequence path, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fXMLAutoRunFln;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fXMLAutoRunValidateFln.isEmpty()) { // no XML validate autorun sequence path is given
    fLar->fXMLAutoRunFln = "/home/nemu/nemu/lemQt5/lemAutoRun/lar_seq_validate.xml";
    errorMsg = QString("lemAutoRun: Couldn't find XML validate autorun sequence path, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fXMLAutoRunValidateFln;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fXMLAutoRunHTML.isEmpty()) { // no HTML autorun status page path is given
    fLar->fXMLAutoRunHTML = "/home/nemu/nemu/midas/experiment/nemu/custom_pages/lemAutoRun.html";
    errorMsg = QString("lemAutoRun: Couldn't find XML autorun sequence path, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fXMLAutoRunHTML;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fAutoRunPath.isEmpty()) { // no autorun path is given
    fLar->fAutoRunPath = "/home/nemu/autoRun/";
    errorMsg = QString("lemAutoRun: Couldn't find XML autorun sequence path, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fAutoRunPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  // no field reaching timeout given, hence set it to 300 (sec)
  if (fLar->fFieldTimeout == 0.0)
    fLar->fFieldTimeout = 300;

  // no field accuracy needed to be reached before going on: default = 0.01 (A)
  if (fLar->fFieldAccuracy == 0.0)
    fLar->fFieldAccuracy = 0.01;

  // no HV reaching timeout given, hence set it to 300 (sec)
  if (fLar->fHVTimeout == 0.0)
    fLar->fHVTimeout = 300;

  // HV accuracy needed to be reached before going on: default = 0.02 (kV)
  if (fLar->fHVAccuracy == 0.0)
    fLar->fHVAccuracy = 0.02;

  // FOM current accuracy needed to be reached before going on: default = 1.0e-4 (mA)
  if (fLar->fFOMCurrentAccuracy == 0.0)
    fLar->fFOMCurrentAccuracy = 1.0e-4;

  // WEW critical current value above which the Penning trap problems is happening, default = 22.65A -> ~130G
  if (fLar->fWEWCriticalCurrentRA == 0.0)
    fLar->fWEWCriticalCurrentRA = 22.65;

  // WEWL max. current not given check
  if (fLar->fWEWLMaxCurrent == 0.0)
    fLar->fWEWLMaxCurrent = 50.0;

  // WEWH max. current not given check
  if (fLar->fWEWHMaxCurrent == 0.0)
    fLar->fWEWHMaxCurrent = 595.0;

  // Danfysik max. current not given check
  if (fLar->fDanfysikMaxCurrent == 0.0)
    fLar->fDanfysikMaxCurrent = 20.0;

  if (fLar->fTriggerEventsPath.isEmpty() && fLar->fEnabled["trigger_events_odb"]) { // odb path to the trigger events missing
    fLar->fTriggerEventsPath = "/Equipment/Trigger/Statistics/Events sent";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the trigger events in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fTriggerEventsPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fEnableOnOffModePath.isEmpty() && fLar->fEnabled["enable_on_off_mode_odb"]) { // odb path to the Enable_OnOff_Mode missing
    fLar->fEnableOnOffModePath = "/Equipment/Trigger/Settings/Enable_OnOff_Mode";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the Enable_OnOff_Mode in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fEnableOnOffModePath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fAlarmsPath.isEmpty() && fLar->fEnabled["alarms_odb"]) { // odb path to the alarms missing
    fLar->fAlarmsPath = "/Alarms/Alarms";
    errorMsg = QString("lemAutoRun: Couldn't find the path to alarms in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fAlarmsPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fAlarmTdHvTripPath.isEmpty() && fLar->fEnabled["alarms_td_hv_trip_odb"]) { // odb path to the alarms missing
    fLar->fAlarmTdHvTripPath = "/Alarms/Alarms/hv_fug_check_trip_level/Triggered";
    errorMsg = QString("lemAutoRun: Couldn't find the path to TD HV Trip flag in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fAlarmTdHvTripPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }
  
  if (fLar->fRunInfoPath.isEmpty()) { // odb path to run info missing
    fLar->fRunInfoPath = "/Runinfo";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the run info in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fRunInfoPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fRunCommentPath.isEmpty() && fLar->fEnabled["run_comment_odb"]) { // odb path to run comments missing
    fLar->fRunCommentPath = "/Experiment/Run Parameters/comment";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the run title in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fRunCommentPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fTofMinPath.isEmpty() && fLar->fEnabled["tof_min_odb"]) { // odb path to TOF Min missing
    fLar->fTofMinPath = "/Analyzer/Parameters/MCP2AnaModule/TofM2Fmin";
    errorMsg = QString("lemAutoRun: Couldn't find the path to TOF Min in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fTofMinPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fTofMaxPath.isEmpty() && fLar->fEnabled["tof_max_odb"]) { // odb path to TOF Max missing
    fLar->fTofMaxPath = "/Analyzer/Parameters/MCP2AnaModule/TofM2Fmax";
    errorMsg = QString("lemAutoRun: Couldn't find the path to TOF Max in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fTofMaxPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fModNamePath.isEmpty() && fLar->fEnabled["mod_name_odb"]) { // odb path to moderator name
    fLar->fModNamePath = "/Info/Moderator";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the moderator name in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fModNamePath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fModDatePath.isEmpty() && fLar->fEnabled["mod_date_odb"]) { // odb path to moderator date
    fLar->fModDatePath = "/Info/ModeratorDATE";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the moderator date in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fModDatePath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fLemSetupPath.isEmpty() && fLar->fEnabled["lem_setup_odb"]) { // odb path to LEM setup
    fLar->fLemSetupPath = "/Info/LEM_Setup";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the LEM setup in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fLemSetupPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fSampleNamePath.isEmpty() && fLar->fEnabled["sample_name_info_odb"]) { // odb path to Sample Name
    fLar->fSampleNamePath = "/Info/Sample Name";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the Sample Name in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fSampleNamePath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fSpinRotEnabledPath.isEmpty() && fLar->fEnabled["spin_rot_calib_odb"]) { // odb path to spin rotation enabled flag
    fLar->fSpinRotEnabledPath = "/Info/SpinRot_Parameter/Enable spin rotator calibration";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the spin rotation enabled flag in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fSpinRotEnabledPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fSpinRotAnglePath.isEmpty() && fLar->fEnabled["spin_rot_angle_odb"]) { // odb path to spin rotation angle
    fLar->fSpinRotAnglePath = "/Info/SpinRot_Parameter/RotationAngle";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the spin rotation angle in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fSpinRotAnglePath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fMagParamWewPath.isEmpty() && fLar->fEnabled["mag_param_wew_odb"]) { // odb path to the WEW calibration (A->G)
    fLar->fMagParamWewPath = "/Info/Magnet_Parameter/WEW";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the WEW magnet calibration (A->G) in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fMagParamWewPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fMagParamBparPath.isEmpty() && fLar->fEnabled["mag_param_bpar_odb"]) { // odb path to the Bpar calibration (A->G)
    fLar->fMagParamBparPath = "/Info/Magnet_Parameter/Bpar";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the Bpar magnet calibration (A->G) in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fMagParamBparPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fSetupSampleEnabledPath.isEmpty() && fLar->fEnabled["setup_sample_odb"]) { // odb path to sample enable flag
    fLar->fSetupSampleEnabledPath = "/Info/LEM_Setup_Parameter/Sample";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the sample enable flag in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fSetupSampleEnabledPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fSetupWewEnabledPath.isEmpty() && fLar->fEnabled["setup_wew_odb"]) { // odb path to WEW enable flag
    fLar->fSetupWewEnabledPath = "/Info/LEM_Setup_Parameter/WEW";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the WEW enable flag in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fSetupWewEnabledPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fSetupBparEnabledPath.isEmpty() && fLar->fEnabled["setup_bpar_odb"]) { // odb path to Bpar enable flag
    fLar->fSetupBparEnabledPath = "/Info/LEM_Setup_Parameter/Bpar";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the Bpar enable flag in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fSetupBparEnabledPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fSampleCryoPath.isEmpty() && fLar->fEnabled["sample_cryo_info_odb"]) { // odb path to Sample Cryo
    fLar->fSampleCryoPath = "/Info/Sample Cryo";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the Sample Cryo in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fSampleCryoPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fEnergyLossParamPath.isEmpty() && fLar->fEnabled["energy_loss_param_odb"]) { // odb path to energy loss parameters
    fLar->fEnergyLossParamPath = "/Info/EnergyLoss_Parameter";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the energy loss parameters in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fEnergyLossParamPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fClientsPath.isEmpty()) { // odb path to the system/clients missing
    fLar->fClientsPath = "/System/Clients";
    errorMsg = QString("lemAutoRun: Couldn't find the path to clients in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fClientsPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fAnalyzerName.isEmpty() && fLar->fEnabled["analyzer_fe"]) { // no analyzer ODB name found
    fLar->fAnalyzerName = "Analyzer";
    errorMsg = QString("lemAutoRun: Couldn't find ODB name for the analyzer, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fAnalyzerName;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fFrontendName.isEmpty() && fLar->fEnabled["vme_fe"]) { // no frontend ODB name found
    fLar->fFrontendName = "VME_FE";
    errorMsg = QString("lemAutoRun: Couldn't find ODB name for the frontend, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fFrontendName;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fTflFeName.isEmpty() && fLar->fEnabled["tfl_scfe"]) { // no tfl_scfe ODB name found
    fLar->fTflFeName = "TFL_SC";
    errorMsg = QString("lemAutoRun: Couldn't find ODB name for tfl_scfe, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fTflFeName;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fSampleFeName.isEmpty() && fLar->fEnabled["sample_scfe"]) { // no sample_scfe ODB name found
    fLar->fSampleFeName = "Sample_SC";
    errorMsg = QString("lemAutoRun: Couldn't find ODB name for sample_scfe, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fSampleFeName;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fSampleOvenOmegaFeName.isEmpty() && fLar->fEnabled["omega_scfe"]) { // no sample oven omega scfe ODB name found
    fLar->fSampleOvenOmegaFeName = "Omega SC";
    errorMsg = QString("lemAutoRun: Couldn't find ODB name for Oven Omega SCFE, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fSampleOvenOmegaFeName;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fWEWFeName.isEmpty() && fLar->fEnabled["wew_scfe"]) { // no WEW scfe ODB name found
    fLar->fWEWFeName = "WEW SC";
    errorMsg = QString("lemAutoRun: Couldn't find ODB name for WEW SCFE, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fWEWFeName;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fDanfysikFeName.isEmpty() && fLar->fEnabled["danfysik_scfe"]) { // no danfysik scfe ODB name found
    fLar->fDanfysikFeName = "Danfysik_SC";
    errorMsg = QString("lemAutoRun: Couldn't find ODB name for Danfysik SCFE, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fDanfysikFeName;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fHVFeName.isEmpty() && fLar->fEnabled["fug_scfe"]) { // no hv_fug_scfe ODB name found
    fLar->fHVFeName = "FUG";
    errorMsg = QString("lemAutoRun: Couldn't find ODB name for hv_fug_scfe, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fHVFeName;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fLemvacFeName.isEmpty() && fLar->fEnabled["lemvac_scfe"]) { // no lemvac_scfe ODB name found
    fLar->fLemvacFeName = "LEMVAC_SC";
    errorMsg = QString("lemAutoRun: Couldn't find ODB name for lemvac_scfe, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fLemvacFeName;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fHVDemandPath.isEmpty() && fLar->fEnabled["fug_eq"]) { // path to the HV demand values
    fLar->fHVDemandPath = "/Equipment/HV/Variables/Demand";
    errorMsg = QString("lemAutoRun: Couldn't find the path to HV demand values in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fHVDemandPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fHVMeasuredPath.isEmpty() && fLar->fEnabled["fug_eq"]) { // path to the HV measured values
    fLar->fHVMeasuredPath = "/Equipment/HV/Variables/Measured";
    errorMsg = QString("lemAutoRun: Couldn't find the path to HV measured values in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fHVMeasuredPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fHVCurrentPath.isEmpty() && fLar->fEnabled["fug_eq"]) { // path to the HV current values
    fLar->fHVCurrentPath = "/Equipment/HV/Variables/Current";
    errorMsg = QString("lemAutoRun: Couldn't find the path to HV current values in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fHVCurrentPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fHVDetectorDemandPath.isEmpty() && fLar->fEnabled["hv_detectors_eq"]) { // path to the HV Detectors demand values
    fLar->fHVDetectorDemandPath = "/Equipment/HV Detectors/Variables/Demand";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the HV Detectors demand values in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fHVDetectorDemandPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fHVDetectorMeasuredPath.isEmpty() && fLar->fEnabled["hv_detectors_eq"]) { // path to the HV Detectors measured values
    fLar->fHVDetectorMeasuredPath = "/Equipment/HV Detectors/Variables/Measured";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the HV Detectors measured values in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fHVDetectorMeasuredPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }
  
  if (fLar->fSpinRotMagInputPath.isEmpty() && fLar->fEnabled["danfysik_spin_rot_eq"]) { // path to the Danfysik spin rotator power supply
    fLar->fSpinRotMagInputPath = "/Equipment/Danfysik_Spin_Rot/Variables/Input";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the Danfysik Spin Rotator power supply input values in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fSpinRotMagInputPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fSpinRotMagOutputPath.isEmpty() && fLar->fEnabled["danfysik_spin_rot_eq"]) { // path to the Danfysik spin rotator power supply
    fLar->fSpinRotMagOutputPath = "/Equipment/Danfysik_Spin_Rot/Variables/Output";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the Danfysik Spin Rotator power supply output values in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fSpinRotMagOutputPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fDanfysikInputPath.isEmpty() && fLar->fEnabled["danfysik_eq"]) { // path to the Danfysik input values
    fLar->fDanfysikInputPath = "/Equipment/Danfysik/Variables/Input";
    errorMsg = QString("lemAutoRun: Couldn't find the path to Danfysik input values in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fDanfysikInputPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fDanfysikOutputPath.isEmpty() && fLar->fEnabled["danfysik_eq"]) { // path to the Danfysik output values
    fLar->fDanfysikOutputPath = "/Equipment/Danfysik/Variables/Output";
    errorMsg = QString("lemAutoRun: Couldn't find the path to Danfysik output values in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fDanfysikOutputPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fWEWOutputPath.isEmpty() && fLar->fEnabled["wew_eq"]) { // path to the WEW output values
    fLar->fWEWOutputPath = "/Equipment/WEW/Variables/Output";
    errorMsg = QString("lemAutoRun: Couldn't find the path to WEW output values in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fWEWOutputPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fWEWInputPath.isEmpty() && fLar->fEnabled["wew_eq"]) { // path to the WEW input values
    fLar->fWEWInputPath = "/Equipment/WEW/Variables/Input";
    errorMsg = QString("lemAutoRun: Couldn't find the path to WEW input values in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fWEWInputPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fMagFieldPath.isEmpty() && fLar->fEnabled["magnet_field_info"]) { // path to the magnet field value
    fLar->fMagFieldPath = "/Info/Magnetic Field (G)";
    errorMsg = QString("lemAutoRun: Couldn't find the path to magnet field parameters of the WEW in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fMagFieldPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fTflInputPath.isEmpty() && fLar->fEnabled["tfl_eq"]) { // path to the tfl input values
    fLar->fTflInputPath = "/Equipment/TFL/Variables/Input";
    errorMsg = QString("lemAutoRun: Couldn't find the path to tfl input values in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fTflInputPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fTflOutputPath.isEmpty() && fLar->fEnabled["tfl_eq"]) { // path to the tfl output values
    fLar->fTflOutputPath = "/Equipment/TFL/Variables/Output";
    errorMsg = QString("lemAutoRun: Couldn't find the path to tfl input values in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fTflOutputPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fSampleCtrlChPath.isEmpty() && fLar->fEnabled["sample_eq"]) { // path to the sample cryo ctrl channel of the LS340
    fLar->fSampleCtrlChPath = "/Equipment/SampleCryo/Settings/Devices/Lake336_Sample_0/DD/Loop1/CTRL_CH";
    errorMsg = QString("lemAutoRun: Couldn't find the path to ctrl channel of the LS340 in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fSampleCtrlChPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fSampleChannelPath.isEmpty() && fLar->fEnabled["sample_eq"]) { // path to the sample cryo channel assignment of the LS340
    fLar->fSampleChannelPath = "/Equipment/SampleCryo/Settings/Devices/Lake336_Sample_0/DD/Sensors/Channel";
    errorMsg = QString("lemAutoRun: Couldn't find the path to channel assignment of the LS340 in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fSampleChannelPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fSampleSensorTypePath.isEmpty() && fLar->fEnabled["sample_eq"]) { // path to the sample cryo sensor type assignment of the LS340
    fLar->fSampleSensorTypePath = "/Equipment/SampleCryo/Settings/Devices/Lake336_Sample_0/DD/Sensors/Sensor Type";
    errorMsg = QString("lemAutoRun: Couldn't find the path to sensor type assignment of the LS340 in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fSampleSensorTypePath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fSampleInputPath.isEmpty() && fLar->fEnabled["sample_eq"]) { // path to the sample input values
    fLar->fSampleInputPath = "/Equipment/SampleCryo/Variables/Input";
    errorMsg = QString("lemAutoRun: Couldn't find the path to sample cryo input values in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fSampleInputPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fSampleOutputPath.isEmpty() && fLar->fEnabled["sample_eq"]) { // path to the sample output values
    fLar->fSampleOutputPath = "/Equipment/SampleCryo/Variables/Output";
    errorMsg = QString("lemAutoRun: Couldn't find the path to sample cryo output values in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fSampleOutputPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fSampleRawVoltagePath.isEmpty() && fLar->fEnabled["sample_eq"]) { // path to the sample DD raw voltage variable
    fLar->fSampleRawVoltagePath = "/Equipment/SampleCryo/Settings/Devices/Lake336_Sample_0/DD/Sensors/Raw Input Channel";
    errorMsg = QString("lemAutoRun: Couldn't find the path to sample cryo 'RawVoltage' in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fSampleRawVoltagePath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if ((fLar->fSampleBhOdbOffsetInput == -1) && fLar->fEnabled["sample_eq"]) { // odb offset for bronkhorst input missing
    fLar->fSampleBhOdbOffsetInput = 10;
    errorMsg = QString("lemAutoRun: Couldn't find input ODB offset for the bronkhorst flow meter, ") +
               QString("will try hard-wired one (no warranty that it works):%1 ").arg(fLar->fSampleBhOdbOffsetInput);
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if ((fLar->fSampleBhOdbOffsetOutput == -1) && fLar->fEnabled["sample_eq"]) { // odb offset for bronkhorst output missing
    fLar->fSampleBhOdbOffsetOutput = 7;
    errorMsg = QString("lemAutoRun: Couldn't find output ODB offset for the bronkhorst flow meter, ") +
               QString("will try hard-wired one (no warranty that it works):%1 ").arg(fLar->fSampleBhOdbOffsetOutput);
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fSampleOvenOmegaInputPath.isEmpty() && fLar->fEnabled["omega_eq"]) { // path to the sample oven omega input values
    fLar->fSampleOvenOmegaInputPath = "/Equipment/Omega/Variables/Input";
    errorMsg = QString("lemAutoRun: Couldn't find the path to sample oven omega input values in the ODB, ") +
        QString("will try hard-wired one (no warranty that it works): ") +
        fLar->fSampleOvenOmegaInputPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fSampleOvenOmegaOutputPath.isEmpty() && fLar->fEnabled["omega_eq"]) { // path to the sample oven omega output values
    fLar->fSampleOvenOmegaOutputPath = "/Equipment/Oven/Variables/Output";
    errorMsg = QString("lemAutoRun: Couldn't find the path to sample oven output values in the ODB, ") +
        QString("will try hard-wired one (no warranty that it works): ") +
        fLar->fSampleOvenOmegaOutputPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fLemvacInputPath.isEmpty() && fLar->fEnabled["lemvac_eq"]) { // path to the lemvac input values
    fLar->fLemvacInputPath = "/Equipment/LEMVAC/Variables/Input";
    errorMsg = QString("lemAutoRun: Couldn't find the path to lemvac input values in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fLemvacInputPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fLemvacOutputPath.isEmpty() && fLar->fEnabled["lemvac_eq"]) { // path to the lemvac output values
    fLar->fLemvacOutputPath = "/Equipment/LEMVAC/Variables/Output";
    errorMsg = QString("lemAutoRun: Couldn't find the path to lemvac output values in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fLemvacOutputPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fFOMInputPath.isEmpty() && fLar->fEnabled["fom_eq"]) { // path to the FOM input values
    fLar->fFOMInputPath = "/Equipment/FOM/Variables/Input";
    errorMsg = QString("lemAutoRun: Couldn't find the path to FOM input values in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fFOMInputPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fFOMOutputPath.isEmpty() && fLar->fEnabled["fom_eq"]) { // path to the FOM output values
    fLar->fFOMOutputPath = "/Equipment/FOM/Variables/Output";
    errorMsg = QString("lemAutoRun: Couldn't find the path to FOM output values in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fFOMOutputPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fBeamlineDemandPath.isEmpty() && fLar->fEnabled["beamline_eq"]) { // path to the Beamline demand values
    fLar->fBeamlineDemandPath = "/Equipment/Beamline/Variables/Demand";
    errorMsg = QString("lemAutoRun: Couldn't find the path to the Beamline demand values in the ODB, ") +
               QString("will try hard-wired one (no warranty that it works): ") +
               fLar->fBeamlineDemandPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  if (fLar->fEnabled["sample_eq"] && !fLar->fEnabled["sample_cryo_info_odb"]) {
    errorMsg = QString("lemAutoRun: Sample Cryo enabled, but access to '/Info/Sample Cryo' disabled.") +
               QString("will most likely not work!") +
               fLar->fBeamlineDemandPath;
    emit fLar->ErrorMsg(1, 0, LAR_XML_MISSING_ENTRY, -1, errorMsg);
  }

  return true;
}

//**********************************************************************
// setAttribute
//**********************************************************************
void PLemAutoRunXMLParser::setAttribute(const QString key, const QXmlStreamAttributes &qAttr)
{
  if (qAttr.hasAttribute("enabled")) {
    if (qAttr.value("enabled") == "yes") {
      fLar->SetEnabled(key, true);
    } else if (qAttr.value("enabled") == "no") {
      fLar->SetEnabled(key, false);
    }
  }
}


//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// implementation of PLemSampleCryoXMLParser
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//**********************************************************************
// constructor
//**********************************************************************
PLemSampleCryoXMLParser::PLemSampleCryoXMLParser(const QString fln, PLemAutoRun *lar)
{
  fLar = lar;

  QFile file(fln);
  if (!file.open(QFile::ReadOnly | QFile::Text) || (file.size()==0))
    return;

  fValid = parse(&file);
}

//**********************************************************************
// destructor
//**********************************************************************
PLemSampleCryoXMLParser::~PLemSampleCryoXMLParser()
{
}

//**********************************************************************
// parse
//**********************************************************************
bool PLemSampleCryoXMLParser::parse(QIODevice *device)
{
  fXml.setDevice(device);

  bool expectChars = false;
  while (!fXml.atEnd()) {
    fXml.readNext();
    if (fXml.isStartDocument()) {
      startDocument();
    } else if (fXml.isStartElement()) {
      startElement();
      expectChars = true;
    } else if (fXml.isCharacters() && expectChars) {
      characters();
    } else if (fXml.isEndElement()) {
      endElement();
      expectChars = false;
    } else if (fXml.isEndDocument()) {
      endDocument();
    }
  }
  if (fXml.hasError()) {
    QString msg;
    msg = QString("%1 Line %2, column %3").arg(fXml.errorString()).arg(fXml.lineNumber()).arg(fXml.columnNumber());
    cm_msg(MERROR, "lemAutoRun", msg.toLatin1().data());
    cm_yield(0);
    return false;
  }

  return true;
}

//**********************************************************************
// startDocument
//**********************************************************************
bool PLemSampleCryoXMLParser::startDocument()
{
  return true;
}

//**********************************************************************
// startElement
//**********************************************************************
bool PLemSampleCryoXMLParser::startElement()
{
  QString qName = fXml.name().toString();

  if (qName == "temp_regulation") {
    fKey = eTemp_regulation;
  } else if (qName == "max_temp_increase") {
    fKey = eMax_temp_increase;
  } else if (qName == "bh_max_flow") {
    fKey = eBh_max_flow;
  } else if (qName == "bh_min_flow") {
    fKey = eBh_min_flow;
  } else if (qName == "bh_flow_p_heat_0") {
    fKey = eBh_flow_p_heat_0;
  } else if (qName == "bh_flow_p_heat_1") {
    fKey = eBh_flow_p_heat_1;
  } else if (qName == "bh_flow_d_heat") {
    fKey = eBh_flow_d_heat;
  } else if (qName == "bh_flow_temp") {
    fKey = eBh_flow_temp;
  } else if (qName == "bh_flow_temp_offset") {
    fKey = eBh_flow_temp_offset;
  } else if (qName == "bh_flow_offset") {
    fKey = eBh_flow_offset;
  } else if (qName == "d_set_ratio") {
    fKey = eD_set_ratio;
  } else if (qName == "abs_max_temp_diff") {
    fKey = eAbs_max_temp_diff;
  } else if (qName == "rel_max_temp_diff") {
    fKey = eRel_max_temp_diff;
  } else if (qName == "max_temp_trend") {
    fKey = eMax_temp_trend;
  } else if (qName == "heater_min") {
    fKey = eHeater_min;
  } else if (qName == "heater_max") {
    fKey = eHeater_max;
  } else if (qName == "flow_factor") {
    fKey = eFlow_factor;
  } else if (qName == "flow_set_ratio") {
    fKey = eFlow_set_ratio;
  } else if (qName == "flow_set_absolute") {
    fKey = eFlow_set_absolute;
  } else if (qName == "flow_timeout_reduction") {
    fKey = eFlow_timeout_reduction;
  } else if (qName == "timeout_flow_set") {
    fKey = eTimeout_flow_set;
  } else if (qName == "flowLowestFlowToConsider") {
    fKey = eFlowLowestFlowToConsider;
  } else if (qName == "flowMaxRelFlowDiffToConsider") {
    fKey = eFlowMaxRelFlowDiffToConsider;
  } else if (qName == "dFlowDp0") {
    fKey = eDFlowDp0;
  } else if (qName == "dFlowDp1") {
    fKey = eDFlowDp1;
  } else if (qName == "dFlowDpExp") {
    fKey = eDFlowDpExp;
  } else if (qName == "heatCapCof1") {
    fKey = eHeatCapCof1;
  } else if (qName == "heatCapCof2") {
    fKey = eHeatCapCof2;
  } else if (qName == "heatCapCof3") {
    fKey = eHeatCapCof3;
  } else if (qName == "needleValveInUse") {
    fKey = eNeedleValveInUse;
  } else if (qName == "prefNeedleValveCof_1_0") {
    fKey = ePrefNeedleValveCof_1_0;
  } else if (qName == "prefNeedleValveCof_1_1") {
    fKey = ePrefNeedleValveCof_1_1;
  } else if (qName == "prefNeedleValveCof_2_0") {
    fKey = ePrefNeedleValveCof_2_0;
  } else if (qName == "prefNeedleValveCof_2_1") {
    fKey = ePrefNeedleValveCof_2_1;
  } else if (qName == "prefNeedleValveCof_3_0") {
    fKey = ePrefNeedleValveCof_3_0;
  } else if (qName == "prefNeedleValveCof_3_1") {
    fKey = ePrefNeedleValveCof_3_1;
  } else if (qName == "prefNeedleValveCof_4_0") {
    fKey = ePrefNeedleValveCof_4_0;
  } else if (qName == "prefNeedleValveCof_4_1") {
    fKey = ePrefNeedleValveCof_4_1;
  } else if (qName == "prefNeedleValveRelStep") {
    fKey = ePrefNeedleValveRelStep;
  } else if (qName == "prefNeedleValveAbsStep") {
    fKey = ePrefNeedleValveAbsStep;
  }

  return true;
}

//**********************************************************************
// endElement
//**********************************************************************
bool PLemSampleCryoXMLParser::endElement()
{
  fKey = eEmpty; // no key word anymore

  return true;
}

//**********************************************************************
// characters
//**********************************************************************
bool PLemSampleCryoXMLParser::characters()
{
  QString str = fXml.text().toString();

  switch (fKey) {
    case eTemp_regulation:
      if (str == "true")
        fLar->fSampleTempRegulation = true;
      else
        fLar->fSampleTempRegulation = false;
      break;
    case eMax_temp_increase:
      fLar->fMaxTempIncrease = str.toFloat();
      break;
    case eBh_max_flow:
      fLar->fBHMaxFlow = str.toFloat();
      break;
    case eBh_min_flow:
      fLar->fBHMinFlow = str.toFloat();
      break;
    case eBh_flow_p_heat_0:
      fLar->fBHFlowPHeat0 = str.toFloat();
      break;
    case eBh_flow_p_heat_1:
      fLar->fBHFlowPHeat1 = str.toFloat();
      break;
    case eBh_flow_d_heat:
      fLar->fBHFlowDHeat = str.toFloat();
      break;
    case eBh_flow_temp:
      fLar->fBHFlowTemp = str.toFloat();
      break;
    case eBh_flow_temp_offset:
      fLar->fBHFlowTempOffset = str.toFloat();
      break;
    case eBh_flow_offset:
      fLar->fBHFlowOffset = str.toFloat();
      break;
    case eD_set_ratio:
      fLar->fDSetRatio = str.toFloat();
      break;
    case eAbs_max_temp_diff:
      fLar->fAbsMaxTempDiff = str.toFloat();
      break;
    case eRel_max_temp_diff:
      fLar->fRelMaxTempDiff = str.toFloat();
      break;
    case eMax_temp_trend:
      fLar->fMaxTempTrend = str.toFloat();
      break;
    case eHeater_min:
      fLar->fHeaterMin = str.toFloat();
      break;
    case eHeater_max:
      fLar->fHeaterMax = str.toFloat();
      break;
    case eTimeout_flow_set:
      fLar->fTimeoutFlowSet = 1000.0 * str.toFloat(); // in (msec)
      break;
    case eFlow_factor:
      fLar->fFlowFactor = str.toFloat();
      break;
    case eFlow_set_ratio:
      fLar->fFlowSetRatio = str.toFloat();
      break;
    case eFlow_set_absolute:
      fLar->fFlowSetAbsolute = str.toFloat();
      break;
    case eFlow_timeout_reduction:
      fLar->fFlowTimeoutReduction = 1000.0 * str.toFloat(); // in (msec)
      break;
    case eFlowLowestFlowToConsider:
      fLar->fFlowLowestFlowToConsider = str.toFloat();
      break;
    case eFlowMaxRelFlowDiffToConsider:
      fLar->fFlowMaxRelFlowDiffToConsider = str.toFloat();
      break;
    case eDFlowDp0:
      fLar->fDFlowDp0 = str.toFloat();
      break;
    case eDFlowDp1:
      fLar->fDFlowDp1 = str.toFloat();
      break;
    case eDFlowDpExp:
      fLar->fDFlowDpExp = str.toFloat();
      break;
    case eHeatCapCof1:
      fLar->fHeatCapCof1 = str.toFloat();
      break;
    case eHeatCapCof2:
      fLar->fHeatCapCof2 = str.toFloat();
      break;
    case eHeatCapCof3:
      fLar->fHeatCapCof3 = str.toFloat();
      break;
    case eNeedleValveInUse:
      fLar->fNeedleValveInUse = (bool) str.toInt();
      break;
    case ePrefNeedleValveCof_1_0:
      fLar->fPrefNeedleValveCof_1_0 = str.toFloat();
      break;
    case ePrefNeedleValveCof_1_1:
      fLar->fPrefNeedleValveCof_1_1 = str.toFloat();
      break;
    case ePrefNeedleValveCof_2_0:
      fLar->fPrefNeedleValveCof_2_0 = str.toFloat();
      break;
    case ePrefNeedleValveCof_2_1:
      fLar->fPrefNeedleValveCof_2_1 = str.toFloat();
      break;
    case ePrefNeedleValveCof_3_0:
      fLar->fPrefNeedleValveCof_3_0 = str.toFloat();
      break;
    case ePrefNeedleValveCof_3_1:
      fLar->fPrefNeedleValveCof_3_1 = str.toFloat();
      break;
    case ePrefNeedleValveCof_4_0:
      fLar->fPrefNeedleValveCof_4_0 = str.toFloat();
      break;
    case ePrefNeedleValveCof_4_1:
      fLar->fPrefNeedleValveCof_4_1 = str.toFloat();
      break;
    case ePrefNeedleValveRelStep:
      fLar->fPrefNeedleValveRelStep = str.toFloat();
      break;
    case ePrefNeedleValveAbsStep:
      fLar->fPrefNeedleValveAbsStep = str.toFloat();
      break;

    default:
      break;
  }

  return true;
}

//**********************************************************************
// endDocument
//**********************************************************************
bool PLemSampleCryoXMLParser::endDocument()
{
  QString errorMsg;

  // check if all expected input is found

  // no max temp increase given, hence set it to 20 (K)
  if (fLar->fMaxTempIncrease == 0.0)
    fLar->fMaxTempIncrease = 20.0;

  return true;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// implementation of PLemHvSettingsFileParser
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//**********************************************************************
// constructor
//**********************************************************************
PLemHvSettingsFileParser::PLemHvSettingsFileParser(const QString fln)
{
  fValid = true;
  fErrorMsg = "";

  fHvDeviceName = "";

  QFile file(fln);
  if (!file.open(QFile::ReadOnly | QFile::Text) || (file.size()==0))
    return;

  fParseIsValid = parse(&file);
}

//**********************************************************************
// destructor
//**********************************************************************
PLemHvSettingsFileParser::~PLemHvSettingsFileParser()
{
  fHvChNo.clear();
  fHvChName.clear();
  fHvDemand.clear();
  fCurrentLimit.clear();
}

//**********************************************************************
// parse
//**********************************************************************
bool PLemHvSettingsFileParser::parse(QIODevice *device)
{
  fXml.setDevice(device);

  bool expectChars = false;
  while (!fXml.atEnd()) {
    fXml.readNext();
    if (fXml.isStartDocument()) {
      startDocument();
    } else if (fXml.isStartElement()) {
      startElement();
      expectChars = true;
    } else if (fXml.isCharacters() && expectChars) {
      characters();
    } else if (fXml.isEndElement()) {
      endElement();
      expectChars = false;
    } else if (fXml.isEndDocument()) {
      endDocument();
    }
  }
  if (fXml.hasError()) {
    QString msg;
    msg = QString("%1 Line %2, column %3").arg(fXml.errorString()).arg(fXml.lineNumber()).arg(fXml.columnNumber());
    cm_msg(MERROR, "lemAutoRun", msg.toLatin1().data());
    cm_yield(0);
    return false;
  }

  return true;
}

//**********************************************************************
// startDocument
//**********************************************************************
bool PLemHvSettingsFileParser::startDocument()
{
  fKey = eEmpty;

  return true;
}

//**********************************************************************
// startElement
//**********************************************************************
bool PLemHvSettingsFileParser::startElement()
{
  QString qName = fXml.name().toString();

  if (qName == "hvDeviceName") {
    fKey = eHvDeviceName;
  } else if (qName == "chNo") {
    fKey = eHvChNo;
  } else if (qName == "name") {
    fKey = eHvChName;
  } else if (qName == "hvDemand") {
    fKey = eHvDemand;
  } else if (qName == "currentLimit") {
    fKey = eCurrentLimit;
  }

  return true;
}

//**********************************************************************
// endElement
//**********************************************************************
bool PLemHvSettingsFileParser::endElement()
{
  fKey = eEmpty; // no key word anymore

  return true;
}

//**********************************************************************
// characters
//**********************************************************************
bool PLemHvSettingsFileParser::characters()
{
  int ival=0;
  float fval=0.0;
  bool ok;

  QString str = fXml.text().toString();

  switch (fKey) {
    case eHvDeviceName:
      fHvDeviceName = str.trimmed();
      if (fHvDeviceName != "FUG") {
        fErrorMsg = "**ERROR** only handle FUG's, i.e. transport settings, but found '" + fHvDeviceName + "'";
        fValid = false;
        return false;
      }
      break;
    case eHvChNo:
      ival = str.toInt(&ok);
      if (ok) {
        fHvChNo.push_back(ival);
      } else {
        fErrorMsg = "**ERROR** found HV channel '" + str + "' at position" + QString("%1").arg(fHvChNo.size()) + " which is not an integer?!?";
        fValid = false;
        return false;
      }
      break;
    case eHvChName:
      fHvChName.push_back(str);
      break;
    case eHvDemand:
      fval = str.toFloat(&ok);
      if (ok) {
        fHvDemand.push_back(fval);
      } else {
        fErrorMsg = "**ERROR** found HV demand '" + str + "' at position" + QString("%1").arg(fHvChNo.size()) + " which is not an double?!?";
        fValid = false;
        return false;
      }
      break;
    case eCurrentLimit:
      fval = str.toFloat(&ok);
      if (ok) {
        fCurrentLimit.push_back(fval);
      } else {
        fErrorMsg = "**ERROR** found current limit '" + str + "' at position" + QString("%1").arg(fHvChNo.size()) + " which is not an double?!?";
        fValid = false;
        return false;
      }
      break;
    default:
      break;
  }

  return true;
}

//**********************************************************************
// endDocument
//**********************************************************************
bool PLemHvSettingsFileParser::endDocument()
{
  QString errorMsg;

  if (!fValid) {
    fHvChNo.clear();
    fHvChName.clear();
    fHvDemand.clear();
    fCurrentLimit.clear();
  }

  return true;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// implementation of PLemAutoRun
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//**********************************************************************
// constructor
//**********************************************************************
PLemAutoRun::PLemAutoRun(QString &host, QString &exp)  :
  fHostName(host),
  fExpName(exp)
{
  fEnableAll = false;
  InitEnabled(); // initialize all the enable flags to 'false'

  fXMLSchemaFln      = "";
  fXMLAutoRunFln     = "";
  fXMLAutoRunHTML    = "";
  fAutoRunPath       = "";

  fAutoRunSequence   = "";
  fShowComments      = true;
  fGotoLine          = -1;
  fNextAutoRunSequence = "";
  fAutoRunStatusMsg  = "";
  fAutoRunState      = 0;

  fHvTripFlag        = 0;
  fFieldPwrSupply    = "";

  fNoOfAutoRunCmds    = 0;
  fCurrentAutoRunCmd  = 0;
  fAutoRunCurrentIter = 0;

  fSampleCryoInUse = CRYO_NO;

  // init system 'constants'
  for (int i=0; i<NO_ENERGY_LOSS_PARAM; i++)
    fEnergyLossParam[i] = 0.0;
  fMaxTempIncrease      = 0.0;
  fFieldTimeout         = 0.0;
  fFieldAccuracy        = 0.0;
  fHVTimeout            = 0.0;
  fHVAccuracy           = 0.0;
  fBHMaxFlow            = 25000.0;
  fBHMinFlow            = 500.0;
  fBHFlowTemp           = 1.0e5;
  fBHFlowTempOffset     = 0.0;
  fBHFlowOffset         = 300.0;
  fDSetRatio            = 0.1;
  fAbsMaxTempDiff       = 1.0e-2;
  fRelMaxTempDiff       = 1.0e-4;
  fMaxTempTrend         = 1.0e-3;
  fHeaterMax            = 95.0;
  fHeaterMin            = 5.0;
  fTimeoutFlowSet       = 60.0e3; // in (msec)
  fFlowFactor           = 0.05;
  fFlowSetRatio         = 0.02;
  fFlowSetAbsolute      = 1.0;
  fFlowTimeoutReduction = 30.0e3; // in (msec)
  fSampleHistoLastTime  = 0.0;
  fFlowLowestFlowToConsider     = 0.0;     //<! lowest demand flow to consider
  fFlowMaxRelFlowDiffToConsider = 100.0;   //<! maximum rel flow error to consider
  fDFlowDp0             = 0.0;             //<! calculates d(flow)/dP from d(flow)/dP =
  fDFlowDp1             = 0.0;             //<! fDFlowDp0 + fDFlowDp1 * exp( fDFlowDpExp * Temp )
  fDFlowDpExp           = -1.0;

  // heat capacity related coefficients
  fHeatCapCof1          = 0.0;             //<! heat Capacity of cryo =
  fHeatCapCof2          = 0.0;             //<! fHeatCapCof1 * T + fHeatCapCof2 * T + fHeatCapCof3 * T
  fHeatCapCof3          = 0.0;

  // Coefficients for preferred needle valve settings
  fNeedleValveInUse       = FALSE;     //<! Tag for use of electric needle valve
  fPrefNeedleValveCof_1_0 = 0.0;       //<! NV setting = _1_0 * _1_1 * T for T<8
  fPrefNeedleValveCof_1_1 = 0.0;
  fPrefNeedleValveCof_2_0 = 0.0;       //<! NV setting = _1_0 * _1_1 * T for 8<T<10
  fPrefNeedleValveCof_2_1 = 0.0;
  // Test changes for T ranges
  fPrefNeedleValveCof_3_0 = 0.0;       //<! NV setting = _1_0 * _1_1 * T for 10<T<20
  fPrefNeedleValveCof_3_1 = 0.0;
  fPrefNeedleValveCof_4_0 = 0.0;       //<! NV setting = _1_0 * _1_1 * T for 20<T
  fPrefNeedleValveCof_4_1 = 0.0;
  fPrefNeedleValveRelStep = 0.0;       //<! relative change in SampleTempConsiderNeedleValve
  fPrefNeedleValveAbsStep = 0.0;       //<! absolute change in SampleTempConsiderNeedleValve

  // critical current for the WEW. For larger currents, the RA HV's should be switched off due to the Penning trap problem
  fWEWCriticalCurrentRA = 22.65; // ~130G

  // maximal currents for the magnet power supplied
  fWEWLMaxCurrent = 50.0;
  fWEWHMaxCurrent = 595.0;
  fDanfysikMaxCurrent = 20.0;

  // FOM related variables int
  fFOMCurrentAccuracy = 0.0;

  // init warmup related variables
  fWarmUpWished = false;
  fWarmUpVent = false;

  // init debug flag, which is used to print out additional information
  fDebug = false;

  // init ignore clients flag, if set true it will be ignored if frontends are running or not!! ONLY FOR TESTING!!
  fIgnoreClients = false;
  // init ignore alarms flag, if set true it will ignore alarm messages. ONLY FOR TESTING!!
  fIgnoreAlarms = false;
  // init FUG HV check flag, if set to true it will perform a check that demand==measured, otherwise not. This should be set the false ONLY FOR TESTING!!
  fFugHvCheck = true;

  // init temperature regulation flag
  fSampleTempRegulation = true;
  fSampleTempUnstable = false;

  // init temperature tolerance
  fSampleTempAccuracy = 0.1;

  // init run related variables
  fRunStopped = true;
  fRunCheckEvents = true;
  fRunNoEventsNeeded = 0;
  fRunTimeout = 0;

  // init hotlink variables
  for (int i=0; i<SAMPLE_CRYO_INPUT; i++)
    fSampleInput[i] = 0.0;
  for (int i=0; i<SAMPLE_CRYO_OUTPUT; i++)
    fSampleOutput[i] = 0.0;

  // init temperature history related variables
  fSampleHistoNoEntries = 0;
  fSampleHistoPos       = 0;

  // init raw voltage dumps to be made
  fDumpInUse   = false;
  fDumpCounter = 0;
  fDumpFileName = "";

  // init setup related variables
  fSetupSampleEnabled = false;
  fSetupWewEnabled    = false;
  fSetupBparEnabled   = false;

  // default HV settings path, in case it is not found int the lemAutoRun.xml
  fHvSettingsPath = QString("/home/nemu/nemu/midas/experiment/nemu/hv_settings/");

  // init odb related variables
  fTriggerEventsPath       = "";
  fEnableOnOffModePath     = "";
  fAlarmsPath              = "";
  fAlarmTdHvTripPath       = "";
  fRunInfoPath             = "";
  fRunCommentPath          = "";
  fTofMinPath              = "";
  fTofMaxPath              = "";
  fModNamePath             = "";
  fModDatePath             = "";
  fLemSetupPath            = "";
  fSampleCryoPath          = "";
  fSpinRotEnabledPath      = "";
  fSpinRotAnglePath        = "";
  fEnergyLossParamPath     = "";
  fClientsPath             = "";
  fHVDemandPath            = "";
  fHVMeasuredPath          = "";
  fHVCurrentPath           = "";
  fHVDetectorDemandPath    = "";
  fHVDetectorMeasuredPath  = "";
  fSpinRotMagInputPath     = "";
  fSpinRotMagOutputPath    = "";
  fDanfysikInputPath       = "";
  fDanfysikOutputPath      = "";
  fWEWOutputPath           = "";
  fWEWInputPath            = "";
  fMagFieldPath            = "";
  fTflInputPath            = "";
  fTflOutputPath           = "";
  fSampleCtrlChPath        = "";
  fSampleChannelPath       = "";
  fSampleSensorTypePath    = "";
  fSampleInputPath         = "";
  fSampleOutputPath        = "";
  fSampleRawVoltagePath    = "";
  fSampleOvenOmegaInputPath  = "";
  fSampleOvenOmegaOutputPath = "";
  fLemvacInputPath         = "";
  fLemvacOutputPath        = "";
  fFOMInputPath            = "";
  fFOMOutputPath           = "";
  fBeamlineDemandPath      = "";
  fMagParamWewPath         = "";
  fMagParamBparPath        = "";
  fSetupSampleEnabledPath  = "";
  fSetupWewEnabledPath     = "";
  fSetupBparEnabledPath    = "";

  fSampleBhOdbOffsetInput  = -1;
  fSampleBhOdbOffsetOutput = -1;

  // initialize running client flags
  fAnalyzerName        = "";
  fFrontendName        = "";
  fSampleFeName        = "";
  fWEWFeName           = "";
  fDanfysikFeName      = "";
  fHVFeName            = "";
  fLemvacFeName        = "";
  fAnalyzerRunning     = false;
  fFrontendRunning     = false;
  fSampleFeRunning     = false;
  fSampleOvenOmegaFeRunning = false;
  fWEWFeRunning        = false;
  fDanfysikFeRunning   = false;
  fHVFeRunning         = false;
  fLemvacFeRunning     = false;

  // initialize pointers
  fExp = nullptr;
  fTriggerEventsKey      = nullptr;
  fAlarmsKey             = nullptr;
  fAlarmTdHvTripKey      = nullptr;
  fRunInfoKey            = nullptr;
  fRunCommentKey         = nullptr;
  fTofMinKey             = nullptr;
  fTofMaxKey             = nullptr;
  fModNameKey            = nullptr;
  fModDateKey            = nullptr;
  fLemSetupKey           = nullptr;
  fSampleCryoKey         = nullptr;
  fSpinRotEnabledKey     = nullptr;
  fSpinRotAngleKey       = nullptr;
  fEnergyLossParamKey    = nullptr;
  fClientsKey            = nullptr;
  fHVDemandKey           = nullptr;
  fHVMeasuredKey         = nullptr;
  fHVCurrentKey          = nullptr;
  fHVDetectorDemandKey   = nullptr;
  fHVDetectorMeasuredKey = nullptr;
  fSpinRotMagInputKey    = nullptr;
  fSpinRotMagOutputKey   = nullptr;
  fDanfysikInputKey      = nullptr;
  fDanfysikOutputKey     = nullptr;
  fWEWOutputKey          = nullptr;
  fWEWInputKey           = nullptr;
  fMagFieldKey           = nullptr;
  fTflInputKey           = nullptr;
  fTflOutputKey          = nullptr;
  fSampleCtrlChKey       = nullptr;
  fSampleChannelKey      = nullptr;
  fSampleSensorTypeKey   = nullptr;
  fSampleInputKey        = nullptr;
  fSampleOutputKey       = nullptr;
  fSampleNoConnectionKey = nullptr;
  fSampleOvenOmegaInputKey  = nullptr;
  fSampleOvenOmegaOutputKey = nullptr;
  fLemvacInputKey        = nullptr;
  fLemvacOutputKey       = nullptr;
  fFOMInputKey           = nullptr;
  fFOMOutputKey          = nullptr;
  fBeamlineDemandKey     = nullptr;
  fMagParamWewKey        = nullptr;
  fMagParamBparKey       = nullptr;
  fSetupSampleEnabledKey = nullptr;
  fSetupWewEnabledKey    = nullptr;
  fSetupBparEnabledKey   = nullptr;
  fSampleRawVoltageKey   = nullptr;

  fRAPulsingEnabled = false;

  // connect internal signal and slot
  QObject::connect(this, SIGNAL(StatusMsg(QString)), this, SLOT(UpdateStatusMsg(QString)));
}

//**********************************************************************
// destructor
//**********************************************************************
PLemAutoRun::~PLemAutoRun()
{
  if (fExp) {
    delete fExp;
    fExp = nullptr;
  }
  if (fTriggerEventsKey) {
    delete fTriggerEventsKey;
    fTriggerEventsKey = nullptr;
  }
  if (fAlarmsKey) {
    delete fAlarmsKey;
    fAlarmsKey = nullptr;
  }
  if (fAlarmTdHvTripKey) {
    delete fAlarmTdHvTripKey;
    fAlarmTdHvTripKey = nullptr;
  }
  if (fRunInfoKey) {
    delete fRunInfoKey;
    fRunInfoKey = nullptr;
  }
  if (fRunCommentKey) {
    delete fRunCommentKey;
    fRunCommentKey = nullptr;
  }
  if (fTofMinKey) {
    delete fTofMinKey;
    fTofMinKey = nullptr;
  }
  if (fTofMaxKey) {
    delete fTofMaxKey;
    fTofMaxKey = nullptr;
  }
  if (fModNameKey) {
    delete fModNameKey;
    fModNameKey = nullptr;
  }
  if (fModDateKey) {
    delete fModDateKey;
    fModDateKey = nullptr;
  }
  if (fLemSetupKey) {
    delete fLemSetupKey;
    fLemSetupKey = nullptr;
  }
  if (fSampleCryoKey) {
    delete fSampleCryoKey;
    fSampleCryoKey = nullptr;
  }
  if (fSpinRotEnabledKey) {
    delete fSpinRotEnabledKey;
    fSpinRotEnabledKey = nullptr;
  }
  if (fSpinRotAngleKey) {
    delete fSpinRotAngleKey;
    fSpinRotAngleKey = nullptr;
  }
  if (fEnergyLossParamKey) {
    delete fEnergyLossParamKey;
    fEnergyLossParamKey = nullptr;
  }
  if (fClientsKey) {
    delete fClientsKey;
    fClientsKey = nullptr;
  }
  if (fHVDemandKey) {
    delete fHVDemandKey;
    fHVDemandKey = nullptr;
  }
  if (fHVMeasuredKey) {
    delete fHVMeasuredKey;
    fHVMeasuredKey = nullptr;
  }
  if (fHVCurrentKey) {
    delete fHVCurrentKey;
    fHVCurrentKey = nullptr;
  }
  if (fHVDetectorDemandKey) {
    delete fHVDetectorDemandKey;
    fHVDetectorDemandKey = nullptr;
  }
  if (fHVDetectorMeasuredKey) {
    delete fHVDetectorMeasuredKey;
    fHVDetectorMeasuredKey = nullptr;
  }

  if (fSpinRotMagInputKey) {
    delete fSpinRotMagInputKey;
    fSpinRotMagInputKey = nullptr;
  }
  if (fSpinRotMagOutputKey) {
    delete fSpinRotMagOutputKey;
    fSpinRotMagOutputKey = nullptr;
  }
  if (fDanfysikInputKey) {
    delete fDanfysikInputKey;
    fDanfysikInputKey = nullptr;
  }
  if (fDanfysikOutputKey) {
    delete fDanfysikOutputKey;
    fDanfysikOutputKey = nullptr;
  }
  if (fWEWOutputKey) {
    delete fWEWOutputKey;
    fWEWOutputKey = nullptr;
  }
  if (fWEWInputKey) {
    delete fWEWInputKey;
    fWEWInputKey = nullptr;
  }
  if (fMagFieldKey) {
    delete fMagFieldKey;
    fMagFieldKey = nullptr;
  }
  if (fTflInputKey) {
    delete fTflInputKey;
    fTflInputKey = nullptr;
  }
  if (fTflOutputKey) {
    delete fTflOutputKey;
    fTflOutputKey = nullptr;
  }
  if (fSampleCtrlChKey) {
    delete fSampleCtrlChKey;
    fSampleCtrlChKey = nullptr;
  }
  if (fSampleChannelKey) {
    delete fSampleChannelKey;
    fSampleChannelKey = nullptr;
  }
  if (fSampleSensorTypeKey) {
    delete fSampleSensorTypeKey;
    fSampleSensorTypeKey = nullptr;
  }
  if (fSampleInputKey) {
    delete fSampleInputKey;
    fSampleInputKey = nullptr;
  }
  if (fSampleOutputKey) {
    delete fSampleOutputKey;
    fSampleOutputKey = nullptr;
  }
  if (fSampleRawVoltageKey) {
    delete fSampleRawVoltageKey;
    fSampleRawVoltageKey = nullptr;
  }
  if (fSampleNoConnectionKey) {
    delete fSampleNoConnectionKey;
    fSampleNoConnectionKey = nullptr;
  }
  if (fSampleOvenOmegaInputKey) {
    delete fSampleOvenOmegaInputKey;
    fSampleOvenOmegaInputKey = nullptr;
  }
  if (fSampleOvenOmegaOutputKey) {
    delete fSampleOvenOmegaOutputKey;
    fSampleOvenOmegaOutputKey = nullptr;
  }
  if (fLemvacInputKey) {
    delete fLemvacInputKey;
    fLemvacInputKey = nullptr;
  }
  if (fLemvacOutputKey) {
    delete fLemvacOutputKey;
    fLemvacOutputKey = nullptr;
  }
  if (fFOMInputKey) {
    delete fFOMInputKey;
    fFOMInputKey = nullptr;
  }
  if (fFOMOutputKey) {
    delete fFOMOutputKey;
    fFOMOutputKey = nullptr;
  }
  if (fBeamlineDemandKey) {
    delete fBeamlineDemandKey;
    fBeamlineDemandKey = nullptr;
  }
  if (fMagParamWewKey) {
    delete fMagParamWewKey;
    fMagParamWewKey = nullptr;
  }
  if (fMagParamBparKey) {
    delete fMagParamBparKey;
    fMagParamBparKey = nullptr;
  }
  if (fSetupSampleEnabledKey) {
    delete fSetupSampleEnabledKey;
    fSetupSampleEnabledKey = nullptr;
  }
  if (fSetupWewEnabledKey) {
    delete fSetupWewEnabledKey;
    fSetupWewEnabledKey = nullptr;
  }
  if (fSetupBparEnabledKey) {
    delete fSetupBparEnabledKey;
    fSetupBparEnabledKey = nullptr;
  }
}

//**********************************************************************
// ReadStartupXML
//**********************************************************************
void PLemAutoRun::ReadStartupXML()
{
  QString fln = "/home/nemu/nemu/midas/bin/.lemXMLs/lemAutoRun.xml";
  if (!QFile::exists(fln)) {
    QString err = "lemAutoRun: Couldn't find XML startup file " + fln;
    emit ErrorMsg(1, 0, LAR_XML_FILE_MISSING, -1, err);
    return;
  }

  PLemAutoRunXMLParser handler(fln, this);
  if (!handler.isValid()) {
    cm_msg(MERROR, "lemAutoRun", "**ERROR** lemAutoRun: couldn't read lemAutoRun.xml");
    cm_yield(0);
  }
}

//**********************************************************************
// ReadSampleCryoXML
//**********************************************************************
void PLemAutoRun::ReadSampleCryoXML()
{
  char    str[NAME_LENGTH];
  int     size;
  QString sampleCryoName = "";
  QString fln = "";

  if (!fEnabled["sample_eq"] || !fEnabled["sample_cryo_info_odb"]) {
    return;
  }

  // get the sample cryo name
  size = sizeof(str);
  fSampleCryoKey->GetData((void *)&str, &size, TID_STRING);
  sampleCryoName = QString(str);

  if (sampleCryoName == "Konti-1") {
    fln = "/home/nemu/nemu/midas/bin/.lemXMLs/lemAutoRun_KontiCryo1.xml";
    fSampleCryoInUse = CRYO_KONTI;
  } else if (sampleCryoName == "Konti-2") {
    fln = "/home/nemu/nemu/midas/bin/.lemXMLs/lemAutoRun_KontiCryo2.xml";
    fSampleCryoInUse = CRYO_KONTI;
  } else if (sampleCryoName == "Konti-3") {
    fln = "/home/nemu/nemu/midas/bin/.lemXMLs/lemAutoRun_KontiCryo3.xml";
    fSampleCryoInUse = CRYO_KONTI;
  } else if (sampleCryoName == "Konti-4") {
    fln = "/home/nemu/nemu/midas/bin/.lemXMLs/lemAutoRun_KontiCryo4.xml";
    fSampleCryoInUse = CRYO_KONTI;
  } else if (sampleCryoName == "LowTemp-1") { // former Mango
    fln = "/home/nemu/nemu/midas/bin/.lemXMLs/lemAutoRun_LowTemp1.xml";
    fSampleCryoInUse = CRYO_LOWTEMP;
  } else if (sampleCryoName == "LowTemp-2") { // former Lemon
    fln = "/home/nemu/nemu/midas/bin/.lemXMLs/lemAutoRun_LowTemp2.xml";
    fSampleCryoInUse = CRYO_LOWTEMP;
  } else if (sampleCryoName == "Omega") {
    fln = "/home/nemu/nemu/midas/bin/.lemXMLs/lemAutoRun_Oven.xml";
    fSampleCryoInUse = CRYO_OVEN_OMEGA;
  } else if (sampleCryoName == "NoCryo") {
    fSampleCryoInUse = CRYO_NO;
    return;
  }

  if (!QFile::exists(fln)) {
    QString err = "lemAutoRun: Couldn't find XML startup file " + fln + " ";
    err += "Perhaps the sample cryo name (" + sampleCryoName + ") is wrong?!";
    emit ErrorMsg(1, 0, LAR_XML_FILE_MISSING, -1, err);
    return;
  }

  PLemSampleCryoXMLParser handler(fln, this);
  if (!handler.isValid()) {
    QString msg = QString("**ERROR** lemAutoRun: Couldn't read cryo xml-file '%1'").arg(fln);
    cm_msg(MERROR, "lemAutoRun", msg.toLatin1().data());
    cm_yield(0);
  }
}

//**********************************************************************
// InitEnabled
//**********************************************************************
void PLemAutoRun::InitEnabled()
{
  // feed ODB stuff
  fEnabled.insert("trigger_events_odb", false);
  fEnabled.insert("enable_on_off_mode_odb", false);
  fEnabled.insert("alarms_odb", false);
  fEnabled.insert("alarms_td_hv_trip_odb", false);
  fEnabled.insert("run_comment_odb", false);
  fEnabled.insert("tof_min_odb", false);
  fEnabled.insert("tof_max_odb", false);
  fEnabled.insert("mod_name_odb", false);
  fEnabled.insert("mod_date_odb", false);
  fEnabled.insert("lem_setup_odb", false);
  fEnabled.insert("energy_loss_param_odb", false);
  fEnabled.insert("sample_cryo_info_odb", false);
  fEnabled.insert("sample_name_info_odb", false);
  fEnabled.insert("spin_rot_calib_odb", false);
  fEnabled.insert("spin_rot_angle_odb", false);
  fEnabled.insert("mag_param_wew_odb", false);
  fEnabled.insert("mag_param_bpar_odb", false);
  fEnabled.insert("setup_sample_odb", false);
  fEnabled.insert("setup_wew_odb", false);
  fEnabled.insert("setup_bpar_odb", false);

  // feed all clients
  fEnabled.insert("analyzer_fe", false);
  fEnabled.insert("vme_fe", false);
  fEnabled.insert("tfl_scfe", false);
  fEnabled.insert("sample_scfe", false);
  fEnabled.insert("omega_scfe", false);
  fEnabled.insert("wew_scfe", false);
  fEnabled.insert("danfysik_scfe", false);
  fEnabled.insert("fug_scfe", false);
  fEnabled.insert("lemvac_scfe", false);

  // feed all equipment
  fEnabled.insert("fug_eq", false);
  fEnabled.insert("hv_detectors_eq", false);
  fEnabled.insert("danfysik_spin_rot_eq", false);
  fEnabled.insert("danfysik_eq", false);
  fEnabled.insert("wew_eq", false);
  fEnabled.insert("magnet_field_info", false);
  fEnabled.insert("tfl_eq", false);
  fEnabled.insert("sample_eq", false);
  fEnabled.insert("omega_eq", false);
  fEnabled.insert("lemvac_eq", false);
  fEnabled.insert("fom_eq", false);
  fEnabled.insert("beamline_eq", false);
}

//**********************************************************************
// SetEnabled
//**********************************************************************
void PLemAutoRun::SetEnabled(const QString key, bool val)
{
  if (!key.compare("all", Qt::CaseInsensitive)) { // change all
    QMapIterator<QString, bool> i(fEnabled);
    while (i.hasNext()) {
      i.next();
      fEnabled[i.key()] = val;
    }
  } else {
    if (fEnabled.contains(key)) {
      fEnabled[key] = val;
    }
  }
}

//**********************************************************************
// ConnectExp
//**********************************************************************
void PLemAutoRun::ConnectToExp()
{
  // create object
  fExp = new PExperiment("lemAutoRun1");
  if (!fExp) {
    return;
  }

  // connect to MIDAS
  fExp->Connect(fHostName, fExpName, "lemAutoRun1");
  if (!fExp->IsConnected()) {
    return;
  }

  // start watchdog timer
  fExp->StartTimer();

  // make sure that we start from a clean state
  CleanLiveData();

  // get all the ODB keys needed to work
  if (!GetAllKeys()) {
    QString err = QString("lemAutoRun: Couldn't collect the necessary ODB keys");
    emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
    return;
  }

  if (fEnabled["sample_eq"]) {
    // check if setup flags do make sense
    if (!fSetupSampleEnabled) {
      QString err = QString("lemAutoRun: **WARNING** MCP2 setup detected.");
      emit ErrorMsg(1, 0, LAR_MSG, -1, err);
    }
    if (fEnabled["wew_eq"] && fEnabled["danfysik_eq"]) {
      if ((fSetupWewEnabled && fSetupBparEnabled) || (!fSetupWewEnabled && !fSetupBparEnabled)) {
        QString err = QString("lemAutoRun: Setup flags doesn't make any sense: WEW enabled=%1, Bpar enabled=%2").arg(fSetupWewEnabled).arg(fSetupBparEnabled);
        emit ErrorMsg(1, 0, LAR_FATAL, -1, err);
        return;
      }
    }
  }

  // get information which magnet power supply is in use
  if (fSetupWewEnabled)
    fFieldPwrSupply = QString("wew");
  else
    fFieldPwrSupply = QString("danfysik");

  if (fEnabled["enable_on_off_mode_odb"]) {
    // get the Enable_OnOff_Mode flag which shows if RA are operated in pulsed mode
    PKey *onOffMode = new PKey(fExp, fEnableOnOffModePath);
    if (!onOffMode->IsValid()) {
      QString err = QString("lemAutoRun: Enable_OnOff_Mode key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
    } else {
      int ival, size=sizeof(int);
      onOffMode->GetData(&ival, &size, TID_BOOL);
      if (ival == 1)
        fRAPulsingEnabled = true;
      else
        fRAPulsingEnabled = false;
    }
    // clean up
    delete onOffMode;
  }

  QObject::connect(fExp, SIGNAL(NetworkConnectionLost()), this, SLOT(NetworkConnectionLost()));
  QObject::connect(fExp, SIGNAL(ReceivedShutdownCmd()), this, SLOT(ReceivedShutdownCmd()));

}

//**********************************************************************
// NetworkConnectionLost (SLOT)
//**********************************************************************
void PLemAutoRun::NetworkConnectionLost()
{
  QString err = QString("lemAutoRun: Lost Network Connection");
  emit ErrorMsg(1, 0, LAR_LOST_NETWORK_CONNECTION, -1, err);
}

//**********************************************************************
// ReceivedShutdownCmd (SLOT)
//**********************************************************************
void PLemAutoRun::ReceivedShutdownCmd()
{
  QString err;
  
  // set autoRun state to stopped
  int runState = LAR_STATE_STOPPED;
  PKey runStateKey(fExp, "/AutoRun/Run State");
  if (runStateKey.IsValid()) {
    runStateKey.SetData((void*)&runState, 1, TID_INT);
  }

  if (fAutoRunCurrentIter)
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);

  err = QString("Autorun aborted.");
  emit StatusMsg(err);

  err = QString("lemAutoRun: Received Shutdown Command");
  emit ErrorMsg(1, 0, LAR_RECIEVED_SHUTDOWN_CMD, -1, err);

  DisconnectAndQuit();
}

//**********************************************************************
// UpdateStatusMsg (SLOT)
//**********************************************************************
void PLemAutoRun::UpdateStatusMsg(const QString statusMsg)
{
  QDateTime dt = QDateTime::currentDateTime();
  QString msg;

  msg = "["+dt.toString("dd.MM.yy, hh:mm:ss")+"] " + statusMsg;

  PKey statusMsgKey(fExp, "/AutoRun/Status");
  if (statusMsgKey.IsValid()) {
    char cmsg[128];
    memset(cmsg, 0, sizeof(cmsg));
    strncpy(cmsg, msg.toLatin1().data(), sizeof(cmsg)-1);
    statusMsgKey.SetData(cmsg, 1, TID_STRING);
  }
}

//**********************************************************************
// GetRunState
//**********************************************************************
int PLemAutoRun::GetRunState()
{
  int state = -1;
  PKey key(fExp, "/AutoRun/Run State");
  if (key.IsValid()) {
    int ival;
    int size = sizeof(ival);
    int status = key.GetData(&ival, &size, TID_INT);
    if (status == DB_SUCCESS) {
      state = ival;
    }
  }

  return state;
}

//**********************************************************************
// UpdateRunState
//**********************************************************************
void PLemAutoRun::UpdateRunState(const int state)
{
  PKey key(fExp, "/AutoRun/Run State");
  if (key.IsValid()) {
    key.SetData((void*)&state, 1, TID_INT);
  }
}

//**********************************************************************
// GetAutoRunSequence
//**********************************************************************
QString PLemAutoRun::GetAutoRunSequence()
{
  QString fln("");

  PKey larSeqKey(fExp, "/AutoRun/Auto Run Sequence");
  if (larSeqKey.IsValid()) {
    char autoRunSequence[64];
    int size = sizeof(autoRunSequence);
    int status = larSeqKey.GetData(autoRunSequence, &size, TID_STRING);
    if (status == DB_SUCCESS)
      fln = autoRunSequence;
  }

  return fln;
}

//**********************************************************************
// ShowComments
//**********************************************************************
bool PLemAutoRun::ShowComments()
{
  bool showComments = true;

  PKey key(fExp, "/AutoRun/Show Comments");
  if (key.IsValid()) {
    int ival;
    int size = sizeof(ival);
    int status = key.GetData(&ival, &size, TID_BOOL);
    if (status == DB_SUCCESS) {
      if (ival != 1)
        showComments = false;
    }
  }

  return showComments;
}

//**********************************************************************
// SetGotoLine
//**********************************************************************
void PLemAutoRun::SetGotoLine(const int line)
{
  PKey key(fExp, "/AutoRun/GotoLine");
  if (key.IsValid()) {
    key.SetData((void*)&line, 1, TID_INT);
  }
}

//**********************************************************************
// GetGotoLine
//**********************************************************************
int PLemAutoRun::GetGotoLine()
{
  int line = -1;
  PKey key(fExp, "/AutoRun/GotoLine");
  if (key.IsValid()) {
    int ival;
    int size = sizeof(ival);
    int status = key.GetData(&ival, &size, TID_INT);
    if (status == DB_SUCCESS) {
      line = ival;
    }
  }

  return line;
}

//**********************************************************************
// CleanLiveData
//**********************************************************************
void PLemAutoRun::CleanLiveData()
{
  // make sure that not already an autorun is ongoing
  PKey larRunStateKey(fExp, "/AutoRun/Run State");
  if (larRunStateKey.IsValid()) {
    int state = -1;
    int size = sizeof(int);
    larRunStateKey.GetData(&state, &size, TID_INT);
    if ((state == LAR_STATE_STARTING) || (state == LAR_STATE_RUNNING))
      return;
  }

  // clean
  PKey liveDataKey(fExp, "/AutoRun/LiveData");

  if (liveDataKey.IsValid()) {
    // clean ErrorInLine
    PKey *errorInLineKey = new PKey(&liveDataKey, "ErrorInLine");
    if (errorInLineKey == 0) {
      cm_msg(MDEBUG, "lemAutoRun", "**ERROR** couldn't invoke errorInLineKey");
      return;
    }
    if (errorInLineKey->IsValid()) {
      int ival[10];
      for (int i=0; i<10; i++) {
        ival[i] = -1;
      }
      errorInLineKey->SetData((void *)&ival[0], 10, TID_INT);
    }
    delete errorInLineKey;

    // clean ErrorMsg
    PKey *errorMsgKey = new PKey(&liveDataKey, "ErrorMsg");
    if (errorMsgKey == 0) {
      cm_msg(MDEBUG, "lemAutoRun", "**ERROR** couldn't invoke errorMsgKey");
      return;
    }
    if (errorMsgKey->IsValid()) {
      char msg[10][128];
      for (int i=0; i<10; i++) {
        memset(msg[i], 0, 128);
        strcpy(msg[i], "empty");
      }
      errorMsgKey->SetData((void*)msg, 10, TID_STRING);
    }
    delete errorMsgKey;
  } else { // key not valid, i.e. likely doesn't exist yet -> try to create it
    cm_msg(MINFO, "lemAutoRun", "try to create default /AutoRun/LiveData record.");
    cm_yield(0);
    // AutoRun LiveData initial record
    const char *lar_live_data_settings =
"ErrorInLine = INT[10] : \n\
[0] -1,\n\
[1] -1,\n\
[2] -1,\n\
[3] -1,\n\
[4] -1,\n\
[5] -1,\n\
[6] -1,\n\
[7] -1,\n\
[8] -1,\n\
[9] -1,\n\
ErrorMsg = STRING[10] : \n\
[128] empty\n\
[128] empty\n\
[128] empty\n\
[128] empty\n\
[128] empty\n\
[128] empty\n\
[128] empty\n\
[128] empty\n\
[128] empty\n\
[128] empty\n\
CurrentLineNo = INT : -1\n\
LoopVal =  STRING : [32] empty\n\
TransitionTag = INT : 0\n\
AutoRun = STRING : [32] empty\n\
";
    if (db_create_record(fExp->GetHdb(), 0, "/AutoRun/LiveData", lar_live_data_settings) != DB_SUCCESS) { // error
      cm_msg(MERROR, "lemAutoRun", "**ERROR** couldn't create /AutoRun/LiveData default record.");
      cm_yield(0);
      return;
    }
  }
}

//**********************************************************************
// FeedLiveDataErrors
//**********************************************************************
void PLemAutoRun::FeedLiveDataErrors(int noOfErrors, int idx, int /*errorNo*/, int line, QString errorMsg)
{
  cm_msg(MDEBUG, "lemAutoRun", "debug> noOfErrors=%d, idx=%d, line=%d, errMsg=%s", noOfErrors, idx, line, errorMsg.toLatin1().data()); cm_yield(0);

  PKey errorInLineKey(fExp, "/AutoRun/LiveData/ErrorInLine");
  PKey errorMsgKey(fExp, "/AutoRun/LiveData/ErrorMsg");
  PKey transTagKey(fExp, "/AutoRun/LiveData/TransitionTag");

  int ival = LAR_TT_IDLE;
  transTagKey.SetData((void*)&ival, 1, TID_INT);

  int i=0;
  if (noOfErrors != 0) {
    i = idx;
  }

  ival=0;
  if (line != -1)
    ival = line;
  if (errorInLineKey.IsValid()) {
    errorInLineKey.SetDataIndex((void *)&ival, i, TID_INT);
  }
  if (errorMsgKey.IsValid()) {
    char msg[128];
    memset(msg, 0, sizeof(msg));
    strncpy(msg, errorMsg.toLatin1().data(), sizeof(msg));
    errorMsgKey.SetDataIndex(msg, i, TID_STRING);
  }
}

//**********************************************************************
// DisconnectFromExp
//**********************************************************************
void PLemAutoRun::DisconnectFromExp()
{
  QString runStatePath = "/AutoRun/Run State";
  PKey key(fExp, runStatePath);
  if (key.IsValid()) {
    INT ival;
    int size = sizeof(ival);
    // check if run state is LAR_STATE_NEXT
    key.GetData((void*)&ival, &size, TID_INT);

    if (ival != LAR_STATE_NEXT) {
      ival = LAR_STATE_STOPPED;
      key.SetData((void*)&ival, 1, TID_INT);
    }
  }

  if (fExp)
    fExp->Disconnect();
}

//**********************************************************************
// HandleParseError (SLOT)
//**********************************************************************
void PLemAutoRun::HandleParseError(int noOfErrors, int idx, int errorNo, int line, QString errorMsg)
{
  // set autorun state to stopped
  UpdateRunState(LAR_STATE_STOPPED);

  // set autorun status message
  char msg[128];
  if (line > 0)
    sprintf(msg, "**ERROR** in line no %d (errorNo: %d)", line, errorNo);
  else 
    sprintf(msg, "**ERROR** errorNo: %d",  errorNo);

  FeedLiveDataErrors(noOfErrors, idx, errorNo, line, errorMsg);

  UpdateStatusMsg(msg);
  UpdateWebPage(0, HTML_PARSE_ERROR, line, errorMsg);
}

//**********************************************************************
// DisconnectAndQuit (SLOT)
//**********************************************************************
void PLemAutoRun::DisconnectAndQuit()
{
  DisconnectFromExp();

  QCoreApplication::exit(0);
  exit(0);
}

//**********************************************************************
// IsIdle
//**********************************************************************
bool PLemAutoRun::IsIdle()
{
  bool isIdle = true;

  // check if more than one lemAutoRun is present and if yes, idle=false
  int count=0;
  HNDLE hKey;
  int size, status;
  char str[NAME_LENGTH];
  for (int i=0; ; i++) {
    // check if there is a subkey
    if (fClientsKey->EnumSubKey(i, &hKey) == DB_NO_MORE_SUBKEYS)
      break;
    // get the content of the variable Name from the subkey
    size = sizeof(str);
    status = db_get_value(fClientsKey->GetHdb(), hKey, "Name", str, &size, TID_STRING, FALSE);
    if (status != DB_SUCCESS) {
      QString err = QString("Autorun: check clients failure ...");
      emit StatusMsg(err);
      err = QString("PLemAutoRun::CheckClients(): Couldn't get value from subkey.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
    }
    // check if the name is one of the monitored frontends
    if (!strncmp(str, "lemAutoRun", sizeof(str)))
      count++;
  }

  if (count > 1)
    isIdle = false;

  return isIdle;  
}

//**********************************************************************
// GetUserAutoRunSeqFln
//**********************************************************************
QString PLemAutoRun::GetUserAutoRunSeqFln()
{
  QString result = fAutoRunPath;

  result += GetAutoRunSequence();

  return result;
}

//**********************************************************************
// GetAllKeys
//**********************************************************************
bool PLemAutoRun::GetAllKeys()
{
  int  size, status;
  QString err;

  // get key to the trigger events
  if (fEnabled["trigger_events_odb"]) {
    fTriggerEventsKey = new PKey(fExp, fTriggerEventsPath);
    if (!fTriggerEventsKey->IsValid()) {
      err = QString("lemAutoRun: Trigger Events key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  // get key to the alarms
  if (fEnabled["alarms_odb"]) {
    fAlarmsKey = new PKey(fExp, fAlarmsPath);
    if (!fAlarmsKey->IsValid()) {
      err = QString("lemAutoRun: Alarms key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  // get key to the Alarm: TD HV trip trigger
  if (fEnabled["alarms_td_hv_trip_odb"]) {
    fAlarmTdHvTripKey = new PKey(fExp, fAlarmTdHvTripPath);
    if (!fAlarmTdHvTripKey->IsValid()) {
      err = QString("lemAutoRun: Alarm TD HV trip trigger key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
    // hotlink TD HV trip trigger flag
    size = sizeof(fHvTripFlag);
    status = fAlarmTdHvTripKey->HotLink(&fHvTripFlag, size, MODE_READ, TdHvTripFlagChanged, this);
    if (status != DB_SUCCESS) {
      err = QString("lemAutoRun: Couldn't hotlink Alarm TD HV trip trigger flag.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  // get run info and hotlink runinfo structure
  fRunInfoKey = new PKey(fExp, fRunInfoPath);
  if (!fRunInfoKey->IsValid()) {
    err = QString("lemAutoRun: Run info key not found.");
    emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
    return false;
  }

  // get key to run comment
  if (fEnabled["run_comment_odb"]) {
    fRunCommentKey = new PKey(fExp, fRunCommentPath);
    if (!fRunCommentKey->IsValid()) {
      err = QString("lemAutoRun: Run comment key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  // get key to TOF Min
  if (fEnabled["tof_min_odb"]) {
    fTofMinKey = new PKey(fExp, fTofMinPath);
    if (!fTofMinKey->IsValid()) {
      err = QString("lemAutoRun: TOF Min key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  // get key to TOF Max
  if (fEnabled["tof_max_odb"]) {
    fTofMaxKey = new PKey(fExp, fTofMaxPath);
    if (!fTofMaxKey->IsValid()) {
      err = QString("lemAutoRun: TOF Max key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  // get key to moderator name
  if (fEnabled["mod_name_odb"]) {
    fModNameKey = new PKey(fExp, fModNamePath);
    if (!fModNameKey->IsValid()) {
      err = QString("lemAutoRun: Moderator name key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  // get key to moderator date
  if (fEnabled["mod_date_odb"]) {
    fModDateKey = new PKey(fExp, fModDatePath);
    if (!fModDateKey->IsValid()) {
      err = QString("lemAutoRun: Moderator date key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  // get key to LEM Setup
  if (fEnabled["lem_setup_odb"]) {
    fLemSetupKey = new PKey(fExp, fLemSetupPath);
    if (!fLemSetupKey->IsValid()) {
      err = QString("lemAutoRun: LEM setup key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  // get key to Sample Name
  if (fEnabled["sample_name_info_odb"]) {
    fSampleNameKey = new PKey(fExp, fSampleNamePath);
    if (!fSampleNameKey->IsValid()) {
      err = QString("lemAutoRun: Sample Name key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  // get key to Spin Rotation Enabled flag
  if (fEnabled["spin_rot_calib_odb"]) {
    fSpinRotEnabledKey = new PKey(fExp, fSpinRotEnabledPath);
    if (!fSpinRotEnabledKey->IsValid()) {
      err = QString("lemAutoRun: spin rotation enabled key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  // get key to Spin Rotation Angle
  if (fEnabled["spin_rot_angle_odb"]) {
    fSpinRotAngleKey = new PKey(fExp, fSpinRotAnglePath);
    if (!fSpinRotAngleKey->IsValid()) {
      err = QString("lemAutoRun: spin rotation angle key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  // get key to Sample Cryo
  if (fEnabled["sample_cryo_info_odb"]) {
    fSampleCryoKey = new PKey(fExp, fSampleCryoPath);
    if (!fSampleCryoKey->IsValid()) {
      err = QString("lemAutoRun: Sample Cryo key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  // get key to the energy loss parameters
  if (fEnabled["energy_loss_param_odb"]) {
    QString path;
    for (int i=0; i<NO_ENERGY_LOSS_PARAM; i++) {
      path = fEnergyLossParamPath + QString("/p%1").arg(i);
      fEnergyLossParamKey = new PKey(fExp, path);
      if (!fEnergyLossParamKey->IsValid()) {
        err = QString("lemAutoRun: Energy loss parameter p%1 key not found.").arg(i);
        emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
        return false;
      }
      size = sizeof(float);
      fEnergyLossParamKey->GetData((void *)&fEnergyLossParam[i], &size, TID_FLOAT);
      delete fEnergyLossParamKey;
      fEnergyLossParamKey = nullptr;
    }
  }

  // get key to system/clients
  fClientsKey = new PKey(fExp, fClientsPath);
  if (!fClientsKey->IsValid()) {
    err = QString("lemAutoRun: Clients key not found.");
    emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
    return false;
  }

  if (fEnabled["fug_eq"]) {
    // get key to the HV demand values of the FUG's
    fHVDemandKey = new PKey(fExp, fHVDemandPath);
    if (!fHVDemandKey->IsValid()) {
      err = QString("lemAutoRun: HV demand key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }

    // get key to the HV measured values of the FUG's
    fHVMeasuredKey = new PKey(fExp, fHVMeasuredPath);
    if (!fHVMeasuredKey->IsValid()) {
      err = QString("lemAutoRun: HV measured key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }

    // get key to the HV current values of the FUG's
    fHVCurrentKey = new PKey(fExp, fHVCurrentPath);
    if (!fHVCurrentKey->IsValid()) {
      err = QString("lemAutoRun: HV current key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  if (fEnabled["hv_detectors_eq"]) {
    // get key to the HV Detectors demand values
    fHVDetectorDemandKey = new PKey(fExp, fHVDetectorDemandPath);
    if (!fHVDetectorDemandKey->IsValid()) {
      err = QString("lemAutoRun: HV Detectors demand key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }

    // get key to the HV Detectors measured values
    fHVDetectorMeasuredKey = new PKey(fExp, fHVDetectorMeasuredPath);
    if (!fHVDetectorMeasuredKey->IsValid()) {
      err = QString("lemAutoRun: HV Detectors measured key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  if (fEnabled["danfysik_spin_rot_eq"]) {
    // get key to the Danfysik Spin Rotator input values
    fSpinRotMagInputKey = new PKey(fExp, fSpinRotMagInputPath);
    if (!fSpinRotMagInputKey->IsValid()) {
      err = QString("lemAutoRun: Danfysik Spin Rotator input key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }

    // get key to the Danfysik Spin Rotator output values
    fSpinRotMagOutputKey = new PKey(fExp, fSpinRotMagOutputPath);
    if (!fSpinRotMagOutputKey->IsValid()) {
      err = QString("lemAutoRun: Danfysik Spin Rotator output key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  if (fEnabled["danfysik_eq"]) {
    // get key to the Danfysik input values
    fDanfysikInputKey = new PKey(fExp, fDanfysikInputPath);
    if (!fDanfysikInputKey->IsValid()) {
      err = QString("lemAutoRun: Danfysik input key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }

    // get key to the Danfysik output values
    fDanfysikOutputKey = new PKey(fExp, fDanfysikOutputPath);
    if (!fDanfysikOutputKey->IsValid()) {
      err = QString("lemAutoRun: Danfysik output key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  if (fEnabled["wew_eq"]) {
    // get key to the WEW output values
    fWEWOutputKey = new PKey(fExp, fWEWOutputPath);
    if (!fWEWOutputKey->IsValid()) {
      err = QString("lemAutoRun: WEW output key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }

    // get key to the WEW input values
    fWEWInputKey = new PKey(fExp, fWEWInputPath);
    if (!fWEWInputKey->IsValid()) {
      err = QString("lemAutoRun: WEW input key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  if (fEnabled["magnet_field_info"]) {
    // get key to the magnetic field parameters key of the WEW
    fMagFieldKey = new PKey(fExp, fMagFieldPath);
    if (!fMagFieldKey->IsValid()) {
      err = QString("lemAutoRun: magnetic field value key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  if (fEnabled["tfl_eq"]) {
    // get key to TFL input
    fTflInputKey = new PKey(fExp, fTflInputPath);
    if (!fTflInputKey->IsValid()) {
      err = QString("lemAutoRun: tfl input key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }

    // get key to TFL output
    fTflOutputKey = new PKey(fExp, fTflOutputPath);
    if (!fTflOutputKey->IsValid()) {
      err = QString("lemAutoRun: tfl output key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  if (fEnabled["sample_eq"]) {
    // get key to the ctrl channel of the sample cryo LS340
    fSampleCtrlChKey = new PKey(fExp, fSampleCtrlChPath);
    if (!fSampleCtrlChKey->IsValid()) {
      err = QString("lemAutoRun: sample cryo LS340 ctrl channel key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
    // check if the ctrl channel is valid
    char ctrl_ch[4];
    size = sizeof(ctrl_ch);
    fSampleCtrlChKey->GetData(ctrl_ch, &size, TID_STRING);
    if (strstr(ctrl_ch, "A")) {
      fSampleCtrlCh = LS336_INPUT_CF1;
    } else if (strstr(ctrl_ch, "B")) {
      fSampleCtrlCh = LS336_INPUT_CF2;
    } else { // neither 'A' or 'B', set it to 'A'
      err = QString("lemAutoRun: sample cryo LS340 ctrl channel neither 'A' or 'B'. Needs to be fixed first!");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }

    // get key to the channel assignment of the sample cryo LS340
    fSampleChannelKey = new PKey(fExp, fSampleChannelPath);
    if (!fSampleChannelKey->IsValid()) {
      err = QString("lemAutoRun: sample cryo LS340 channel assignment key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }

    // get key to the sensor type assignment of the sample cryo LS340
    fSampleSensorTypeKey = new PKey(fExp, fSampleSensorTypePath);
    if (!fSampleSensorTypeKey->IsValid()) {
      err = QString("lemAutoRun: sample cryo LS340 sensor type assignment key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }

    // get key to the sample cryo input values
    fSampleInputKey = new PKey(fExp, fSampleInputPath);
    if (!fSampleInputKey->IsValid()) {
      err = QString("lemAutoRun: sample cryo input key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
    // hotlink input variables
    size = sizeof(fSampleInput);
    status = fSampleInputKey->HotLink(&fSampleInput, size, MODE_READ, NULL, NULL);
    if (status != DB_SUCCESS) {
      err = QString("lemAutoRun: Couldn't hotlink sample input variables.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }

    // get key to the sample cryo output values
    fSampleOutputKey = new PKey(fExp, fSampleOutputPath);
    if (!fSampleOutputKey->IsValid()) {
      err = QString("lemAutoRun: sample cryo output key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
    // hotlink output variables
    size = sizeof(fSampleOutput);
    status = fSampleOutputKey->HotLink(&fSampleOutput, size, MODE_READ, NULL, NULL);
    if (status != DB_SUCCESS) {
      err = QString("lemAutoRun: Couldn't hotlink sample output variables.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
    // get key to the sample raw voltages
    fSampleRawVoltageKey = new PKey(fExp, fSampleRawVoltagePath);
    if (!fSampleRawVoltageKey->IsValid()) {
      err = QString("lemAutoRun: sample cryo 'raw voltage key' key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  if (fEnabled["omega_scfe"]) {
    // get key to the sample oven omega input values
    fSampleOvenOmegaInputKey = new PKey(fExp, fSampleOvenOmegaInputPath);
    if (!fSampleOvenOmegaInputKey->IsValid()) {
      err = QString("lemAutoRun: sample oven omega output key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
    // hotlink input variables
    size = sizeof(fSampleOvenOmegaInput);
    status = fSampleOvenOmegaInputKey->HotLink(&fSampleOvenOmegaInput, size, MODE_READ, NULL, NULL);
    if (status != DB_SUCCESS) {
      err = QString("lemAutoRun: Couldn't hotlink sample oven omega input variables.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }

    // get key to the sample oven omega output values
    fSampleOvenOmegaOutputKey = new PKey(fExp, fSampleOvenOmegaOutputPath);
    if (!fSampleOvenOmegaOutputKey->IsValid()) {
      err = QString("lemAutoRun: sample oven omega output key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
    // hotlink input variables
    size = sizeof(fSampleOvenOmegaOutput);
    status = fSampleOvenOmegaOutputKey->HotLink(&fSampleOvenOmegaOutput, size, MODE_READ, NULL, NULL);
    if (status != DB_SUCCESS) {
      err = QString("lemAutoRun: Couldn't hotlink sample oven omega output variables.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  if (fEnabled["lemvac_scfe"]) {
    // get key to the lemvac input values
    fLemvacInputKey = new PKey(fExp, fLemvacInputPath);
    if (!fLemvacInputKey->IsValid()) {
      err = QString("lemAutoRun: lemvac input key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }

    // get key to the lemvac output values
    fLemvacOutputKey = new PKey(fExp, fLemvacOutputPath);
    if (!fLemvacOutputKey->IsValid()) {
      err = QString("lemAutoRun: lemvac output key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  if (fEnabled["fom_eq"]) {
    // get key to the FOM input values
    fFOMInputKey = new PKey(fExp, fFOMInputPath);
    if (!fFOMInputKey->IsValid()) {
      err = QString("lemAutoRun: FOM input key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }

    // get key to the FOM output values
    fFOMOutputKey = new PKey(fExp, fFOMOutputPath);
    if (!fFOMOutputKey->IsValid()) {
      err = QString("lemAutoRun: FOM output key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  if (fEnabled["beamline_eq"]) {
    // get key to the Beamline demand values
    fBeamlineDemandKey = new PKey(fExp, fBeamlineDemandPath);
    if (!fBeamlineDemandKey->IsValid()) {
      err = QString("lemAutoRun: Beamline demand key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  if (fEnabled["mag_param_wew_odb"]) {
    // get key to the WEW calibration (A->G)
    fMagParamWewKey = new PKey(fExp, fMagParamWewPath);
    if (!fMagParamWewKey->IsValid()) {
      err = QString("lemAutoRun: Mag. Param. WEW calibration key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
    // get the calibration parameters
    size = sizeof(fMagParamWew);
    fMagParamWewKey->GetData(&fMagParamWew, &size, TID_FLOAT);
    if (fMagParamWew[1] == 0.0) { // the linear part in the calibration musn't be zero!!
      err = QString("lemAutoRun: Mag. Param. WEW calibration with linear part == 0! Something is wrong!!");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  if (fEnabled["mag_param_bpar_odb"]) {
    // get key to the Bpar calibration (A->G)
    fMagParamBparKey = new PKey(fExp, fMagParamBparPath);
    if (!fMagParamBparKey->IsValid()) {
      err = QString("lemAutoRun: Mag. Param. Bpar calibration key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
    // get the calibration parameters
    size = sizeof(fMagParamBpar);
    fMagParamBparKey->GetData(&fMagParamBpar, &size, TID_FLOAT);
    if (fMagParamBpar[1] == 0.0) { // the linear part in the calibration musn't be zero!!
      err = QString("lemAutoRun: Mag. Param. Bpar calibration with linear part == 0! Something is wrong!!");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
  }

  if (fEnabled["setup_sample_odb"]) {
    // get the sample setup enabled flag
    fSetupSampleEnabledKey = new PKey(fExp, fSetupSampleEnabledPath);
    if (!fSetupSampleEnabledKey->IsValid()) {
      err = QString("lemAutoRun: Sample setup enabled key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
    int ival = -1;
    size = sizeof(ival);
    fSetupSampleEnabledKey->GetData(&ival, &size, TID_BOOL);
    if (ival == 1)
      fSetupSampleEnabled = true;
  }

  if (fEnabled["setup_wew_odb"]) {
    // get the WEW setup enabled flag
    fSetupWewEnabledKey = new PKey(fExp, fSetupWewEnabledPath);
    if (!fSetupWewEnabledKey->IsValid()) {
      err = QString("lemAutoRun: WEW setup enabled key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
    int ival = -1;
    size = sizeof(ival);
    fSetupWewEnabledKey->GetData(&ival, &size, TID_BOOL);
    if (ival == 1)
      fSetupWewEnabled = true;
  }

  if (fEnabled["setup_bpar_odb"]) {
    // get the Bpar setup enabled flag
    fSetupBparEnabledKey = new PKey(fExp, fSetupBparEnabledPath);
    if (!fSetupBparEnabledKey->IsValid()) {
      err = QString("lemAutoRun: Bpar setup enabled key not found.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
    }
    int ival = -1;
    size = sizeof(ival);
    fSetupBparEnabledKey->GetData(&ival, &size, TID_BOOL);
    if (ival == 1)
      fSetupBparEnabled = true;
  }

  // create RawVoltage dump file name
  if (fEnabled["sample_eq"]) {
    fDumpFileName = "RawVoltageOutput-";
    char cryoName[NAME_LENGTH];
    size = sizeof(cryoName);
    if (fEnabled["sample_cryo_info_odb"])
      fSampleCryoKey->GetData(cryoName, &size, TID_STRING);
    else
      strcpy(cryoName, "cryo");
    fDumpFileName += cryoName;
    fDumpFileName += "-";
    QDateTime dt(QDate::currentDate(), QTime::currentTime());
    QString dtStr = dt.toString("ddMMyy-hhmm");
    fDumpFileName += dtStr + ".dat";
  }

  return true;
}

//**********************************************************************
// GetEnergyLoss
//**********************************************************************
float PLemAutoRun::GetEnergyLoss(float hv_mod)
{
  float energy_loss = 0.0;

  if (!fEnabled["energy_loss_param_odb"])
    return 0.0;

  if (hv_mod < 20.1) {
    for (int i=0; i<NO_ENERGY_LOSS_PARAM; i++)
      energy_loss += fEnergyLossParam[i] * powf(hv_mod, i);
  } else {
    energy_loss = 0.23;
  }

  return energy_loss;
}

//**********************************************************************
// CheckClients
//**********************************************************************
void PLemAutoRun::CheckClients()
{
  if (fIgnoreClients) {
    fAnalyzerRunning = true;
    fFrontendRunning = true;
    fTflFeRunning = true;
    fSampleFeRunning = true;
    fSampleOvenOmegaFeRunning = true;
    fWEWFeRunning = true;
    fDanfysikFeRunning = true;
    fHVFeRunning     = true;
    fLemvacFeRunning = true;
    return;
  }
  
  HNDLE   subKey;
  char    str[128];
  INT     size, status;
  QString name;

  fAnalyzerRunning = false;
  fFrontendRunning = false;
  fTflFeRunning = false;
  fSampleFeRunning = false;
  fSampleOvenOmegaFeRunning = false;
  fWEWFeRunning = false;
  fDanfysikFeRunning = false;
  fHVFeRunning     = false;
  fLemvacFeRunning = false;

  for (int i=0; ; i++) {
    // check if there is a subkey
    if (fClientsKey->EnumSubKey(i, &subKey) == DB_NO_MORE_SUBKEYS)
      break;
    // get the content of the variable Name from the subkey
    size = sizeof(str);
    status = db_get_value(fClientsKey->GetHdb(), subKey, "Name", str, &size, TID_STRING, FALSE);
    if (status != DB_SUCCESS) {
      QString err = QString("Autorun: check clients failure ...");
      emit StatusMsg(err);
      err = QString("PLemAutoRun::CheckClients(): Couldn't get value from subkey.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
    }
    // check if the name is one of the monitored frontends
    name = QString(str);
    if (name == fAnalyzerName)
      fAnalyzerRunning = true;
    else if (name == fFrontendName)
      fFrontendRunning = true;
    else if (name == fTflFeName)
      fTflFeRunning = true;
    else if (name == fSampleFeName)
      fSampleFeRunning = true;
    else if (name == fSampleOvenOmegaFeName)
      fSampleOvenOmegaFeRunning = true;
    else if (name == fWEWFeName)
      fWEWFeRunning = true;
    else if (name == fDanfysikFeName)
      fDanfysikFeRunning = true;
    else if (name == fHVFeName)
      fHVFeRunning = true;
    else if (name == fLemvacFeName)
      fLemvacFeRunning = true;

    // if analyzer_fe is disabled -> running to true
    if (!fEnabled["analyzer_fe"])
      fAnalyzerRunning = true;
    // if vme_fe is disabled -> running to true
    if (!fEnabled["vme_fe"])
      fFrontendRunning = true;
    // if tfl_scfe is disabled -> running to true
    if (!fEnabled["tfl_scfe"])
      fTflFeRunning = true;
    // if sample_scfe is disabled -> running to true
    if (!fEnabled["sample_scfe"])
      fSampleFeRunning = true;
    // if omega_scfe is disabled -> running to true
    if (!fEnabled["omega_scfe"])
      fSampleOvenOmegaFeRunning = true;
    // if WEW scfe is disabled -> running to true
    if (!fEnabled["wew_scfe"])
      fWEWFeRunning = true;
    // if Danfysik scfe (Bpar) is disabled -> running to true
    if (!fEnabled["danfysik_scfe"])
      fDanfysikFeRunning = true;
    // if FUG handling is disabled, fake the FUG FE to running
    if (!fEnabled["fug_scfe"])
      fHVFeRunning = true;
    // if LEMVAC handling is disabled, fake the FUG FE to running
    if (!fEnabled["lemvac_scfe"])
      fLemvacFeRunning = true;
  }
}

//**********************************************************************
// CheckMidasAlarms
//**********************************************************************
void PLemAutoRun::CheckMidasAlarms(PAutoRunCmdVector::Iterator iter)
{
  if (!fEnabled["alarms_odb"])
    return;

  if (fIgnoreAlarms)
    return;
  
  HNDLE   subKey;
  INT     size, status;

  struct {
    BOOL  active;
    INT   triggered;
    INT   type;
    INT   check_interval;
    DWORD checked_last;
    char  trigger_first[32];
    char  trigger_last[32];
    char  condition[256];
    char  alarm_class[32];
    char  alarm_msg[80];
  } alarmData;

  for (int i=0; ; i++) {
    if (fAlarmsKey->EnumSubKey(i, &subKey) == DB_NO_MORE_SUBKEYS)
      break;
    // get the trigger flag if the current alarm
    size = sizeof(alarmData);
    status = db_get_record(fAlarmsKey->GetHdb(), subKey, &alarmData, &size, 0);
    if (status != DB_SUCCESS) {
      QString err = QString("Autorun: check alarms failure ...");
      emit StatusMsg(err);
      err = QString("PLemAutoRun::CheckMidasAlarms(): Couldn't get value from subkey.");
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
    }
    if (alarmData.triggered && strstr(alarmData.alarm_class, "Alarm")) { // found an alarm which fired
      UpdateWebPage(iter, HTML_ALARM);

      QString err = QString("Autorun: Alarm fired ...");
      emit StatusMsg(err);
      err = QString("PLemAutoRun::CheckMidasAlarms: Alarm fired! ")+
            QString("  msg: %1 ").arg(alarmData.alarm_msg)+
            QString("  Error too severe, will stop.");
      emit ErrorMsg(1, 0, LAR_MIDAS_FE_NOT_RUNNING, -1, err);
      DisconnectFromExp();
      QCoreApplication::exit(0);
      exit(0);
    }
  }
}

//**********************************************************************
// LakeShoreTime
//**********************************************************************
double PLemAutoRun::LakeShoreTime(char *str)
{
  int    status;
  int    imonth, day, year, hour, min, sec, msec;
  double days = 0, result;
  int    month[12] = {31,28,31,30,31,30,31,31,30,31,30,31};

  // extract date and time values
  status = sscanf(str, "%d,%d,%d,%d,%d,%d,%d", &imonth, &day, &year, &hour, &min, &sec, &msec);
  if (status != 7) { // str does not have the proper format
    return -1.0;
  }

  // check for leap year
  for (int i=2006; i<year; i++)  {
    if ( ((i % 4) == 0 && (i % 100) != 0) || (i % 400) == 0 )
      days = days + 366;
    else
      days = days + 365;
  }
  if ( ((year % 4) == 0 && (year % 100) != 0) || (year % 400) == 0 ) month[1] = 29;

  for (int i = 1; i<imonth; i++ ) days = days + month[i-1];

  days      = days + day;
  result    = (double)days * 86400.0 + (double)hour * 3600.0 + (double)min * 60.0 +
              (double)sec + (double)msec / 1000.0;

  return result;
}

//**********************************************************************
// SampleTempTrend
//**********************************************************************
void PLemAutoRun::SampleTempTrend()
{
  double    x[SAMPLE_TEMP_HISTO_MAX];
  double    s     = 0.0;
  double    sx    = 0.0;
  double    sxx   = 0.0;
  double    sxxx  = 0.0;
  double    sxxxx = 0.0;
  double    sT    = 0.0;
  double    sh    = 0.0;
  double    sf    = 0.0;
  double    sp    = 0.0;
  double    sxT   = 0.0;
  double    sxh   = 0.0;
  double    sxf   = 0.0;
  double    sxp   = 0.0;
  double    sxxT  = 0.0;
  double    sxxh  = 0.0;
  double    sxxf  = 0.0;
  double    sxxp  = 0.0;

  double    help  = 0.0;
  double    xx    = 0.0;

  if ( fSampleHistoNoEntries < 4 )
    return;

  for (int i=0; i<fSampleHistoNoEntries; i++) {
    s   += 1.0;
    sx  += fSampleTempHisto[i].datetime;
  }

  sx = sx / s;              // average time
  fSampleTempAverage.datetime = sx;
  // to calculate the time difference between the current and the previous temp
  // one needs to be careful since the data are stored in a ring buffer.
  // The current counter 'fSampleHistoPos' is always one count ahead!
  switch (fSampleHistoPos) {
    case 0: // current counter at the begining
      fSampleTempTrend.datetime = fSampleTempHisto[fSampleHistoNoEntries-1].datetime -
                                  fSampleTempHisto[fSampleHistoNoEntries-2].datetime;
      break;
    case 1: // current counter at the 2nd entry
      fSampleTempTrend.datetime = fSampleTempHisto[0].datetime -
                                  fSampleTempHisto[fSampleHistoNoEntries-1].datetime;
      break;
    default:
      fSampleTempTrend.datetime = fSampleTempHisto[fSampleHistoPos-1].datetime -
                                  fSampleTempHisto[fSampleHistoPos-2].datetime;
      break;
  }

  for (int i=0; i<fSampleHistoNoEntries; i++)
    x[i] = fSampleTempHisto[i].datetime - sx;

  sx = 0.0;
  for (int i=0; i<fSampleHistoNoEntries; i++) {
    xx     = x[i] * x[i];
    sx    += x[i];
    sxx   += xx;
    sxxx  += xx * x[i];
    sxxxx += xx * xx;
    sT    += fSampleTempHisto[i].measured_T;
    sh    += fSampleTempHisto[i].heater;
    sf    += fSampleTempHisto[i].flow;
    sp    += fSampleTempHisto[i].pressure;
    sxT   += x[i] * fSampleTempHisto[i].measured_T;
    sxh   += x[i] * fSampleTempHisto[i].heater;
    sxf   += x[i] * fSampleTempHisto[i].flow;
    sxp   += x[i] * fSampleTempHisto[i].pressure;
    sxxT  += xx * fSampleTempHisto[i].measured_T;
    sxxh  += xx * fSampleTempHisto[i].heater;
    sxxf  += xx * fSampleTempHisto[i].flow;
    sxxp  += xx * fSampleTempHisto[i].pressure;

  }

  double denominator = -s * sxx * sxxxx + s * sxxx * sxxx + sx * sx * sxxxx
                       - 2.0 * sxxx * sx * sxx + sxx * sxx * sxx;

  if ( fabs( denominator ) > 0.0 )  {
    fSampleTempAverage.measured_T = -(sx * sxxx * sxxT - sx * sxT * sxxxx + sxx * sxxx * sxT - sxx * sxx * sxxT +
                                      sT * sxx * sxxxx - sT * sxxx * sxxx) / denominator;
    fSampleTempAverage.heater     = -(sx * sxxx * sxxh - sx * sxh * sxxxx + sxx * sxxx * sxh - sxx * sxx * sxxh +
                                      sh * sxx * sxxxx - sh * sxxx * sxxx) / denominator;
    fSampleTempAverage.flow       = -(sx * sxxx * sxxf - sx * sxf * sxxxx + sxx * sxxx * sxf - sxx * sxx * sxxf +
                                      sf * sxx * sxxxx - sf * sxxx * sxxx) / denominator;
    fSampleTempAverage.pressure   = -(sx * sxxx * sxxp - sx * sxp * sxxxx + sxx * sxxx * sxp - sxx * sxx * sxxp +
                                      sp * sxx * sxxxx - sp * sxxx * sxxx) / denominator;
    fSampleTempTrend.measured_T   = -(- s * sxxx * sxxT + s * sxT * sxxxx - sxT * sxx * sxx + sxx * sx * sxxT +
                                      sxx * sxxx * sT - sx * sT * sxxxx) / denominator;
    fSampleTempTrend.heater       = -(- s * sxxx * sxxh + s * sxh * sxxxx - sxh * sxx * sxx + sxx * sx * sxxh +
                                      sxx * sxxx * sh - sx * sh * sxxxx) / denominator;
    fSampleTempTrend.flow         = -(- s * sxxx * sxxf + s * sxf * sxxxx - sxf * sxx * sxx + sxx * sx * sxxf +
                                      sxx * sxxx * sf - sx * sf * sxxxx) / denominator;
    fSampleTempTrend.pressure     = -(- s * sxxx * sxxp + s * sxp * sxxxx - sxp * sxx * sxx + sxx * sx * sxxp +
                                      sxx * sxxx * sp - sx * sp * sxxxx) / denominator;
    fSampleTempSecond.measured_T  =  (- sxxx * sx * sT + sx * sx * sxxT + s * sxxx * sxT - s * sxx * sxxT -
                                      sxx * sx * sxT + sxx * sxx * sT) / denominator;
    fSampleTempSecond.heater      =  (- sxxx * sx * sh + sx * sx * sxxh + s * sxxx * sxh - s * sxx * sxxh -
                                      sxx * sx * sxh + sxx * sxx * sh) / denominator;
    fSampleTempSecond.flow        =  (- sxxx * sx * sf + sx * sx * sxxf + s * sxxx * sxf - s * sxx * sxxf -
                                      sxx * sx * sxf + sxx * sxx * sf) / denominator;
    fSampleTempSecond.pressure    =  (- sxxx * sx * sp + sx * sx * sxxp + s * sxxx * sxp - s * sxx * sxxp -
                                      sxx * sx * sxp + sxx * sxx * sp) / denominator;

  }

  fSampleTempRmsqd.measured_T = 0.0;
  fSampleTempRmsqd.heater     = 0.0;
  fSampleTempRmsqd.flow       = 0.0;
  fSampleTempRmsqd.pressure   = 0.0;
  for (int i=0; i<fSampleHistoNoEntries; i++) {
    xx   = x[i] * x[i];
    help = (fSampleTempHisto[i].measured_T - fSampleTempAverage.measured_T - fSampleTempTrend.measured_T * x[i] -
            fSampleTempSecond.measured_T * xx);
    fSampleTempRmsqd.measured_T += help * help;
    help = (fSampleTempHisto[i].heater - fSampleTempAverage.heater - fSampleTempTrend.heater * x[i] -
            fSampleTempSecond.heater * xx);
    fSampleTempRmsqd.heater += help * help;
    help = (fSampleTempHisto[i].flow - fSampleTempAverage.flow - fSampleTempTrend.flow * x[i] -
            fSampleTempSecond.flow * xx);
    fSampleTempRmsqd.flow += help * help;
    help = (fSampleTempHisto[i].pressure - fSampleTempAverage.pressure - fSampleTempTrend.pressure * x[i] -
            fSampleTempSecond.pressure * xx);
    fSampleTempRmsqd.pressure += help * help;
  }
  fSampleTempRmsqd.measured_T = sqrt( fSampleTempRmsqd.measured_T ) / fSampleHistoNoEntries;
  fSampleTempRmsqd.heater     = sqrt( fSampleTempRmsqd.heater     ) / fSampleHistoNoEntries;
  fSampleTempRmsqd.flow       = sqrt( fSampleTempRmsqd.flow       ) / fSampleHistoNoEntries;
  fSampleTempRmsqd.pressure   = sqrt( fSampleTempRmsqd.pressure   ) / fSampleHistoNoEntries;

  if (fDebug) {
    std::cout << std::endl << "SampleTempTrend:";
    std::cout << std::endl << "  fSampleTempAverage (T, heater, flow, pressure):";
    std::cout << "  " << fSampleTempAverage.measured_T;
    std::cout << ", " << fSampleTempAverage.heater;
    std::cout << ", " << fSampleTempAverage.flow;
    std::cout << ", " << fSampleTempAverage.pressure;
    std::cout << std::endl << "  fSampleTempTrend   (T, heater, flow, pressure):";
    std::cout << "  " << fSampleTempTrend.measured_T;
    std::cout << ", " << fSampleTempTrend.heater;
    std::cout << ", " << fSampleTempTrend.flow;
    std::cout << ", " << fSampleTempTrend.pressure;
    std::cout << std::endl << "  fSampleTempSecond  (T, heater, flow, pressure):";
    std::cout << "  " << fSampleTempSecond.measured_T;
    std::cout << ", " << fSampleTempSecond.heater;
    std::cout << ", " << fSampleTempSecond.flow;
    std::cout << ", " << fSampleTempSecond.pressure;
    std::cout << std::endl << "  fSampleTempRmsqd   (T, heater, flow, pressure):";
    std::cout << "  " << fSampleTempRmsqd.measured_T;
    std::cout << ", " << fSampleTempRmsqd.heater;
    std::cout << ", " << fSampleTempRmsqd.flow;
    std::cout << ", " << fSampleTempRmsqd.pressure;
    std::cout << std::endl;
  }

}

//**********************************************************************
// SampleTempPrefHeaterOutput
//**********************************************************************
float PLemAutoRun::SampleTempPrefHeaterOutput(float heaterRange)
{
  float value = 0;
  int   hr = (int)heaterRange;

  if (fDebug)
    std::cout << std::endl << "in SampleTempPrefHeaterOutput: hr = " << hr;

  switch (hr) {
    case 3:
      value = 50.0;
      break;
    case 4:
      value = 40.0;
      break;
    case 5:
      value = 10.0 + 0.04 * fSampleOutput[LS336_OUTPUT_SETPOINT];
      break;
    default:
      break;
  }

  return value;
}

//**********************************************************************
// SampleTempAdjustFlow
//**********************************************************************
void PLemAutoRun::SampleTempAdjustFlow()
{
  float change = 1.0;
  float value;
  float p_heat, d_heat, pref_heat;

  if (fDebug)
    std::cout << std::endl << "in SampleTempAdjustFlow ...";

  p_heat    = -(fBHFlowPHeat0 + fBHFlowPHeat1 *
               fSampleOutput[LS336_OUTPUT_SETPOINT]) * fSampleTempTrend.datetime;

  d_heat    = fBHFlowDHeat;
  pref_heat = SampleTempPrefHeaterOutput(fSampleInput[LS336_INPUT_HEATER_RANGE]);
  change = exp( p_heat * (( fSampleInput[LS336_INPUT_HEATER] - pref_heat ) +  d_heat * fSampleTempTrend.heater ));

  value = change * fSampleOutput[fSampleBhOdbOffsetOutput+BH_OUTPUT_FLOW];

  if (fDebug) {
    std::cout << std::endl << "--------------------";
    std::cout << std::endl << "SampleTempAdjustFlow: p0 = " << fBHFlowPHeat0 << ", p1 = " << fBHFlowPHeat1;
    std::cout << std::endl << "SampleTempAdjustFlow: p_heat = " << p_heat << ", d_heat = " << d_heat << ", pref_heat = " << pref_heat;
    std::cout << std::endl << "SampleTempAdjustFlow: heater = " << fSampleInput[LS336_INPUT_HEATER] << ", dH/dt = " << fSampleTempTrend.heater;
    std::cout << std::endl << "change = " << change;
    std::cout << std::endl << "SampleTempAdjustFlow: new flow value = " << value;
  }

  if ( value > fBHMaxFlow ) value = fBHMaxFlow;
  if ( value < fBHMinFlow ) value = fBHMinFlow;

  fSampleOutputKey->SetDataIndex(&value, fSampleBhOdbOffsetOutput+BH_OUTPUT_FLOW, TID_FLOAT);

  //  also have a look at the needle valve

  SampleTempConsiderNeedleValve();
}

//**********************************************************************
// SampleTempStable
//**********************************************************************
bool PLemAutoRun::SampleTempStable()
{
  float maxdiff = fRelMaxTempDiff * fSampleInput[LS336_INPUT_SETPOINT];

  if (maxdiff < fAbsMaxTempDiff) {
    maxdiff = fAbsMaxTempDiff;
  }

  if (fDebug)
    std::cout << std::endl << "in SampleTempStable. maxdiff = " << maxdiff;

  if ( (fabs( fSampleTempAverage.measured_T - fSampleOutput[LS336_OUTPUT_SETPOINT]) < maxdiff) &&
       (fabs( fSampleTempTrend.measured_T ) < fMaxTempTrend) &&
       (fSampleTempRmsqd.measured_T < maxdiff) &&
       (fSampleTempAverage.heater > fHeaterMin) &&
       (fSampleTempAverage.heater < fHeaterMax)) {
    if (fDebug)
      std::cout << std::endl << "in SampleTempStable. stability reached.";
    return true;
  }

  return false;
}

//**********************************************************************
// SampleTempConsiderNeedleValve
//**********************************************************************
void PLemAutoRun::SampleTempConsiderNeedleValve()
{
  float value  = 1.0e6;
  float modus  = 0.0;
  float bh_valve;
  float needle_valve;
  int   size;
  float demand_flow;

  if (fDebug)
    std::cout << std::endl << "in SampleTempConsiderNeedleValve ...";

  // check the modus of the needle valve.
  size = sizeof(modus);
  fTflOutputKey->GetDataIndex(&modus, &size, SM_MODUS_NEEDLEVALVE, TID_FLOAT);

  if (fNeedleValveInUse && modus > 1.0) { // only set the needle valve when it is in_use and in auto-modus
    size = sizeof(bh_valve);
    fSampleInputKey->GetDataIndex(&bh_valve, &size, fSampleBhOdbOffsetInput + BH_INPUT_VALVE,
                                  TID_FLOAT);

    size = sizeof(needle_valve);
    fTflInputKey->GetDataIndex(&needle_valve, &size, SM_INPUT_NEEDLEVALVE, TID_FLOAT);
    if (bh_valve > 0.9) { // almost open bronkhorst needle valve
      size = sizeof(demand_flow);
      fSampleOutputKey->GetDataIndex(&demand_flow, &size,
                               fSampleBhOdbOffsetOutput + BH_OUTPUT_FLOW,
                               TID_FLOAT);
      if (demand_flow > 2.0*fSampleTempAverage.flow) // measured flow far off demand flow -> open transferline needle valve quickly
        value = needle_valve + fPrefNeedleValveAbsStep;
      else // measured flow not too far off demand flow -> open transferline needle valve more gradually
        value = ( 1.0 + fPrefNeedleValveRelStep ) * needle_valve;
    }

    // pressure on the cryo exhaust too high -> close transferline needle valve a bit
    if (fSampleTempAverage.pressure > 0.8) 
      value = ( 1.0 - fPrefNeedleValveRelStep ) * needle_valve;

    if (fDebug)
      std::cout << std::endl << "in SampleTempConsiderNeedleValve: value = " << value;

    // value still 1.0e6, i.e. nothing to be done, get out
    if (value == 1.0e6)
      return;

    // something changed, but lets check if value is out of range
    if (value > 99.0)
      value = 99.0;

    if (value < fPrefNeedleValveCof_4_0)
      value =  fPrefNeedleValveCof_4_0;

    fTflOutputKey->SetDataIndex(&value, SM_OUTPUT_NEEDLEVALVE, TID_FLOAT);
  }
}

//**********************************************************************
// SampleTempSetNeedleValve
//**********************************************************************
void PLemAutoRun::SampleTempSetNeedleValve(float value)
{
  float   modus = 0.0;
  float   tempSP = 0.0;
  int     size = sizeof(float);

  if (!fEnabled["tfl_eq"] || !fEnabled["sample_eq"]) {
    QString err  = QString("PLemAutoRun::SampleTempSetNeedleValve(): TFL(%1) and/or Sample(%2) equipment not available. Do nothing here.").arg(fEnabled["tfl_eq"]).arg(fEnabled["sample_eq"]);
    emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, err);
    return;
  }

  // get demand temperature
  fSampleOutputKey->GetDataIndex(&tempSP, &size, LS336_OUTPUT_SETPOINT, TID_FLOAT);

  // check the modus of the needlevalve.
  size = sizeof(float);
  fTflOutputKey->GetDataIndex(&modus, &size, SM_MODUS_NEEDLEVALVE, TID_FLOAT);

  // make sure that value is within proper bounds
  if (value > 100.0)
    value = 98.0;
  if (value < 0.0)
    value = 0.0;

  // only set the needle valve when it is in_use and in auto-modus
  if (fNeedleValveInUse && modus > 1.0) {
    if (tempSP < 5.0) // do not tweak NV for demand T<5K
      value = fPrefNeedleValveCof_1_0;
    fTflOutputKey->SetDataIndex((void *)&value, SM_OUTPUT_NEEDLEVALVE, TID_FLOAT);
  }
}


//**********************************************************************
// SampleTempConsiderFlow
//**********************************************************************
void PLemAutoRun::SampleTempConsiderFlow()
{
  float change = 1.0;
  float value;
  float demand;
  int   size = sizeof(float);

  if (fDebug) {
    cm_msg(MDEBUG, "SampleTempConsiderFlow", "in SampleTempConsiderFlow ...");
    cm_yield(0);
  }

  // if at large flow do nothing. Only used if no ramping while cooling
  if (fLargeFlow) 
    return;

  fSampleOutputKey->GetDataIndex(&demand, &size, fSampleBhOdbOffsetOutput + BH_OUTPUT_FLOW,
                                 TID_FLOAT);

  // if the demand value < fFlowLowestFlowToConsider (given in the XML startup file) do nothing
  if ( demand < fFlowLowestFlowToConsider ) {
    cm_msg(MINFO,"SampleTempConsiderFlow", "SampleTempConsiderFlow, demand = %e", demand);
    cm_yield(0);
    return;
  }

  // if the real flow is far off from the demand value do nothing
  if ( fabs( fSampleTempAverage.flow - demand - 150.0 ) / demand > fFlowMaxRelFlowDiffToConsider ) { // the -150 are the typical BH offset at low flow values
    cm_msg(MINFO,"SampleTempConsiderFlow",
            "SampleTempConsiderFlow: skipped consideration, demand = %e, present flow = %e",
             demand, fSampleTempAverage.flow);
    cm_yield(0);
    return;
  }

  // flow is relatively close to the demand value -> only tweak it
  if ((fSampleTempAverage.measured_T < fSampleInput[LS336_INPUT_SETPOINT]) && // it is too cold
      (fSampleTempTrend.measured_T < 0.05)   && // and it is not warming
      (fSampleTempSecond.measured_T < 0.005) && // and it is not going to warm
      (fSampleTempAverage.heater > fHeaterMax))  // while the heater is doing its utmost
            change -= fFlowFactor;               // then DECREASE flow

  if ((fSampleTempAverage.measured_T > fSampleInput[LS336_INPUT_SETPOINT]) && // it is too warm
      (fSampleTempTrend.measured_T > -0.05)   && // and it is not cooling
      (fSampleTempSecond.measured_T > -0.005) && // and it is not going to cool
      (fSampleTempAverage.heater < fHeaterMin))   // while the heater is doing nothing
            change += fFlowFactor;                // then INCREASE flow

  if (fabs( change - 1.0 ) > 0.001 ) { // change flow
    value = change * fSampleOutput[fSampleBhOdbOffsetOutput+BH_OUTPUT_FLOW];

    // try to learn from this consideration of the flow; fBHFlowTemp is used to estimate
    // the initial flow for a given temperature: flow = fBHFlowTemp/(T+fBHFlowTempOffset) + fBHFlowOffset
    fBHFlowTemp = change * fBHFlowTemp;

    if ( value > fBHMaxFlow ) 
      value = fBHMaxFlow;

    if ( value < fBHMinFlow ) 
      value = fBHMinFlow;

    cm_msg(MDEBUG, "SampleTempConsiderFlow", "SampleTempConsiderFlow: new flow=%f", value);
    cm_yield(0);

    fSampleOutputKey->SetDataIndex(&value, fSampleBhOdbOffsetOutput + BH_OUTPUT_FLOW, TID_FLOAT);
  }

  if (fDebug) {
    cm_msg(MDEBUG, "SampleTempConsiderFlow", "SampleTempConsiderFlow: new flow value = %f", fSampleTempAverage.flow * change);
    cm_msg(MDEBUG, "SampleTempConsiderFlow", "SampleTempConsiderFlow: (change = %f, fSampleTempAverage.flow = %f)", change, fSampleTempAverage.flow);
    cm_yield(0);
    std::cout << std::endl << "SampleTempConsiderFlow: new flow value = " << fSampleTempAverage.flow * change;
    std::cout << " (change = " << change << ", fSampleTempAverage.flow = " << fSampleTempAverage.flow << ")";
  }
}

//**********************************************************************
// CheckTempStability
//**********************************************************************
void PLemAutoRun::CheckTempStability()
{
  QString err;

  if (!fEnabled["sample_eq"])
    return;

  if (!fSampleFeRunning)
    return;

  static int tempDeviationToHighCounter = 0; // counter needed to eliminate error messages due to readback errors

  if (fDebug)
    std::cout << std::endl << "in CheckTempStability ...";

  if ((fSampleInput[fSampleCtrlCh] <= 0.0) && !fIgnoreAlarms) { // CF1 or CF2 temperature <= 0, i.e. frontend error
    err  = QString("PLemAutoRun::CheckTempStability(): CF1 readback = %1. ").arg(fSampleInput[fSampleCtrlCh]);
    err += QString("Does not make any sense!");
    emit ErrorMsg(1, 0, LAR_LS_INPUT_NONSENSE, -1, err);
    return;
  }

  if (!fSampleTempRegulation) { // no temperature adjustment wanted
    if (fabs(fSampleInput[LS336_INPUT_SETPOINT]-fSampleInput[fSampleCtrlCh]) > fSampleTempAccuracy) {
      if (!fSampleTempUnstable) { // to reduce the number of error messages
        fSampleTempUnstable = true;
        err  = QString("PLemAutoRun::CheckTempStability(): | Setpoint=%1 ").arg(fSampleInput[LS336_INPUT_SETPOINT]);
        err += QString("- CF1=%1 | > %2").arg(fSampleInput[fSampleCtrlCh]).arg(fSampleTempAccuracy);
        emit ErrorMsg(1, 0, LAR_LS_TEMP_NOT_STABLE, -1, err);
      }
    } else {
      fSampleTempUnstable = false;
    }
    return;
  }

  // feed history ring buffer ----------------------------------------------
  // get LS340/LS336 date and time
  fSampleHistoTime = ss_time();
  if (fSampleHistoTime != fSampleHistoLastTime)
    fSampleHistoLastTime = fSampleHistoTime; // keep as previous time for next time
  else
    return; // no new timestamp available, therefore return

  // update counter of how many elements are present in the history buffer
  if (fSampleHistoNoEntries < SAMPLE_TEMP_HISTO_MAX)
    fSampleHistoNoEntries++;
  // feed data to the history buffer
  fSampleTempHisto[fSampleHistoPos].datetime   = fSampleHistoTime;
  fSampleTempHisto[fSampleHistoPos].measured_T = fSampleInput[fSampleCtrlCh];
  fSampleTempHisto[fSampleHistoPos].demand_T   = fSampleInput[LS336_INPUT_SETPOINT];
  fSampleTempHisto[fSampleHistoPos].heater     = fSampleInput[LS336_INPUT_HEATER];
  fSampleTempHisto[fSampleHistoPos].flow       = fSampleInput[fSampleBhOdbOffsetInput+BH_INPUT_FLOW];
  fSampleTempHisto[fSampleHistoPos].pressure   = fSampleInput[LS336_INPUT_PRESSURE];
  // increment history buffer counter modulo its length
  fSampleHistoPos = (fSampleHistoPos + 1) % SAMPLE_TEMP_HISTO_MAX;

  QString datetime;
  if (fDebug) {
    std::cout << std::endl << "Timedate History: " << fSampleHistoPos << std::endl;
    for (int i=0; i<SAMPLE_TEMP_HISTO_MAX; i++) {
      if (i>fSampleHistoNoEntries)
        break;
      datetime.setNum(fSampleTempHisto[i].datetime, 'f', 2);
      std::cout << datetime.toLatin1().data() << ", ";
    }
    std::cout << std::endl;
    std::cout << std::endl << "Temperature History: " << fSampleHistoPos << std::endl;
    for (int i=0; i<SAMPLE_TEMP_HISTO_MAX; i++) {
      if (i>fSampleHistoNoEntries)
        break;
      std::cout << fSampleTempHisto[i].measured_T << ", ";
    }
    std::cout << std::endl;
  }

  // calculate trend parameters
  SampleTempTrend();

  // check if temperature within the required boundaries
  if (fabs(fSampleInput[LS336_INPUT_SETPOINT]-fSampleInput[fSampleCtrlCh]) > fSampleTempAccuracy) {
    tempDeviationToHighCounter++;
    if (!fSampleTempUnstable && (tempDeviationToHighCounter > 5)) { // to reduce the number of error messages
      fSampleTempUnstable = true;
      err  = QString("PLemAutoRun::CheckTempStability(): | Setpoint=%1 ").arg(fSampleInput[LS336_INPUT_SETPOINT]);
      err += QString("- CF1=%1 | > %2").arg(fSampleInput[fSampleCtrlCh]).arg(fSampleTempAccuracy);
      emit ErrorMsg(1, 0, LAR_LS_TEMP_NOT_STABLE, -1, err);
    }
  } else {
    tempDeviationToHighCounter = 0;
  }
}

//**********************************************************************
// CheckTempStabilityOvenOmega
//**********************************************************************
void PLemAutoRun::CheckTempStabilityOvenOmega()
{
  QString err;

  if (!fEnabled["sample_eq"])
    return;

  if (!fSampleOvenOmegaFeRunning)
    return;

  fSampleTempAccuracy = 2.0; // the omega controller has an accuracy of 1°C only!!
  if (fabs(fSampleOvenOmegaInput[OMEGA_OVEN_INPUT_TEMP]-fSampleOvenOmegaOutput[OMEGA_OVEN_OUTPUT_SETPOINT]) > fSampleTempAccuracy) {
    if (!fSampleTempUnstable) { // to reduce the number of error messages
      fSampleTempUnstable = true;
      err  = QString("PLemAutoRun::CheckTempStabilityOvenOmega(): | Setpoint=%1 ").arg(fSampleOvenOmegaOutput[OMEGA_OVEN_OUTPUT_SETPOINT]);
      err += QString("- Temp.Measured=%1 | > %2").arg(fSampleOvenOmegaInput[OMEGA_OVEN_INPUT_TEMP]).arg(fSampleTempAccuracy);
      emit ErrorMsg(1, 0, LAR_LS_TEMP_NOT_STABLE, -1, err);
    }
  } else {
    fSampleTempUnstable = false;
  }
}

//**********************************************************************
// UpdateWebPage
//**********************************************************************
void PLemAutoRun::UpdateWebPage(PAutoRunCmdVector::Iterator currentIter, int tag, int errLineNo, QString errMsg)
{
  PAutoRunCmdVector::Iterator iter;
  QFile file(fXMLAutoRunHTML);

  // open HTML file
  if ( !file.open( QIODevice::WriteOnly ) ) { // couldn't open file
    QString err  = QString("PLemAutoRun::UpdateWebPage(): Couldn't open %1").arg(fXMLAutoRunHTML);
    emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, err);
    return;
  }

  // write HTML code
  QTextStream stream( &file );

  // write HTML start tag
  stream << "<html>" << Qt::endl;

  // write header
  stream << "  <head>" << Qt::endl;
  stream << "<link rel=\"stylesheet\" href=\"mhttpd.css\" type=\"text/css\" />" << Qt::endl;
  stream << "    <title>LEM Autorun Parameter Page</title>" << Qt::endl;
  stream << "    <meta http-equiv=\"Refresh\" content=\"30\">" << Qt::endl;
  stream << "    <script type=\"text/javascript\" src=\"mhttpd.js\"></script>" << Qt::endl;
  stream << "    <script type=\"text/javascript\" src=\"midas.js\"></script>" << Qt::endl;
  stream << "    <script type=\"text/javascript\" src=\"obsolete.js\"></script>" << Qt::endl;
  stream << "    <script type=\"text/javascript\">" << Qt::endl;
  stream << "      var lar_state;" << Qt::endl;
  stream << "      function lar_running()" << Qt::endl;
  stream << "      {" << Qt::endl;
  stream << "        var result=confirm(\"Are you sure you want to start the autorun?\")" << Qt::endl;
  stream << "        if (result==true) {" << Qt::endl;
  stream << "          ODBSet(\"/AutoRun/Run State\", \"2\");" << Qt::endl;
  stream << "          setTimeout(\"lar_refresh()\", 4000);" << Qt::endl;
  stream << "        }" << Qt::endl;
  stream << "      }" << Qt::endl;
  stream << Qt::endl;
  stream << "      function lar_resume()" << Qt::endl;
  stream << "      {" << Qt::endl;
  stream << "        ODBSet(\"/AutoRun/Run State\", \"3\");" << Qt::endl;
  stream << "        setTimeout(\"lar_refresh()\", 4000);" << Qt::endl;
  stream << "      }" << Qt::endl;
  stream << Qt::endl;
  stream << "      function lar_stop()" << Qt::endl;
  stream << "      {" << Qt::endl;
  stream << "        var result=confirm(\"Are you sure you want to stop the autorun?\")" << Qt::endl;
  stream << "        if (result==true) {" << Qt::endl;
  stream << "          ODBSet(\"/AutoRun/Run State\", \"0\");" << Qt::endl;
  stream << "          setTimeout(\"lar_refresh()\", 4000);" << Qt::endl;
  stream << "        }" << Qt::endl;
  stream << "      }" << Qt::endl;
  stream << Qt::endl;
  stream << "      function lar_pause()" << Qt::endl;
  stream << "      {" << Qt::endl;
  stream << "        ODBSet(\"/AutoRun/Run State\", \"1\");" << Qt::endl;
  stream << "        setTimeout(\"lar_refresh()\", 4000);" << Qt::endl;
  stream << "      }" << Qt::endl;
  stream << Qt::endl;
  stream << "      function lar_load()" << Qt::endl;
  stream << "      {" << Qt::endl;
  stream << "        ODBSet(\"/AutoRun/Run State\", \"4\");" << Qt::endl;
  stream << "        setTimeout(\"lar_refresh()\", 4000);" << Qt::endl;
  stream << "      }" << Qt::endl;
  stream << Qt::endl;
  stream << "      function lar_refresh()" << Qt::endl;
  stream << "      {" << Qt::endl;
  stream << "        window.location.reload(true);" << Qt::endl;
  stream << "      }" << Qt::endl;
  stream << "      function compProp(prop_odb) {" << Qt::endl;
  stream << "        fetch('https://duo.psi.ch/duo/rest.php/cal/smus/lem?SECRET=change-bib-eva-grille',{method:'POST'})" << Qt::endl;
  stream << "           .then( data => data.json(), console.error)" << Qt::endl;
  stream << "           .then( data => {" << Qt::endl;
  stream << "                           console.log('propid_duo:', data.proposal);" << Qt::endl;
  stream << "                           if (data.proposal != prop_odb ) {" << Qt::endl;
  stream << "                             alert(\"The proposal number does NOT match the official schedule!\");" << Qt::endl;
  stream << "                           }" << Qt::endl;
  stream << "                          });" << Qt::endl;
  stream << "      }" << Qt::endl;
  stream << "      mjsonrpc_db_get_values([\"/Info/File_Header_Info/Proposal Number\"])" << Qt::endl;
  stream << "      .then(function(rpc) {console.log('propid_odb:', rpc.result.data[0]);" << Qt::endl;
  stream << "                           compProp(rpc.result.data[0]);});" << Qt::endl;
  stream << "      " << Qt::endl;
  stream << "      " << Qt::endl;
  stream << "      " << Qt::endl;
  stream << "    </script>" << Qt::endl;
  stream << "  </head>" << Qt::endl;

  // write body
  stream << "  <body style=\"font-size: 10pt;\">" << Qt::endl;
  stream << "    <form name=\"form1\" method=\"Get\" action=\"/CS/AutoRun&\">" << Qt::endl;
  stream << "      <input type=\"hidden\" name=\"exp\" value=\"" << fExpName.toLatin1().data() << "\">" << Qt::endl;
  stream << "      <table border=3 cellpadding=2 class=\"genericTable\">" << Qt::endl;
  stream << "        <tr><th colspan=3 class=\"subStatusTitle\">NEMU Experiment: Autorun Parameters</th></tr>" << Qt::endl;
  stream << "        <tr><td colspan=3>" << Qt::endl;
  stream << "          <input value=\"Status\" name=\"cmd\" type=\"submit\">" << Qt::endl;
  stream << "          <input value=\"ODB\" name=\"cmd\" type=\"submit\">" << Qt::endl;
  stream << "          <input value=\"Messages\" name=\"cmd\" type=\"submit\">" << Qt::endl;
  stream << "        </td></tr>" << Qt::endl;
  stream << "        <tr><td colspan=3 style=\"text-align:left;\">" << Qt::endl;
  stream << "          <script type=\"text/javascript\">" << Qt::endl;
  stream << "            lar_state = ODBGet('/AutoRun/Run State');" << Qt::endl;
  stream << "            if ((lar_state == 0) || (lar_state == 2) || (lar_state == 4) || (lar_state == 5)) { // stopped or starting up" << Qt::endl;
  stream << "              document.write('<input type=\"button\" value=\"Start AutoRun\" onclick=\"lar_running()\">');" << Qt::endl;
  stream << "              document.write('<input type=\"button\" value=\"Load Sequence\" onclick=\"lar_load()\">');" << Qt::endl;
  stream << "            } else if (lar_state == 1) { // paused" << Qt::endl;
  stream << "              document.write('<input type=\"button\" value=\"Resume AutoRun\" onclick=\"lar_resume()\">');" << Qt::endl;
  stream << "            } else { // running" << Qt::endl;
  stream << "              document.write('<input type=\"button\" value=\"Stop AutoRun\" onclick=\"lar_stop()\">');" << Qt::endl;
  stream << "              document.write('  ');" << Qt::endl;
  stream << "              document.write('<input type=\"button\" value=\"Pause AutoRun\" onclick=\"lar_pause()\">');" << Qt::endl;
  stream << "            }" << Qt::endl;
  stream << "          </script>" << Qt::endl;
  stream << "        </td></tr>" << Qt::endl;
  stream << "        <tr><td class=\"ODBtableEven\" colspan=3 style=\"text-align:left;\">Sample Name: <b><odb src=\"/Info/Sample Name\" edit=2></b></td>" << Qt::endl;
  stream << "        <tr><td class=\"ODBtableOdd\" colspan=2 style=\"text-align:left;\">Proposal Number: <b><odb src=\"/Info/File_Header_Info/Proposal Number\" edit=2></b></td>" << Qt::endl;
  stream << "            <td class=\"ODBtableOdd\" style=\"text-align:left;\">PI: <b><odb src=\"/Info/File_Header_Info/Main Proposer\" edit=2></b></td>" << Qt::endl;
  stream << "        <tr><td class=\"ODBtableOdd\" colspan=2 style=\"text-align:left;\">Sequence: <b><odb src=\"/AutoRun/Auto Run Sequence\" edit=2></b></td>" << Qt::endl;
  stream << "            <td class=\"ODBtableOdd\" style=\"text-align:left;\">Show Comments: <b><odb src=\"/AutoRun/Show Comments\" edit=2></b></td></tr>" << Qt::endl;
  stream << "        <tr><td class=\"ODBtableEven\" colspan=2 style=\"text-align:left;\">Goto Line: <b><odb src=\"/AutoRun/GotoLine\" edit=2></b></td>" << Qt::endl;
  stream << "            <td class=\"ODBtableEven\" style=\"text-align:left;\">Next    : <b><odb src=\"/AutoRun/Next\" edit=2></b></td></tr>" << Qt::endl;
  stream << "        <tr><td colspan=3 style=\"text-align:left;\">Status  : <b><odb src=\"/AutoRun/Status\" edit=0></b></td></tr>" << Qt::endl;

  // write sequence
  stream << "        <tr><td colspan=3 style=\"text-align:left;font-family:Fixed;line-height:1.25\" bgcolor=\"#FFFFFF\">" << Qt::endl;
  stream << "          <pre>" << Qt::endl;

  if (tag == HTML_PARSE_ERROR) { // handle errors
    if (errLineNo > 0) {
      // get input file name
      QString pathFln = fAutoRunPath + GetAutoRunSequence();
      // read input file
      QFile f(pathFln);
      QTextStream fstream(&f);
      QString line;
      int lineNo = 1;
      if (f.exists()) {
        f.open(QIODevice::ReadOnly);
        while (!fstream.atEnd()) {
          line = fstream.readLine();
          stream << lineNo << ": " << line << Qt::endl;
          if (lineNo == errLineNo) {
            stream << "<span style=\"background-color: #FF8800;font-weight: bold;\">" << errMsg.toLatin1().data() << "</span>";
            stream << Qt::endl;
          }
          lineNo++;
        }
        f.close();
      } else {
        stream << "<span style=\"background-color: #FF8800;font-weight: bold;\">" << errMsg.toLatin1().data() << "</span>";
      }
    } else {
      stream << "<span style=\"background-color: #FF8800font-weight: bold;\">" << errMsg.toLatin1().data() << "</span>";
    }
  } else if (tag == HTML_FATAL) {
      stream << "<span style=\"background-color: #FF0000font-weight: bold;\">" << errMsg.toLatin1().data() << "</span>";
  } else { // normal command handling 
    QString cmd;

    if (tag == HTML_LOAD) {
      QDateTime dt = QDateTime::currentDateTime();
      cmd = QString("<span style=\"background-color: #11FF11;font-weight: bold;\">&gt;&gt; %1: SEQUENCE LOADED ONLY, PRESS START AUTORUN BOTTOM IF YOU WANT TO START IT &lt;&lt;</span>").arg(dt.toString("dd.MM.yy, hh:mm:ss"));
      stream << cmd << Qt::endl;
    }

    // write commands
    int width = 0, count = 0;
    if (fAutoRunCmdVector->count()>0)
      width = (int)(log10(fAutoRunCmdVector->count())+1);
    for (iter = fAutoRunCmdVector->begin(); iter != fAutoRunCmdVector->end(); ++iter) {

      if (!ShowComments() && (iter->cmd == "comment"))
        continue;

      if ((iter == currentIter) && (tag != HTML_LOAD)) // current command start
        cmd  = "<span style=\"background-color: #FFFF00;font-weight: bold;\">";
      else
        cmd  = "";

      count++;
      cmd += QString("%1 (%2):  ").arg(count, width).arg(iter->lineNo, width);

      // command
      if (iter->cmd == "comment")
        cmd += "<span style=\"color:grey;font-style:italic\">";

      cmd += iter->cmdString;

      if (iter->cmd == "comment")
        cmd += "</span>";

      if (iter == currentIter) { // current command end
        if (tag == HTML_ABORTED) {
          if (!errMsg.isEmpty())
            cmd += QString("\n<span style=\"background-color: #FF0000;font-weight: bold;\">%1</span></span>").arg(errMsg);
          cmd += "\n<span style=\"background-color: #FF0000;font-weight: bold;\">AUTORUN ABORTED ...</span></span>";
        } else if (tag == HTML_WARMUP) {
          cmd += "\nEXECUTING WARMUP COMMAND ...</span>";
        } else if (tag == HTML_ALARM) {
          cmd += "\n<span style=\"background-color: #FF0000;font-weight: bold;\">ALARM FIRED, HENCE AUTORUN STOPPED...</span></span>";
        } else if (tag == HTML_STRANGE) {
          cmd += "\n<span style=\"background-color: #FF0000;font-weight: bold;\">THERE IS ALREADY A RUN GOING ON. AUTORUN WILL ONLY START THE FIRST COMMAND AFTER THE CURRENT RUN WILL BE STOPPED ...</span></span>";
        } else {
          cmd += "</span>";
        }
      }
  
      stream << cmd << Qt::endl;
    }
  
    if (tag == HTML_STOP) {
      cmd = "<span style=\"background-color: #FFFF00;font-weight: bold;\">AUTORUN FINISHED ...</span>";
      stream << cmd << Qt::endl;
    }
  }
  
  stream << "          </pre>" << Qt::endl;
  stream << "        </td></tr>" << Qt::endl;
  stream << "      </table>" << Qt::endl;
  stream << "    </form>" << Qt::endl;
  stream << "  </body>" << Qt::endl;

  // write HTML end tag
  stream << "</html>" << Qt::endl;

  file.close();
}

//**********************************************************************
// FeedLiveDataAutoRun
//**********************************************************************
void PLemAutoRun::FeedLiveDataAutoRun()
{
  // delete /AutoRun/LiveData/AutoRun
  HNDLE hKey;
  INT status = db_find_key(fExp->GetHdb(), 0, "/AutoRun/LiveData/AutoRun", &hKey);
  if (status == DB_SUCCESS) { // key found, hence delete it
    status = db_delete_key(fExp->GetHdb(), hKey, TRUE);
  }

  // get input file name from the current lar-file
  QString pathFln = fAutoRunPath + GetAutoRunSequence();

  // read current lar-file
  QFile f(pathFln);
  QTextStream fstream(&f);
  QString line;
  QVector<QString> data;
  if (f.exists()) {
    f.open(QIODevice::ReadOnly);
    while (!fstream.atEnd()) {
      line = fstream.readLine();
      data.push_back(line);
    }
    f.close();
  }

  // create /AutoRun/LiveData/AutoRun from the current lar-file
  char str[128];
  for (int i=0; i<data.size(); i++) {
    memset(str, 0, sizeof(str));
    strncpy(str, data[i].toLatin1(), sizeof(str));
    status = db_set_value_index(fExp->GetHdb(), 0, "/AutoRun/LiveData/AutoRun", str, sizeof(str), i, TID_STRING, FALSE);
  }
}

//**********************************************************************
// ExecAutoRun
//**********************************************************************
void PLemAutoRun::ExecAutoRun()
{
  PAutoRunCmdVector::Iterator iter;
  int  size;
  bool stopped;
  bool aborted = false;
  int  maxCount = 0;

  // paranoia check to make sure that there are really autorun commands present
  if (fAutoRunCmdVector->size() == 0) {
    QString msg("**FATAL ERROR** no autorun commands present!!");
    UpdateWebPage(fAutoRunCmdVector->begin(), HTML_FATAL, 0, msg);
    emit ErrorMsg(1, 0, LAR_FATAL, 0, msg);
    return;
  }

  // check that the magnet parameters are within range
  QString err("");
  int pos = CheckFieldCmd(err);
  if (pos != -1) {
    UpdateWebPage(fAutoRunCmdVector->begin(), HTML_PARSE_ERROR, pos, err);
    emit ErrorMsg(1, 0, LAR_FATAL, 0, err);
    return;
  }

  // check for a warmup command
  CheckForWarmUpCmd();

  // check if ODB_SET_DATA commands are present and if yes, check if the ODB path etc make sense
  CheckForOdbSetDataCmds();

  // check if a TRANSPORT_HV <fln> command is present, and if yes, check if <fln> exists and is loadable
  if (!CheckForTransportHvCmd())
    return;

  // check if there is a setTemp command and if yes, set the sample LS340 ZONE settings
  // (in case somebody was fooling around with the LS340 sample, this will fix it)
  SetSampleLSZoneSettings();

  // autorun command counters
  fNoOfAutoRunCmds = fAutoRunCmdVector->count();
  // remove all the comments from the total number of autorun commands
  iter = fAutoRunCmdVector->begin();
  do {
    if (iter->cmd == "comment")
      fNoOfAutoRunCmds--;
      if (iter->lineNo > maxCount) // get the largest line number
        maxCount = iter->lineNo;
      iter++;
  } while (iter != fAutoRunCmdVector->end());
  fCurrentAutoRunCmd = 1;

  // key to set the transition tag
  PKey transTagKey(fExp, "/AutoRun/LiveData/TransitionTag");
  if (!transTagKey.IsValid()) {
    QString msg("**FATAL ERROR** cannot get necessary key /AutoRun/LiveData/TransitionTag!");
    UpdateWebPage(fAutoRunCmdVector->begin(), HTML_FATAL, 0, msg);
    emit ErrorMsg(1, 0, LAR_FATAL, 0, msg);
    return;
  }
  int ival=LAR_TT_IDLE;
  transTagKey.SetData((void*)&ival, 1, TID_INT);

  // check if only load is wanted
  int runState = GetRunState();
  if ((runState == LAR_STATE_LOAD) || (runState == LAR_STATE_LOADING)) {
    // set autorun state to stopped
    UpdateRunState(LAR_STATE_STOPPED);

    QString msg("Loading Sequence ...");
    UpdateStatusMsg(msg);

    iter = fAutoRunCmdVector->begin();
    UpdateWebPage(iter, HTML_LOAD);

    return;
  }

  // check if there is already an ongoing run before entering the main loop
  // runningWhenStarting is needed to check the following:
  // run already underway when autorun is starting. If yes, make sure that the first
  // real command is a STOP and nothing else.
  bool runningWhenStarting = false;
  // get current runinfo state
  size = sizeof(fRunInfo);
  fRunInfoKey->GetRecord((void *)&fRunInfo, &size);
  if ((fRunInfo.state == RUN_RUNNING) || (fRunInfo.state == RUN_PAUSED))
    runningWhenStarting = true;

  // key to the live data line number
  PKey lineNoKey(fExp, "/AutoRun/LiveData/CurrentLineNo");
  if (!lineNoKey.IsValid()) {
    QString msg("**FATAL ERROR** cannot get necessary key /AutoRun/LiveData/CurrentLineNo!");
    UpdateWebPage(fAutoRunCmdVector->begin(), HTML_FATAL, 0, msg);
    emit ErrorMsg(1, 0, LAR_FATAL, 0, msg);
    return;
  }
  // key to the live data loop value
  PKey loopValKey(fExp, "/AutoRun/LiveData/LoopVal");
  if (!loopValKey.IsValid()) {
    QString msg("**FATAL ERROR** cannot get necessary key /AutoRun/LiveData/LoopVal!");
    UpdateWebPage(fAutoRunCmdVector->begin(), HTML_FATAL, 0, msg);
    emit ErrorMsg(1, 0, LAR_FATAL, 0, msg);
    return;
  }

  // loop over all commands
  iter = fAutoRunCmdVector->begin();
  do {
    // set current line number for the live data
    lineNoKey.SetData(&(iter->lineNo), 1, TID_INT);

    // set potential loop value
    char loopValStr[32];
    memset(loopValStr, 0, sizeof(loopValStr));
    if (iter->loopVal.isEmpty())
      strncpy(loopValStr, "empty", sizeof(loopValStr));
    else
      strncpy(loopValStr, iter->loopVal.toLatin1().data(), sizeof(loopValStr));
    loopValKey.SetData(loopValStr, 1, TID_STRING);

    // get current runinfo state
    size = sizeof(fRunInfo);
    fRunInfoKey->GetRecord((void *)&fRunInfo, &size);

    // check if somebody was starting an autorun while a run is already underway
    if (((fRunInfo.state == RUN_RUNNING) || (fRunInfo.state == RUN_PAUSED)) && runningWhenStarting &&
        !((iter->cmd == "setWait") || (iter->cmd == "runStop") ||
          (iter->cmd == "warmUp") || (iter->cmd == "alias") || (iter->cmd == "comment") ||
          (iter->cmd == "odbTag"))) {
      UpdateWebPage(iter, HTML_STRANGE);
    } else {
      UpdateWebPage(iter, HTML_RUNNING);
    }

    // handle alias, odbTag and comment independently of the run state
    if ((iter->cmd == "alias") || (iter->cmd == "odbTag") || (iter->cmd == "comment")) {
      iter++;
      if (iter == fAutoRunCmdVector->end())
        break;
      if ((iter->cmd == "alias") || (iter->cmd == "odbTag"))
        fCurrentAutoRunCmd++;
      UpdateWebPage(iter, HTML_RUNNING);
      continue;
    }

    // handle run stop command
    if (((fRunInfo.state == RUN_RUNNING) || (fRunInfo.state == RUN_PAUSED)) &&
        (iter->cmd == "runStop") && fRunStopped) {
      UpdateWebPage(iter, HTML_RUNNING);
      RunStop(iter);
    } else if ((fRunInfo.state == RUN_STOPPED) && (iter->cmd == "runStop")) { // i.e. run stop and STOP cmd pending: this doesn't make any sense
      QString err("STOP cmd for a stopped run doesn't make any sense. Will change the STOP to a START cmd!");
      emit ErrorMsg(1, 0, LAR_STOP_STOP_NONSENSE, -1, err);
      iter->cmd = "runStart";
      iter->cmdString = "START " + iter->param[0];
      if (iter->noElements == 2) {
        iter->cmdString += " sec";
      }
    }

    // check if a run needs to be stopped
    stopped = RunStopCheck();
    if (stopped) {
      runningWhenStarting = false;
      iter++;
      if (iter == fAutoRunCmdVector->end())
        break;
    }

    runState = GetRunState();
    if (runState == LAR_STATE_STOPPED) {
      UpdateWebPage(iter, HTML_ABORTED);
      aborted = true;
      continue;
    }
        
    // do next command only if run is stopped, TD rate HV trip didn't fire, and autorun not paused
    runState = GetRunState();
    if ((fRunInfo.state == RUN_STOPPED) && !fHvTripFlag && (runState != LAR_STATE_PAUSED)) {
      runningWhenStarting = false;

      // check for goto command
      if (GetGotoLine() > 0) {
        GotoLine(iter, maxCount);
      }

      UpdateWebPage(iter, HTML_RUNNING);
      // filter the command and execute it
      if (iter->cmd == "runStart") {
        RunStart(iter);
      } else if (iter->cmd == "degaussWEW") {
        DegaussWEW(iter);
        iter++;
      } else if (iter->cmd == "degaussDanfysik") {
        DegaussDanfysik(iter);
        iter++;
      } else if (iter->cmd == "degaussMagnet") {
        Degauss(iter);
        iter++;
      } else if (iter->cmd == "degaussSpinRot") {
        DegaussSpinRot(iter);
        iter++;
      } else if (iter->cmd == "ignore_alarms") {
        SetIgnoreAlarms(iter);
        iter++;
      } else if (iter->cmd == "ignore_clients") {
        SetIgnoreClients(iter);
        iter++;
      } else if (iter->cmd == "setBPV") {
        SetBPV(iter);
        iter++;
      } else if (iter->cmd == "setDump") {
        SetDump(iter);
        iter++;
      } else if (iter->cmd == "setFOM") {
        SetFOM(iter);
        iter++;
      } else if (iter->cmd == "setFieldWEWL") {
        SetFieldWEWL(iter);
        iter++;
      } else if (iter->cmd == "setFieldWEWH") {
        SetFieldWEWH(iter);
        iter++;
      } else if (iter->cmd == "setFieldDanfysik") {
        SetFieldDanfysik(iter);
        iter++;
      } else if (iter->cmd == "setField") {
        SetField(iter);
        iter++;
      } else if (iter->cmd == "setSpinRot") {
        SetSpinRot(iter);
        iter++;
      } else if (iter->cmd == "setLEMSetup") {
        SetLEMSetup(iter);
        iter++;
      } else if (iter->cmd == "setModInfo") {
        SetModInfo(iter);
        iter++;
      } else if (iter->cmd == "setOdbData") {
        SetOdbData(iter);
        iter++;
      } else if (iter->cmd == "setOdbDataArray") {
        SetOdbDataArray(iter);
        iter++;
      } else if (iter->cmd == "setSampleHV") {
        SetSampleHV(iter);
        iter++;
      } else if (iter->cmd == "setRA_HV") {
        SetRA_HV(iter);
        iter++;
      } else if (iter->cmd == "setTransportHV") {
        SetTransportHV(iter);
        iter++;
      } else if (iter->cmd == "setHVOff") {
        SetHvOff(iter);
        iter++;
      } else if (iter->cmd == "setTfl") {
        SetTfl(iter);
        iter++;
      } else if (iter->cmd == "setTemp") {
        SetTemp(iter);
        iter++;
      } else if (iter->cmd == "setTitle") {
        SetTitle(iter);
        iter++;
      } else if (iter->cmd == "setTOF") {
        SetTof(iter);
        iter++;
      } else if (iter->cmd == "setWait") {
        SetWait(iter);
        iter++;
      } else if (iter->cmd == "warmUp") { // already taken care of, just increment iterator
        iter++;
        fCurrentAutoRunCmd++;
      }
      fAutoRunCurrentIter = iter;
    }

    // feed midas watchdog
    fExp->FeedMidasWatchdog();

    // check temperature stability
    if (fSampleCryoInUse == CRYO_OVEN_OMEGA)
      CheckTempStabilityOvenOmega();
    else
      CheckTempStability();

    // see whether the raw voltage should be dumped to file
    if (fDumpInUse) {
      if (fDumpCounter > 0) {
        RawVoltageDump();
      } else {
        fDumpFile.close();
        fDumpInUse = false;
      }
    }

    if (fSampleCryoInUse == CRYO_KONTI) {
      // adjust flow
      if ( fSampleTempRegulation && (!fSampleTempUnstable) && (fSampleHistoNoEntries >= SAMPLE_TEMP_HISTO_MAX) ) {
        SampleTempAdjustFlow();
      }
    }

    // check alarm system
    CheckMidasAlarms(iter);

    // sleep for 5 sec before proceeding to keep the system happy
    Wait(5000);

    // check if the warmup command needs to be executed
    if (fWarmUpWished && (QDateTime::currentDateTime() > fWarmUpDateTime)) {
      fWarmUpWished = false;
      WarmUp(iter);
      break;
    }

  } while ((iter != fAutoRunCmdVector->end()) && !aborted);

  if (!aborted) {
    // auto run finished before warm up timer kicked in, therefore warm up now
    if (fWarmUpWished) {
      int ival = LAR_TT_WARMUP;
      transTagKey.SetData((void*)&ival, 1, TID_INT);
      WarmUp(iter);
    }
    int ival = LAR_TT_FINISHED;
    transTagKey.SetData((void*)&ival, 1, TID_INT);

    // increment CurrentLineNo so that nothing is 'active' anymore on the web-page
    int size = sizeof(ival);
    lineNoKey.GetData((void*)&ival, &size, TID_INT);
    ival += 1;
    lineNoKey.SetData((void*)&ival, 1, TID_INT);

    // update status
    QString msg = QString("Autorun finished.");
    emit StatusMsg(msg);

    UpdateWebPage(0, HTML_STOP);
    Wait(5000);

    // handle autoRunState
    PKey nextAutoRun(fExp, "/AutoRun/Next");
    if (nextAutoRun.IsValid()) {
      char next[64];
      int size = sizeof(next);
      nextAutoRun.GetData(next, &size, TID_STRING);
      int runState = LAR_STATE_NEXT;
      if (!strcmp(next, "none")) { // set autoRunState to stopped
        runState = LAR_STATE_STOPPED;
      }
      UpdateRunState(runState);
    }
  } else { // aborted
    int ival = LAR_TT_ABORTED;
    transTagKey.SetData((void*)&ival, 1, TID_INT);
  }
}

//**********************************************************************
// RunStart
//**********************************************************************
void PLemAutoRun::RunStart(AutoRunCmd *arc)
{
  // param: [0] events/time, [[1] "sec"]

  int status, size;
  QString msg, err;

  msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;

  if (arc->noElements == 1) {
    fRunCheckEvents = true;
  } else {
    fRunCheckEvents = false;
    fRunTimeout = arc->param[0].toFloat();
  }
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  // check if the vme frontend and analyzer are enabled
  if (!fEnabled["vme_fe"] || !fEnabled["analyzer_fe"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    QString err  = msg + QString("PLemAutoRun::RunStart(): VME_FE(%1) and/or Analyzer(%2) not enabled. Do nothing here.").arg(fEnabled["vme_fe"]).arg(fEnabled["analyzer_fe"]);
    emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, err);
    fCurrentAutoRunCmd++;
    return;
  }

  // check if frontend and analyzer are running
  CheckClients();
  if (!fFrontendRunning || !fAnalyzerRunning) { // frontend or analyzer NOT running
    err = QString("PLemAutoRun::RunStart: ");
    if (!fFrontendRunning)
      err += QString(" %1 ").arg(fFrontendName);
    if (!fAnalyzerRunning)
      err += QString(" %1 ").arg(fAnalyzerName);
    err += QString("not running, will stop! Fix it first ;-)");
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED, 0, err);
    emit ErrorMsg(1, 0, LAR_MIDAS_FE_NOT_RUNNING, -1, err);
    DisconnectFromExp();
    QCoreApplication::exit(0);
    exit(0);
  }

  if (fEnabled["lemvac_scfe"]) { // only check BPVX/Y if LEMVAC is enableds
    // check the BPVX/Y state
    GetBPV(); // get the current state of the BPVX/Y
    if (fLemVacValveInitialState[BPVX] == BPV_STATE_CLOSED) { // BPVX closed
      err = QString("PLemAutoRun::RunStart: BPVX still closed! Check also sample regions HV's");
      emit ErrorMsg(1, 0, LAR_BPV_CLOSED_AT_RUN_START, -1, err);
    }
    if (fLemVacValveInitialState[BPVY] == BPV_STATE_CLOSED) { // BPVY closed
      err = QString("PLemAutoRun::RunStart: BPVY still closed! Check also sample regions HV's");
      emit ErrorMsg(1, 0, LAR_BPV_CLOSED_AT_RUN_START, -1, err);
    }
  }

  if (fEnabled["fug_eq"]) { // only check FUG's if enabled
    // check if RA HV's are set for Bpar, and for Bperp < 130G
    float fval;
    if (fFieldPwrSupply == "danfysik") { // Bpar
      for (int i=HV_FUG_RAL; i<=HV_FUG_RAB; i++) {
        size = sizeof(fval);
        fHVDemandKey->GetDataIndex(&fval, &size, i, TID_FLOAT);
        if (fval < 0.2) {
          err = QString("PLemAutoRun::RunStart: RA HV's < 0.2kV! Unlikely to be correct, please check!");
          emit ErrorMsg(1, 0, LAR_RA_HV_OFF_AT_RUN_START, -1, err);
          break;
        }
      }
    } else if (fFieldPwrSupply == "wew") { // Bperp
      if (fEnabled["wew_eq"]) { // only deal with WEW if equipment is enabled
        // get WEW input record
        float wew_input[11];
        size = sizeof(wew_input);
        fWEWInputKey->GetData(&wew_input, &size, TID_FLOAT);

        // find out if WEWL or WEWH is in use
        int current_idx;
        if (wew_input[WEWL_INPUT_STATUS] == 1.0) {
          current_idx = WEWL_INPUT_CURRENT;
        } else {
          current_idx = WEWH_INPUT_CURRENT;
        }

        // get the WEW current
        size = sizeof(fval);
        fWEWInputKey->GetDataIndex(&fval, &size, current_idx, TID_FLOAT);
        if (fval <= fWEWCriticalCurrentRA) {
          for (int i=HV_FUG_RAL; i<=HV_FUG_RAB; i++) {
            size = sizeof(fval);
            fHVDemandKey->GetDataIndex(&fval, &size, i, TID_FLOAT);
            if (fval < 0.2) {
              err = QString("PLemAutoRun::RunStart: RA HV's < 0.2kV! Unlikely to be correct, please check!");
              emit ErrorMsg(1, 0, LAR_RA_HV_OFF_AT_RUN_START, -1, err);
              break;
            }
          }
        }
      }
    }
  }

  // keep the number of trigger events needed to complete a run
  fRunNoEventsNeeded = arc->param[0].toInt();

  // start run
  fRunInfo.run_number++;
  status = cm_transition(TR_START, fRunInfo.run_number, NULL, 0, TR_SYNC, FALSE);
  if (status != CM_SUCCESS) { // error
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    err = QString("PLemAutoRun::RunStart: Cannot start the run.");
    emit ErrorMsg(1, 0, LAR_MIDAS_CANNOT_START_RUN, -1, err);
  }

  // check that the run really started
  QElapsedTimer t;
  t.start();
  size = sizeof(fRunInfo);
  do {
    if (fDebug)
      std::cout << std::endl << "RunStart: Runinfo.state = " << fRunInfo.state;
    fRunInfoKey->GetRecord((void *)&fRunInfo, &size);
    Wait(2000);
    if (t.elapsed() > 60e3) {
      err = QString("PLemAutoRun::RunStart: Didn't get run transition after run started.");
      UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED, 0, err);
      emit ErrorMsg(1, 0, LAR_MIDAS_NO_RUN_TRANSITION, -1, err);
      break;
    }
  } while (fRunInfo.state != RUN_RUNNING);

  // run is on the way
  fRunStopped = false;

  // time stamp run start
  fRunStarted.start();

  // increment command counter
  fCurrentAutoRunCmd++;

  // update status
  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);
}

//**********************************************************************
// RunStop
//**********************************************************************
void PLemAutoRun::RunStop(AutoRunCmd *arc)
{
  // param: [0] events/time, [[1] "sec"]

  QString msg, err;

  msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;

  if (arc->noElements == 1) {
    fRunCheckEvents = true;
  } else {
    fRunCheckEvents = false;
    fRunTimeout = arc->param[0].toFloat();
  }
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  // check if the vme frontend and analyzer are enabled
  if (!fEnabled["vme_fe"] || !fEnabled["analyzer_fe"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    QString err  = msg + QString("PLemAutoRun::RunStop(): VME_FE(%1) and/or Analyzer(%2) not enabled. Do nothing here.").arg(fEnabled["vme_fe"]).arg(fEnabled["analyzer_fe"]);
    emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, err);
    fCurrentAutoRunCmd++;
    return;
  }

  // check if frontend and analyzer are running
  CheckClients();
  if (!fFrontendRunning || !fAnalyzerRunning) { // frontend or analyzer NOT running
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    QString err = QString("PLemAutoRun::RunStop: ");
    if (!fFrontendRunning)
      err += QString(" %1 ").arg(fFrontendName);
    if (!fAnalyzerRunning)
      err += QString(" %1 ").arg(fAnalyzerName);
    err += QString("not running, will stop! Fix it first ;-)");
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED, 0, err);
    emit ErrorMsg(1, 0, LAR_MIDAS_FE_NOT_RUNNING, -1, err);
    DisconnectFromExp();
    QCoreApplication::exit(0);
    exit(0);
  }

  // keep the number of trigger events needed to complete a run
  fRunNoEventsNeeded = arc->param[0].toInt();

  // run is on the way
  fRunStopped = false;

  // time stamp run start
  fRunStarted.start();

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// RunStopCheck
//**********************************************************************
bool PLemAutoRun::RunStopCheck()
{
  int     status, size;
  double  value;
  QString err;
  bool    stopped = false;

  // update Runinfo structure
  size = sizeof(fRunInfo);
  fRunInfoKey->GetRecord((void *)&fRunInfo, &size);

  // check only if Run is active 10sec after run start to allow the Trigger statistics to
  // the get the right Event stats
  if ((fRunInfo.state == RUN_RUNNING) && (fRunStarted.elapsed() > 10000)) {
    // check if frontend and analyzer are running
    CheckClients();
    if (!fFrontendRunning || !fAnalyzerRunning) { // frontend or analyzer NOT running
      UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
      QString err = QString("PLemAutoRun::RunStopCheck: ");
      if (!fFrontendRunning)
        err += QString(" %1 ").arg(fFrontendName);
      if (!fAnalyzerRunning)
        err += QString(" %1 ").arg(fAnalyzerName);
      err += QString("not running, will stop! Fix it first ;-)");
      emit ErrorMsg(1, 0, LAR_MIDAS_FE_NOT_RUNNING, -1, err);
      DisconnectFromExp();
      QCoreApplication::exit(0);
      exit(0);
    }

    if (fRunCheckEvents) { // check if number of events criteria or time shall be used
      // get no of events
      size = sizeof(value);
      status = fTriggerEventsKey->GetData(&value, &size, TID_DOUBLE);
      if (status != DB_SUCCESS) { // error
        UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
        err = "PLemAutoRun::RunStopCheck: Couldn't get current number of events";
        emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      }
      // check if enough events to stop the current run
      if ((value >= fRunNoEventsNeeded) && !fRunStopped) { // run can be stopped if not already done so
        // stop run
        status = cm_transition(TR_STOP, fRunInfo.run_number, NULL, 0, TR_SYNC, FALSE);
        if (status != CM_SUCCESS) { // error
          UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
          err = QString("PLemAutoRun::RunStart: Cannot stop the run.");
          emit StatusMsg(err);
          emit ErrorMsg(1, 0, LAR_MIDAS_CANNOT_START_RUN, -1, err);
        }
        err = QString("Autorun running: run stopped.");
        emit StatusMsg(err);
        err = QString(">> End of run; read=%1 of requested = %2").arg(value).arg(fRunNoEventsNeeded);
        emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, err);
        fRunNoEventsNeeded = 0;
        fRunStopped = true;
        stopped = true;
      }
    } else { // check if the time elapsed passed the timing criterium
      if ((fRunStarted.elapsed() > (int)(1e3*fRunTimeout)) && !fRunStopped) { // stop the run
        // stop run
        status = cm_transition(TR_STOP, fRunInfo.run_number, NULL, 0, TR_SYNC, FALSE);
        if (status != CM_SUCCESS) { // error
          UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
          err = QString("PLemAutoRun::RunStart: Cannot stop the run.");
          emit StatusMsg(err);
          emit ErrorMsg(1, 0, LAR_MIDAS_CANNOT_START_RUN, -1, err);
        }
        err = QString("Autorun running: run stopped.");
        emit StatusMsg(err);
        err = QString(">> End of run; read=%1 of requested = %2").arg(value).arg(fRunNoEventsNeeded);
        emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, err);
        fRunNoEventsNeeded = 0;
        fRunStopped = true;
        stopped = true;
      }
    }
  }

  // check if run was stopped manually
  if ((fRunInfo.state == RUN_STOPPED) && (fRunStarted.elapsed() > 10000) && !fRunStopped) {
    fRunStopped = true;
    stopped = true;
  }

  return stopped;
}

//**********************************************************************
// CheckFieldCmd
//**********************************************************************
int PLemAutoRun::CheckFieldCmd(QString &errMsg)
{
  if (!fEnabled["mag_param_wew_odb"] || !fEnabled["mag_param_bpar_odb"])
    return -1;

  float fval, maxField;
  for (int i=0; i<fAutoRunCmdVector->size(); i++) {
    if (fAutoRunCmdVector->at(i).cmd == "setFieldWEWL") {
      fval = fAutoRunCmdVector->at(i).param[0].toFloat(); // field/current value
      if (fAutoRunCmdVector->at(i).param[1] == "A") { // value in Ampere
        if (fabs(fval) > fWEWLMaxCurrent) { // out of range current
          errMsg = QString("PLemAutoRun::CheckFieldCmd: WEWL current out of range (%1 A > %2 A) in line %3").arg(fval).arg(fWEWLMaxCurrent).arg(fAutoRunCmdVector->at(i).lineNo);
          emit StatusMsg(errMsg);
          return i;
        }
      } else { // value in Gauss
        maxField = fMagParamWew[0] + fMagParamWew[1] * fWEWLMaxCurrent;
        if (fabs(fval) > maxField) { // out of range field
          errMsg = QString("PLemAutoRun::CheckFieldCmd: WEW field out of range (%1 G > %2 G) in line %3").arg(fval).arg(maxField).arg(fAutoRunCmdVector->at(i).lineNo);
          emit StatusMsg(errMsg);
          return i;
        }
      }
    } else if (fAutoRunCmdVector->at(i).cmd == "setFieldWEWH") {
      fval = fAutoRunCmdVector->at(i).param[0].toFloat(); // field/current value
      if (fAutoRunCmdVector->at(i).param[1] == "A") { // value in Ampere
        if (fabs(fval) > fWEWHMaxCurrent) { // out of range current
          errMsg = QString("PLemAutoRun::CheckFieldCmd: WEWH current out of range (%1 A > %2 A) in line %3").arg(fval).arg(fWEWHMaxCurrent).arg(fAutoRunCmdVector->at(i).lineNo);
          emit StatusMsg(errMsg);
          return i;
        }
      } else { // value in Gauss
        maxField = fMagParamWew[0] + fMagParamWew[1] * fWEWHMaxCurrent;
        if (fabs(fval) > maxField) { // out of range field
          errMsg = QString("PLemAutoRun::CheckFieldCmd: WEW field out of range (%1 G > %2 G) in line %3").arg(fval).arg(maxField).arg(fAutoRunCmdVector->at(i).lineNo);
          emit StatusMsg(errMsg);
          return i;
        }
      }
    } else if (fAutoRunCmdVector->at(i).cmd == "setFieldDanfysik") {
      fval = fAutoRunCmdVector->at(i).param[0].toFloat(); // field/current value
      if (fAutoRunCmdVector->at(i).param[1] == "A") { // value in Ampere
        if (fabs(fval) > fDanfysikMaxCurrent) { // out of range current
          errMsg = QString("PLemAutoRun::CheckFieldCmd: Bpar current out of range (%1 A > %2 A) in line %3").arg(fval).arg(fDanfysikMaxCurrent).arg(fAutoRunCmdVector->at(i).lineNo);
          emit StatusMsg(errMsg);
          return i;
        }
      } else { // value in Gauss
        maxField = fMagParamBpar[0] + fMagParamBpar[1] * fDanfysikMaxCurrent;
        if (fabs(fval) > maxField) { // out of range field
          errMsg = QString("PLemAutoRun::CheckFieldCmd: Bpar field out of range (%1 G > %2 G) in line %3").arg(fval).arg(maxField).arg(fAutoRunCmdVector->at(i).lineNo);
          emit StatusMsg(errMsg);
          return i;
        }
      }
    } else if (fAutoRunCmdVector->at(i).cmd == "setField") {
      fval = fAutoRunCmdVector->at(i).param[0].toFloat(); // field/current value
      if (fSetupWewEnabled) {
        if (fAutoRunCmdVector->at(i).param[1] == "A") { // value in Ampere
          if (fabs(fval) > fWEWHMaxCurrent) { // out of range current
            errMsg = QString("PLemAutoRun::CheckFieldCmd: WEW current out of range (%1 A > %2 A) in line %3").arg(fval).arg(fWEWHMaxCurrent).arg(fAutoRunCmdVector->at(i).lineNo);
            emit StatusMsg(errMsg);
            return i;
          }
        } else { // value in Gauss
          maxField = fMagParamWew[0] + fMagParamWew[1] * fWEWHMaxCurrent;
          if (fabs(fval) > maxField) { // out of range field
            errMsg = QString("PLemAutoRun::CheckFieldCmd: WEW field out of range (%1 G > %2 G) in line %3").arg(fval).arg(maxField).arg(fAutoRunCmdVector->at(i).lineNo);
            emit StatusMsg(errMsg);
            return i;
          }
        }
      } else { // Bpar
        if (fAutoRunCmdVector->at(i).param[1] == "A") { // value in Ampere
          if (fabs(fval) > fDanfysikMaxCurrent) { // out of range current
            errMsg = QString("PLemAutoRun::CheckFieldCmd: Bpar current out of range (%1 A > %2 A) in line %3").arg(fval).arg(fDanfysikMaxCurrent).arg(fAutoRunCmdVector->at(i).lineNo);
            emit StatusMsg(errMsg);
            return i;
          }
        } else { // value in Gauss
          maxField = fMagParamBpar[0] + fMagParamBpar[1] * fDanfysikMaxCurrent;
          if (fabs(fval) > maxField) { // out of range field
            errMsg = QString("PLemAutoRun::CheckFieldCmd: Bpar field out of range (%1 G > %2 G) in line %3").arg(fval).arg(maxField).arg(fAutoRunCmdVector->at(i).lineNo);
            emit StatusMsg(errMsg);
            return i;
          }
        }
      }
    }
  }

  return -1;
}

//**********************************************************************
// DegaussWEW
//**********************************************************************
void PLemAutoRun::DegaussWEW(AutoRunCmd *arc)
{
  float hv[5], fval;
  float current_wewh[3] = {+600.0, -40.0, 0.0};
  float current_wewl[3] = {+50.0, -45.0, 0.0};
  int   size;
  QString msg("");

  // check if FUG handling is disabled in lemAutoRun
  if (!fEnabled["fug_scfe"]) {
    msg = QString("(%1/%2) DEGAUSS_WEW: FUG disabled in lemAutoRun. Will do nothing here.").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }
  // check of WEW equipment is disabled in lemAutoRun
  if (!fEnabled["wew_eq"]) {
    msg = QString("(%1/%2) DEGAUSS_WEW: WEW equipment disabled in lemAutoRun. Will do nothing here.").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  // check if wew scfe is running
  CheckClients();
  if (!fWEWFeRunning) {
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    QString err = QString("PLemAutoRun::DegaussWEW: WEW Slowcontrol Frontend NOT running. Error too severe, will stop.");
    emit ErrorMsg(1, 0, LAR_MIDAS_FE_NOT_RUNNING, -1, err);
    DisconnectFromExp();
    QCoreApplication::exit(0);
    exit(0);
  }

  msg = QString("(%1/%2) DEGAUSS_WEW").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);
  
  // get current RA HV values
  // get RAL
  size = sizeof(fval);
  fHVDemandKey->GetDataIndex(&fval, &size, HV_FUG_RAL, TID_FLOAT);
  hv[0] = fval;
  // get RAT
  size = sizeof(fval);
  fHVDemandKey->GetDataIndex(&fval, &size, HV_FUG_RAT, TID_FLOAT);
  hv[1] = fval;
  // get RAR
  size = sizeof(fval);
  fHVDemandKey->GetDataIndex(&fval, &size, HV_FUG_RAR, TID_FLOAT);
  hv[2] = fval;
  // get RAB
  size = sizeof(fval);
  fHVDemandKey->GetDataIndex(&fval, &size, HV_FUG_RAB, TID_FLOAT);
  hv[3] = fval;
  // get SampleHV
  size = sizeof(fval);
  fHVDemandKey->GetDataIndex(&fval, &size, HV_FUG_SAMPLE, TID_FLOAT);
  hv[4] = fval;

  // set RA HV values to zero
  fval = 0.0;
  fHVDemandKey->SetDataIndex(&fval, HV_FUG_RAL, TID_FLOAT);
  fHVDemandKey->SetDataIndex(&fval, HV_FUG_RAT, TID_FLOAT);
  fHVDemandKey->SetDataIndex(&fval, HV_FUG_RAR, TID_FLOAT);
  fHVDemandKey->SetDataIndex(&fval, HV_FUG_RAB, TID_FLOAT);
  fHVDemandKey->SetDataIndex(&fval, HV_FUG_SAMPLE, TID_FLOAT);

  // message to midas
  cm_msg(MINFO, "lemAutoRun", "DegaussWEW: RA HV down. Will wait 5 sec to settle things.");
  cm_yield(0);

  Wait(5000); // wait 5 sec

  // do the degaussing procedure which is the following current cycle:
  // 1) set WEWL/H demand current to zero
  // 2) switch off WEWL
  // 3) unlock WEW/SSP
  // 4) WEWH: 600A -> -40A -> 0
  // 5) WEWL: 50A -> -45A -> 0
  // 6) lock WEW/SSP
  // -------------------------------------------------
  // 1) set WEWL/H demand current to zero
  fval = 0.0;
  fWEWOutputKey->SetDataIndex(&fval, WEWL_OUTPUT_CURRENT, TID_FLOAT);
  fval = 0.0;
  fWEWOutputKey->SetDataIndex(&fval, WEWH_OUTPUT_CURRENT, TID_FLOAT);
  cm_msg(MDEBUG, "lemAutoRun", "DegaussWEW: set WEWL/H demand current to zero");
  cm_yield(0); // make the watchdog happy
  Wait(2000); // wait 2 sec

  // 2) switch off WEWL
  fval = 0.0;
  fWEWOutputKey->SetDataIndex(&fval, WEWL_OUTPUT_CMD, TID_FLOAT);
  cm_msg(MDEBUG, "lemAutoRun", "DegaussWEW: switch off WEWL");
  cm_yield(0); // make the watchdog happy
  Wait(2000); // wait 2 sec

  // 3) unlock WEW/SSP
  fval = 0.0;
  fWEWOutputKey->SetDataIndex(&fval, WEW_SSP_LOCK, TID_FLOAT);
  cm_msg(MDEBUG, "lemAutoRun", "DegaussWEW: unlock WEW/SSP");
  cm_yield(0); // make the watchdog happy
  Wait(2000); // wait 2 sec

  // 4) WEWH: 600A -> -40A -> 0
  fval = 1.0;
  fWEWOutputKey->SetDataIndex(&fval, WEWH_OUTPUT_CMD, TID_FLOAT);
  cm_msg(MDEBUG, "lemAutoRun", "DegaussWEW: switch on WEWH");
  cm_yield(0); // make the watchdog happy
  Wait(5000); // wait 5 sec
  for (unsigned int i=0; i<3; i++) {
    fval = current_wewh[i];
    fWEWOutputKey->SetDataIndex(&fval, WEWH_OUTPUT_CURRENT, TID_FLOAT);
    // message to midas
    cm_msg(MDEBUG, "lemAutoRun", "DegaussWEW: set current %f A via WEWH.", fval);
    cm_yield(0); // make the watchdog happy
    // check that the field value is reached
    do {
      // wait a bit
      Wait(5000); // wait 5 sec
      size = sizeof(fval);
      fWEWInputKey->GetDataIndex(&fval, &size, WEWH_INPUT_CURRENT, TID_FLOAT);
    } while (fabs(fabs(fval)-fabs(current_wewh[i])) > 2.0); // 2A is needed for WEWH (zero is ~1.5)
    // keep the field for 15 sec
    Wait(15000);
  }

  // switch WEWH off and WEWL on
  cm_msg(MDEBUG, "lemAutoRun", "DegaussWEW: switch WEWH off, WEWL on.");
  cm_yield(0); // make the watchdog happy
  fval = 0.0;
  fWEWOutputKey->SetDataIndex(&fval, WEWH_OUTPUT_CMD, TID_FLOAT);
  // check that WEWH is indeed switched off before proceeding
  QElapsedTimer tt;
  tt.start();
  int timeDiff = 0;
  do {
    size = sizeof(fval);
    fWEWInputKey->GetDataIndex(&fval, &size, WEWH_INPUT_STATUS, TID_FLOAT);
    timeDiff = tt.elapsed();
    if (timeDiff % 500 < 50) // make sure cm_yield is called periodically to make the watchdog happy
      cm_yield(0); // make the watchdog happy
  } while ((fval != 0.0) && (timeDiff < 120000)); // wait no longer than 2 min
  if (timeDiff >= 120000) {
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    QString err = QString("PLemAutoRun::DegaussWEW: Couldn't switch off WEWH - check. Error too severe, will stop.");
    emit ErrorMsg(1, 0, LAR_MIDAS_READBACK_FAILURE, -1, err);
    DisconnectFromExp();
    QCoreApplication::exit(0);
    exit(0);
  }
  // switch on WEWL
  Wait(2000); // wait 2 sec
  fval = 1.0;
  fWEWOutputKey->SetDataIndex(&fval, WEWL_OUTPUT_CMD, TID_FLOAT);
  Wait(2000); // wait 2 sec
  // check that WEWL is indeed switched on before proceeding
  tt.start();
  timeDiff = 0;
  bool try_again = false;
  do {
    size = sizeof(fval);
    fWEWInputKey->GetDataIndex(&fval, &size, WEWL_INPUT_STATUS, TID_FLOAT);
    timeDiff = tt.elapsed();
    if (timeDiff % 500 < 50) // make sure cm_yield is called periodically to make the watchdog happy
      cm_yield(0); // make the watchdog happy
    if ((timeDiff >= 60000) && !try_again) {
      try_again = true;
      // will try to switch on WEWL once more. For this it needs to be switched off first (DD needs a change)
      // before it can switched on again.
      // switch off WEWL
      fval = 0.0;
      fWEWOutputKey->SetDataIndex(&fval, WEWL_OUTPUT_CMD, TID_FLOAT);
      Wait(2000);
      // switch on WEWL
      fval = 1.0;
      fWEWOutputKey->SetDataIndex(&fval, WEWL_OUTPUT_CMD, TID_FLOAT);
      cm_msg(MINFO, "lemAutoRun", "DegaussWEW: couldn't switch on the WEWL yet, will try again.");
    }
  } while ((fval != 1.0) && (timeDiff < 120000)); // wait no longer than 2 min
  if (timeDiff >= 120000) {
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    QString err = QString("PLemAutoRun::DegaussWEW: Couldn't switch on WEWL - check. Error too severe, will stop.");
    emit ErrorMsg(1, 0, LAR_MIDAS_READBACK_FAILURE, -1, err);
    DisconnectFromExp();
    QCoreApplication::exit(0);
    exit(0);
  }

  // 5) WEWL: 50A -> -45A -> 0
  for (unsigned int i=0; i<3; i++) {
    fval = current_wewl[i];
    fWEWOutputKey->SetDataIndex(&fval, WEWL_OUTPUT_CURRENT, TID_FLOAT);
    // message to midas
    cm_msg(MDEBUG, "lemAutoRun", "DegaussWEW: set current %f A via WEWL.", fval);
    cm_yield(0); // make the watchdog happy
    // check that the field value is reached
    do {
      // wait a bit
      Wait(2000); // wait 2 sec
      size = sizeof(fval);
      fWEWInputKey->GetDataIndex(&fval, &size, WEWL_INPUT_CURRENT, TID_FLOAT);
    } while (fabs(fabs(fval)-fabs(current_wewl[i])) > 0.2);
    // keep the field for 15 sec
    Wait(15000);
  }

  // 6) lock WEW/SSP
  fval = 1.0;
  fWEWOutputKey->SetDataIndex(&fval, WEW_SSP_LOCK, TID_FLOAT);
  cm_msg(MDEBUG, "lemAutoRun", "DegaussWEW: lock WEW/SSP");
  cm_yield(0); // make the watchdog happy
  Wait(2000); // wait 2 sec

  cm_msg(MINFO, "lemAutoRun", "DegaussWEW: ramping back RA HV's.");
  cm_yield(0);

  // ramp the RA HV's back
  fHVDemandKey->SetDataIndex(&hv[0], HV_FUG_RAL, TID_FLOAT);
  fHVDemandKey->SetDataIndex(&hv[1], HV_FUG_RAT, TID_FLOAT);
  fHVDemandKey->SetDataIndex(&hv[2], HV_FUG_RAR, TID_FLOAT);
  fHVDemandKey->SetDataIndex(&hv[3], HV_FUG_RAB, TID_FLOAT);
  fHVDemandKey->SetDataIndex(&hv[4], HV_FUG_SAMPLE, TID_FLOAT);

  if (fFugHvCheck) {
    // check that the RA HV's are back to its previous values
    int done = 0;
    tt.restart();
    do {
      // check RAL
      size = sizeof(fval);
      fHVMeasuredKey->GetDataIndex(&fval, &size, HV_FUG_RAL, TID_FLOAT);
      if (fabs(fval-hv[0]) < 0.2)
        done++;

      // check RAT
      size = sizeof(fval);
      fHVMeasuredKey->GetDataIndex(&fval, &size, HV_FUG_RAT, TID_FLOAT);
      if (fabs(fval-hv[1]) < 0.2)
        done++;

      // check RAR
      size = sizeof(fval);
      fHVMeasuredKey->GetDataIndex(&fval, &size, HV_FUG_RAR, TID_FLOAT);
      if (fabs(fval-hv[2]) < 0.2)
        done++;

      // check RAB
      size = sizeof(fval);
      fHVMeasuredKey->GetDataIndex(&fval, &size, HV_FUG_RAB, TID_FLOAT);
      if (fabs(fval-hv[3]) < 0.2)
        done++;
      
      // check SampleHV
      size = sizeof(fval);
      fHVMeasuredKey->GetDataIndex(&fval, &size, HV_FUG_SAMPLE, TID_FLOAT);
      if (fabs(fval-hv[4]) < 0.2)
        done++;

      if (done < 5) {
        Wait(2000); // wait 2 sec
      }

      if (tt.elapsed() > 300000) { // it takes more than 5 min
        QString err = QString("lemAutoRun: **WARNING** Sample region HV's couldn't be ramped back within 5min.");
        emit ErrorMsg(1, 0, LAR_MSG, -1, err);
        done = 10;
      }

    } while (done < 5);
  } else { // NO FUG HV check, hence just wait a 1 min
    Wait(60000);
  }

  cm_msg(MINFO, "lemAutoRun", "DegaussWEW: degauss done.");
  cm_yield(0);
}

//**********************************************************************
// DegaussDanfysik
//**********************************************************************
void PLemAutoRun::DegaussDanfysik(AutoRunCmd *arc)
{
  float currentFieldValue;
  QString msg;

  // check of Danfysik equipment is disabled in lemAutoRun
  if (!fEnabled["danfysik_eq"]) {
    msg = QString("(%1/%2) DEGAUSS_DANFYSIK: danfysik equipment disabled in lemAutoRun. Will do nothing here.").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  // check if danfysik scfe is running
  CheckClients();
  if (!fDanfysikFeRunning) {
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    QString err = QString("PLemAutoRun::DegaussDanfysik: Danfysik Slowcontrol Frontend NOT running. Error too severe, will stop.");
    emit ErrorMsg(1, 0, LAR_MIDAS_FE_NOT_RUNNING, -1, err);
    DisconnectFromExp();
    QCoreApplication::exit(0);
    exit(0);
  }

  msg = QString("(%1/%2) DEGAUSS_DANFYSIK").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  // set current field to -8A
  currentFieldValue = -8.0;
  fDanfysikOutputKey->SetDataIndex(&currentFieldValue, DANFYSIK_OUTPUT_CURRENT, TID_FLOAT);
  cm_msg(MINFO, "lemAutoRun", "DegaussDanfysik: set Bpar current to -8.0A");
  cm_yield(0);

  // wait 60 sec
  Wait(60000);

  // set current field to +8A
  currentFieldValue = +8.0;
  fDanfysikOutputKey->SetDataIndex(&currentFieldValue, DANFYSIK_OUTPUT_CURRENT, TID_FLOAT);
  cm_msg(MINFO, "lemAutoRun", "DegaussDanfysik: set Bpar current to +8.0A");
  cm_yield(0);

  // wait 60 sec
  Wait(60000);

  // reduce the current field value gradually
  do {
    // set the new field value
    currentFieldValue /= -2.0;
    fDanfysikOutputKey->SetDataIndex(&currentFieldValue, DANFYSIK_OUTPUT_CURRENT, TID_FLOAT);
    cm_msg(MINFO, "lemAutoRun", "DegaussDanfysik: set Bpar current to %.2f A", currentFieldValue);
    cm_yield(0);

    // wait a bit
    Wait(30000);
  } while (fabs(currentFieldValue) > 0.1);

  // set field value to zero
  currentFieldValue = 0.0;
  fDanfysikOutputKey->SetDataIndex(&currentFieldValue, DANFYSIK_OUTPUT_CURRENT, TID_FLOAT);
  cm_msg(MINFO, "lemAutoRun", "DegaussDanfysik: done");
  cm_yield(0);
}

//**********************************************************************
// Degauss
//**********************************************************************
void PLemAutoRun::Degauss(AutoRunCmd *arc)
{
  if (fSetupWewEnabled)
    DegaussWEW(arc);
  else
    DegaussDanfysik(arc);
}

//**********************************************************************
// DegaussSpinRot
//**********************************************************************
void PLemAutoRun::DegaussSpinRot(AutoRunCmd *arc)
{
  QString msg("");

  // check if FUG handling is disabled in lemAutoRun
  if (!fEnabled["fug_scfe"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += arc->cmdString;
    msg += ": FUG disabled in lemAutoRun. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }
  // check the danfysik spin rot equipment is enabled
  if (!fEnabled["danfysik_spin_rot_eq"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += QString("PLemAutoRun::DegaussSpinRot: danfysik spin rot equipment is disabled. Will do nothing here.");
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  // check if the hv_fug_scfe frontend is running
  CheckClients();
  if (!fHVFeRunning) { // error too severe to going on
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    QString err = QString("PLemAutoRun::DegaussSpinRot: Slowcontrol Frontend NOT running. Error too severe, will stop.");
    emit ErrorMsg(1, 0, LAR_MIDAS_FE_NOT_RUNNING, -1, err);
    DisconnectFromExp();
    QCoreApplication::exit(0);
    exit(0);
  }

  msg = QString("(%1/%2) DEGAUSS_SPIN_ROT").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  // set spin rotator HV's to zero
  cm_msg(MINFO, "DegaussSpinRot", "DegaussSpinRot: shut down Spin Rot HV's.");
  cm_yield(0);
  // Loop over set HV. This is done this way to reduce hangers due to network problems
  int i, size;
  float hv_measured[HV_FUG_CHS];
  float value;
  float timeout;
  bool done, happy;
  QElapsedTimer t;
  for (i=0; i<HV_FUG_MAX_TRY; i++) {
    // set spin rotator hv's to zero
    value = 0.0;
    fHVDemandKey->SetDataIndex((void *)&value, HV_FUG_RIGHT_RODS, TID_FLOAT);
    value = 0.0;
    fHVDemandKey->SetDataIndex((void *)&value, HV_FUG_LEFT_RODS, TID_FLOAT);
    value = 0.0;
    fHVDemandKey->SetDataIndex((void *)&value, HV_FUG_LEFT_PLATE, TID_FLOAT);
    value = 0.0;
    fHVDemandKey->SetDataIndex((void *)&value, HV_FUG_RIGHT_PLATE, TID_FLOAT);

    if (fFugHvCheck) {
      // check that the spin rotator HV's are all zero
      done  = false;
      happy = false;
      timeout = fHVTimeout * 1e3;
      t.start();
      do {
        // sleep for 5 sec before reading the next value
        Wait(5000);

        // read sample hv
        size  = HV_FUG_CHS*sizeof(float);
        fHVMeasuredKey->GetData(&hv_measured, &size, TID_FLOAT);

        // check if all measured spin rotator HV's are zero
        int count = 0;
        for (int j=HV_FUG_RIGHT_RODS; j<=HV_FUG_RIGHT_PLATE; j++) {
          if (fabs(hv_measured[j]) < fHVAccuracy)
            count++;
        }
        if (count == 4) { // all spin rotator HV's down
          done  = true;
          happy = true;
        }

        // check if too much time elapsed to reach the final sample hv
        if (t.elapsed() > timeout) {
          done = true;  // quit loop
          // emit warning
          msg = QString("Couldn't shut down Spin Rot HVs within %1 sec: will give it another try in 120 sec.").arg(fHVTimeout);
          emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, arc->lineNo, msg);
        }
      } while (!done);

      if (happy) // everything is OK, get out of the loop
        break;

      // wait 120 sec before retrial
      Wait(120000);
    } else { // NO FUG HV check, hence just wait a 1 min
      Wait(60000);
      break;
    }
  }

  if (i == HV_FUG_MAX_TRY) {
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    // emit error
    msg = QString("Couldn't shut down the Spin Rotator HV, even after a few trials :-( .");
    emit ErrorMsg(1, 0, LAR_SAMPLE_HV_NOT_REACHED, arc->lineNo, msg);
  }

  // degauss spin rotator magnet
  // 1st set current to 0
  cm_msg(MINFO, "DegaussSpinRot", "DegaussSpinRot: set Spin Rot Magnet current to 0.");
  cm_yield(0);
  value = 0.0;
  fSpinRotMagOutputKey->SetDataIndex((void*)&value, SPINT_ROT_OUTPUT_CURRENT, TID_FLOAT);
  // check that measured current is going to 0
  done = false;
  timeout = fFieldTimeout * 1e3; // ms -> sec
  t.start(); // start timer
  do {
    // sleep for 1 sec before reading the next value
    Wait(1000);

    size = sizeof(value);
    fSpinRotMagInputKey->GetDataIndex(&value, &size, SPINT_ROT_INPUT_CURRENT, TID_FLOAT);

    if (fabs(value) < 0.1)
      done = true;

    // check if too much time elapsed to reach the final spin rotator magnet current
    if (t.elapsed() > timeout) {
      done = true;  // quit loop
      // emit warning
      msg = QString("Couldn't set the Spin Rot Magnet current within %1 sec.").arg(fFieldTimeout);
      emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, arc->lineNo, msg);
    }
  } while (!done);

  // wait 10 sec
  Wait(10000);

  // 2nd set current to +12.0
  cm_msg(MINFO, "DegaussSpinRot", "DegaussSpinRot: set Spin Rot Magnet current to 12.0 A.");
  cm_yield(0);
  value = 12.0;
  fSpinRotMagOutputKey->SetDataIndex((void*)&value, SPINT_ROT_OUTPUT_CURRENT, TID_FLOAT);
  // check that measured current is going to 12A
  done = false;
  timeout = fFieldTimeout * 1e3; // ms -> sec
  t.start(); // start timer
  do {
    // sleep for 1 sec before reading the next value
    Wait(1000);

    size = sizeof(value);
    fSpinRotMagInputKey->GetDataIndex(&value, &size, SPINT_ROT_INPUT_CURRENT, TID_FLOAT);

    if (fabs(value-12.0) < 0.1)
      done = true;

    // check if too much time elapsed to reach the final spin rotator magnet current
    if (t.elapsed() > timeout) {
      done = true;  // quit loop
      // emit warning
      msg = QString("Couldn't set the Spin Rot Magnet current within %1 sec.").arg(fFieldTimeout);
      emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, arc->lineNo, msg);
    }
  } while (!done);

  // wait 30 sec
  Wait(30000);

  // 3rd set current to -1.3A
  cm_msg(MINFO, "DegaussSpinRot", "DegaussSpinRot: set Spin Rot Magnet current to -1.3 A.");
  cm_yield(0);
  value = -1.3;
  fSpinRotMagOutputKey->SetDataIndex((void*)&value, SPINT_ROT_OUTPUT_CURRENT, TID_FLOAT);
  // check that measured current is going to -1.3A
  done = false;
  timeout = fFieldTimeout * 1e3; // ms -> sec
  t.start(); // start timer
  do {
    // sleep for 1 sec before reading the next value
    Wait(1000);

    size = sizeof(value);
    fSpinRotMagInputKey->GetDataIndex(&value, &size, SPINT_ROT_INPUT_CURRENT, TID_FLOAT);

    if (fabs(value+1.3) < 0.1)
      done = true;

    // check if too much time elapsed to reach the final spin rotator magnet current
    if (t.elapsed() > timeout) {
      done = true;  // quit loop
      // emit warning
      msg = QString("Couldn't set the Spin Rot Magnet current within %1 sec.").arg(fFieldTimeout);
      emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, arc->lineNo, msg);
    }
  } while (!done);

  // wait 30 sec
  Wait(30000);

  // 4th set current to 0
  cm_msg(MINFO, "DegaussSpinRot", "DegaussSpinRot: set Spin Rot Magnet current to 0 - done.");
  cm_yield(0);
  value = 0.0;
  fSpinRotMagOutputKey->SetDataIndex((void*)&value, SPINT_ROT_OUTPUT_CURRENT, TID_FLOAT);
  // check that measured current is going to 0
  done = false;
  timeout = fFieldTimeout * 1e3; // ms -> sec
  t.start(); // start timer
  do {
    // sleep for 1 sec before reading the next value
    Wait(1000);

    size = sizeof(value);
    fSpinRotMagInputKey->GetDataIndex(&value, &size, SPINT_ROT_INPUT_CURRENT, TID_FLOAT);

    if (fabs(value) < 0.1)
      done = true;

    // check if too much time elapsed to reach the final spin rotator magnet current
    if (t.elapsed() > timeout) {
      done = true;  // quit loop
      // emit warning
      msg = QString("Couldn't set the Spin Rot Magnet current within %1 sec.").arg(fFieldTimeout);
      emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, arc->lineNo, msg);
    }
  } while (!done);

  // set spin rot angle to its virgin value, i.e. +11.1965°
  value = 11.1965;
  fSpinRotAngleKey->SetData((void*)&value, 1, TID_FLOAT);

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// SetIgnoreAlarms
//**********************************************************************
void PLemAutoRun::SetIgnoreAlarms(AutoRunCmd *arc)
{
  QString msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  if ((arc->param[0] == "yes") || (arc->param[0] == "1") || (arc->param[0] == "true"))
    fIgnoreAlarms = true;
  else
    fIgnoreAlarms = false;

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// SetIgnoreClients
//**********************************************************************
void PLemAutoRun::SetIgnoreClients(AutoRunCmd *arc)
{
  QString msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  if ((arc->param[0] == "yes") || (arc->param[0] == "1") || (arc->param[0] == "true"))
    fIgnoreClients = true;
  else
    fIgnoreClients = false;

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// SetDump
//**********************************************************************
void PLemAutoRun::SetDump(AutoRunCmd *arc)
{
   QString msg("");

  // check the danfysik spin rot equipment is enabled
  if (!fEnabled["sample_eq"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += QString("PLemAutoRun::SetDump: sample equipment is disabled. Will do nothing here.");
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  msg = QString("(%1/%2) DUMP %3 (times)").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds).arg(arc->param[0]);
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  // indicate that there is a dump
  fDumpInUse = true;

  // open file
  fDumpFile.setFileName(fAutoRunPath + fDumpFileName);
  fDumpFile.open(QIODevice::WriteOnly | QIODevice::Append);

  // get necessary information from the ODB
  static bool write_header = true;

  if (write_header) {
    write_header = false;

    // get temperature control channel
    char ctrl_ch[4];
    int  size = sizeof(ctrl_ch);
    fSampleCtrlChKey->GetData(ctrl_ch, &size, TID_STRING);

    // get raw data voltage channels
    char sensor_ch[10][4];
    size = sizeof(sensor_ch[0]);
    for (int i=0; i<fSampleChannelKey->GetNumValues(); i++) {
      fSampleChannelKey->GetDataIndex(sensor_ch[i], &size, i, TID_STRING);
    }

    // get raw data sensor type assignement
    int sensor_type[10];
    size = sizeof(int);
    for (int i=0; i<fSampleSensorTypeKey->GetNumValues(); i++) {
      fSampleSensorTypeKey->GetDataIndex(&sensor_type[i], &size, i, TID_INT);
    }

    // write header (there can be more than one header in the RawVoltageOutput data file!!)
    QTextStream stream( &fDumpFile );
    stream << "%--------------------------------------------------------------------------" << Qt::endl;
    stream << "% Number of Entries : 21" << Qt::endl;
    stream << "% Number of Raw Data Reading   : 8" << Qt::endl;
    stream << "% First Raw Data Reading Entry : 14" << Qt::endl;
    stream << "% Entry  1 : month" << Qt::endl;
    stream << "% Entry  2 : day" << Qt::endl;
    stream << "% Entry  3 : year" << Qt::endl;
    stream << "% Entry  4 : hour" << Qt::endl;
    stream << "% Entry  5 : minutes" << Qt::endl;
    stream << "% Entry  6 : seconds" << Qt::endl;
    stream << "% Entry  7 : msec" << Qt::endl;
    stream << "% Entry  8 : measured temperature of control channel = " << ctrl_ch << Qt::endl;
    stream << "% Entry  9 : pressure" << Qt::endl;
    stream << "% Entry 10 : heater output" << Qt::endl;
    stream << "% Entry 11 : setpoint temperature" << Qt::endl;
    stream << "% Entry 12 : heater range" << Qt::endl;
    stream << "% Entry 13 : BH1 flow measured" << Qt::endl;
    for (int i=0; i<8; i++) {
      stream << "% Entry " << 14+i << " : Raw Data Reading Entry " << i << " : Channel " << sensor_ch[i] << " : Sensor Type " << sensor_type[i] << Qt::endl;
    }
    stream << "%--------------------------------------------------------------------------" << Qt::endl;
    fDumpFile.flush();
  }


  // set the number of dumps to be made
  fDumpCounter = arc->param[0].toInt();

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// SetFieldWEWL
//**********************************************************************
void PLemAutoRun::SetFieldWEWL(AutoRunCmd *arc)
{
  // param: [0] field value, [1] field unit (A | G)
  float value, demand;
  int   size, err_count;
  QString msg("");

  // check if FUG handling is disabled in lemAutoRun
  if (!fEnabled["fug_scfe"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += arc->cmdString;
    msg += ": FUG disabled in lemAutoRun. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  // set field power supply (possibly needed in setTitle)
  fFieldPwrSupply = "wew";

  // check if the wew_scfe frontend is running
  CheckClients();
  if (!fWEWFeRunning) { // error too severe to going on
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    QString err = QString("PLemAutoRun::SetFieldWEWL: WEW Slowcontrol Frontend NOT running.\n")+
                  QString("  Error too severe, will stop.");
    emit ErrorMsg(1, 0, LAR_MIDAS_FE_NOT_RUNNING, -1, err);
    DisconnectFromExp();
    QCoreApplication::exit(0);
    exit(0);
  }

  msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  // 2 things to be checked at this  point: 1) WEWH needs to be OFF, 2) WEWL needs to be ON
  // make sure WEWH is OFF
  size  = sizeof(value);
  fWEWOutputKey->GetDataIndex(&value, &size, WEWH_OUTPUT_CMD, TID_FLOAT);
  if (value == 1.0) {
    cm_msg(MINFO, "PLemAutoRun::SetFieldWEWL", "**WARNING** WEWH still ON! Will ramp it to zero and switch it off first.");
    cm_yield(0);
    // WEWH demand to zero
    demand = 0.0;
    fWEWOutputKey->SetDataIndex((void*)&demand, WEWH_OUTPUT_CURRENT, TID_FLOAT);
    // make sure that WEWH demand current is zero
    err_count = 0;
    do {
      size = sizeof(value);
      fWEWInputKey->GetDataIndex(&value, &size, WEWH_INPUT_CURRENT, TID_FLOAT);
      Wait(500);
    } while ((value > 2.0) && (err_count++ < 120));
    // switch WEWH OFF
    demand = 0.0;
    fWEWOutputKey->SetDataIndex((void*)&demand, WEWH_OUTPUT_CMD, TID_FLOAT);
    // make sure WEWH is switched OFF
    err_count = 0;
    do {
      size = sizeof(value);
      fWEWInputKey->GetDataIndex(&value, &size, WEWH_INPUT_STATUS, TID_FLOAT);
      Wait(500);
    } while ((value != 0.0) && (err_count++ < 120));
    if (err_count >= 120) {
      cm_msg(MINFO, "PLemAutoRun::SetFieldWEWL", "**WARNING** WEWH status is still ON. Please check! EPICS Gateway Problems?");
      cm_yield(0);
    }
  }
  Wait(500);
  // make sure WEWL is ON
  size  = sizeof(value);
  fWEWOutputKey->GetDataIndex(&value, &size, WEWL_OUTPUT_CMD, TID_FLOAT);
  if (value == 0.0) {
    // just out of paranoia set the demand current first to zero
    demand = 0.0;
    fWEWOutputKey->SetDataIndex((void*)&demand, WEWL_OUTPUT_CURRENT, TID_FLOAT);
    Wait(500);
    cm_msg(MINFO, "PLemAutoRun::SetFieldWEWL", "**WARNING** WEWL still OFF! Will switch it on first.");
    cm_yield(0);
    demand = 1.0;
    fWEWOutputKey->SetDataIndex((void*)&demand, WEWL_OUTPUT_CMD, TID_FLOAT);
    Wait(2000);
  }

  value = arc->param[0].toFloat();
  if (arc->param[1] == "G") { // field given in Gauss, convert it to Ampere for the WEWL
    float curVal = (value - fMagParamWew[0]) / fMagParamWew[1];
    value = curVal;
  }

  // check if WEW current value is too large for having the RA's on, if so switch the RA HV's off first
  // in the RA pulsed mode, this is not needed
  if ((value > fWEWCriticalCurrentRA) && !fRAPulsingEnabled) {
    float fval;
    int count = 0;
    for (int i=HV_FUG_RAL; i<=HV_FUG_RAB; i++) {
      size = sizeof(fval);
      fHVDemandKey->GetDataIndex(&fval, &size, i, TID_FLOAT);
      if (fval > 2.0) {
        count++;
      }
    }
    if (count == 4) { // all RA HV's on
      // emit warning
      msg = QString("PLemAutoRun::SetFieldWEWL: demand current %1 > %2, hence RA HV's will be shut down").arg(value).arg(fWEWCriticalCurrentRA);
      emit ErrorMsg(1, 0, LAR_FORCED_RA_OFF, arc->lineNo, msg);
      for (int i=HV_FUG_RAL; i<=HV_FUG_RAB; i++) {
        fval = 0.0;
        fHVDemandKey->SetDataIndex(&fval, i, TID_FLOAT);
      }
      Wait(5000); // sleep 5sec before proceeding
    }
  }

  // set field value
  fWEWOutputKey->SetDataIndex((void *)&value, WEWL_OUTPUT_CURRENT, TID_FLOAT);

  // check if field value is reached
  bool  done = false;
  float timeout = fFieldTimeout * 1e3; // timeout in (msec)
  QElapsedTimer t;
  t.start();
  demand = value; // keep demand current
  do {
     // sleep for 5 sec before reading the next value
    Wait(5000);

    // read current value
    size  = sizeof(value);
    fWEWInputKey->GetDataIndex(&value, &size, WEWL_INPUT_CURRENT, TID_FLOAT);

    // check if final current is reached
    if (fabs(demand-value) < fFieldAccuracy) {
      done = true;
    }

    if (t.elapsed() > timeout) {
      done = true;  // quit loop
      // emit error
      msg = QString("Field (WEW) was not reached within %1 sec. (demand=%2, measured=%3)").arg(fFieldTimeout).arg(demand).arg(value);
      emit ErrorMsg(1, 0, LAR_FIELD_NOT_REACHED, arc->lineNo, msg);
    }
  } while (!done);

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// SetFieldWEWH
//**********************************************************************
void PLemAutoRun::SetFieldWEWH(AutoRunCmd *arc)
{
  // param: [0] field value, [1] field unit (A | G)
  float value, demand;
  int   size, err_count;
  QString msg("");

  // check if FUG handling is disabled in lemAutoRun
  if (!fEnabled["fug_scfe"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += arc->cmdString;
    msg += ": FUG disabled in lemAutoRun. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  // set field power supply (possibly needed in setTitle)
  fFieldPwrSupply = "wew";

  // check if the wew_scfe frontend is running
  CheckClients();
  if (!fWEWFeRunning) { // error too severe to going on
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    QString err = QString("PLemAutoRun::SetFieldWEWH: WEW Slowcontrol Frontend NOT running.\n")+
                  QString("  Error too severe, will stop.");
    emit ErrorMsg(1, 0, LAR_MIDAS_FE_NOT_RUNNING, -1, err);
    DisconnectFromExp();
    QCoreApplication::exit(0);
    exit(0);
  }

  msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  // 2 things to be checked at this  point: 1) WEWL needs to be OFF, 2) WEWH needs to be ON
  // make sure WEWL is OFF
  size  = sizeof(value);
  fWEWOutputKey->GetDataIndex(&value, &size, WEWL_OUTPUT_CMD, TID_FLOAT);
  if (value == 1.0) {
    cm_msg(MINFO, "PLemAutoRun::SetFieldWEWH", "**WARNING** WEWL still ON! Will ramp it to zero and switch it off first.");
    cm_yield(0);
    // WEWL demand to zero
    demand = 0.0;
    fWEWOutputKey->SetDataIndex((void*)&demand, WEWL_OUTPUT_CURRENT, TID_FLOAT);
    // make sure that WEWL demand current is zero
    err_count = 0;
    do {
      size = sizeof(value);
      fWEWInputKey->GetDataIndex(&value, &size, WEWL_INPUT_CURRENT, TID_FLOAT);
      Wait(500);
    } while ((value > 0.1) && (err_count++ < 120));
    // switch WEWL off
    demand = 0.0;
    fWEWOutputKey->SetDataIndex((void*)&demand, WEWL_OUTPUT_CMD, TID_FLOAT);
    // make sure WEWL is switched OFF
    err_count = 0;
    do {
      size = sizeof(value);
      fWEWInputKey->GetDataIndex(&value, &size, WEWL_INPUT_STATUS, TID_FLOAT);
      Wait(500);
    } while ((value != 0.0) && (err_count++ < 120));
    if (err_count >= 120) {
      cm_msg(MINFO, "PLemAutoRun::SetFieldWEWH", "**WARNING** WEWL status is still ON. Please check! EPICS Gateway Problems?");
      cm_yield(0);
    }
  }
  Wait(500);
  // make sure WEWH is ON
  size  = sizeof(value);
  fWEWOutputKey->GetDataIndex(&value, &size, WEWH_OUTPUT_CMD, TID_FLOAT);
  if (value == 0.0) {
    // just out of paranoia set the demand current first to zero
    demand = 0.0;
    fWEWOutputKey->SetDataIndex((void*)&demand, WEWH_OUTPUT_CURRENT, TID_FLOAT);
    Wait(500);
    cm_msg(MINFO, "PLemAutoRun::SetFieldWEWH", "**WARNING** WEWH still OFF! Will switch it on first.");
    cm_yield(0);
    demand = 1.0;
    fWEWOutputKey->SetDataIndex((void*)&demand, WEWH_OUTPUT_CMD, TID_FLOAT);
    Wait(1000);
  }

  value = arc->param[0].toFloat();
  if (arc->param[1] == "G") { // field given in Gauss, convert it to Ampere for the WEWH
    float curVal = (value - fMagParamWew[0]) / fMagParamWew[1];
    value = curVal;
  }

  // check if WEW current value is too large for having the RA's on, if so switch the RA HV's off first
  // in the RA pulsed mode, this is not needed
  if ((value > fWEWCriticalCurrentRA) && !fRAPulsingEnabled) {
    float fval;
    int count = 0;
    for (int i=HV_FUG_RAL; i<=HV_FUG_RAB; i++) {
      size = sizeof(fval);
      fHVDemandKey->GetDataIndex(&fval, &size, i, TID_FLOAT);
      if (fval > 2.0) {
        count++;
      }
    }
    if (count == 4) { // all RA HV's on
      // emit warning
      msg = QString("PLemAutoRun::SetFieldWEWH: demand current %1 > %2, hence RA HV's will be shut down").arg(value).arg(fWEWCriticalCurrentRA);
      emit ErrorMsg(1, 0, LAR_FORCED_RA_OFF, arc->lineNo, msg);
      for (int i=HV_FUG_RAL; i<=HV_FUG_RAB; i++) {
        fval = 0.0;
        fHVDemandKey->SetDataIndex(&fval, i, TID_FLOAT);
      }
      Wait(5000); // sleep 5sec before proceeding
    }
  }

  // set field value
  fWEWOutputKey->SetDataIndex((void *)&value, WEWH_OUTPUT_CURRENT, TID_FLOAT);

  // check if field value is reached
  bool  done = false;
  float timeout = fFieldTimeout * 1e3; // timeout in (msec)
  QElapsedTimer t;
  t.start();
  demand = value; // keep demand current
  do {
     // sleep for 5 sec before reading the next value
    Wait(5000);

    // read current value
    size  = sizeof(value);
    fWEWInputKey->GetDataIndex(&value, &size, WEWH_INPUT_CURRENT, TID_FLOAT);

    // check if final current is reached
    if (fabs(demand) < 2.0) {
      if (fabs(demand-value) < 2.0)
        done = true;
    } else if (fabs(demand-value) < fFieldAccuracy) {
      done = true;
    }

    if (t.elapsed() > timeout) {
      done = true;  // quit loop
      // emit error
      msg = QString("Field (WEW) was not reached within %1 sec. (demand=%2, measured=%3)").arg(fFieldTimeout).arg(demand).arg(value);
      emit ErrorMsg(1, 0, LAR_FIELD_NOT_REACHED, arc->lineNo, msg);
    }
  } while (!done);

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// SetFieldDanfysik
//**********************************************************************
void PLemAutoRun::SetFieldDanfysik(AutoRunCmd *arc)
{
  // param: [0] current

  float value, demand;
  int   size;
  QString msg("");

  // check if danfysik equipment is disabled in lemAutoRun
  if (!fEnabled["danfysik_eq"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += ": PLemAutoRun::SetFieldDanfysik: danfysik equipment disabled in lemAutoRun. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }


  // set field power supply (possibly needed in setTitle)
  fFieldPwrSupply = "danfysik";

  // check if the danfysik_scfe frontend is running
  CheckClients();
  if (!fDanfysikFeRunning) { // error too severe to going on
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    QString err = QString("PLemAutoRun::SetFieldDanfysik: Danfysik Slowcontrol Frontend NOT running.\n")+
                  QString("  Error too severe, will stop.");
    emit ErrorMsg(1, 0, LAR_MIDAS_FE_NOT_RUNNING, -1, err);
    DisconnectFromExp();
    QCoreApplication::exit(0);
    exit(0);
  }

  msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  value = arc->param[0].toFloat();
  if (arc->param[1] == "G") { // field given in Gauss, convert it to Ampere for the Danfysik
    float curVal = (value - fMagParamBpar[0]) / fMagParamBpar[1];
    value = curVal;
  }

  // set field value
  fDanfysikOutputKey->SetDataIndex((void *)&value, DANFYSIK_OUTPUT_CURRENT, TID_FLOAT);

  // check if field value is reached
  bool  done = false;
  float timeout = fFieldTimeout * 1e3; // timeout in (msec)
  QElapsedTimer t;
  t.start();
  demand = value; // keep demand current
  do {
     // sleep for 5 sec before reading the next value
    Wait(5000);

    // read current value
    size  = sizeof(value);
    fDanfysikInputKey->GetDataIndex(&value, &size, DANFYSIK_INPUT_CURRENT, TID_FLOAT);

    // check if final current is reached
    if (fabs(demand-value) < fFieldAccuracy) {
      done = true;
    }

    if (t.elapsed() > timeout) {
      done = true;  // quit loop
      // emit error
      msg = QString("Field (Danfysik) was not reached within %1 sec. (demand=%2, measured=%3)").arg(fFieldTimeout).arg(demand).arg(value);
      emit ErrorMsg(1, 0, LAR_FIELD_NOT_REACHED, arc->lineNo, msg);
    }
  } while (!done);

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// SetField
//**********************************************************************
void PLemAutoRun::SetField(AutoRunCmd *arc)
{
  if (fSetupWewEnabled) { // WEW in use
    // get the current to decide which power supply to be used
    float value = arc->param[0].toFloat();
    if (arc->param[1] == "G") {
      float curVal = (value - fMagParamWew[0]) / fMagParamWew[1];
      value = curVal;
    }
    if (fabs(value) < 50.0)
      SetFieldWEWL(arc);
    else
      SetFieldWEWH(arc);
  } else if (fSetupBparEnabled) { // Bpar in use
    SetFieldDanfysik(arc);
  } else { // no magnets are enabled
    QString msg("");
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += "PLemAutoRun::SetField: no magnet is enabled. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
  }
}

//**********************************************************************
// SetSpinRot
//**********************************************************************
void PLemAutoRun::SetSpinRot(AutoRunCmd *arc)
{
  // param: [0] angle or 'off'; [1] 'ndg' if present

  QString msg("");

  // check if FUG handling is disabled in lemAutoRun
  if (!fEnabled["fug_scfe"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += arc->cmdString;
    msg += ": FUG disabled in lemAutoRun. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }
  if (!fEnabled["danfysik_spin_rot_eq"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += QString("PLemAutoRun::SetSpinRot: danfysik spin rot equipment disabled. Will do nothing here.");
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  BOOL enabled;

  // only degauss if no 'ndg' is present and not SPIN_ROT off command is present
  if (((arc->noElements != 2) || (arc->param[1] != "ndg")) || (arc->param[0] == "off")) {
    // always first degauss the spin rotator. This way, the user doesn't need to think about the spin rotator's history
    enabled = FALSE;
    fSpinRotEnabledKey->SetData((void*)&enabled, 1, TID_BOOL);

    // set spin rotator HV's to zero
    cm_msg(MINFO, "SetSpinRot", "SetSpinRot: start Spin Rot shutdown and degauss procedure.");
    cm_msg(MINFO, "SetSpinRot", "SetSpinRot: shut down Spin Rot HV's.");
    cm_yield(0);
    // Loop over set HV. This is done this way to reduce hangers due to network problems
    int i, size;
    float hv_measured[HV_FUG_CHS];
    float value;
    float timeout;
    bool done, happy;
    QElapsedTimer t;
    for (i=0; i<HV_FUG_MAX_TRY; i++) {
      // set spin rotator hv's to zero
      value = 0.0;
      fHVDemandKey->SetDataIndex((void *)&value, HV_FUG_RIGHT_RODS, TID_FLOAT);
      value = 0.0;
      fHVDemandKey->SetDataIndex((void *)&value, HV_FUG_LEFT_RODS, TID_FLOAT);
      value = 0.0;
      fHVDemandKey->SetDataIndex((void *)&value, HV_FUG_LEFT_PLATE, TID_FLOAT);
      value = 0.0;
      fHVDemandKey->SetDataIndex((void *)&value, HV_FUG_RIGHT_PLATE, TID_FLOAT);

      if (fFugHvCheck) {
        // check that the spin rotator HV's are all zero
        done  = false;
        happy = false;
        timeout = fHVTimeout * 1e3;
        t.start();
        do {
          // sleep for 5 sec before reading the next value
          Wait(5000);

          // read sample hv
          size  = HV_FUG_CHS*sizeof(float);
          fHVMeasuredKey->GetData(&hv_measured, &size, TID_FLOAT);

          // check if all measured spin rotator HV's are zero
          int count = 0;
          for (int j=HV_FUG_RIGHT_RODS; j<=HV_FUG_RIGHT_PLATE; j++) {
            if (fabs(hv_measured[j]) < fHVAccuracy)
              count++;
          }
          if (count == 4) { // all spin rotator HV's down
            done  = true;
            happy = true;
          }

          // check if too much time elapsed to reach the final sample hv
          if (t.elapsed() > timeout) {
            done = true;  // quit loop
            // emit warning
            msg = QString("Couldn't shut down Spin Rot HVs within %1 sec: will give it another try in 120 sec.").arg(fHVTimeout);
            emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, arc->lineNo, msg);
          }
        } while (!done);

        if (happy) // everything is OK, get out of the loop
          break;

        // wait 120 sec before retrial
        Wait(120000);
      } else { // NO FUG HV check, hence just wait a 1 min
        Wait(60000);
        break;
      }
    }

    if (i == HV_FUG_MAX_TRY) {
      UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
      // emit error
      msg = QString("Couldn't shut down the Spin Rotator HV, even after a few trials :-( .");
      emit ErrorMsg(1, 0, LAR_SAMPLE_HV_NOT_REACHED, arc->lineNo, msg);
    }

    // degauss spin rotator magnet
    // 1st set current to 0
    cm_msg(MINFO, "SetSpinRot", "SetSpinRot: set Spin Rot Magnet current to 0.");
    cm_yield(0);
    value = 0.0;
    fSpinRotMagOutputKey->SetDataIndex((void*)&value, SPINT_ROT_OUTPUT_CURRENT, TID_FLOAT);
    // check that measured current is going to 0
    done = false;
    timeout = fFieldTimeout * 1e3; // ms -> sec
    t.start(); // start timer
    do {
      // sleep for 1 sec before reading the next value
      Wait(1000);

      size = sizeof(value);
      fSpinRotMagInputKey->GetDataIndex(&value, &size, SPINT_ROT_INPUT_CURRENT, TID_FLOAT);

      if (fabs(value) < 0.1)
        done = true;

      // check if too much time elapsed to reach the final spin rotator magnet current
      if (t.elapsed() > timeout) {
        done = true;  // quit loop
        // emit warning
        msg = QString("Couldn't set the Spin Rot Magnet current within %1 sec.").arg(fFieldTimeout);
        emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, arc->lineNo, msg);
      }
    } while (!done);

    // wait 10 sec
    Wait(10000);

    // 2nd set current to +12.0
    cm_msg(MINFO, "SetSpinRot", "SetSpinRot: set Spin Rot Magnet current to 12.0 A.");
    cm_yield(0);
    value = 12.0;
    fSpinRotMagOutputKey->SetDataIndex((void*)&value, SPINT_ROT_OUTPUT_CURRENT, TID_FLOAT);
    // check that measured current is going to 12A
    done = false;
    timeout = fFieldTimeout * 1e3; // ms -> sec
    t.start(); // start timer
    do {
      // sleep for 1 sec before reading the next value
      Wait(1000);

      size = sizeof(value);
      fSpinRotMagInputKey->GetDataIndex(&value, &size, SPINT_ROT_INPUT_CURRENT, TID_FLOAT);

      if (fabs(value-12.0) < 0.1)
        done = true;

      // check if too much time elapsed to reach the final spin rotator magnet current
      if (t.elapsed() > timeout) {
        done = true;  // quit loop
        // emit warning
        msg = QString("Couldn't set the Spin Rot Magnet current within %1 sec.").arg(fFieldTimeout);
        emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, arc->lineNo, msg);
      }
    } while (!done);

    // wait 30 sec
    Wait(30000);

    // 3rd set current to -1.3A
    cm_msg(MINFO, "SetSpinRot", "SetSpinRot: set Spin Rot Magnet current to -1.3 A.");
    cm_yield(0);
    value = -1.3;
    fSpinRotMagOutputKey->SetDataIndex((void*)&value, SPINT_ROT_OUTPUT_CURRENT, TID_FLOAT);
    // check that measured current is going to -1.3A
    done = false;
    timeout = fFieldTimeout * 1e3; // ms -> sec
    t.start(); // start timer
    do {
      // sleep for 1 sec before reading the next value
      Wait(1000);

      size = sizeof(value);
      fSpinRotMagInputKey->GetDataIndex(&value, &size, SPINT_ROT_INPUT_CURRENT, TID_FLOAT);

      if (fabs(value+1.3) < 0.1)
        done = true;

      // check if too much time elapsed to reach the final spin rotator magnet current
      if (t.elapsed() > timeout) {
        done = true;  // quit loop
        // emit warning
        msg = QString("Couldn't set the Spin Rot Magnet current within %1 sec.").arg(fFieldTimeout);
        emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, arc->lineNo, msg);
      }
    } while (!done);

    // wait 30 sec
    Wait(30000);

    // 4th set current to 0
    cm_msg(MINFO, "SetSpinRot", "SetSpinRot: set Spin Rot Magnet current to 0 - done.");
    cm_yield(0);
    value = 0.0;
    fSpinRotMagOutputKey->SetDataIndex((void*)&value, SPINT_ROT_OUTPUT_CURRENT, TID_FLOAT);
    // check that measured current is going to 0
    done = false;
    timeout = fFieldTimeout * 1e3; // ms -> sec
    t.start(); // start timer
    do {
      // sleep for 1 sec before reading the next value
      Wait(1000);

      size = sizeof(value);
      fSpinRotMagInputKey->GetDataIndex(&value, &size, SPINT_ROT_INPUT_CURRENT, TID_FLOAT);

      if (fabs(value) < 0.1)
        done = true;

      // check if too much time elapsed to reach the final spin rotator magnet current
      if (t.elapsed() > timeout) {
        done = true;  // quit loop
        // emit warning
        msg = QString("Couldn't set the Spin Rot Magnet current within %1 sec.").arg(fFieldTimeout);
        emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, arc->lineNo, msg);
      }
    } while (!done);
  }

  if (arc->param[0] != "off") { // set spin rotation angle
    // check if it is necessary to enable the spin rotator
    int size = sizeof(enabled);
    fSpinRotEnabledKey->GetData((void*)&enabled, &size, TID_BOOL);
    cm_msg(MDEBUG, "SetSpinRot", "SetSpinRot: enabled=%d.", enabled);
    cm_yield(0);
    if (enabled == FALSE) {
      enabled = TRUE;
      cm_msg(MINFO, "SetSpinRot", "SetSpinRot: enable spin rotator.");
      cm_yield(0);
      fSpinRotEnabledKey->SetData((void*)&enabled, 1, TID_BOOL);
      // wait for 10 sec in order to make sure that the analyzer got it enough time to have it updated
      Wait(10000);
    }
    float angle = arc->param[0].toFloat();
    cm_msg(MINFO, "SetSpinRot", "SetSpinRot: set spin rotation angle to %f", angle);
    cm_yield(0);
    fSpinRotAngleKey->SetData((void*)&angle, 1, TID_FLOAT);

    // wait 120 sec
    Wait(120000);
  }

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// SetFOM
//**********************************************************************
void PLemAutoRun::SetFOM(AutoRunCmd *arc)
{
  // param: [0] current

  int   size, status;
  float standby, demand_current, measured_current;
  bool  done;
  float timeout;
  QString msg("");

  if (!fEnabled["fom_eq"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += QString("PLemAutoRun::SetFOM: fom equipment disabled. Will do nothing here.");
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  // get FOM standby flag from ODB
  size = sizeof(standby);
  status = fFOMOutputKey->GetDataIndex(&standby, &size, FOM_STANDBY, TID_FLOAT);
  if (status != DB_SUCCESS) { // error ODB reading
    msg = QString("(%1/%2) FOM %3: Couldn't get standby status, therefore the command will be ignored").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds).arg(arc->param[0]);
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  // get current from parameter list
  demand_current = arc->param[0].toFloat();

  if (demand_current == 0.0) {

    // set current
    fFOMOutputKey->SetDataIndex(&demand_current, FOM_CURRENT_DEMAND, TID_FLOAT);

    // check that current is actually set
    done = false;
    timeout = 300 * 1e3; // timeout in (msec), i.e. 300 sec
    QElapsedTimer t;
    t.start();
    do {
      // sleep for 5 sec before reading the next value
      Wait(5000);

      // read current value
      size  = sizeof(measured_current);
      fFOMInputKey->GetDataIndex(&measured_current, &size, FOM_CURRENT_MEASURED, TID_FLOAT);

      // check if final current is reached
      if (fabs(demand_current-measured_current) < fFOMCurrentAccuracy) {
        done = true;
      }

      if (t.elapsed() > timeout) {
        done = true;  // quit loop
        // emit error
        msg = QString("Current (FOM) was not reached within 300 sec. (demand=%2, measured=%3)").arg(fFieldTimeout).arg(demand_current).arg(measured_current);
        emit ErrorMsg(1, 0, LAR_FOM_CURRENT_NOT_REACHED, arc->lineNo, msg);
      }
    } while (!done);

    // set FOM into standby mode
    standby = 1.0;
    fFOMOutputKey->SetDataIndex(&standby, FOM_STANDBY, TID_FLOAT);

  } else { // current != 0

    // check if FOM is on standby and, if yes, bring it back into operation 
    if (standby != 0.0) {
      standby = 0.0;
      fFOMOutputKey->SetDataIndex(&standby, FOM_STANDBY, TID_FLOAT);
    }

    // wait 20sec so that FOM has the chance to wake up
    Wait(20000);

    // set current
    fFOMOutputKey->SetDataIndex(&demand_current, FOM_CURRENT_DEMAND, TID_FLOAT);

    // check that current is actually set
    done = false;
    timeout = 300 * 1e3; // timeout in (msec), i.e. 300 sec
    QElapsedTimer t;
    t.start();
    do {
      // sleep for 5 sec before reading the next value
      Wait(5000);

      // read current value
      size  = sizeof(measured_current);
      fFOMInputKey->GetDataIndex(&measured_current, &size, FOM_CURRENT_MEASURED, TID_FLOAT);

      // check if final current is reached
      if (fabs(demand_current-measured_current) < fFOMCurrentAccuracy) {
        done = true;
      }

      if (t.elapsed() > timeout) {
        done = true;  // quit loop
        // emit error
        msg = QString("Current (FOM) was not reached within 300 sec. (demand=%2, measured=%3)").arg(fFieldTimeout).arg(demand_current).arg(measured_current);
        emit ErrorMsg(1, 0, LAR_FOM_CURRENT_NOT_REACHED, arc->lineNo, msg);
      }
    } while (!done);

  }

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// SetLEMSetup
//**********************************************************************
void PLemAutoRun::SetLEMSetup(AutoRunCmd *arc)
{
  QString msg("");

  if (!fEnabled["lem_setup_odb"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += QString("PLemAutoRun::SetLEMSetup: setup info ODB entries disabled. Will do nothing here.");
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  fLemSetupKey->SetData((void *)arc->param[0].toLatin1().data(), 1, TID_STRING);

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// SetModInfo
//**********************************************************************
void PLemAutoRun::SetModInfo(AutoRunCmd *arc)
{
  QString msg("");

  if (!fEnabled["mod_name_odb"] || !fEnabled["mod_date_odb"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += QString("PLemAutoRun::SetModInfo: moderator info ODB entries disabled. Will do nothing here.");
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  fModNameKey->SetData((void *)arc->param[0].toLatin1().data(), 1, TID_STRING);
  fModDateKey->SetData((void *)arc->param[1].toLatin1().data(), 1, TID_STRING);

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// CheckOdbType
//**********************************************************************
bool PLemAutoRun::CheckOdbType(INT type, AutoRunCmd *arc)
{
  int     ival;
  float   fval;
  double  dval;
  bool    ok;
  QString str(arc->param[2]);

  switch (type) {
    case TID_BYTE:
    case TID_CHAR:
      ival = str.toInt(&ok);
      if (!ok) { // conversion error
        QString err = QString("PLemAutoRun::CheckOdbType: ODB key type TID_BYTE/TID_CHAR is not compatible with %1. See line no %2").arg(str).arg(arc->lineNo);
        emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
        return false;
      }
      if ((ival < 0) || (ival > 255)) { // range error
        QString err = QString("PLemAutoRun::CheckOdbType: ODB key type TID_BYTE/TID_CHAR; %1 out of range. See line no %2").arg(str).arg(arc->lineNo);
        emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
        return false;
      }
      break;
    case TID_SBYTE:
      ival = str.toInt(&ok);
      if (!ok) { // conversion error
        QString err = QString("PLemAutoRun::CheckOdbType: ODB key type TID_SBYTE is not compatible with %1. See line no %2").arg(str).arg(arc->lineNo);
        emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
        return false;
      }
      if ((ival < -128) || (ival > 127)) { // range error
        QString err = QString("PLemAutoRun::CheckOdbType: ODB key type TID_SBYTE; %1 out of range. See line no %2").arg(str).arg(arc->lineNo);
        emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
        return false;
      }
      break;
    case TID_WORD:
      ival = str.toInt(&ok);
      if (!ok) { // conversion error
        QString err = QString("PLemAutoRun::CheckOdbType: ODB key type TID_WORD is not compatible with %1. See line no %2").arg(str).arg(arc->lineNo);
        emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
        return false;
      }
      if ((ival < 0) || (ival > 65535)) { // range error
        QString err = QString("PLemAutoRun::CheckOdbType: ODB key type TID_WORD; %1 out of range. See line no %2").arg(str).arg(arc->lineNo);
        emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
        return false;
      }
      break;
    case TID_SHORT:
      ival = str.toInt(&ok);
      if (!ok) { // conversion error
        QString err = QString("PLemAutoRun::CheckOdbType: ODB key type TID_SHORT is not compatible with %1. See line no %2").arg(str).arg(arc->lineNo);
        emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
        return false;
      }
      if ((ival < -32768) || (ival > 32767)) { // range error
        QString err = QString("PLemAutoRun::CheckOdbType: ODB key type TID_SHORT; %1 out of range. See line no %2").arg(str).arg(arc->lineNo);
        emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
        return false;
      }
      break;
    case TID_DWORD:
      ival = str.toInt(&ok);
      if (!ok) { // conversion error
        QString err = QString("PLemAutoRun::CheckOdbType: ODB key type TID_DWORD is not compatible with %1. See line no %2").arg(str).arg(arc->lineNo);
        emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
        return false;
      }
      if (ival < 0) { // range error 0 .. 2^31 - 1
        QString err = QString("PLemAutoRun::CheckOdbType: ODB key type TID_DWORD; %1 out of range. See line no %2").arg(str).arg(arc->lineNo);
        emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
        return false;
      }
      break;
    case TID_INT:
      ival = str.toInt(&ok);
      if (!ok) { // conversion error
        QString err = QString("PLemAutoRun::CheckOdbType: ODB key type TID_INT is not compatible with %1. See line no %2").arg(str).arg(arc->lineNo);
        emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
        return false;
      }
      break;
    case TID_BOOL:
      ival = str.toInt(&ok);
      if (!ok) { // conversion error
        QString err = QString("PLemAutoRun::CheckOdbType: ODB key type TID_BOOL is not compatible with %1. See line no %2").arg(str).arg(arc->lineNo);
        emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
        return false;
      }
      if ((ival != 1) && (ival != 0)) { // range error 0 or 1
        QString err = QString("PLemAutoRun::CheckOdbType: ODB key type TID_BOOL; %1 out of range. See line no %2").arg(str).arg(arc->lineNo);
        emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
        return false;
      }
      break;
    case TID_FLOAT:
      fval = str.toFloat(&ok);
      if (!ok) { // conversion error
        QString err = QString("PLemAutoRun::CheckOdbType: ODB key type TID_FLOAT is not compatible with %1. See line no %2").arg(str).arg(arc->lineNo);
        emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
        return false;
      }
      break;
    case TID_DOUBLE:
      dval = str.toDouble(&ok);
      if (!ok) { // conversion error
        QString err = QString("PLemAutoRun::CheckOdbType: ODB key type TID_DOUBLE is not compatible with %1. See line no %2").arg(str).arg(arc->lineNo);
        emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
        return false;
      }
      break;
    case TID_STRING:
      break;
    default:
      QString err = QString("PLemAutoRun::CheckOdbType: Do not now how to handle key type %1 of an ODB_SET_DATA cmd. See line no %2").arg(type).arg(arc->lineNo);
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      return false;
      break;
  }

  return true;
}

//**********************************************************************
// CheckForOdbSetDataCmds
//**********************************************************************
void PLemAutoRun::CheckForOdbSetDataCmds()
{
  PAutoRunCmdVector::Iterator iter;

  // go through all the cmd's and check for setOdbData cmds in order to perform the 
  // necessary tests **before** starting the autorun.
  for (iter = fAutoRunCmdVector->begin(); iter != fAutoRunCmdVector->end(); ++iter) {
    if (iter->cmd == "setOdbData") {
      // check if set path makes sense
      PKey *setKey = 0;
      QString setPath = iter->param[0];
      setKey = new PKey(fExp, setPath);
      if (!setKey->IsValid()) { // key not found
        // error message
        QString err = QString("PLemAutoRun::CheckForOdbSetDataCmds: Couldn't access ODB set key %1 from the ODB_SET_DATA cmd.").arg(iter->param[0]);
        emit StatusMsg(err);
        emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
        // clean up
        if (setKey) {
          delete setKey;
          setKey = 0;
        }
        return;
      }

      // check if the set index is within bounds
      if (!iter->param[1].isEmpty()) { // i.e. set_key_index is present
        int index = iter->param[1].toInt();
        if (index > setKey->GetNumValues()) { // index out of range
          // error message
          QString err = QString("PLemAutoRun::CheckForOdbSetDataCmds: ODB_SET_DATA set index '%1' out of range (%2)!").arg(iter->param[1]).arg(setKey->GetNumValues());
          emit StatusMsg(err);
          emit ErrorMsg(1, 0, LAR_MIDAS_ODB_FAILURE, -1, err);
          // clean up
          if (setKey) {
            delete setKey;
            setKey = 0;
          }
          return;
        }
      }

      // check if the data type makes sense
      if (!CheckOdbType(setKey->GetType(), iter)) {
        // clean up
        if (setKey) {
          delete setKey;
          setKey = 0;
        }
        return;
      }

      // check if there is a readback part
      if (!iter->param[3].isEmpty()) { // i.e. odb_readback_key_path is present

        // get read path and check for aliases
        QString readPath = iter->param[3];

        PKey *readKey = new PKey(fExp, readPath);
        if (!readKey->IsValid()) { // key not found
          // error message
          QString err = QString("PLemAutoRun::CheckForOdbSetDataCmds: Couldn't access ODB read key %1 from the ODB_SET_DATA cmd.").arg(iter->param[3]);
          emit StatusMsg(err);
          emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
          // clean up
          if (setKey) {
            delete setKey;
            setKey = 0;
          }
          if (readKey) {
            delete readKey;
            readKey = 0;
          }
          return;
        }

        if (!iter->param[4].isEmpty()) {
          int index = iter->param[4].toInt();
          if (index > readKey->GetNumValues()) { // index out of range
            // error message
            QString err = QString("PLemAutoRun::CheckForOdbSetDataCmds: ODB_SET_DATA read index '%1'' out of range (%2)!").arg(index).arg(readKey->GetNumValues());
            emit StatusMsg(err);
            emit ErrorMsg(1, 0, LAR_MIDAS_ODB_FAILURE, -1, err);
            // clean up
            if (setKey) {
              delete setKey;
              setKey = 0;
            }
            if (readKey) {
              delete readKey;
              readKey = 0;
            }
            return;
          }
        }
        // clean up
        if (readKey) {
          delete readKey;
          readKey = 0;
        }
      }

      // clean up
      if (setKey) {
        delete setKey;
        setKey = 0;
      }
    }

    if (iter->cmd == "setOdbDataArray") {
      // check if set path makes sense
      PKey *setKey = 0;
      QString setPath = iter->param[0];
      setKey = new PKey(fExp, setPath);
      if (!setKey->IsValid()) { // key not found
        // error message
        QString err = QString("PLemAutoRun::CheckForOdbSetDataCmds: Couldn't access ODB set key %1 from the ODB_SET_DATA_ARRAY cmd.").arg(iter->param[0]);
        emit StatusMsg(err);
        emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
        // clean up
        if (setKey) {
          delete setKey;
          setKey = 0;
        }
        return;
      }

      // check type
      bool  ok;
      QString type;
      for (int i=1; i<iter->noElements; i++) {
        // get out what type the key is in order to convert the set value string
        switch (setKey->GetType()) {
          case TID_BYTE:
          type = "TID_BYTE";
          if (iter->param[i].length() > 1)
            ok = false;
          break;
          case TID_CHAR:
            type = "TID_CHAR";
            if (iter->param[i].length() > 1)
              ok = false;
            break;
          case TID_SBYTE:
            type = "TID_SBYTE";
            if (iter->param[i].length() > 1)
              ok = false;
            break;
          case TID_WORD:
            type = "TID_WORD";
            iter->param[i].toInt(&ok);
            break;
          case TID_SHORT:
            type = "TID_SHORT";
            iter->param[i].toInt(&ok);
            break;
          case TID_DWORD:
            type = "TID_DWORD";
            iter->param[i].toInt(&ok);
            break;
          case TID_INT:
            type = "TID_INT";
            iter->param[i].toInt(&ok);
            break;
          case TID_BOOL:
            type = "TID_BOOL";
            iter->param[i].toInt(&ok);
            break;
          case TID_FLOAT:
            type = "TID_FLOAT";
            iter->param[i].toFloat(&ok);
            break;
          case TID_DOUBLE:
            type = "TID_DOUBLE";
            iter->param[i].toDouble(&ok);
            break;
          default:
            type = "TID_STRING";
            return;
        }
        if (!ok) { // error occured
          // error message
          QString err = QString("CheckForOdbSetDataCmds: Wrong data type of element '%1', should be '%2'").arg(iter->param[i]).arg(type);
          emit StatusMsg(err);
          emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
        }
      }

      // make sure that the number of elements fit
      if (iter->noElements-1 != setKey->GetNumValues()) {
        // error message
        QString err = QString("CheckForOdbSetDataCmds: Wrong number of element '%1', should be '%2'").arg(iter->noElements-1).arg(setKey->GetNumValues());
        emit StatusMsg(err);
        emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      }

      // clean up
      if (setKey) {
        delete setKey;
        setKey = 0;
      }
    }
  }
}

//**********************************************************************
// SetOdbData
//**********************************************************************
void PLemAutoRun::SetOdbData(AutoRunCmd *arc)
{
  QString msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  // convert all the necessary values
  int    timeout   = 0;
  double tolerance = 0.0;
  int    ival = 0;
  float  fval = 0.0;
  double dval = 0.0;
  double setVal;
  char   sval[256];
  int    typeTag = 0; // 0 = int etc.; 1 = float; 2 = double; 3 = string
  int    setIndex;
  int    readIndex;

  // check odb set path for alias
  QString setPath = arc->param[0];

  if (!arc->param[5].isEmpty()) // timeout given
    timeout = arc->param[5].toInt() * 1000; // timeout in (ms)

  if (!arc->param[6].isEmpty()) // tolerance given
    tolerance = arc->param[6].toDouble();

  // open set key
  PKey *setKey = 0;
  setKey = new PKey(fExp, setPath);
  if (!setKey->IsValid()) { // key not found
    // error message
    QString err = QString("PLemAutoRun::SetOdbData: Couldn't access ODB set key %1 from the ODB_SET_DATA cmd.").arg(arc->param[0]);
    emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
    // clean up
    if (setKey) {
      delete setKey;
      setKey = 0;
    }
    return;
  }

  // get out what type the key is in order to convert the set value string
  switch (setKey->GetType()) {
    case TID_BYTE:
    case TID_CHAR:
    case TID_SBYTE:
    case TID_WORD:
    case TID_SHORT:
    case TID_DWORD:
    case TID_INT:
    case TID_BOOL:
      ival = arc->param[2].toInt();
      setVal = ival;
      typeTag = 0;
      break;
    case TID_FLOAT:
      fval = arc->param[2].toFloat();
      setVal = fval;
      typeTag = 1;
      break;
    case TID_DOUBLE:
      dval = arc->param[2].toDouble();
      setVal = dval;
      typeTag = 2;
      break;
    case TID_STRING:
      typeTag = 3;
      break;
    default:
      return;
  }

  // open read key if needed
  PKey *readKey = 0;
  if (!arc->param[3].isEmpty()) { // i.e. odb_readback_key_path is present
    QString readPath = arc->param[3];

    readKey = new PKey(fExp, readPath);
    if (!readKey->IsValid()) { // key not found
      // error message
      QString err = QString("PLemAutoRun::SetOdbData: Couldn't access ODB read key %1 from the ODB_SET_DATA cmd.").arg(arc->param[3]);
      emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
      // clean up
      if (setKey) {
        delete setKey;
        setKey = 0;
      }
      if (readKey) {
        delete readKey;
        readKey = 0;
      }
      return;
    }
  }

  // set value
  if (arc->param[1].isEmpty()) { // no index given
    switch (typeTag) {
      case 0: // int etc.
        setKey->SetData(&ival, 1, setKey->GetType());
        break;
      case 1: // float
        setKey->SetData(&fval, 1, setKey->GetType());
        break;
      case 2: // double
        setKey->SetData(&dval, 1, setKey->GetType());
        break;
      case 3: // int etc.
        strcpy(sval, arc->param[2].toLatin1().data());
        setKey->SetData(sval, 1, setKey->GetType());
        break;
      default:
        break;
    }
  } else { // index given
    setIndex = arc->param[1].toInt();
    switch (typeTag) {
      case 0: // int etc.
        setKey->SetDataIndex(&ival, setIndex, setKey->GetType());
        break;
      case 1: // float
        setKey->SetDataIndex(&fval, setIndex, setKey->GetType());
        break;
      case 2: // double
        setKey->SetDataIndex(&dval, setIndex, setKey->GetType());
        break;
      case 3: // int etc.
        strcpy(sval, arc->param[2].toLatin1().data());
        setKey->SetDataIndex(sval, setIndex, setKey->GetType());
        break;
      default:
        break;
    }
  }

  if (readKey) { // readback key given, i.e. not only set ODB value, but compare it with its readback value
    // check if read index is given
    if (!arc->param[4].isEmpty())
      readIndex = arc->param[4].toInt();
    else
      readIndex = -1;

    QElapsedTimer  time;
    bool   done = false;
    INT    size;
    double readVal = 0.0;

    time.start();
    do {
      // get value
      if (readIndex < 0) { // not an array
        switch (readKey->GetType()) {
          case TID_BYTE:
          case TID_CHAR:
          case TID_SBYTE:
          case TID_WORD:
          case TID_SHORT:
          case TID_DWORD:
          case TID_INT:
          case TID_BOOL:
            size = sizeof(ival);
            readKey->GetData(&ival, &size, readKey->GetType());
            readVal = ival;
            break;
          case TID_FLOAT:
            size = sizeof(fval);
            readKey->GetData(&fval, &size, readKey->GetType());
            readVal = fval;
            break;
          case TID_DOUBLE:
            size = sizeof(dval);
            readKey->GetData(&dval, &size, readKey->GetType());
            readVal = dval;
            break;
          default:
            break;
        }
      } else { // value from an array
        switch (readKey->GetType()) {
          case TID_BYTE:
          case TID_CHAR:
          case TID_SBYTE:
          case TID_WORD:
          case TID_SHORT:
          case TID_DWORD:
          case TID_INT:
          case TID_BOOL:
            size = sizeof(ival);
            readKey->GetDataIndex(&ival, &size, readIndex, readKey->GetType());
            readVal = ival;
            break;
          case TID_FLOAT:
            size = sizeof(fval);
            readKey->GetDataIndex(&fval, &size, readIndex, readKey->GetType());
            readVal = fval;
            break;
          case TID_DOUBLE:
            size = sizeof(dval);
            readKey->GetDataIndex(&dval, &size, readIndex, readKey->GetType());
            readVal = dval;
            break;
          default:
            break;
        }
      }

      // check if job is done
      if (fabs(setVal-readVal) < tolerance) {
        done = true;
      }

      // sleep for 2 sec before reading the next value
      Wait(2000);
    } while((time.elapsed() < timeout) && !done);

    if (!done) { // timeout fired before job was done
      QString err = QString("WARNING: Couldn't reach demand value: | demand = %1 - measured = %2 | > %3 after timeout of %4 (sec) was reached.").arg(setVal).arg(readVal).arg(tolerance).arg(timeout/1000.0);
      emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, err);
      return;
    }
  }

  // clean up
  if (setKey) {
    delete setKey;
    setKey = 0;
  }
  if (readKey) {
    delete readKey;
    readKey = 0;
  }

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// SetOdbDataArray
//**********************************************************************
void PLemAutoRun::SetOdbDataArray(AutoRunCmd *arc)
{
  QString msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  // check odb set path for alias
  QString setPath = arc->param[0];

  // open set key
  PKey *setKey = 0;
  setKey = new PKey(fExp, setPath);
  if (!setKey->IsValid()) { // key not found
    // error message
    QString err = QString("PLemAutoRun::SetOdbData: Couldn't access ODB set key %1 from the ODB_SET_DATA cmd.").arg(arc->param[0]);
    emit ErrorMsg(1, 0, LAR_MIDAS_KEY_FAILURE, -1, err);
    // clean up
    if (setKey) {
      delete setKey;
      setKey = 0;
    }
    return;
  }

  // fill data
  float *data = new float[arc->noElements-1];
  for (int i=1; i<arc->noElements; i++)
    data[i-1] = arc->param[i].toFloat();

  // set it in ODB
  setKey->SetData(data, arc->noElements-1, TID_FLOAT);

  // clean up
  if (data) {
    delete data;
    data = 0;
  }
  if (setKey) {
    delete setKey;
    setKey = 0;
  }

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// SetSampleHV
//**********************************************************************
void PLemAutoRun::SetSampleHV(AutoRunCmd *arc)
{
  int   size;
  int   i;
  float value;
  float demand;
  QString msg("");

  // check if FUG handling is disabled in lemAutoRun
  if (!fEnabled["fug_scfe"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += arc->cmdString;
    msg += ": FUG disabled in lemAutoRun. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }
  // check if FUG equipment is disabled in lemAutoRun
  if (!fEnabled["fug_eq"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += "PLemAutoRun::SetSampleHV: FUG equipment disabled in lemAutoRun. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  // check if the hv_fug_scfe frontend is running
  CheckClients();
  if (!fHVFeRunning) { // error too severe to going on
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    QString err = QString("PLemAutoRun::SetSampleHV: Slowcontrol Frontend NOT running.\n")+
                  QString("  Error too severe, will stop.");
    emit ErrorMsg(1, 0, LAR_MIDAS_FE_NOT_RUNNING, -1, err);
    DisconnectFromExp();
    QCoreApplication::exit(0);
    exit(0);
  }

  // send command notifier
  msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  // Loop over set HV. This is done this way to reduce hangers due to network problems
  for (i=0; i<HV_FUG_MAX_TRY; i++) {
    // set sample hv
    size  = sizeof(value);
    value = arc->param[0].toFloat() + (-1)*(i%2)*0.001; // i-term to force the DD set command being executed
    fHVDemandKey->SetDataIndex((void *)&value, HV_FUG_SAMPLE, TID_FLOAT);

    if (fFugHvCheck) {
      // check that the final sample hv is reached reached it
      bool  done  = false;
      bool  happy = false;
      float timeout = fHVTimeout * 1e3;
      QElapsedTimer t;
      t.start();
      demand = value; // keep demand hv
      do {
        // sleep for 5 sec before reading the next value
        Wait(5000);

        // read sample hv
        size  = sizeof(value);
        fHVMeasuredKey->GetDataIndex(&value, &size, HV_FUG_SAMPLE, TID_FLOAT);

        // check if final sample hv is reached
        if (fabs(demand-value) < fHVAccuracy) { // final hv reached within fHVAccuracy
          done  = true;
          happy = true;
        }

        // check if too much time elapsed to reach the final sample hv
        if (t.elapsed() > timeout) {
          done = true;  // quit loop
          // emit warning
          msg = QString("Sample HV of demand=%1 (kV) was not reached (measured=%2 (kV)) within %3 sec: will give it another try in 120 sec.").arg(demand).arg(value).arg(fHVTimeout);
          emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, arc->lineNo, msg);
        }
      } while (!done);

      if (happy) // everything is OK, get out of the loop
        break;

      // wait 120 sec before retrial
      Wait(120000);
    } else { // NO FUG HV check, hence just wait a 1 min
      Wait(60000);
      break;
    }
  }

  if (i == HV_FUG_MAX_TRY) {
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    // emit error
    msg = QString("Couldn't set Sample HV of %1 (kV), even after a few trials :-( .").arg(demand);
    emit ErrorMsg(1, 0, LAR_SAMPLE_HV_NOT_REACHED, arc->lineNo, msg);
  }

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// SetRA_HV
//**********************************************************************
void PLemAutoRun::SetRA_HV(AutoRunCmd *arc)
{
  int   size;
  int   i;
  float value[4];
  float demand[4];
  QString msg("");

  // check if FUG handling is disabled in lemAutoRun
  if (!fEnabled["fug_scfe"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += arc->cmdString;
    msg += ": FUG disabled in lemAutoRun. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }
  // check if FUG equipment is disabled in lemAutoRun
  if (!fEnabled["fug_eq"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += "PLemAutoRun::SetRA_HV: FUG equipment disabled in lemAutoRun. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  // check if the hv_fug_scfe frontend is running
  CheckClients();
  if (!fHVFeRunning) { // error too severe to going on
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    QString err = QString("PLemAutoRun::SetRA_HV: Slowcontrol Frontend NOT running.\n")+
                  QString("  Error too severe, will stop.");
    emit ErrorMsg(1, 0, LAR_MIDAS_FE_NOT_RUNNING, -1, err);
    DisconnectFromExp();
    QCoreApplication::exit(0);
    exit(0);
  }

  // send command notifier
  msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  // Loop over set HV. This is done this way to reduce hangers due to network problems
  for (i=0; i<HV_FUG_MAX_TRY; i++) {
    // set RA HV left
    size  = sizeof(float);
    value[0] = arc->param[0].toFloat() + (-1)*(i%2)*0.001; // i-term to force the DD set command being executed
    fHVDemandKey->SetDataIndex((void *)&value[0], HV_FUG_RAL, TID_FLOAT);
    // set RA HV right
    size  = sizeof(float);
    value[1] = arc->param[1].toFloat() + (-1)*(i%2)*0.001; // i-term to force the DD set command being executed
    fHVDemandKey->SetDataIndex((void *)&value[1], HV_FUG_RAR, TID_FLOAT);
    if (arc->noElements == 4) {
      // set RA HV top
      size  = sizeof(float);
      value[2] = arc->param[2].toFloat() + (-1)*(i%2)*0.001; // i-term to force the DD set command being executed
      fHVDemandKey->SetDataIndex((void *)&value[2], HV_FUG_RAT, TID_FLOAT);
      // set RA HV bottom
      size  = sizeof(float);
      value[3] = arc->param[3].toFloat() + (-1)*(i%2)*0.001; // i-term to force the DD set command being executed
      fHVDemandKey->SetDataIndex((void *)&value[3], HV_FUG_RAB, TID_FLOAT);
    }

    if (fFugHvCheck) {
      // check that the final sample hv is reached reached it
      bool  done  = false;
      bool  happy = false;
      float timeout = fHVTimeout * 1e3;
      QElapsedTimer t;
      t.start();
      // keep demand hv
      for (int j=0; j<arc->noElements; j++) {
        demand[j] = value[j];
      }

      do {
        // sleep for 5 sec before reading the next value
        Wait(5000);

        // read RA left HV
        size  = sizeof(float);
        fHVMeasuredKey->GetDataIndex(&value[0], &size, HV_FUG_RAL, TID_FLOAT);
        // read RA right HV
        size  = sizeof(float);
        fHVMeasuredKey->GetDataIndex(&value[1], &size, HV_FUG_RAR, TID_FLOAT);
        if (arc->noElements == 4) {  // L,R,T,B given
          // read RA top HV
          size  = sizeof(float);
          fHVMeasuredKey->GetDataIndex(&value[2], &size, HV_FUG_RAT, TID_FLOAT);
          // read RA bottom HV
          size  = sizeof(float);
          fHVMeasuredKey->GetDataIndex(&value[3], &size, HV_FUG_RAB, TID_FLOAT);
        }

        // check if final RA hv's are reached
        if (arc->noElements == 4) { // L,R,T,B given
          if ((fabs(demand[0]-value[0]) < fHVAccuracy) &&
              (fabs(demand[1]-value[1]) < fHVAccuracy) &&
              (fabs(demand[2]-value[2]) < fHVAccuracy) &&
              (fabs(demand[3]-value[3]) < fHVAccuracy)) { // final hv reached within fHVAccuracy
            done  = true;
            happy = true;
          }
        } else {// L,R given
          if ((fabs(demand[0]-value[0]) < fHVAccuracy) &&
              (fabs(demand[1]-value[1]) < fHVAccuracy)) { // final hv reached within fHVAccuracy
            done  = true;
            happy = true;
          }
        }

        // check if too much time elapsed to reach the final sample hv
        if (t.elapsed() > timeout) {
          done = true;  // quit loop
          // emit warning
          if (arc->noElements == 2) { // L,R given
            msg = QString("RA HV of demand=(%1/%2), measured=(%3/%4) (kV), was not reached within %5 sec: will give it another try in 120 sec.").arg(demand[0]).arg(demand[1]).arg(value[0]).arg(value[1]).arg(fHVTimeout);
          } else { // L,R,T,B given
            msg = QString("RA HV of demand=(%1/%2/%3/%4), measured=(%5/%6/%7/%8) (kV), was not reached within %9 sec: will give it another try in 120 sec.").arg(demand[0]).arg(demand[1]).arg(demand[2]).arg(demand[3]).arg(value[0]).arg(value[1]).arg(value[2]).arg(value[3]).arg(fHVTimeout);
          }
          emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, arc->lineNo, msg);
        }
      } while (!done);

      if (happy) // everything is OK, get out of the loop
        break;

      // wait 120 sec before retrial
      Wait(120000);
    } else { // NO FUG HV check, hence just wait a 1 min
      Wait(60000);
      break;
    }
  }

  if (i == HV_FUG_MAX_TRY) {
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    if (arc->noElements == 2) { // L,R given
      msg = QString("RA HV of (%1/%2) (kV), was not reached even after several trials :-( ").arg(arc->param[0]).arg(arc->param[1]);
    } else { // L,R,T,B given
      msg = QString("RA HV of (%1/%2/%3/%4) (kV), was not reached even after several trials :-( ").arg(arc->param[0]).arg(arc->param[1]).arg(arc->param[2]).arg(arc->param[3]);
    }
    emit ErrorMsg(1, 0, LAR_SAMPLE_HV_NOT_REACHED, arc->lineNo, msg);
  }

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// CheckForTransportHvCmd
//**********************************************************************
bool PLemAutoRun::CheckForTransportHvCmd()
{
  PAutoRunCmdVector::Iterator iter;

  for (iter = fAutoRunCmdVector->begin(); iter != fAutoRunCmdVector->end(); ++iter) {
    if (iter->cmd == "setTransportHV") {
      // check if the hv setting file exists
      QString filePath = fHvSettingsPath + iter->param[0];
      QFileInfo fileInfo(filePath);
      if (!fileInfo.exists()) {
        QString msg = filePath + QString(" does not exist! Fix that first!");
        emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, msg);

        UpdateWebPage(iter, HTML_PARSE_ERROR, iter->lineNo, msg);

        msg = QString("Autorun stopped: Skript failure");
        emit StatusMsg(msg);

        return false;
      }

      // check the file is a proper hv setting file
      if (!LoadHvSettings(iter, filePath, iter->lineNo, true)) {
        return false;
      }
    }
  }

  return true;
}

//**********************************************************************
// LoadHvSettings
//**********************************************************************
bool PLemAutoRun::LoadHvSettings(PAutoRunCmdVector::Iterator iter, QString fln, int lineNo, bool simulated)
{
  // check if FUG equipment is disabled in lemAutoRun
  if (!fEnabled["fug_eq"]) {
    return true;
  }

  // try to load the HV settings file
  if (!QFile::exists(fln)) {
    QString err = "lemAutoRun: Couldn't find HV setting file: " + fln;
    emit ErrorMsg(1, 0, LAR_XML_FILE_MISSING, -1, err);
    return false;
  }

  PLemHvSettingsFileParser handler(fln);
  if (!handler.parseIsValid()) {
    QString err = "lemAutoRun: Couldn't parse HV setting file: " + fln;
    emit ErrorMsg(1, 0, LAR_XML_FILE_MISSING, -1, err);
    return false;
  }

  QString errMsg = "";
  if (!handler.isValid(errMsg)) {
    UpdateWebPage(iter, HTML_PARSE_ERROR, iter->lineNo, errMsg);

    QString err = "lemAutoRun: Couldn't read HV setting file: " + fln;
    emit ErrorMsg(1, 0, LAR_XML_FILE_MISSING, -1, errMsg);

    return false;
  }

  if (simulated)
    return true;

  QVector<int> *hvCh = handler.GetChNo();
  QVector<QString> *hvChName = handler.GetHvChNames();
  QVector<float> *hvDemand = handler.GetHvDemands();
  QVector<float> *currentLimit = handler.GetCurrentLimits();

  float *pHvDemand = (float*)malloc(hvDemand->size()*sizeof(float));
  float *pCurrentLimit = (float*)malloc(currentLimit->size()*sizeof(float));
  float *pHvMeasured = (float*)malloc(hvDemand->size()*sizeof(float));

  // current magnetic field value
  int size = sizeof(float);
  float magFieldValue{0.0};
  fMagFieldKey->GetData(&magFieldValue, &size, TID_FLOAT);
  for (int i=0; i<hvCh->size(); i++) {
    if (fSetupWewEnabled && hvChName->at(i).startsWith("RA-") && (magFieldValue > 110.0)) { // WEW in use && HV RA channel && B>110G        
      pHvDemand[hvCh->at(i)-1] = 0.0;
      if (hvChName->at(i).startsWith("RA-L")) {
        cm_msg(MINFO, "lemAutoRun", "The field of WEW (%0.2f G) > 110.0 G. Hence, the RA HV-values are set to 0.0kV.", magFieldValue);
        cm_yield(0);
      }
    } else {
      pHvDemand[hvCh->at(i)-1] = hvDemand->at(i);
    }
    pCurrentLimit[hvCh->at(i)-1] = currentLimit->at(i);
  }

  // set current limit values
  QString path = QString("/Equipment/HV/Settings/Current Limit");
  PKey currentLimitKey(fExp, path);
  if (!currentLimitKey.IsValid()) {
    errMsg = "**ERROR** couldn't obtain the current limit ODB key";

    UpdateWebPage(iter, HTML_PARSE_ERROR, iter->lineNo, errMsg);

    QString err = "lemAutoRun: Couldn't read HV setting file: " + fln;
    emit ErrorMsg(1, 0, LAR_XML_FILE_MISSING, -1, errMsg);

    // clean up
    free(pHvDemand);
    free(pCurrentLimit);

    return false;
  }
  currentLimitKey.SetData(pCurrentLimit, currentLimit->size(), TID_FLOAT);

  // set HV values
  fHVDemandKey->SetData(pHvDemand, hvDemand->size(), TID_FLOAT);

  if (fFugHvCheck) {
    // make sure that the demanded HV's are actually reached within a given time
    bool done = false;
    QVector<int> hv_reached;
    hv_reached.resize(hvDemand->size());
    for (int i=0; i<hv_reached.size(); i++)
      hv_reached[i] = 0;
    float timeout = fHVTimeout * 1e3;
    QElapsedTimer t;
    t.start();
    int size;
    do {
      // sleep for 5 sec before reading the next value
      Wait(5000);

      // get the measured HV's
      size = hvDemand->size()*sizeof(float);
      fHVMeasuredKey->GetData(pHvMeasured, &size, TID_FLOAT);

      // check if the HV's reached the demand values
      size = 0;
      for (int i=0; i<hvDemand->size(); i++) {
        if (fabs(pHvDemand[i]-pHvMeasured[i]) < fHVAccuracy) { // final hv reached within fHVAccuracy
          hv_reached[i] = 1;
        }
        size += hv_reached[i];
      }

      // if all HV's reached their demand values
      if (size == (int)hvDemand->size())
        done = true;

      // check if too much time elapsed to reach the final HV settings
      if (t.elapsed() > timeout) {
        done = true;  // quit loop
        // emit warning
        QString msg = QString("HV settings could not be reached within %3 sec.").arg(fHVTimeout);
        emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, lineNo, msg);
      }
    } while (!done);
  } else { // NO FUG HV check, hence just wait a 1 min
    Wait(60000);
  }

  // clean up
  free(pHvDemand);
  free(pCurrentLimit);
  free(pHvMeasured);

  return true;
}

//**********************************************************************
// SetTransportHV
//**********************************************************************
void PLemAutoRun::SetTransportHV(AutoRunCmd *arc)
{
  QString msg("");

  // check if FUG handling is disabled in lemAutoRun
  if (!fEnabled["fug_scfe"]) {
    msg  = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += arc->cmdString;
    msg += ": FUG disabled in lemAutoRun. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }
  // check if FUG equipment is disabled in lemAutoRun
  if (!fEnabled["fug_eq"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += "PLemAutoRun::SetTransportHV: FUG equipment disabled in lemAutoRun. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  // send command notifier
  msg  = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  QString filePath = fHvSettingsPath + arc->param[0];
  LoadHvSettings(arc, filePath, arc->lineNo);

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// SetHvOff
//**********************************************************************
void PLemAutoRun::SetHvOff(AutoRunCmd *arc)
{
  QString msg("");

  // check if FUG handling is disabled in lemAutoRun
  if (!fEnabled["fug_scfe"]) {
    msg  = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += arc->cmdString;
    msg += ": FUG disabled in lemAutoRun. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }
  // check if FUG equipment is disabled in lemAutoRun
  if (!fEnabled["fug_eq"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += "PLemAutoRun::SetHvOff: FUG equipment disabled in lemAutoRun. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  // send command notifier
  msg  = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  int size;
  float fval[4] = {0.0, 0.0, 0.0, 0.0};
  QElapsedTimer t;
  float timeout = 300 * 1e3; // 5 min
  bool done=false;
  if (arc->param[0].contains("mc", Qt::CaseInsensitive)) {
    // switch off FUG's in the MC
    cm_msg(MINFO, "PLemAutoRun::SetHvOff", "PLemAutoRun::SetHvOff: shut down FUG HV's in the Moderator Chamber ...");
    cm_yield(0);
    for (int i=HV_FUG_MOD; i<=HV_FUG_MIRROR; i++)
      fHVDemandKey->SetDataIndex((void *)&fval[0], i, TID_FLOAT);
    // switch off MCP1 HV
    cm_msg(MINFO, "PLemAutoRun::SetHvOff", "PLemAutoRun::SetHvOff: shut down MCP1 HV in the Moderator Chamber ...");
    cm_yield(0);
    fHVDetectorDemandKey->SetDataIndex((void *)&fval[0], HV_NHQ_MCP1, TID_FLOAT);
    // wait until MCP1 HV is small enough
    t.start();
    do {
      // sleep for 5 sec before reading the next value
      Wait(5000);

      // read MCP1 HV
      size  = sizeof(float);
      fHVDetectorMeasuredKey->GetDataIndex(&fval[0], &size, HV_NHQ_MCP1, TID_FLOAT);

      if (fabs(fval[0]) < 0.3) {
        done = true;
      }

      // check if too much time elapsed to reach the final sample hv
      if (t.elapsed() > timeout) {
        done = true;  // quit loop
        // emit warning
        msg = QString("HV_OFF MC: demand=0.0kV [measured=(%5/%6/%7/%8) (kV)] was not reached within 180 sec. will go to the next command.").arg(fval[0]).arg(fval[1]).arg(fval[2]).arg(fval[3]);
        emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, arc->lineNo, msg);
      }
    } while (!done);
  } else if (arc->param[0].contains("tc", Qt::CaseInsensitive)) {
    // switch off FUG's in the TC
    cm_msg(MINFO, "PLemAutoRun::SetHvOff", "PLemAutoRun::SetHvOff: shut down FUG HV's in the Trigger Chamber ...");
    cm_yield(0);
    // Spin Rot Off
    for (int i=HV_FUG_RIGHT_RODS; i<=HV_FUG_RIGHT_PLATE; i++)
      fHVDemandKey->SetDataIndex((void *)&fval[0], i, TID_FLOAT);
    for (int i=HV_FUG_LENSE_2; i<=HV_FUG_LENSE_3; i++)
      fHVDemandKey->SetDataIndex((void *)&fval[0], i, TID_FLOAT);
    // switch off TD HV
    cm_msg(MINFO, "PLemAutoRun::SetHvOff", "PLemAutoRun::SetHvOff: shut down TD HV's in the Trigger Chamber ...");
    cm_yield(0);
    for (int i=HV_NHQ_TD_FIRST; i<=HV_NHQ_TD_LAST; i++)
      fHVDetectorDemandKey->SetDataIndex((void *)&fval[0], i, TID_FLOAT);
    // wait until TD HV is small enough
    t.start();
    do {
      // sleep for 5 sec before reading the next value
      Wait(5000);

      // read TD HV's
      for (int i=HV_NHQ_TD_FIRST; i<=HV_NHQ_TD_LAST; i++) {
        size  = sizeof(float);
        fHVDetectorMeasuredKey->GetDataIndex(&fval[i], &size, i, TID_FLOAT);
      }

      if ((fabs(fval[0]) < 0.3) && (fabs(fval[1]) < 0.3) && (fabs(fval[2]) < 0.3) && (fabs(fval[4]) < 0.3)) {
        done = true;
      }

      // check if too much time elapsed to reach the final sample hv
      if (t.elapsed() > timeout) {
        done = true;  // quit loop
        // emit warning
        msg = QString("HV_OFF TC: demand=0.0kV [measured=(%5/%6/%7/%8) (kV)] was not reached within 180 sec. will go to the next command.").arg(fval[0]).arg(fval[1]).arg(fval[2]).arg(fval[3]);
        emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, arc->lineNo, msg);
      }
    } while (!done);
  } else if (arc->param[0].contains("sc", Qt::CaseInsensitive)) {
    // switch off FUG's in the SC
    cm_msg(MINFO, "PLemAutoRun::SetHvOff", "PLemAutoRun::SetHvOff: shut down FUG HV's in the Trigger Chamber ...");
    cm_yield(0);
    for (int i=HV_FUG_RAL; i<=HV_FUG_SAMPLE; i++)
      fHVDemandKey->SetDataIndex((void *)&fval, i, TID_FLOAT);
  }

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// SetSampleLSZoneSettings
//**********************************************************************
void PLemAutoRun::SetSampleLSZoneSettings()
{
  // check if sample equipment is disabled in lemAutoRun
  if (!fEnabled["sample_eq"]) {
    return;
  }

  PAutoRunCmdVector::Iterator iter;
  bool check_needed = false;
  int  status, size;

  for (iter = fAutoRunCmdVector->begin(); iter != fAutoRunCmdVector->end(); ++iter) {
    if (iter->cmd == "setTemp") {
      check_needed = true;
      break;
    }
  }

  if (!check_needed) // no check needed: get out of here
    return;

  // check if CMODE==2, i.e. ZONE setting active
  // if yes -> overwrite potential rubbish
  // if no  -> it is the experimenters business what he/she is doing
  float cmode;
  size = sizeof(cmode); 
  fSampleOutputKey->GetDataIndex(&cmode, &size, LS336_OUTPUT_HEATER_MODE, TID_FLOAT);
  if (cmode != 2) // control mode different than ZONE setting -> nothing to be done
    return;

  // get ZONE settings key
  PKey *zoneKey;
  QString str = QString("/Equipment/SampleCryo/Settings/Devices/Lake336_Sample_0/DD/Zone/Zone");

  zoneKey = new PKey(fExp, str);
  if (!zoneKey->IsValid()) {
    QString err = QString("sample cryo ZONE settings key not found.");
    emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, err);
    return;
  }

  // get current demand temperature
  float temp;
  size = sizeof(float);
  fSampleOutputKey->GetDataIndex(&temp, &size, LS336_OUTPUT_SETPOINT, TID_FLOAT);

  char zone_str[64];
  size = sizeof(zone_str);
  float loop, zone, top_value, p_pid, i_pid, d_pid, mount_value, range;
  for (int i=0; i<10; i++) {
    // get ith zone setting
    zoneKey->GetDataIndex(zone_str, &size, i, TID_STRING);
    // extract parameters
    status = sscanf(zone_str, "%f,%f,%f,%f,%f,%f,%f,%f", &loop, &zone, &top_value,
                    &p_pid, &i_pid, &d_pid, &mount_value, &range);
    if (status != 8) {
      QString err = QString("Couldn't extract sample cryo ZONE settings (%1/%2).").arg(status).arg(zone_str);
      emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, err);
      return;
    }
    if (temp < top_value) // found proper zone
      break;
  }

  // set all the proper parameters
  fSampleOutputKey->SetDataIndex(&p_pid, LS336_OUTPUT_PID_P ,TID_FLOAT);
  fSampleOutputKey->SetDataIndex(&i_pid, LS336_OUTPUT_PID_I ,TID_FLOAT);
  fSampleOutputKey->SetDataIndex(&d_pid, LS336_OUTPUT_PID_D ,TID_FLOAT);
  fSampleOutputKey->SetDataIndex(&range, LS336_OUTPUT_HEATER_RANGE ,TID_FLOAT);
  float mode = 2; // ZONE settings
  fSampleOutputKey->SetDataIndex(&mode, LS336_OUTPUT_HEATER_MODE ,TID_FLOAT);
}

//**********************************************************************
// NeedleValve (Konti-Cryos only)
//**********************************************************************
float PLemAutoRun::NeedleValve(float Tset)
{
  float value;

  if ( Tset < 8.0 ) {
    value = fPrefNeedleValveCof_1_0 + fPrefNeedleValveCof_1_1 * Tset;
  } else {
    if ( Tset < 10.0 ) {
      value = fPrefNeedleValveCof_2_0 + fPrefNeedleValveCof_2_1 * Tset;
    } else {
      // Test changes of ranges
      if ( Tset < 20.0 ) {
        value = fPrefNeedleValveCof_3_0 + fPrefNeedleValveCof_3_1 * Tset;
      } else {
        value = fPrefNeedleValveCof_4_0 + fPrefNeedleValveCof_4_1 * Tset;
      }
    }
  }

  if (fDebug) {
    cm_msg(MDEBUG,"NeedleValve", "NeedleValve: demand = %e", value);
    cm_yield(0);
  }

  if ( value > 100.0 ) 
    value = 100.0;

  if ( value < fPrefNeedleValveCof_4_0 ) 
    value = fPrefNeedleValveCof_4_0;
  return value;
}

//**********************************************************************
// Empirical_Flow (Konti-Cryos only)
//**********************************************************************
float PLemAutoRun::EmpiricalFlow(float Tset, float rampSpeed)
{
  float demandflow;

  demandflow = fBHFlowTemp / (Tset + fBHFlowTempOffset) + fBHFlowOffset
    /* speed of ramp in K/sec */
               + (rampSpeed / 60.0)  *
    /* heat capacity in J/K */
                 (   fHeatCapCof1 * Tset
                   + fHeatCapCof2 * Tset * Tset
                   + fHeatCapCof3 * Tset * Tset * Tset )
    /* d(flow)/dP in BH_units / Watt */
               * (fDFlowDp0 + fDFlowDp1 * exp( fDFlowDpExp * log(Tset)));

  if (fDebug) {
    cm_msg(MDEBUG,"EmpircalFlow", "EmpiricalFlow: demandflow = %e", demandflow);
    cm_yield(0);
  }

  if ( demandflow > fBHMaxFlow ) 
    demandflow = fBHMaxFlow;

  if ( demandflow < fBHMinFlow ) 
    demandflow = fBHMinFlow;

  return demandflow;
}


//**********************************************************************
// SetDemandTempRamping
//**********************************************************************
float PLemAutoRun::SetDemandTempRamping(QString rampParam)
{
  float rampSpeed=0.0;
  float value=0.0;

  if (!rampParam.isEmpty()) { // demand temp ramp given
    rampSpeed = rampParam.toFloat();
  }

  fSampleOutputKey->SetDataIndex((void *)&rampSpeed, LS336_OUTPUT_RAMP, TID_FLOAT);

  // check that the demand temperature ramping is indeed set (for maximal 1 min).
  QElapsedTimer t;
  t.start();
  do {
    if (value == fSampleInput[LS336_INPUT_RAMP])
      break;
    Wait(1000);
  } while (t.elapsed() < 60e3);

  return rampSpeed;
}

//**********************************************************************
// SetFlowAndNeedleValve (Konti-Cryos only)
//**********************************************************************
void PLemAutoRun::SetFlowAndNeedleValve(QString flowParam, float &rampSpeed, float newDemandTemp, 
                                        float deltaT, float flowScale)
{
  float value;

  if (rampSpeed == 0.0) { // no ramping
    if (!flowParam.isEmpty()) { // Flow
      value = flowParam.toFloat();
    } else { // no explicit flow was given will get the empirical one
      value = EmpiricalFlow(newDemandTemp, 0.0);
    }
    fSampleOutputKey->SetDataIndex((void *)&value, fSampleBhOdbOffsetOutput + BH_OUTPUT_FLOW, TID_FLOAT);
    value = NeedleValve(newDemandTemp);
    SampleTempSetNeedleValve(value);
  } else { // ramping
    // calculate the flow according to the new setpoint
    if (!flowParam.isEmpty()) { // flow explicitly given
      value = newDemandTemp / fSampleInput[LS336_INPUT_SETPOINT] * (flowParam.toFloat() - fBHFlowOffset) + fBHFlowOffset;
    } else { // no explicit flow was given will get the empirical one
      value = EmpiricalFlow(fSampleInput[LS336_INPUT_SETPOINT], 0.0);
      // correct flow to the optimized one
      value *= (flowScale-1.0)*(fSampleInput[LS336_INPUT_SETPOINT]-newDemandTemp)/deltaT+1.0;
    }
    // set flow
    fSampleOutputKey->SetDataIndex((void *)&value, fSampleBhOdbOffsetOutput + BH_OUTPUT_FLOW, TID_FLOAT);

    //
    //  Do not set the needlevalve in case of ramping, leave that to ConsiderNeedleValve
    //
    //    value = NeedleValve(fSampleInput[LS336_INPUT_SETPOINT]);
    //    SampleTempSetNeedleValve(value);
    // check if final setpoint is reached, than it is necessary to disable flow ramping,
    // since otherwise the flow adjustment will not work!
    if (fabs(fSampleInput[LS336_INPUT_SETPOINT] - newDemandTemp) < 0.1)
      rampSpeed = 0.0;
  }
}


//**********************************************************************
// SetFlow (LowTemp only)
//**********************************************************************
void PLemAutoRun::SetFlow(QString flowParam)
{
  if (flowParam.isEmpty())
    return;

  float value = flowParam.toFloat();

  fSampleOutputKey->SetDataIndex((void *)&value, fSampleBhOdbOffsetOutput + BH_OUTPUT_FLOW, TID_FLOAT);
}

//**********************************************************************
// SetLSMode
//**********************************************************************
void PLemAutoRun::SetLSMode(AutoRunCmd *arc)
{
  float value;

  // check if it is necessary to switch the LS340 from CMODE == 2 (Zone), i.e. internal settings
  //     to CMODE == 1 (manual PID) or vice versa
  if (!arc->param[TEMP_HEATER_RANGE].isEmpty() || !arc->param[TEMP_P_PID].isEmpty() ||
      !arc->param[TEMP_I_PID].isEmpty() || !arc->param[TEMP_D_PID].isEmpty()) { // parameters given which require CMODE==1
    if (fSampleInput[LS336_INPUT_HEATER_MODE] == LS_CTRL_ZONE) {
      value = LS_CTRL_PID;
      fSampleOutputKey->SetDataIndex((void *)&value, LS336_OUTPUT_HEATER_MODE, TID_FLOAT);
    }
  } else { // no parameters given, switch to CMODE == 2 (Zone) if necessary
    if (fSampleInput[LS336_INPUT_HEATER_MODE] == LS_CTRL_PID) {
/* //as35, do nothing here for the LS336 since there we are working with soft Zone settings
      value = LS_CTRL_ZONE;
      fSampleOutputKey->SetDataIndex((void *)&value, LS336_OUTPUT_HEATER_MODE, TID_FLOAT);
*/
    }
  }
}

//**********************************************************************
// SetLSHeaterRangeAndPIDs
//**********************************************************************
void PLemAutoRun::SetLSHeaterRangeAndPIDs(AutoRunCmd *arc)
{
  float value;

  if (!arc->param[TEMP_HEATER_RANGE].isEmpty()) { // heater Range
    value = arc->param[TEMP_HEATER_RANGE].toFloat();
    fSampleOutputKey->SetDataIndex((void *)&value, LS336_OUTPUT_HEATER_RANGE, TID_FLOAT);
  }
  if (!arc->param[TEMP_P_PID].isEmpty()) { // P
    value = arc->param[TEMP_P_PID].toFloat();
    fSampleOutputKey->SetDataIndex((void *)&value, LS336_OUTPUT_PID_P, TID_FLOAT);
  }
  if (!arc->param[TEMP_I_PID].isEmpty()) { // I
    value = arc->param[TEMP_I_PID].toFloat();
    fSampleOutputKey->SetDataIndex((void *)&value, LS336_OUTPUT_PID_I, TID_FLOAT);
  }
  if (!arc->param[TEMP_D_PID].isEmpty()) { // D
    value = arc->param[TEMP_D_PID].toFloat();
    fSampleOutputKey->SetDataIndex((void *)&value, LS336_OUTPUT_PID_D, TID_FLOAT);
  }
}

//**********************************************************************
// WaitUntilSampleLSReady
//**********************************************************************
void PLemAutoRun::WaitUntilSampleLSReady()
{
  int size, status;
  QElapsedTimer t;

  // check if the DD is happy at the moment
  t.start();
  do {
    size = sizeof(status);
    fSampleNoConnectionKey->GetData((void *)&status, &size, TID_INT);
    if (!status) { // connection OK
      break;
    }
    Wait(5000);
  } while (t.elapsed() < 300e3); // try for 5 min.
}

//**********************************************************************
// SetLSSetpoint
//**********************************************************************
void PLemAutoRun::SetLSSetpoint(float setpoint, float rampSpeed)
{
  QElapsedTimer t;

  // set the temperature setpoint
  fSampleOutputKey->SetDataIndex((void *)&setpoint, LS336_OUTPUT_SETPOINT, TID_FLOAT);

  // check that the readback setpoint is the demand one before going on if no demand temp ramping
  Wait(3000);
  if (rampSpeed == 0.0) { // no ramping
    float fvalue;
    bool  setpoint_readback_failure = true;
    t.start();
    do {
      if (fabs(setpoint - fSampleInput[LS336_INPUT_SETPOINT])<1.0e-4) {
        setpoint_readback_failure = false;
        break;
      }
      // set the temperature setpoint again (the additional tiny random number is necessary
      // otherwise MIDAS will not do anything).
      fvalue = setpoint + 1.0e-4 * (float)rand()/(float)RAND_MAX;
      fSampleOutputKey->SetDataIndex((void *)&fvalue, LS336_OUTPUT_SETPOINT, TID_FLOAT);
      Wait(5000);
    } while (t.elapsed() < 600e3);
    if (setpoint_readback_failure) {
      UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
      QString err = QString("setTemp: Couldn't get new setpoint readback value within 10 min!");
      emit ErrorMsg(1, 0, LAR_MIDAS_READBACK_FAILURE, -1, err);
    }
  }
}

//**********************************************************************
// SetOmegaSetpoint
//**********************************************************************
void PLemAutoRun::SetOmegaSetpoint(float setpoint)
{
  QElapsedTimer t;

  // set the temperature setpoint
  fSampleOvenOmegaOutputKey->SetDataIndex((void *)&setpoint, OMEGA_OVEN_OUTPUT_SETPOINT, TID_FLOAT);

  // check that the readback setpoint is the demand one before going on if no demand temp ramping
  Wait(3000);

  float fvalue;
  bool  setpoint_readback_failure = true;
  t.start();
  do {
    if (fabs(setpoint - fSampleOvenOmegaInput[OMEGA_OVEN_INPUT_SETPOINT])<1) {
      setpoint_readback_failure = false;
      break;
    }
    // set the temperature setpoint again (the additional tiny random number is necessary
    // otherwise MIDAS will not do anything).
    fvalue = setpoint + 1.0e-4 * (float)rand()/(float)RAND_MAX;
    fSampleOvenOmegaOutputKey->SetDataIndex((void *)&fvalue, OMEGA_OVEN_OUTPUT_SETPOINT, TID_FLOAT);
    Wait(5000);
  } while (t.elapsed() < 600e3);
  if (setpoint_readback_failure) {
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    QString err = QString("setTempOvenOmega: Couldn't get new setpoint readback value within 10 min!");
    emit ErrorMsg(1, 0, LAR_MIDAS_READBACK_FAILURE, -1, err);
  }
}

//**********************************************************************
// SetFlowTweak (Konti-Cryos only)
//**********************************************************************
void PLemAutoRun::SetFlowTweak(float flow)
{
  QElapsedTimer t;

  fSampleOutputKey->SetDataIndex((void *)&flow, fSampleBhOdbOffsetOutput + BH_OUTPUT_FLOW, TID_FLOAT);

  t.start();
  do {
    // wait a bit and feed the watchdog
    Wait(2000); // sleep 2 sec

    // check temperature stability and feed history buffer
    CheckTempStability();
  } while (t.elapsed() > fFlowTimeoutReduction);
}

//**********************************************************************
// SetTfl
//**********************************************************************
void PLemAutoRun::SetTfl(AutoRunCmd *arc)
{
  QString msg("");

  // check if tfl equipment is disabled in lemAutoRun
  if (!fEnabled["tfl_eq"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += "PLemAutoRun::SetHvOff: TFL equipment disabled in lemAutoRun. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  float tfl_pos = arc->param[0].toFloat();
  float tfl_mode = arc->param[1].toFloat();

  if (fDebug)
    std::cout << std::endl << "in SetTfl ...";

  // check that tfl_scfe is running
  CheckClients();
  if (!fTflFeRunning) {
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    QString err = QString("PLemAutoRun::SetTfl: TFL Slowcontrol Frontend NOT running.\n")+
        QString("  Error too severe, will stop.");
    emit ErrorMsg(1, 0, LAR_MIDAS_FE_NOT_RUNNING, -1, err);
    DisconnectFromExp();
    QCoreApplication::exit(0);
    exit(0);
  }

  msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  // set mode value
  fTflOutputKey->SetDataIndex((void*)&tfl_mode, SM_MODUS_NEEDLEVALVE, TID_FLOAT);

  ss_sleep(200);

  // set NV position
  fTflOutputKey->SetDataIndex((void*)&tfl_pos, SM_OUTPUT_NEEDLEVALVE, TID_FLOAT);

  // no readback NV position check will be done

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// SetTemp
//**********************************************************************
void PLemAutoRun::SetTemp(AutoRunCmd *arc)
{
  int   size;
  float value;
  float newDemandTemp;
  float newDemandFlow = -1.0;
  float currentPID_D;
  float rampSpeed = 0.0;
  QElapsedTimer t, t_flow_set;
  QString msg("");

  // check if sample equipment is disabled in lemAutoRun
  if (!fEnabled["sample_eq"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += "PLemAutoRun::SetTemp: sample equipment disabled in lemAutoRun. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  if (fDebug)
    std::cout << std::endl << "in SetTemp ...";

  // get the name of the current Cryo/Oven
  char cryoName[NAME_LENGTH];
  size = sizeof(cryoName);
  if (!fEnabled["sample_cryo_info_odb"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += "PLemAutoRun::SetTemp: '/Info/Sample Cryo' access disabled. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }
  fSampleCryoKey->GetData(cryoName, &size, TID_STRING);
  if (QString(cryoName).startsWith("omega", Qt::CaseInsensitive)) {
    SetTempOvenOmega(arc);
    return;
  }

  // keep temp stability tolerance
  fSampleTempAccuracy = arc->param[TEMP_DELTA_T].toFloat();

  // before do anything, check if the currently set demand temperature is the same as
  // the target demand temperature. Furthermore check if the target demand temperature
  // and the currently measured temperature are within fSampleTempAccuracy.
  // If both conditions are fullfilled, do not do anything and just get out
  newDemandTemp = arc->param[TEMP_DEMAND_TEMP].toFloat();
  if ((fabs(newDemandTemp-fSampleInput[LS336_INPUT_SETPOINT]) < fSampleTempAccuracy) &&
      (fabs(newDemandTemp-fSampleInput[fSampleCtrlCh]) < fSampleTempAccuracy)) {
    // notify that the command is executed
    QString msg = QString("(%1/%2) TEMP ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    for (int i=0; i<arc->noElements; i++) {
      msg += arc->param[i];
      if (i<arc->noElements-1)
        msg += ", ";
    }
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    // get out of here
    return;  
  }

  // set the temperature unstable flag to true
  fSampleTempUnstable = true;

  if (fDebug)
    std::cout << std::endl << "in SetTemp: will check clients ...";

  // check if the sample_scfe is running
  CheckClients();
  if (!fSampleFeRunning) { // error too severe to going on
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    QString err = QString("PLemAutoRun::SetTemp: Slowcontrol Frontend NOT running.\n")+
                  QString("  Error too severe, will stop.");
    emit ErrorMsg(1, 0, LAR_MIDAS_FE_NOT_RUNNING, -1, err);
    DisconnectFromExp();
    QCoreApplication::exit(0);
    exit(0);
  }

/* uncomment for LS340
  // check if the sample controller is remote
  if (fSampleOutput[LS340_OUTPUT_REMOTE] == 0.0) { // not remote
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    QString err = QString("PLemAutoRun::SetTemp: LakeShore is not remote.\n")+
                  QString("  Error too severe, will stop.");
    emit ErrorMsg(1, 0, LAR_MIDAS_DEVICE_NOT_REMOTE, -1, err);
    DisconnectFromExp();
    QCoreApplication::exit(0);
    exit(0);
  }
*/

  // notify that the command is executed
  msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  if (fDebug)
    std::cout << std::endl << "in SetTemp: check lemvac and BPVX/Y positions ...";

  if (fEnabled["lemvac_scfe"]) { // only needed if LEMVAC is enabled
    // check if lemvac_scfe is running
    if (!fLemvacFeRunning) { // error too severe to going on
      UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
      QString err = QString("PLemAutoRun::SetTemp: Lemvac NOT running. Error too severe, will stop.");
      emit ErrorMsg(1, 0, LAR_MIDAS_FE_NOT_RUNNING, -1, err);
      DisconnectFromExp();
      QCoreApplication::exit(0);
      exit(0);
    }

    // get BPV settings (both valves)
    if (!GetBPV()) {
      UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
      QString err = QString("PLemAutoRun::SetTemp: Couldn't read BPVX/Y. Error too severe, will stop.");
      emit ErrorMsg(1, 0, LAR_BPVY_NO_RESPONSE, arc->lineNo, err);
    }

    if ( fLemVacValveInitialState[BPVX] == BPV_STATE_OPEN ) {
      // close BPVX
      if (!SetBPV(BPVX, BPV_CLOSE)) {
        UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
        QString err = QString("PLemAutoRun::SetTemp: Couldn't close BPVX. Error too severe, will stop.");
        emit ErrorMsg(1, 0, LAR_BPVY_NO_RESPONSE, arc->lineNo, err);
      }
    }
  }

  // keep new demand temperature
  newDemandTemp = arc->param[TEMP_DEMAND_TEMP].toFloat();

  // set demand temperature and check stability. The procedure is different for increasing or decreasing
  // temperature.
  if (newDemandTemp-fSampleInput[fSampleCtrlCh] > 0.0) { // increasing temperature ******************

    if (fDebug)
      std::cout << std::endl << "in SetTemp: increasing temperature ..." << std::endl;

    // check if it is necessary to shut down the hv's and to close BPVY
    if (fDebug)
      std::cout << std::endl << "in SetTemp: check if it is necessary to shut down the hv's and to close BPVY ...";
    bool shut = false;
    // requested demand more than fMaxTempIncrease (K) higher than current one, need to shut HV
    // fMaxTempIncrease is defined in the startup XML.
    if ((newDemandTemp-fSampleInput[fSampleCtrlCh] > fMaxTempIncrease) && fEnabled["fug_eq"]) {
      shut = true;

      // get HV's from the sample region
      if (fDebug)
        std::cout << std::endl << "in SetTemp: get HV's from the sample region ...";
      GetDemandHVSampleChamber();

      // shut down the sample HV's
      if (fDebug)
        std::cout << std::endl << "in SetTemp: shut down the sample HV's ...";
      ChangeSampleChamberHV(true);
    }

    if (fDebug)
      std::cout << std::endl << "in SetTemp: set demand temperature, ramping, flow ...";

    // set demand temperature ramping if wished
    rampSpeed = SetDemandTempRamping(arc->param[TEMP_RAMP]);

    float flowScale;
    float deltaT;
    if (fSampleCryoInUse == CRYO_KONTI) {
      // factor needed to pick up the flow at its current value if ramping is used
      // current BH flow divided by the estimated flow for the current temperature
      flowScale = fSampleOutput[fSampleBhOdbOffsetOutput + BH_OUTPUT_FLOW] / EmpiricalFlow(fSampleInput[LS336_INPUT_SETPOINT], 0.0);
      // temperature difference between the current temperature and the new demand temperature, need: see comment above
      deltaT = fSampleInput[LS336_INPUT_SETPOINT] - newDemandTemp;

      // set the new bronkhorst flow and needle valve
      if (fDebug)
        std::cout << std::endl << "in SetTemp: set the new bronkhorst flow and needle valve ...";
      SetFlowAndNeedleValve(arc->param[TEMP_FLOW], rampSpeed, newDemandTemp, deltaT, flowScale);
    } else if (fSampleCryoInUse == CRYO_LOWTEMP) {
      SetFlow(arc->param[TEMP_FLOW]);
    }

    // set the parameters of the LS340 or LS336 -------------------------------------------
    if (fDebug)
      std::cout << std::endl << "in SetTemp: set the parameters of the LS340 or LS336...";

    // set the control mode of the LS340 (see 'User's Manual' p.9-28) or the LS336 (see 'User's Manual' p.140, cmd: OUTMODE)
    SetLSMode(arc);

    // set heaterRange, PID's
    SetLSHeaterRangeAndPIDs(arc);

    // wait 1 sec
    Wait(1000);

    // check if the DD is happy at the moment
    // uncomment next line for the LS340
//    WaitUntilSampleLSReady();

    SetLSSetpoint(newDemandTemp, rampSpeed);

    // get the current D from the PID
    currentPID_D = fSampleInput[LS336_INPUT_PID_D];
    // set D to zero while approaching the temperature
    value = 0.0;
    fSampleOutputKey->SetDataIndex((void *)&value, LS336_OUTPUT_PID_D, TID_FLOAT);

    // check and tweak temperature until stability is reached or timeout happend
    if (fDebug)
      std::cout << std::endl << "in SetTemp: check and tweak temperature until stability is reached or timeout happend ...";
    bool done = false;
    int timeout = 1000 * arc->param[TEMP_STABILITY_TIMEOUT].toInt(); // timeout in (msec)
    t.start();
    t_flow_set.start();
    do {

      if (fSampleCryoInUse == CRYO_KONTI) {
        // if ramping, adjust the flow according to the current temperature
        SetFlowAndNeedleValve(arc->param[TEMP_FLOW], rampSpeed, newDemandTemp, deltaT, flowScale);
      }

      // time to set the D value back
      value = fSampleOutput[LS336_OUTPUT_SETPOINT];
      if (fabs(value-fSampleInput[fSampleCtrlCh])/value < fDSetRatio) {
        fSampleOutputKey->SetDataIndex((void *)&currentPID_D, LS336_OUTPUT_PID_D, TID_FLOAT);
      }

      // check temperature stability and feed history buffer
      CheckTempStability();

      if (fSampleCryoInUse == CRYO_KONTI) {
        // see if a flow tweaking is needed
        if (t_flow_set.elapsed() >= fTimeoutFlowSet) {
          SampleTempConsiderFlow();
          SampleTempConsiderNeedleValve();
          t_flow_set.start(); // restart timer
        }
      }

      // wait a bit and feed the watchdog
      Wait(2000); // sleep 2 sec

      if (t.elapsed() > timeout) { // timeout fired
        QString err = QString("PLemAutoRun::SetTemp: couldn't reach temperature %1 (K), ").arg(newDemandTemp) +
                      QString("within required timeout %1 (sec).\n").arg(arc->param[TEMP_STABILITY_TIMEOUT]);
        emit ErrorMsg(1, 0, LAR_LS_TEMP_NOT_STABLE, -1, err);
        done = true;
      }

      if (SampleTempStable())
        done = true;
    } while (!done);

    // if HV is shut down: (i) open BPVY, than (ii) ramp sample HV's back
    if (fDebug)
      std::cout << std::endl << "in SetTemp: if HV is shut down: (i) open BPVY, than (ii) ramp sample HV's back ...";
    if (shut) {
      // ramp sample region HV's back
      ChangeSampleChamberHV(false);
    }

  } else { // decreasing temperature ****************************************************************

    if (fDebug)
      std::cout << std::endl << "in SetTemp: decreasing temperature ..." << std::endl;

    // set the parameters of the LS340 or LS336 -------------------------------------------
    if (fDebug)
      std::cout << std::endl << "in SetTemp: set the parameters of the LS340 or LS336 ...";

    // set the control mode of the LS340 (see 'User's Manual' p.9-28) or the LS336 (see 'User's Manual' p.140, cmd: OUTMODE)
    SetLSMode(arc);

    // set demand temperature ramping if wished, if not, it is set to zero
    // this assures that cooling down is a quick procedure even ramping was set
    // previously and the user has forgotten to set it to zero.
    rampSpeed = SetDemandTempRamping(arc->param[TEMP_RAMP]);

    // check if the DD is happy at the moment
    // uncomment next line for the LS340
//    WaitUntilSampleLSReady();

    // set the temperature setpoint
    SetLSSetpoint(newDemandTemp, rampSpeed);

    // wait 1 sec
    Wait(1000);

    // set heaterRange, PID's
    SetLSHeaterRangeAndPIDs(arc);

    // wait 1 sec
    Wait(1000);

    // get ramping
    value = 0.0;
    size  = sizeof(value);
    fSampleInputKey->GetDataIndex((void *)&value, &size, LS336_INPUT_RAMP, TID_FLOAT);
    if ((value == 0.0) && arc->param[TEMP_FLOW].isEmpty()) { // no ramping and no flow given: the normal case
      // get the current D from the PID
      currentPID_D = fSampleInput[LS336_INPUT_PID_D];
      // set D to zero while approaching the temperature
      value = 0.0;
      fSampleOutputKey->SetDataIndex((void *)&value, LS336_OUTPUT_PID_D, TID_FLOAT);

      if (fSampleCryoInUse == CRYO_KONTI) {
        // check what temporary flow is needed and set it (only if ramping is NOT enabled!!)
        if (newDemandTemp > 50.0)
          value = 1.0e4;
        else
          value = 3.0e4;
        fSampleOutputKey->SetDataIndex((void *)&value, fSampleBhOdbOffsetOutput + BH_OUTPUT_FLOW, TID_FLOAT);
        fLargeFlow = true;
        // Needle valve should be set to the maximum value here, otherwise we will not reach the high flow
        value = 95.0;
        SampleTempSetNeedleValve(value);
      }

      // check and tweak temperature until stability is reached or timeout happend
      if (fDebug)
        std::cout << std::endl << "in SetTemp: check and tweak temperature until stability is reached or timeout happend ...";
      bool  done = false;
      int   timeout = 1000 * arc->param[TEMP_STABILITY_TIMEOUT].toInt(); // timeout in (msec)
      // get the new bronkhorst flow value
      if (fSampleCryoInUse == CRYO_KONTI) {
        if (!arc->param[TEMP_FLOW].isEmpty()) { // Flow given explicitly
          newDemandFlow = arc->param[TEMP_FLOW].toFloat();
        } else { // no explicit flow was given will get the empirical one
          newDemandFlow = fBHFlowTemp / (newDemandTemp + fBHFlowTempOffset) + fBHFlowOffset;
        }
      }

      t_flow_set.start();
      t.start();
      do {
        if (fSampleCryoInUse == CRYO_KONTI) {
          // start reducing the flow if getting close to the setpoint
          if (((fSampleInput[fSampleCtrlCh] - newDemandTemp) / newDemandTemp < fFlowSetRatio) &&
              ((fSampleInput[fSampleCtrlCh] - newDemandTemp) < fFlowSetAbsolute)              &&
              fLargeFlow) {

            // set the needle valve to temperature set point
            value = NeedleValve(newDemandTemp);
            SampleTempSetNeedleValve(value);

            // reduce to 1.5 * the final flow
            value = 1.5 * newDemandFlow;
            SetFlowTweak(value);

            // reduce to 1.2 * the final flow
            value = 1.2 * newDemandFlow;
            SetFlowTweak(value);

            // reduce to 1.1 * the final flow
            value = 1.1 * newDemandFlow;
            SetFlowTweak(value);

            // reduce to the final flow
            value = newDemandFlow;
            SetFlowTweak(value);

            fLargeFlow = false;

            // the following is needed in the situation where the previous demand temp is too close
            // to the newDemandTemp. What happens then? The TFL NV is still opening and is not
            // accepting the new closing command already, hence the TFL NV is set once more here

            // wait a bit and feed the watchdog
            Wait(5000); // sleep 5 sec

            // set the needle valve to temperature set point
            value = NeedleValve(newDemandTemp)-0.01;
            SampleTempSetNeedleValve(value);
          }
        }

        // time to set the D value back
        value = fSampleOutput[LS336_OUTPUT_SETPOINT];
        if (fabs(value-fSampleInput[fSampleCtrlCh])/value < fDSetRatio) {
          fSampleOutputKey->SetDataIndex((void *)&currentPID_D, LS336_OUTPUT_PID_D, TID_FLOAT);
        }

        // check temperature stability and feed history buffer
        CheckTempStability();

        if (fSampleCryoInUse == CRYO_KONTI) {
          // see if a flow tweaking is needed
          if (t_flow_set.elapsed() >= fTimeoutFlowSet) {
            SampleTempConsiderFlow();
            SampleTempConsiderNeedleValve();
            t_flow_set.start(); // restart timer
          }
        }

        // wait a bit and feed the watchdog
        Wait(2000); // sleep 2 sec

        if (t.elapsed() > timeout) { // timeout fired
          QString err = QString("PLemAutoRun::SetTemp: couldn't reach temperature %1 (K), ").arg(newDemandTemp) +
                        QString("within required timeout %1 (sec).\n").arg(arc->param[TEMP_STABILITY_TIMEOUT]);
          emit ErrorMsg(1, 0, LAR_LS_TEMP_NOT_STABLE, -1, err);
          done = true;
        }

        if (SampleTempStable())
          done = true;
      } while (!done);

    } else { // ramping enabled for cooling down or flow explicitly given!!
             // Here it is not possible to increase to flow initially

      if (fDebug)
        std::cout << std::endl << "in SetTemp: ramping enabled for cooling down or flow explicitly given ...";

      if (fSampleCryoInUse == CRYO_KONTI) {
        // get the new bronkhorst flow value and set it
        if (!arc->param[TEMP_FLOW].isEmpty()) { // Flow
          newDemandFlow = arc->param[TEMP_FLOW].toFloat();
        } else { // no explicit flow was given will get the empirical one
          newDemandFlow = EmpiricalFlow(fSampleInput[LS336_INPUT_SETPOINT], rampSpeed);
        }
      } else if (fSampleCryoInUse == CRYO_LOWTEMP) {
        // get the new bronkhorst flow value and set it
        if (!arc->param[TEMP_FLOW].isEmpty()) { // Flow
          newDemandFlow = arc->param[TEMP_FLOW].toFloat();
        } else { // flow not explicitly given, get the currently set one
          size = sizeof(newDemandFlow);
          fSampleOutputKey->GetDataIndex(&newDemandFlow, &size, fSampleBhOdbOffsetOutput + BH_OUTPUT_FLOW, TID_FLOAT);
        }
      }

      fSampleOutputKey->SetDataIndex((void *)&newDemandFlow, fSampleBhOdbOffsetOutput + BH_OUTPUT_FLOW, TID_FLOAT);

      if (fSampleCryoInUse == CRYO_KONTI) {
        value = NeedleValve(fSampleInput[LS336_INPUT_SETPOINT]);
        if ( rampSpeed == 0.0 )
          SampleTempSetNeedleValve(value);   // only if not ramping
      }

      // check and tweak temperature until stability is reached or timeout happend
      if (fDebug)
        std::cout << std::endl << "in SetTemp: check and tweak temperature until stability is reached or timeout happend ...";
      bool  done = false;
      int   timeout = 1000 * arc->param[TEMP_STABILITY_TIMEOUT].toInt(); // timeout in (msec)
      t.start();
      t_flow_set.start();
      do {
        if (fSampleCryoInUse == CRYO_KONTI) {
          // if ramping, adjust the flow according to the current temperature
          if (rampSpeed != 0.0) {
            // calculate the flow according to the new setpoint
            if (!arc->param[TEMP_FLOW].isEmpty()) // flow explicitly given
              value = newDemandTemp / fSampleInput[LS336_INPUT_SETPOINT] *
                      (arc->param[TEMP_FLOW].toFloat() - fBHFlowOffset) + fBHFlowOffset;
            else { // no explicit flow was given will get the empirical one
              if ( t_flow_set.elapsed() >= fTimeoutFlowSet ) {
                SampleTempConsiderFlow();
                SampleTempConsiderNeedleValve();
                Wait(500);
                t_flow_set.start();    // restart timer
              }
              value = EmpiricalFlow(fSampleInput[LS336_INPUT_SETPOINT], rampSpeed);
            }

            if (fDebug)
              std::cout << std::endl << "in SetTemp: set flow and adjust the needle valve of the transferline ...";
            // set flow
            fSampleOutputKey->SetDataIndex((void *)&value, fSampleBhOdbOffsetOutput + BH_OUTPUT_FLOW, TID_FLOAT);

            // adjust needle valve
            SampleTempConsiderNeedleValve();

            // check if final setpoint is reached, than it is necessary to disable flow ramping,
            // since otherwise the flow adjustment will not work!
            if (fDebug)
              std::cout << std::endl << "in SetTemp: check if final setpoint is reached ...";
            if (fabs(fSampleInput[LS336_INPUT_SETPOINT] - newDemandTemp) < 0.1) {
              // gradually reduce the flow to steady value if flow was not given explicitly
              if (fDebug)
                std::cout << std::endl << "in SetTemp: gradually reduce the flow to steady value if flow was not given explicitly ...";
              if (arc->param[TEMP_FLOW].isEmpty()) {
                float value2 = 0.3 * rampSpeed;
                value = EmpiricalFlow(fSampleInput[LS336_INPUT_SETPOINT], value2);
                SetFlowTweak(value);
                SampleTempConsiderNeedleValve();

                value2 = 0.2 * rampSpeed;
                value = EmpiricalFlow(fSampleInput[LS336_INPUT_SETPOINT], value2);
                SetFlowTweak(value);
                SampleTempConsiderNeedleValve();

                value2 = 0.1 * rampSpeed;
                value = EmpiricalFlow(fSampleInput[LS336_INPUT_SETPOINT], value2);
                SetFlowTweak(value);
                SampleTempConsiderNeedleValve();

                value2 = 0.0;
                value = EmpiricalFlow(fSampleInput[LS336_INPUT_SETPOINT], value2);
                SetFlowTweak(value);
                SampleTempConsiderNeedleValve();
              }
              rampSpeed = 0.0;
            }
          }
        }

        // check temperature stability and feed history buffer
        if (fDebug)
          std::cout << std::endl << "in SetTemp: check temperature stability and feed history buffer ...";
        CheckTempStability();

        if (fSampleCryoInUse == CRYO_KONTI) {
          // see if a flow tweaking is needed
          if (fDebug)
            std::cout << std::endl << "in SetTemp: see if a flow tweaking is needed ...";
          if (t_flow_set.elapsed() >= fTimeoutFlowSet) {
            SampleTempConsiderFlow();
            SampleTempConsiderNeedleValve();
            t_flow_set.start(); // restart timer
          }
        }

        // wait a bit and feed the watchdog
        Wait(2000); // sleep 2 sec

        if (t.elapsed() > timeout) { // timeout fired
          QString err = QString("PLemAutoRun::SetTemp: couldn't reach temperature %1 (K), ").arg(newDemandTemp) +
                        QString("within required timeout %1 (sec).\n").arg(arc->param[TEMP_STABILITY_TIMEOUT]);
          emit ErrorMsg(1, 0, LAR_LS_TEMP_NOT_STABLE, -1, err);
          done = true;
        }

        if (SampleTempStable())
          done = true;
      } while (!done);
    }
  }

  if (fEnabled["lemvac_scfe"]) { // only check if LEMVAC is enabled
    // only open the BPVX when it initially was open
    if (fDebug)
      std::cout << std::endl << "in SetTemp: only open the BPVX when it initially was open ...";
    if ( fLemVacValveInitialState[BPVX] == BPV_STATE_OPEN ) {
      // open BPVX
      if (!SetBPV(BPVX, BPV_OPEN)) {
        UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
        QString err = QString("PLemAutoRun::SetTemp: Couldn't open BPVX. Error too severe, will stop.");
        emit ErrorMsg(1, 0, LAR_BPVY_NO_RESPONSE, arc->lineNo, err);
      }
    }
  }

  // set the temperature unstable flag to false
  fSampleTempUnstable = false;

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// SetTempOvenOmega
//**********************************************************************
void PLemAutoRun::SetTempOvenOmega(AutoRunCmd *arc) {
  float newDemandTemp;
  float rampSpeed = 0.0;
  QElapsedTimer t;
  QString msg("");

  // check if omega equipment is disabled in lemAutoRun
  if (!fEnabled["omega_eq"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += "PLemAutoRun::SetTempOvenOmega: omega equipment disabled in lemAutoRun. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  // set the temperature unstable flag to true
  fSampleTempUnstable = true;

  // check if the sample_scfe is running
  CheckClients();
  if (!fSampleOvenOmegaFeRunning) { // error too severe to going on
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    QString err = QString("PLemAutoRun::SetTempOvenOmega: Slowcontrol Frontend (Omega SC) NOT running. Error too severe, will stop.");
    emit ErrorMsg(1, 0, LAR_MIDAS_FE_NOT_RUNNING, -1, err);
    DisconnectFromExp();
    QCoreApplication::exit(0);
    exit(0);
  }

  // notify that the command is executed
  msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  if (fDebug)
    std::cout << std::endl << "in SetTempOvenOmega: check lemvac and BPVX/Y positions ...";

  if (fEnabled["lemvac_scfe"]) { // only needed if LEMVAC is enabled
    // check if lemvac_scfe is running
    if (!fLemvacFeRunning) { // error too severe to going on
      UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
      QString err = QString("PLemAutoRun::SetTemp: Lemvac NOT running. Error too severe, will stop.");
      emit ErrorMsg(1, 0, LAR_MIDAS_FE_NOT_RUNNING, -1, err);
      DisconnectFromExp();
      QCoreApplication::exit(0);
      exit(0);
    }

    // get BPV settings (both valves)
    if (!GetBPV()) {
      UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
      QString err = QString("PLemAutoRun::SetTempOvenOmega: Couldn't read BPVX/Y. Error too severe, will stop.");
      emit ErrorMsg(1, 0, LAR_BPVY_NO_RESPONSE, arc->lineNo, err);
    }

    if ( fLemVacValveInitialState[BPVX] == BPV_STATE_OPEN ) {
      // close BPVX
      if (!SetBPV(BPVX, BPV_CLOSE)) {
        UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
        QString err = QString("PLemAutoRun::SetTempOvenOmega: Couldn't close BPVX. Error too severe, will stop.");
        emit ErrorMsg(1, 0, LAR_BPVY_NO_RESPONSE, arc->lineNo, err);
      }
    }
  }

  // keep new demand temperature
  newDemandTemp = arc->param[TEMP_DEMAND_TEMP].toFloat() - 273.16; // K -> °C

  // set demand temperature and check stability. The procedure is different for increasing or decreasing
  // temperature.
  if (newDemandTemp-fSampleOvenOmegaInput[OMEGA_OVEN_INPUT_TEMP] > 0.0) { // increasing temperature ******************

    if (fDebug)
      std::cout << std::endl << "in SetTempOvenOmega: increasing temperature ..." << std::endl;

    bool shut = false;
    // requested demand more than fMaxTempIncrease (K) higher than current one, need to shut HV
    // fMaxTempIncrease is defined in the startup XML.
    if (newDemandTemp-fSampleOvenOmegaInput[OMEGA_OVEN_INPUT_TEMP] > fMaxTempIncrease) {
      shut = true;

      // get HV's from the sample region
      if (fDebug)
        std::cout << std::endl << "in SetTempOvenOmega: get HV's from the sample region ...";
      GetDemandHVSampleChamber();

      // shut down the sample HV's
      if (fDebug)
        std::cout << std::endl << "in SetTempOvenOmega: shut down the sample HV's ...";
      ChangeSampleChamberHV(true);
    }

    if (fDebug)
      std::cout << std::endl << "in SetTempOvenOmega: set demand temperature, ramping, flow ...";

    // set demand temperature ramping if wished
    // NOT YET IMPLEMENTED

    // set the parameters of the LS340 -------------------------------------------
    if (fDebug)
      std::cout << std::endl << "in SetTempOvenOmega: set the parameters of the LS340 ...";

    // set heaterRange, PID's
    // NOT YET IMPLEMENTED

    // wait 1 sec
    Wait(1000);

    SetOmegaSetpoint(newDemandTemp);

    // check the temperature until stability is reached or timeout happend
    if (fDebug)
      std::cout << std::endl << "in SetTempOvenOmega: check and tweak temperature until stability is reached or timeout happend ...";
    bool done = false;
    int timeout = 1000 * arc->param[TEMP_STABILITY_TIMEOUT].toInt(); // timeout in (msec)
    int stabilityCounter = 0;
    t.start();
    do {
      // check temperature stability and feed history buffer
      CheckTempStabilityOvenOmega();

      // wait a bit and feed the watchdog
      Wait(5000); // sleep 5 sec

      if (t.elapsed() > timeout) { // timeout fired
        QString err = QString("PLemAutoRun::SetTempOvenOmega: couldn't reach temperature %1 (K), ").arg(newDemandTemp) +
                      QString("within required timeout %1 (sec).\n").arg(arc->param[TEMP_STABILITY_TIMEOUT]);
        emit ErrorMsg(1, 0, LAR_LS_TEMP_NOT_STABLE, -1, err);
        done = true;
      }

      if (!fSampleTempUnstable) {
        stabilityCounter++;
        if (stabilityCounter == 60) // i.e. 5 min
          done = true;
      } else {
        stabilityCounter = 0;
      }
    } while (!done);

    // if HV is shut down: ramp sample HV's back
    if (fDebug)
      std::cout << std::endl << "in SetTempOvenOmega: if HV is shut down: ramp sample HV's back ...";
    if (shut) { // ramp sample region HV's back
      ChangeSampleChamberHV(false);
    }
  } else { // decreasing temperature ****************************************************************

    if (fDebug)
      std::cout << std::endl << "in SetTempOvenOmega: decreasing temperature ..." << std::endl;

    // set the parameters of the Omega -------------------------------------------
    if (fDebug)
      std::cout << std::endl << "in SetTempOvenOmega: set the parameters of the Omega ...";

    // set demand temperature ramping if wished
    // NOT YET IMPLEMENTED

    // set the temperature setpoint
    SetOmegaSetpoint(newDemandTemp);

    // wait 1 sec
    Wait(1000);

    // set PID's
    // NOT YET IMPLEMENTED

    // check and tweak temperature until stability is reached or timeout happend
    if (fDebug)
      std::cout << std::endl << "in SetTempOvenOmega: check the temperature until stability is reached or timeout happend ...";
    bool done = false;
    int timeout = 1000 * arc->param[TEMP_STABILITY_TIMEOUT].toInt(); // timeout in (msec)
    int stabilityCounter = 0;
    t.start();
    do {
      // check temperature stability and feed history buffer
      CheckTempStabilityOvenOmega();

      // wait a bit and feed the watchdog
      Wait(5000); // sleep 5 sec

      if (t.elapsed() > timeout) { // timeout fired
        QString err = QString("PLemAutoRun::SetTempOvenOmega: couldn't reach temperature %1 (K), ").arg(newDemandTemp) +
                      QString("within required timeout %1 (sec).\n").arg(arc->param[TEMP_STABILITY_TIMEOUT]);
        emit ErrorMsg(1, 0, LAR_LS_TEMP_NOT_STABLE, -1, err);
        done = true;
      }

      if (!fSampleTempUnstable) {
        stabilityCounter++;
        if (stabilityCounter == 60) // i.e. 5 min
          done = true;
      } else {
        stabilityCounter = 0;
      }
    } while (!done);
  }

  if (fEnabled["lemvac_scfe"]) { // only needed if LEMVAC is enabled
    // only open the BPVX when it initially was open
    if (fDebug)
      std::cout << std::endl << "in SetTempOvenOmega: only open the BPVX when it initially was open ...";
    if ( fLemVacValveInitialState[BPVX] == BPV_STATE_OPEN ) {
      // open BPVX
      if (!SetBPV(BPVX, BPV_OPEN)) {
        UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
        QString err = QString("PLemAutoRun::SetTempOvenOmega: Couldn't open BPVX. Error too severe, will stop.");
        emit ErrorMsg(1, 0, LAR_BPVY_NO_RESPONSE, arc->lineNo, err);
      }
    }
  }

  // set the temperature unstable flag to false
  fSampleTempUnstable = false;

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// SetTitle
//**********************************************************************
void PLemAutoRun::SetTitle(AutoRunCmd *arc)
{
  // arc->param:
  //  0 = title string of the title command
  //  1 = ODB_SAMPLE
  //  2 = ODB_TEMP
  //  3 = ODB_FIELD
  //  4 = ODB_TRANSP
  //  5 = ODB_HV_SAMP
  //  6 = ODB_ENERGY
  //  7 = ODB_RA_DIFF_LR
  //  8 = ODB_RA_DIFF_TB
  //  9 = ODB_SPIN_ROT

  int     size;
  float   fvalue;
  double  dvalue;
  QString valueStr;
  QString msg("");

  // check if necessary ODB info is disabled in lemAutoRun
  if (!fEnabled["sample_name_info_odb"] || !fEnabled["sample_cryo_info_odb"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += "PLemAutoRun::SetTitle: not all necessary ODB settings are enabled in lemAutoRun. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  msg= QString("%1").arg(arc->param[0]);

  // check if odb tags are used
  if (arc->param[1] == "true") { // ODB_SAMPLE flag set
    char str[128];
    size = sizeof(str);
    if (fSampleNameKey)
      fSampleNameKey->GetData((void *)str, &size, TID_STRING);
    msg.replace("ODB_SAMPLE", str);
  }
  if (arc->param[2] == "true") { // ODB_TEMP flag set
    // get the name of the current Cryo/Oven
    char cryoName[NAME_LENGTH];
    size = sizeof(cryoName);
    if (fSampleCryoKey) {
      fSampleCryoKey->GetData(cryoName, &size, TID_STRING);

      if (QString(cryoName).startsWith("omega", Qt::CaseInsensitive)) { // Oven Omega in place
        size = sizeof(fvalue);
        if (fSampleOvenOmegaInputKey) {
          fSampleOvenOmegaInputKey->GetDataIndex((void*)&fvalue, &size, OMEGA_OVEN_INPUT_TEMP, TID_FLOAT);
          dvalue = fvalue + 273.16; // °C -> K
        }
      } else { // Cryo in place
        size = sizeof(fvalue);
        if (fSampleInputKey) {
          fSampleInputKey->GetDataIndex((void *)&fvalue, &size, fSampleCtrlCh, TID_FLOAT);
          dvalue = fvalue;
        }
      }
      valueStr = QString("%1").arg(dvalue, 0, 'f', 2);
      msg.replace("ODB_TEMP", QString("%1").arg(valueStr));
    }
  }
  if (arc->param[3] == "true") { // ODB_FIELD flag set
    if (fFieldPwrSupply == "wew") {
      // check which WEW power supply is used
      size = sizeof(float);
      if (fWEWInputKey) {
        fWEWInputKey->GetDataIndex((void *)&fvalue, &size, WEWL_INPUT_STATUS, TID_FLOAT);
        if (fvalue == 1.0)
          fWEWInputKey->GetDataIndex((void *)&fvalue, &size, WEWL_INPUT_CURRENT, TID_FLOAT);
        else
          fWEWInputKey->GetDataIndex((void *)&fvalue, &size, WEWH_INPUT_CURRENT, TID_FLOAT);
        valueStr = QString("~%1(G)/%2(A)").arg(fMagParamWew[0]+fMagParamWew[1]*fvalue, 0, 'f', 0).arg(fvalue, 0, 'f', 2);
        msg.replace("ODB_FIELD", QString("%1").arg(valueStr));
      }
    } else if (fFieldPwrSupply == "danfysik") {
      if (fDanfysikInputKey) {
        fDanfysikInputKey->GetDataIndex((void *)&fvalue, &size, DANFYSIK_INPUT_CURRENT, TID_FLOAT);
        valueStr = QString("~%1(G)/%2(A)").arg(fMagParamBpar[0]+fMagParamBpar[1]*fvalue, 0, 'f', 0).arg(fvalue, 0, 'f', 2);
        msg.replace("ODB_FIELD", QString("%1").arg(valueStr));
      }
    } else {
      msg.replace("ODB_FIELD", "??(G)/??(A)");
    }
  }
  if (arc->param[4] == "true") { // ODB_TRANSP flag set
    if (fFugHvCheck) {
      size = sizeof(fvalue);
      if (fHVMeasuredKey) {
        fHVMeasuredKey->GetDataIndex((void *)&fvalue, &size, HV_FUG_MOD, TID_FLOAT);
        dvalue = fvalue;
        valueStr = QString("%1").arg(dvalue, 0, 'f', 2);
        msg.replace("ODB_TRANSP", QString("%1").arg(valueStr));
      }
    } else { // fug_hv_check NOT set, hence take the demand rather than the measured values!
      size = sizeof(fvalue);
      if (fHVDemandKey) {
        fHVDemandKey->GetDataIndex((void *)&fvalue, &size, HV_FUG_MOD, TID_FLOAT);
        dvalue = fvalue;
        valueStr = QString("%1").arg(dvalue, 0, 'f', 2);
        msg.replace("ODB_TRANSP", QString("%1").arg(valueStr));
      }
    }
  }
  if (arc->param[5] == "true") { // ODB_HV_SAMP flag set
    if (fFugHvCheck) {
      size = sizeof(fvalue);
      if (fHVMeasuredKey) {
        fHVMeasuredKey->GetDataIndex((void *)&fvalue, &size, HV_FUG_SAMPLE, TID_FLOAT);
        dvalue = fvalue;
        valueStr = QString("%1").arg(dvalue, 0, 'f', 2);
        msg.replace("ODB_HV_SAMP", QString("%1").arg(valueStr));
      }
    } else { // fug_hv_check NOT set, hence take the demand rather than the measured values!
      size = sizeof(fvalue);
      if (fHVDemandKey) {
        fHVDemandKey->GetDataIndex((void *)&fvalue, &size, HV_FUG_SAMPLE, TID_FLOAT);
        dvalue = fvalue;
        valueStr = QString("%1").arg(dvalue, 0, 'f', 2);
        msg.replace("ODB_HV_SAMP", QString("%1").arg(valueStr));
      }
    }
  }
  if (arc->param[6] == "true") { // ODB_ENERGY flag set
    if (fFugHvCheck) {
      if (fHVMeasuredKey) {
        float hv_mod, hv_samp, energy_loss;
        // get hv of the moderator
        size = sizeof(hv_mod);
        fHVMeasuredKey->GetDataIndex((void *)&hv_mod, &size, HV_FUG_MOD, TID_FLOAT);
        // get hv of the sample
        size = sizeof(hv_samp);
        fHVMeasuredKey->GetDataIndex((void *)&hv_samp, &size, HV_FUG_SAMPLE, TID_FLOAT);
        // get energy loss
        energy_loss = GetEnergyLoss(hv_mod);
        // calculate implantation energy
        dvalue = hv_mod - energy_loss - hv_samp;
        valueStr = QString("%1").arg(dvalue, 0, 'f', 2);
        msg.replace("ODB_ENERGY", QString("%1").arg(valueStr));
      }
    } else { // fug_hv_check NOT set, hence take the demand rather than the measured values!
      if (fHVDemandKey) {
        float hv_mod, hv_samp, energy_loss;
        // get hv of the moderator
        size = sizeof(hv_mod);
        fHVDemandKey->GetDataIndex((void *)&hv_mod, &size, HV_FUG_MOD, TID_FLOAT);
        // get hv of the sample
        size = sizeof(hv_samp);
        fHVDemandKey->GetDataIndex((void *)&hv_samp, &size, HV_FUG_SAMPLE, TID_FLOAT);
        // get energy loss
        energy_loss = GetEnergyLoss(hv_mod);
        // calculate implantation energy
        dvalue = hv_mod - energy_loss - hv_samp;
        valueStr = QString("%1").arg(dvalue, 0, 'f', 2);
        msg.replace("ODB_ENERGY", QString("%1").arg(valueStr));
      }
    }
  }
  if (arc->param[7] == "true") { // ODB_RA_DIFF_LR flag set
    if (fFugHvCheck) {
      if (fHVMeasuredKey) {
        float ral, rar;
        // get hv of the RA-L
        size = sizeof(ral);
        fHVMeasuredKey->GetDataIndex((void *)&ral, &size, HV_FUG_RAL, TID_FLOAT);
        // get hv of the RA-R
        size = sizeof(rar);
        fHVMeasuredKey->GetDataIndex((void *)&rar, &size, HV_FUG_RAR, TID_FLOAT);
        dvalue = ral-rar;
        valueStr = QString("%1").arg(dvalue, 0, 'f', 2);
        msg.replace("ODB_RA_DIFF_LR", QString("%1").arg(valueStr));
      }
    } else { // fug_hv_check NOT set, hence take the demand rather than the measured values!
      if (fHVDemandKey) {
        float ral, rar;
        // get hv of the RA-L
        size = sizeof(ral);
        fHVDemandKey->GetDataIndex((void *)&ral, &size, HV_FUG_RAL, TID_FLOAT);
        // get hv of the RA-R
        size = sizeof(rar);
        fHVDemandKey->GetDataIndex((void *)&rar, &size, HV_FUG_RAR, TID_FLOAT);
        dvalue = ral-rar;
        valueStr = QString("%1").arg(dvalue, 0, 'f', 2);
        msg.replace("ODB_RA_DIFF_LR", QString("%1").arg(valueStr));
      }
    }
  }
  if (arc->param[8] == "true") { // ODB_RA_DIFF_TB flag set
    if (fFugHvCheck) {
      if (fHVMeasuredKey) {
        float rat, rab;
        // get hv of the RA-T
        size = sizeof(rat);
        fHVMeasuredKey->GetDataIndex((void *)&rat, &size, HV_FUG_RAT, TID_FLOAT);
        // get hv of the RA-B
        size = sizeof(rab);
        fHVMeasuredKey->GetDataIndex((void *)&rab, &size, HV_FUG_RAB, TID_FLOAT);
        dvalue = rat-rab;
        valueStr = QString("%1").arg(dvalue, 0, 'f', 2);
        msg.replace("ODB_RA_DIFF_TB", QString("%1").arg(valueStr));
      }
    } else { // fug_hv_check NOT set, hence take the demand rather than the measured values!
      if (fHVDemandKey) {
        float rat, rab;
        // get hv of the RA-T
        size = sizeof(rat);
        fHVDemandKey->GetDataIndex((void *)&rat, &size, HV_FUG_RAT, TID_FLOAT);
        // get hv of the RA-B
        size = sizeof(rab);
        fHVDemandKey->GetDataIndex((void *)&rab, &size, HV_FUG_RAB, TID_FLOAT);
        dvalue = rat-rab;
        valueStr = QString("%1").arg(dvalue, 0, 'f', 2);
        msg.replace("ODB_RA_DIFF_TB", QString("%1").arg(valueStr));
      }
    }
  }
  if (arc->param[9] == "true") { // ODB_SPIN_ROT flag set
    if (fSpinRotEnabledKey && fSpinRotAngleKey) {
      // get spin rot value, and spin rot enable flag
      BOOL srEnabled;
      float srAngle;
      int size = sizeof(srEnabled);
      fSpinRotEnabledKey->GetData(&srEnabled, &size, TID_BOOL);
      size = sizeof(srAngle);
      fSpinRotAngleKey->GetData(&srAngle, &size, TID_FLOAT);
      if (srEnabled == FALSE) {
        msg.replace("ODB_SPIN_ROT", "disabled");
      } else {
        valueStr = QString("%1").arg(srAngle, 0, 'f', 2);
        msg.replace("ODB_SPIN_ROT", valueStr);
      }
    }
  }

  // check if they were ODB_TAG entries
  HandleOdbTitleTags(msg);

  // set title
  msg.truncate(220); // truncate overly long title to 220 characters in order to keep the ODB happy
  if (fEnabled["run_comment_odb"])
    fRunCommentKey->SetData((void *)msg.toLatin1().data(), 1, TID_STRING);

  // send command notifier
  msg = QString("(%1/%2) TITLE ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds) + msg;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// HandleOdbTitleTags
//**********************************************************************
void PLemAutoRun::HandleOdbTitleTags(QString &title)
{
  int idx=-1, status=0, size;
  char   bval;
  int    ival;
  float  fval;
  double dval;
  char   str[1024];
  PKey *key=0;
  QString subStr("??");
  for (int i=0; i<fOdbTagVector->size(); i++) {
    // check if an ODB tag is found in the title
    idx = title.indexOf(fOdbTagVector->at(i).tag);
    if (idx != -1) { // something found
      // check that the ODB tag entry is a valid ODB midas entry
      key = new PKey(fExp, fOdbTagVector->at(i).odb_path);
      if (key->IsValid()) {
        if (fOdbTagVector->at(i).idx+1 > key->GetNumValues()) {
          cm_msg(MINFO, "HandleOdbTitleTags", "HandleOdbTitleTags: %s: idx=%d >= number of entries=%d, will ignore it.",
                 fOdbTagVector->at(i).odb_path.toLatin1().data(), fOdbTagVector->at(i).idx, key->GetNumValues());
          cm_yield(0);
        } else if ((key->GetType() != TID_BYTE) &&
                   (key->GetType() != TID_SBYTE) &&
                   (key->GetType() != TID_CHAR) &&
                   (key->GetType() != TID_WORD) &&
                   (key->GetType() != TID_SHORT) &&
                   (key->GetType() != TID_DWORD) &&
                   (key->GetType() != TID_INT) &&
                   (key->GetType() != TID_BOOL) &&
                   (key->GetType() != TID_FLOAT) &&
                   (key->GetType() != TID_DOUBLE) &&
                   (key->GetType() != TID_STRING)) {
          cm_msg(MINFO, "HandleOdbTitleTags", "HandleOdbTitleTags: %s: wrong data type (%d), will ignore it.",
                 fOdbTagVector->at(i).odb_path.toLatin1().data(), key->GetType());
          cm_yield(0);
        } else {
          if (fOdbTagVector->at(i).idx != -1) { // data is an array
            switch (key->GetType()) {
              case TID_BYTE:
                size = sizeof(char);
                status = key->GetDataIndex(&bval, &size, fOdbTagVector->at(i).idx, TID_BYTE);
                subStr = QString("%1").arg(bval);
                break;
              case TID_SBYTE:
                size = sizeof(char);
                status = key->GetDataIndex(&bval, &size, fOdbTagVector->at(i).idx, TID_SBYTE);
                subStr = QString("%1").arg(bval);
                break;
              case TID_CHAR:
                size = sizeof(char);
                status = key->GetDataIndex(&bval, &size, fOdbTagVector->at(i).idx, TID_CHAR);
                subStr = QString("%1").arg(bval);
                break;
              case TID_WORD:
                size = 2*sizeof(char);
                status = key->GetDataIndex(&ival, &size, fOdbTagVector->at(i).idx, TID_WORD);
                subStr = QString("%1").arg(ival);
                break;
              case TID_SHORT:
                size = sizeof(int);
                status = key->GetDataIndex(&ival, &size, fOdbTagVector->at(i).idx, TID_SHORT);
                subStr = QString("%1").arg(ival);
                break;
              case TID_DWORD:
                size = sizeof(int);
                status = key->GetDataIndex(&ival, &size, fOdbTagVector->at(i).idx, TID_DWORD);
                subStr = QString("%1").arg(ival);
                break;
              case TID_INT:
                size = sizeof(int);
                status = key->GetDataIndex(&ival, &size, fOdbTagVector->at(i).idx, TID_INT);
                subStr = QString("%1").arg(ival);
                break;
              case TID_BOOL:
                size = sizeof(int);
                status = key->GetDataIndex(&ival, &size, fOdbTagVector->at(i).idx, TID_BOOL);
                subStr = QString("%1").arg(ival);
                break;
              case TID_FLOAT:
                size = sizeof(float);
                status = key->GetDataIndex(&fval, &size, fOdbTagVector->at(i).idx, TID_FLOAT);
                subStr = QString("%1").arg(fval);
                break;
              case TID_DOUBLE:
                size = sizeof(double);
                status = key->GetDataIndex(&dval, &size, fOdbTagVector->at(i).idx, TID_DOUBLE);
                subStr = QString("%1").arg(dval);
                break;
              case TID_STRING:
                size = key->GetItemSize()*sizeof(float);
                if (size < 1024) {
                  status = key->GetDataIndex(&str, &size, fOdbTagVector->at(i).idx, TID_STRING);
                  subStr = str;
                } else {
                  subStr = "?!?!";
                }
                break;
              default:
                break;
            }
            if (status == DB_SUCCESS) {
              title.replace(fOdbTagVector->at(i).tag, subStr);
            }
          } else { // data is a single value
            switch (key->GetType()) {
              case TID_BYTE:
                size = sizeof(char);
                status = key->GetData(&bval, &size, TID_BYTE);
                subStr = QString("%1").arg(bval);
                break;
              case TID_SBYTE:
                size = sizeof(char);
                status = key->GetData(&bval, &size, TID_SBYTE);
                subStr = QString("%1").arg(bval);
                break;
              case TID_CHAR:
                size = sizeof(char);
                status = key->GetData(&bval, &size, TID_CHAR);
                subStr = QString("%1").arg(bval);
                break;
              case TID_WORD:
                size = 2*sizeof(char);
                status = key->GetData(&ival, &size, TID_WORD);
                subStr = QString("%1").arg(ival);
                break;
              case TID_SHORT:
                size = sizeof(int);
                status = key->GetData(&ival, &size, TID_SHORT);
                subStr = QString("%1").arg(ival);
                break;
              case TID_DWORD:
                size = sizeof(int);
                status = key->GetData(&ival, &size, TID_DWORD);
                subStr = QString("%1").arg(ival);
                break;
              case TID_INT:
                size = sizeof(int);
                status = key->GetData(&ival, &size, TID_INT);
                subStr = QString("%1").arg(ival);
                break;
              case TID_BOOL:
                size = sizeof(int);
                status = key->GetData(&ival, &size, TID_BOOL);
                subStr = QString("%1").arg(ival);
                break;
              case TID_FLOAT:
                size = sizeof(float);
                status = key->GetData(&fval, &size, TID_FLOAT);
                subStr = QString("%1").arg(fval);
                break;
              case TID_DOUBLE:
                size = sizeof(double);
                status = key->GetData(&dval, &size, TID_DOUBLE);
                subStr = QString("%1").arg(dval);
                break;
              case TID_STRING:
                size = key->GetItemSize()*sizeof(char);
                if (size < 1024) {
                  status = key->GetData(&str, &size, TID_STRING);
                  subStr = str;
                } else {
                  subStr = "?!?!";
                }
                break;
              default:
                break;
            }
            if (status == DB_SUCCESS) {
              title.replace(fOdbTagVector->at(i).tag, subStr);
            }
          }
        }
      }
      // clean up
      if (key) {
        delete key;
        key = 0;
      }
      subStr = QString("??");
    }
  }
}

//**********************************************************************
// SetTof
//**********************************************************************
void PLemAutoRun::SetTof(AutoRunCmd *arc)
{
  float value;
  QString msg("");

  // check if TOF ODB entries are disabled in lemAutoRun
  if (!fEnabled["tof_min_odb"] || !fEnabled["tof_max_odb"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += "PLemAutoRun::SetTof: TOF ODB entires disabled in lemAutoRun. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  // send command notifier
  msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  // set values
  value = arc->param[0].toFloat();
  fTofMinKey->SetData((void *)&value, 1, TID_FLOAT);

  value = arc->param[1].toFloat();
  fTofMaxKey->SetData((void *)&value, 1, TID_FLOAT);

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// SetWait
//**********************************************************************
void PLemAutoRun::SetWait(AutoRunCmd *arc)
{
  QString msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  int wait = arc->param[0].toInt();

  for (int i=0; i<wait; i++) {
    Wait(1000); // sleep 1 sec

    if ( ((i+1) % 5) == 0 ) {   // once every 5 seconds

      // adjust flow when needed, but only when regulation is whished, the temperature is stable, and
      // there is a long enough history for a reliable regulation
      if (fSampleCryoInUse == CRYO_OVEN_OMEGA) {
        if (fEnabled["omega_eq"]) // only deal with omega oven if enabled
          CheckTempStabilityOvenOmega();
      } else {
        if (fEnabled["sample_eq"]) // only deal with sample cryo if enabled
          CheckTempStability();
      }
      if (fSampleCryoInUse == CRYO_KONTI) {
        if ( fSampleTempRegulation && (!fSampleTempUnstable) && (fSampleHistoNoEntries == SAMPLE_TEMP_HISTO_MAX) ) {
          if (fEnabled["sample_eq"]) // only deal with sample cryo if enabled
            SampleTempAdjustFlow();
        }
      }

      // dump raw voltage when needed
      if (fEnabled["sample_eq"]) { // only deal with sample cryo if enabled
        if (fDumpInUse) {
          if (fDumpCounter > 0) {
            RawVoltageDump();
          } else {
            fDumpFile.close();
            fDumpInUse = false;
          }
        }
      }
    }
  }

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// CheckForWarmUpCmd
//**********************************************************************
void PLemAutoRun::CheckForWarmUpCmd()
{
  PAutoRunCmdVector::Iterator iter;
  int yy, MM, dd, hh, mm, ss;
  QDate d;
  QTime t;

  for (iter = fAutoRunCmdVector->begin(); iter != fAutoRunCmdVector->end(); ++iter) {
    if (iter->cmd == "warmUp") {
      fWarmUpWished = true;
      sscanf(iter->param[0].toLatin1().data(), "%d-%d-%d", &yy, &MM, &dd);
      d = QDate(yy, MM, dd);
      fWarmUpDateTime.setDate(d);
      sscanf(iter->param[1].toLatin1().data(), "%d:%d:%d", &hh, &mm, &ss);
      t = QTime(hh, mm, ss);
      fWarmUpDateTime.setTime(t);
      if (iter->param[2] == "1")
        fWarmUpVent = true;
      break;
    }
  }
}

//**********************************************************************
// WarmUp
//**********************************************************************
void PLemAutoRun::WarmUp(PAutoRunCmdVector::Iterator iter)
{
  int     status, size;
  QString err, msg;
  unsigned int i, j;
  float   value;
  float   hv[HV_FUG_CHS];
  bool    done, happy;
  QElapsedTimer   t;

  // check if sample equipment is disabled in lemAutoRun
  if (!fEnabled["sample_eq"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += "PLemAutoRun::WarmUp: sample equipment disabled in lemAutoRun. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, 0, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  // notifier
  msg = QString("PLemAutoRun::WarmUp(): warm up procedure starts. Will stop any pending runs, shutdown HV's, ...");
  emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, msg);

  // update web-page
  UpdateWebPage(iter, HTML_WARMUP);

  // if there is an active run, stop it
  if (fRunInfo.state == RUN_RUNNING) {
    // stop run
    status = cm_transition(TR_STOP, fRunInfo.run_number, NULL, 0, TR_SYNC, FALSE);
    if (status != CM_SUCCESS) { // error
      err = QString("PLemAutoRun::RunStart: Cannot stop the run.");
      emit ErrorMsg(1, 0, LAR_MIDAS_CANNOT_START_RUN, -1, err);
      emit StatusMsg(err);
    }
    err = QString("Autorun running: run stopped.");
    emit StatusMsg(err);
    fRunNoEventsNeeded = 0;
    fRunStopped = true;
  }

  // close KV61 and KV62
  msg = QString("PLemAutoRun::WarmUp(): close KV61 and KV62");
  emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, msg);

  value = 0.0;
  fBeamlineDemandKey->SetDataIndex(&value, BEAMLINE_KV61_DEMAND_CH, TID_FLOAT);
  value = 0.0;
  fBeamlineDemandKey->SetDataIndex(&value, BEAMLINE_KV62_DEMAND_CH, TID_FLOAT);

  // switch off all the FUG HV's **************************************************************

  msg = QString("PLemAutoRun::WarmUp(): switch off all the FUG HV's");
  emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, msg);

  if (fEnabled["fug_scfe"]) { // only do something if FUG is enabled
    // Loop over set HV. This is done this way to reduce hangers due to network problems
    for (j=0; j<HV_FUG_MAX_TRY; j++) {

      // set HV's to 0.0
      value = 0.0 + j*0.001; // j-term to force the DD set command being executed
      for (i=0; i<HV_FUG_CHS; i++)
        hv[i] = value;
      fHVDemandKey->SetData((void *)&hv, HV_FUG_CHS, TID_FLOAT);

      if (fFugHvCheck) {
        // check that HV is really down
        done  = false;
        happy = false;
        t.start();
        do {
          Wait(2000); // sleep for 2 sec

          // read measured HV's
          size = sizeof(hv);
          fHVMeasuredKey->GetData(&hv, &size, TID_FLOAT);

          // calculate the sum of all sample region HV's
          value = 0.0;
          for (i=0; i<HV_FUG_CHS; i++)
            value += hv[i];

          // if sum of all HV's is smaller than 500V leave the loop
          if (fabs(value) < 0.5) {
            done  = true;
            happy = true;
          }

          // check if timeout occured
          if (t.elapsed() > 3e5) { // 5 min. timeout
            done = true;
            err = QString("PLemAutoRun::WarmUp(): Couldn't shut down HV's. Will give it another try in 120 sec.");
            emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, err);
          }
        } while (!done);

        if (happy) // everything perfect, get out of the loop
          break;

        // wait 120 sec before retrial
        Wait(120000);
      } else { // NO FUG HV check, hence just wait a 1 min
        Wait(60000);
        j = 0;
      }
    }

    if (j == HV_FUG_MAX_TRY) {
      err = QString("PLemAutoRun::WarmUp(): Couldn't shut down sample region HV's. Error too severe, will stop.");
      emit ErrorMsg(1, 0, LAR_FUG_NO_RESPONSE, -1, err);
    }
  }

  // disable the RA pulsing
  msg = QString("PLemAutoRun::WarmUp(): disable potentially set RA pulsing.");
  emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, msg);

  PKey *enable_RA_pulsing = new PKey(fExp, "/Equipment/Trigger/Settings/Enable_OnOff_Mode");
  if (!enable_RA_pulsing->IsValid()) {
    err = QString("PLemAutoRun::WarmUp(): Couldn't get the Enable_OnOff_Mode key for the RA pulsing. Please check instantly! Error too severe, will stop.");
    emit ErrorMsg(1, 0, LAR_FUG_NO_RESPONSE, -1, err);
  }
  int ival = 0;
  enable_RA_pulsing->SetData((void*)&ival, 1,TID_BOOL);
  if (enable_RA_pulsing) {
    delete enable_RA_pulsing;
    enable_RA_pulsing = 0;
  }

  // close the BPVX/Y *****************************************************************************
  msg = QString("PLemAutoRun::WarmUp(): close BPVX/Y");
  emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, msg);

  // close BPVX
  if (!SetBPV(BPVX, BPV_CLOSE)) {
    QString err = QString("PLemAutoRun::WarmUp(): Couldn't close BPVX. Error too severe, will stop.");
    emit ErrorMsg(1, 0, LAR_BPVY_NO_RESPONSE, -1, err);
  }

  // close BPVY
  if (!SetBPV(BPVY, BPV_CLOSE)) {
    QString err = QString("PLemAutoRun::WarmUp(): Couldn't close BPVY. Error too severe, will stop.");
    emit ErrorMsg(1, 0, LAR_BPVY_NO_RESPONSE, -1, err);
  }

  // set the He Flow (Bronkhorst) to minimal *********************************************************
  msg = QString("PLemAutoRun::WarmUp(): sample He flow set to minimum value");
  emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, msg);
  value = fBHFlowTemp / (300.0 + fBHFlowTempOffset) + fBHFlowOffset;
  fSampleOutputKey->SetDataIndex((void *)&value, fSampleBhOdbOffsetOutput + BH_OUTPUT_FLOW, TID_FLOAT);

  // set demand temperature ramping to zero
  msg = QString("PLemAutoRun::WarmUp(): set demand temperature ramping to zero");
  emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, msg);
  value = 0.0;
  fSampleOutputKey->SetDataIndex((void *)&value, LS336_OUTPUT_RAMP, TID_FLOAT);

  // check that the demand temperature ramping is set before proceeding
  t.start();
  do {
    Wait(3000);
    if (fSampleInput[LS336_INPUT_RAMP] == 0.0)
      break;
  } while (t.elapsed() < 60e3);

  // set the sample cryo temperature to 300K
  msg = QString("PLemAutoRun::WarmUp(): set sample cryo temperature to 300K");
  emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, msg);
  value = 300.0;
  fSampleOutputKey->SetDataIndex((void *)&value, LS336_OUTPUT_SETPOINT, TID_FLOAT);

  // read back temperature, if T>250K set the He Flow to zero, if T>90K and vent shall be performed: vent
  done = false;
  do {
    Wait(3000); // sleep for 3 sec

    size = sizeof(value);
    fSampleInputKey->GetDataIndex((void *)&value, &size, fSampleCtrlCh, TID_FLOAT);

    if ((value > 90.0) && fWarmUpVent && fEnabled["lemvac_scfe"]) {
      msg = QString("PLemAutoRun::WarmUp(): vent the sample chamber.");
      emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, msg);
      value = 1.0; // enable SC vent
      fLemvacOutputKey->SetDataIndex((void*)&value, SC_VENT_ENABLED, TID_FLOAT);
      value = 2.0; // SC vent command
      fLemvacOutputKey->SetDataIndex((void*)&value, SC_VENT_CMD, TID_FLOAT);
      fWarmUpVent = false;
    }

    if (value > 250.0) {
      done = true;
      // set the He Flow (Bronkhorst) to minimal
      msg = QString("PLemAutoRun::WarmUp(): sample He flow set to zero");
      emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, msg);
      value = 0.0;
      fSampleOutputKey->SetDataIndex((void *)&value, fSampleBhOdbOffsetOutput + BH_OUTPUT_FLOW, TID_FLOAT);
    }
  } while (!done);
}


//**********************************************************************
// GotoLine
//**********************************************************************
void PLemAutoRun::GotoLine(PAutoRunCmdVector::Iterator &iter, int max)
{
  int count=0, pos=0, gotoLine=GetGotoLine();
  QString msg;

  // check if goto line is within autorun
  if (gotoLine <= max) {
    for (PAutoRunCmdVector::Iterator loopIter=fAutoRunCmdVector->begin(); loopIter != fAutoRunCmdVector->end(); ++loopIter) {
      if (loopIter->cmd == "comment") {
        if (ShowComments() == true)
          pos++;
      } else {
        count++;
        pos++;
      }
      if (pos == gotoLine) {
        iter = loopIter;
        fCurrentAutoRunCmd = count;
        cm_msg(MINFO, "ExecAutoRun", "ExecAutoRun: will goto line %d", gotoLine);
        cm_yield(0);
        msg = QString("will go to line %1").arg(gotoLine);
        emit StatusMsg(msg);
        break;
      }
    }
  } else { // out of range
    cm_msg(MERROR, "ExecAutoRun", "ExecAutoRun: goto line %d > max. line number (%d). Doesn't make sense. Will ignore it!", gotoLine, max);
    cm_yield(0);
    msg = QString("line number %1 > max. line number (%2). Doesn't make sense. Will ignore it.").arg(gotoLine).arg(max);
    emit StatusMsg(msg);
  }

  // set goto line back to zero
  SetGotoLine(0);
  do { // wait until the hotlink is updated
    cm_yield(100);
  } while (GetGotoLine() != 0);
}

//**********************************************************************
// GetDemandHVSampleChamber
//**********************************************************************
void PLemAutoRun::GetDemandHVSampleChamber()
{
  int   size, status;
  float demands[HV_FUG_CHS];

  size = sizeof(demands);
  status = fHVDemandKey->GetData(&demands, &size, TID_FLOAT);
  if (status != DB_SUCCESS) {
    UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
    QString err = QString("PLemAutoRun::GetDemandHVSampleChamber: Couldn't get demand HV's. Error too severe, will stop.");
    emit ErrorMsg(1, 0, LAR_FUG_NO_RESPONSE, -1, err);
  }

  for (int i=0; i<5; i++)
    fHVDemandSampleChamber[i] = demands[i+HV_FUG_RAL];
}

//**********************************************************************
// ChangeSampleChamberHV
//**********************************************************************
void PLemAutoRun::ChangeSampleChamberHV(bool down)
{
  int   i, j, ok, size;
  float value;
  float measured[HV_FUG_CHS];
  int hv_down;
  bool  done, happy;
  QElapsedTimer t;
  QString err, msg;

  // check if FUG handling is disabled in lemAutoRun
  if (!fEnabled["fug_scfe"]) {
    return;
  }

  if (down) { // shut down sample region HV's

    // notifiy about down ramping
    msg = QString("ramp sample region HV's down.");
    emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, msg);

    // Loop over set HV. This is done this way to reduce hangers due to network problems
    for (j=0; j<HV_FUG_MAX_TRY; j++) {

      // set sample region HV's to 0.0
      value = 0.0 + j*0.001; // j-term to force the DD set command being executed
      for (i=0; i<5; i++)
        fHVDemandKey->SetDataIndex((void *)&value, i+HV_FUG_RAL, TID_FLOAT);

      if (fFugHvCheck) {
        // check that HV is really down
        done  = false;
        happy = false;
        t.start();
        do {
          Wait(2000); // sleep for 2 sec

          // init hv_down tag
          hv_down = 0;

          // read measured HV's
          size = sizeof(measured);
          fHVMeasuredKey->GetData(&measured, &size, TID_FLOAT);

          // calculate the sum of all sample region HV's
          value = 0.0;
          for (i=0; i<5; i++) {
            value += measured[i+HV_FUG_RAL];
            if (measured[i+HV_FUG_RAL] < 0.35) // measured HV of a single channel < 350V
              hv_down += 1;
          }

          // if sum of all the sample region HV's is smaller than 100V leave the loop
          if ((fabs(value) < 0.1) || (hv_down == 5)) {
            done  = true;
            happy = true;
          }

          // check if timeout occured
          if (t.elapsed() > 3e5) { // 5 min. timeout
            done = true;
            err = QString("PLemAutoRun::ChangeSampleChamberHV: Couldn't shut down sample region HV's. Will give it another try in 120 sec.");
            emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, err);
          }
        } while (!done);

        if (happy) // everything perfect, get out of the loop
          break;

        // wait 120 sec before retrial
        Wait(120000);
      } else { // NO FUG HV check, hence just wait a 1 min
        Wait(60000);
        j = 0;
      }
    }
    if (j == HV_FUG_MAX_TRY) {      
      UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
      err = QString("PLemAutoRun::ChangeSampleChamberHV: Couldn't shut down sample region HV's. Error too severe, will stop.");
      emit ErrorMsg(1, 0, LAR_FUG_NO_RESPONSE, -1, err);
      for (int k=0; k<5; k++) {
        if (measured[k+HV_FUG_RAL] > 0.25) {
          cm_msg(MERROR, "lemAutoRun", "FUG channel %d should be 0.0 but found %f", k+HV_FUG_RAL, measured[k+HV_FUG_RAL]);
          cm_yield(0);
        }
      }
    }
  } else { // ramp back sample region HV's

    // notifiy about up ramping
    msg = QString("ramp sample region HV's back up.");
    emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, msg);

    // Loop over set HV. This is done this way to reduce hangers due to network problems
    for (j=0; j<HV_FUG_MAX_TRY; j++) {

      // set sample region HV's to it's previous value
      for (i=0; i<5; i++) {
        value = fHVDemandSampleChamber[i] + (-1)*(j%2)*0.001; // j-term to force the DD set command being executed
        fHVDemandKey->SetDataIndex((void *)&value, i+HV_FUG_RAL, TID_FLOAT);
      }

      if (fFugHvCheck) {
        // check that HV are ramped back
        done  = false;
        happy = false;
        t.start();
        do {
          Wait(2000); // sleep for 2 sec

          // read measured HV's
          size = sizeof(measured);
          fHVMeasuredKey->GetData(&measured, &size, TID_FLOAT);

          // check if HV is ok
          ok = 0;
          for (i=0; i<5; i++) {
            if (fabs(measured[i+HV_FUG_RAL]-fHVDemandSampleChamber[i]) < 0.2)
              ok++;
          }

          // if all the sample region HV's are ok within 200V leave the loop
          if (ok == 5) {
            done  = true;
            happy = true;
          }

          // check if timeout occured
          if (t.elapsed() > 3e5) { // 5 min. timeout
            done = true;
            err = QString("PLemAutoRun::ChangeSampleChamberHV: Couldn't ramp back sample region HV's. Will give it another try in 120 sec.");
            emit ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, err);
          }
        } while (!done);

        if (happy) // everything perfect, get out of the loop
          break;

        // wait 120 sec before retrial
        Wait(120000);
      } else { // NO FUG HV check, hence just wait a 1 min
        Wait(60000);
        j = 0;
      }
    }

    if (j == HV_FUG_MAX_TRY) {
      UpdateWebPage(fAutoRunCurrentIter, HTML_ABORTED);
      err = QString("PLemAutoRun::ChangeSampleChamberHV: Couldn't ramp back sample region HV's. Error too severe, will stop.");
      emit ErrorMsg(1, 0, LAR_FUG_NO_RESPONSE, -1, err);
    }
  }
}

//**********************************************************************
// SetBPV - AutoRunCmd
//**********************************************************************
void PLemAutoRun::SetBPV(AutoRunCmd *arc)
{
  QString msg("");

  // check if lemvac equipment is disabled in lemAutoRun
  if (!fEnabled["lemvac_eq"]) {
    msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
    msg += "PLemAutoRun::SetBPV: lemvac equipment disabled in lemAutoRun. Will do nothing here.";
    emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);
    // increment command counter
    fCurrentAutoRunCmd++;
    return;
  }

  msg = QString("(%1/%2) ").arg(fCurrentAutoRunCmd).arg(fNoOfAutoRunCmds);
  msg += arc->cmdString;
  emit ErrorMsg(1, 0, LAR_MSG, arc->lineNo, msg);

  msg = QString("Autorun running: ") + msg;
  emit StatusMsg(msg);

  int label=BPVX, state=BPV_CLOSE;
  // get valve label
  if (arc->param[0] == "X")
    label = BPVX;
  else
    label = BPVY;

  // get valve state
  if ((arc->param[1] == "1") || (arc->param[1] == "open"))
    state = BPV_OPEN;

  SetBPV(label, state);

  // increment command counter
  fCurrentAutoRunCmd++;
}

//**********************************************************************
// SetBPV
//**********************************************************************
bool PLemAutoRun::SetBPV(int valve, int cmd)
{
  int   size;
  int   index;
  float value;

  if (!fEnabled["lemvac_scfe"]) { // only needed if LEMVAC is enabled
    return true;
  }

  // check if BPVX/Y is enabled
  size  = sizeof(value);
  if (valve == BPVX)
    index = BPVX_ENABLED;
  else
    index = BPVY_ENABLED;
  fLemvacOutputKey->GetDataIndex(&value, &size, index, TID_FLOAT);

  if (value != 1) { // BPVX/Y NOT enabled
    return false;
  }

  // set new state of the BPVX/Y
  value = cmd;
  if (valve == BPVX)
    index = BPVX_SET;
  else
    index = BPVY_SET;

  fLemvacOutputKey->SetDataIndex(&value, index, TID_FLOAT);

  // check if the state really has changed
  if (valve == BPVX)
    index = BPVX_STATE;
  else
    index = BPVY_STATE;
  bool  done = false;
  QElapsedTimer t;
  t.start();
  do {
    Wait(2000); // sleep for 2 sec

    size = sizeof(value);
    fLemvacInputKey->GetDataIndex(&value, &size, index, TID_FLOAT);

    if (value == BPV_STATE_LOCKED)
      return true;

    if (cmd == BPV_CLOSE) { // close command
      if (value == BPV_STATE_CLOSED)
        done = true;
    } else { // open command
      if (value == BPV_STATE_OPEN)
        done = true;
    }

    if (t.elapsed() > 6e4) { // no correct read back within 60 sec
      return false;
    }
  } while (!done);

  return true;
}

//**********************************************************************
// GetBPV
//**********************************************************************
bool PLemAutoRun::GetBPV()
{
  int   size;
  int   index;
  float value;

  if (!fEnabled["lemvac_scfe"]) { // only needed if LEMVAC is enabled
    return true;
  }

  index = BPVX_STATE;
  size = sizeof(value);
  fLemvacInputKey->GetDataIndex(&value, &size, index, TID_FLOAT);
  if ((value != BPV_STATE_OPEN) && (value != BPV_STATE_CLOSED) && (value != BPV_STATE_LOCKED))
    return false;
  fLemVacValveInitialState[BPVX] = value;

  fExp->FeedMidasWatchdog();

  index = BPVY_STATE;
  fLemvacInputKey->GetDataIndex(&value, &size, index, TID_FLOAT);
  if ((value != BPV_STATE_OPEN) && (value != BPV_STATE_CLOSED) && (value != BPV_STATE_LOCKED))
    return false;
  fLemVacValveInitialState[BPVY] = value;

  return true;
}

//**********************************************************************
// RawVoltageDump
//**********************************************************************
void PLemAutoRun::RawVoltageDump()
{
  float         rv[8];
  float         value, value1, value2, value3, value4, value5, value6;
  int           size4  = sizeof(value);

  // get the time in a LS340 compatible way
  struct timespec tp;
  clock_gettime(CLOCK_REALTIME, &tp);
  struct tm *timeinfo;
  timeinfo = localtime(&tp.tv_sec);
  char LSdateTime[32];
  snprintf(LSdateTime, sizeof(LSdateTime), "%02d,%02d,%04d,%02d,%02d,%02d,%03d",
           timeinfo->tm_mon + 1, timeinfo->tm_mday, timeinfo->tm_year + 1900,
           timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec,
           (int)(tp.tv_nsec / 1000000));

  fSampleInputKey->GetDataIndex(&value1, &size4, fSampleCtrlCh, TID_FLOAT);
  fSampleInputKey->GetDataIndex(&value2, &size4, LS336_INPUT_PRESSURE, TID_FLOAT);
  fSampleInputKey->GetDataIndex(&value3, &size4, LS336_INPUT_HEATER, TID_FLOAT);
  fSampleInputKey->GetDataIndex(&value4, &size4, LS336_INPUT_SETPOINT, TID_FLOAT);
  fSampleInputKey->GetDataIndex(&value5, &size4, LS336_INPUT_HEATER_RANGE, TID_FLOAT);
  fSampleInputKey->GetDataIndex(&value6, &size4, fSampleBhOdbOffsetInput+BH_INPUT_FLOW, TID_FLOAT);

  for (int i=0; i<8; i++) {
    fSampleRawVoltageKey->GetDataIndex( &value, &size4, i, TID_FLOAT);
    rv[i] = value;
  }

  QTextStream stream( &fDumpFile );
  stream << LSdateTime <<  "," <<
            value1     <<  "," <<
            value2     <<  "," <<
            value3     <<  "," <<
            value4     <<  "," <<
            value5     <<  "," <<
            value6;
  for (int i=0; i<8; i++)
    stream << "," << rv[i];
  stream << Qt::endl;
  fDumpFile.flush();

  fDumpCounter--;
}

//**********************************************************************
// Wait
//**********************************************************************
void PLemAutoRun::Wait(int timeout)
{
  int count = timeout / 1000; // how many 1 sec steps needed

  for (int i=0; i<count; i++) {
    ss_sleep(1000); // sleep 1 sec
    fExp->FeedMidasWatchdog();
  }

  // deal with the sub-second rest
  if ((timeout % 1000) != 0) {
    ss_sleep(timeout % 1000);
    fExp->FeedMidasWatchdog();
  }
}


//**********************************************************************
// TdHvTripFlagChanged
//**********************************************************************
void TdHvTripFlagChanged(HNDLE, HNDLE, void *info)
{
  PLemAutoRun *lar;
  lar = (PLemAutoRun *)info;

  // check if TD HV Trip Alarm flag is true
  if (lar->fHvTripFlag) {
    QString err  = QString("PLemAutoRun: HV trip due to TD rate trip! Will wait until the problem is resolved.");
    emit lar->ErrorMsg(1, 0, LAR_MSG_NO_LINE_NO, -1, err);
  }
}

//---------------------------------------------------------------------------------------
// end
//---------------------------------------------------------------------------------------