PLemAutoRun.h

Go to the documentation of this file.

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

  PLemAutoRun.h

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

    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.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef _PLEMAUTORUN_H_
#define _PLEMAUTORUN_H_

#include <QObject>
#include <QString>
#include <QDateTime>
#include <QTimer>
#include <QElapsedTimer>
#include <QVector>
#include <QMap>
#include <QIODevice>
#include <QXmlStreamReader>
#include <QFile>

#include "PGlobals.h"
#include "PPwd.h"
#include "PExperiment.h"
#include "PKey.h"

#include "lemAutoRun.h"

#define SAMPLE_CRYO_INPUT  30
#define SAMPLE_CRYO_OUTPUT 20
#define SAMPLE_OVEN_OMEGA_INPUT  10
#define SAMPLE_OVEN_OMEGA_OUTPUT 4
#define SAMPLE_TEMP_HISTO_MAX 10

#define NO_ENERGY_LOSS_PARAM 4

void TdHvTripFlagChanged(HNDLE, HNDLE, void*);

class PLemAutoRun;

//----------------------------------------------------------------------------
typedef struct {
  double datetime;   
  float  demand_T;   
  float  measured_T; 
  float  heater;     
  float  flow;       
  float  pressure;   
} SampleTempInfo;

//----------------------------------------------------------------------------
typedef struct {
  int   state;                   
  int   online_mode;             
  int   run_number;              
  int   transition_in_progress;  
  int   start_abort;             
  int   requested_transition;    
  char  start_time[NAME_LENGTH]; 
  DWORD start_time_binary;       
  char  stop_time[NAME_LENGTH];  
  DWORD stop_time_binary;        
} RunInfo;

//----------------------------------------------------------------------------
class PLemAutoRunXMLParser
{
  public:
    enum ELemAutoRunKeyWords {eEmpty, eEnableAll,
                              eXmlSchemaFln, eXmlAutoRunFln, eXmlAutoRunValidateFln, eXmlAutoRunHTML,
                              eAutoRunPath, eHvSettingsPath, eDebug, eIgnore_clients, eIgnore_alarms, eFugHvCheck,
                              eField_timeout, eField_accuracy, eHv_timeout, eHv_accuracy, eFOM_current_accuracy,
                              eWEW_critical_current_ra, eWEWL_max_current, eWEWH_max_current, eDanfysik_max_current,
                              eMag_param_wew, eMag_param_bpar,
                              eSetup_sample_enabled, eSetup_wew_enabled, eSetup_bpar_enabled,
                              eEnable_OnOff_Mode, eTrigger_events, eAlarms, eAlarm_td_hv_trip,
                              eRun_info, eRun_comment, eTof_min, eTof_max,
                              eMod_name, eMod_date, eLem_setup, eSpin_rot_angle, eSpin_rot_enabled,
                              eSample_name, eSample_cryo,
                              eEnergy_loss_param,
                              eClients, eClients_analyzer, eClients_frontend, eClients_tfl,
                              eClients_sample, eClients_sample_omega,
                              eClients_WEW, eClients_danfysik, eClients_hv, eClients_lemvac,
                              eHv_demand, eHv_measured, eHv_current,
                              eHvDetector_demand, eHvDetector_measured,
                              eSpin_rot_mag_input, eSpin_rot_mag_output,
                              eDanfysik_input, eDanfysik_output,
                              eWEW_input, eWEW_output,
                              eMag_field,
                              eTfl_input, eTfl_output,
                              eSample_ctrl_ch, eSample_sensor_type, eSample_channel, eSample_input,
                              eSample_output,
                              eSample_rawvoltage,
                              eSample_bh_odb_offset_input, eSample_bh_odb_offset_output,
                              eSample_oven_omega_input, eSample_oven_omega_output,
                              eLemvac_input, eLemvac_output, eFOM_input, eFOM_output,
                              eBeamline_demand};

    PLemAutoRunXMLParser(const QString fln, PLemAutoRun *lar);
    ~PLemAutoRunXMLParser();

    bool isValid() { return fValid; }

    bool parse(QIODevice *device);
    bool startDocument();
    bool startElement();
    bool endElement();
    bool characters();
    bool endDocument();

  private:
    bool fValid{false};
    QXmlStreamReader fXml; 
    PLemAutoRun         *fLar; 
    ELemAutoRunKeyWords  fKey; 

    void setAttribute(const QString key, const QXmlStreamAttributes& qAttr);
};

//----------------------------------------------------------------------------
class PLemSampleCryoXMLParser
{
  public:
    enum ELemSampleCryoKeyWords {eEmpty, eTemp_regulation, eMax_temp_increase,
                                 eBh_max_flow, eBh_min_flow, 
                                 eBh_flow_p_heat_0, eBh_flow_p_heat_1, eBh_flow_d_heat,
                                 eBh_flow_temp, eBh_flow_temp_offset, eBh_flow_offset,
                                 eD_set_ratio, eAbs_max_temp_diff, eRel_max_temp_diff,
                                 eMax_temp_trend, eHeater_min, eHeater_max, eTimeout_flow_set, eFlow_factor,
                                 eFlow_set_ratio, eFlow_set_absolute, eFlow_timeout_reduction,
                                 eFlowLowestFlowToConsider, eFlowMaxRelFlowDiffToConsider, 
                                 eDFlowDp0, eDFlowDp1, eDFlowDpExp,
                                 eHeatCapCof1, eHeatCapCof2, eHeatCapCof3,
                                 eNeedleValveInUse,
                                 ePrefNeedleValveCof_1_0, ePrefNeedleValveCof_1_1,
                                 ePrefNeedleValveCof_2_0, ePrefNeedleValveCof_2_1, 
                                 ePrefNeedleValveCof_3_0, ePrefNeedleValveCof_3_1,
                                 ePrefNeedleValveCof_4_0, ePrefNeedleValveCof_4_1,
                                 ePrefNeedleValveRelStep, ePrefNeedleValveAbsStep};

    PLemSampleCryoXMLParser(const QString fln, PLemAutoRun *lar);
    ~PLemSampleCryoXMLParser();

    bool isValid() { return fValid; }

    bool parse(QIODevice *device);
    bool startDocument();
    bool startElement();
    bool endElement();
    bool characters();
    bool endDocument();

  private:
    bool fValid{false};
    QXmlStreamReader fXml; 
    PLemAutoRun            *fLar; 
    ELemSampleCryoKeyWords  fKey; 
};

//----------------------------------------------------------------------------
class PLemHvSettingsFileParser
{
  public:
    enum ELemHvSettingsKeyWords { eEmpty, eHvDeviceName, eHvChNo, eHvChName, eHvDemand, eCurrentLimit };

    PLemHvSettingsFileParser(const QString fln);
    ~PLemHvSettingsFileParser();

    bool parseIsValid() { return fParseIsValid; }

    bool parse(QIODevice *device);
    bool startDocument();
    bool startElement();
    bool endElement();
    bool characters();
    bool endDocument();

    bool isValid(QString &errMsg) { errMsg = fErrorMsg; return fValid; }

    QVector<int> *GetChNo() { return &fHvChNo; }
    QVector<QString> *GetHvChNames() { return &fHvChName; }
    QVector<float> *GetHvDemands() { return &fHvDemand; }
    QVector<float> *GetCurrentLimits() { return &fCurrentLimit; }

  private:
    bool             fValid;
    bool             fParseIsValid{false};
    QString          fErrorMsg;
    QString          fHvDeviceName;
    QVector<int>     fHvChNo;
    QVector<QString> fHvChName;
    QVector<float>   fHvDemand;
    QVector<float>   fCurrentLimit;

    QXmlStreamReader fXml; 
    ELemHvSettingsKeyWords  fKey; 
};

//----------------------------------------------------------------------------
class PLemAutoRun : public QObject
{
  Q_OBJECT

  public:
    PLemAutoRun(QString &host, QString &exp);
    ~PLemAutoRun();

    void     ReadStartupXML();
    void     ReadSampleCryoXML();
    void     ConnectToExp();
    bool     IsConnected() { return fExp->IsConnected(); }
    void     DisconnectFromExp();
    bool     IsIdle();
    void     FeedMidasWatchdog() { fExp->FeedMidasWatchdog(); }

    QString *GetHostName() { return &fHostName; }
    QString *GetExpName() { return &fExpName; }
    QString  GetUserAutoRunSeqFln();
    QString *GetXMLSchemaFln() { return &fXMLSchemaFln; }
    QString *GetXMLAutoRunFln() { return &fXMLAutoRunFln; }
    QString *GetXMLAutoRunValidateFln() { return &fXMLAutoRunValidateFln; }

    void     SetOdbTagVec(POdbTagVector *otv) { fOdbTagVector = otv; }
    void     SetAutoRunSeq(PAutoRunCmdVector *arcv) { fAutoRunCmdVector = arcv; }
    void     FeedLiveDataAutoRun();
    void     ExecAutoRun();

  public slots:
    void     HandleParseError(int noOfErrors, int idx, int errorNo, int line, QString errorMsg);
    void     DisconnectAndQuit();

  signals:
    void     ErrorMsg(int noOfErrors, int idx, int errorNo, int line, QString errorMsg);
    void     StatusMsg(const QString statusMsg);

  private:
    QString  fAutoRunSequence;       
    bool     fShowComments;          
    int      fGotoLine;              
    QString  fNextAutoRunSequence;   
    QString  fAutoRunStatusMsg;      
    int      fAutoRunState;          

    bool     fEnableAll;             
    QMap<QString, bool> fEnabled;    
    bool     fDebug;                 
    bool     fIgnoreClients;         
    bool     fIgnoreAlarms;          
    bool     fFugHvCheck;            
    bool     fRAPulsingEnabled;      
    int      fHvTripFlag;            

    QString  fHostName;              
    QString  fExpName;               
    QString  fXMLSchemaFln;          
    QString  fXMLAutoRunFln;         
    QString  fXMLAutoRunValidateFln; 
    QString  fXMLAutoRunHTML;        
    QString  fAutoRunPath;           
    QString  fFieldPwrSupply;        

    // operation and boundary related variables
    float   fEnergyLossParam[NO_ENERGY_LOSS_PARAM]; 
    float   fMaxTempIncrease;       
    float   fFieldTimeout;          
    float   fFieldAccuracy;         
    float   fHVTimeout;             
    float   fHVAccuracy;            
    float   fHVDemandSampleChamber[5];   
    float   fLemVacValveInitialState[2]; 
    float   fBHMaxFlow;             
    float   fBHMinFlow;             
    float   fBHFlowPHeat0;          
    float   fBHFlowPHeat1;          
    float   fBHFlowDHeat;           
    float   fBHFlowTemp;            
    float   fBHFlowTempOffset;      
    float   fBHFlowOffset;          
    float   fDSetRatio;             
    float   fAbsMaxTempDiff;        
    float   fRelMaxTempDiff;        
    float   fMaxTempTrend;          
    float   fHeaterMax;             
    float   fHeaterMin;             
    float   fTimeoutFlowSet;        
    float   fFlowFactor;            
    float   fFlowSetRatio;          
    float   fFlowSetAbsolute;       
    float   fFlowTimeoutReduction;  
    float   fFlowLowestFlowToConsider;     
    float   fFlowMaxRelFlowDiffToConsider; 
    float   fDFlowDp0;              
    float   fDFlowDp1;              
    float   fDFlowDpExp;
    bool    fLargeFlow;             

    // heat capacity related coefficients
    float   fHeatCapCof1;           
    float   fHeatCapCof2;           
    float   fHeatCapCof3;

    // Coefficients for preferred needle valve settings
    bool    fNeedleValveInUse;             
    float   fPrefNeedleValveCof_1_0;       
    float   fPrefNeedleValveCof_1_1;
    float   fPrefNeedleValveCof_2_0;       
    float   fPrefNeedleValveCof_2_1;
    float   fPrefNeedleValveCof_3_0;       
    float   fPrefNeedleValveCof_3_1;
    float   fPrefNeedleValveCof_4_0;       
    float   fPrefNeedleValveCof_4_1;
    float   fPrefNeedleValveRelStep;       
    float   fPrefNeedleValveAbsStep;       

    // temperature and temp-history related variables
    int    fSampleCtrlCh;         
    int    fSampleCryoInUse;      
    float  fSampleTempAccuracy;   
    bool   fSampleTempRegulation; 
    bool   fSampleTempUnstable;   
    double fSampleHistoTime;      
    double fSampleHistoLastTime;  
    int    fSampleHistoNoEntries; 
    int    fSampleHistoPos;       
    SampleTempInfo fSampleTempHisto[SAMPLE_TEMP_HISTO_MAX]; 
    SampleTempInfo fSampleTempAverage; 
    SampleTempInfo fSampleTempTrend;   
    SampleTempInfo fSampleTempSecond;  
    SampleTempInfo fSampleTempRmsqd;   

    // magnet power supply limits and calibration parameters
    float fWEWLMaxCurrent;     
    float fWEWHMaxCurrent;     
    float fMagParamWew[2];     
    float fDanfysikMaxCurrent; 
    float fMagParamBpar[2];    

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

    // FOM related variables
    float fFOMCurrentAccuracy; 

    // HV settings path
    QString fHvSettingsPath;

    // raw voltage dump related variables
    bool  fDumpInUse;      
    int   fDumpCounter;    
    QString fDumpFileName; 
    QFile fDumpFile;       

    // warmup related variables
    bool      fWarmUpWished;   
    bool      fWarmUpVent;     
    QDateTime fWarmUpDateTime; 

    // hotlinked variables
    float fSampleInput[SAMPLE_CRYO_INPUT];
    float fSampleOutput[SAMPLE_CRYO_OUTPUT];
    float fSampleOvenOmegaInput[SAMPLE_OVEN_OMEGA_INPUT];
    float fSampleOvenOmegaOutput[SAMPLE_OVEN_OMEGA_OUTPUT];

    // setup related variables
    bool fSetupSampleEnabled; 
    bool fSetupWewEnabled;    
    bool fSetupBparEnabled;   

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

    int fSampleBhOdbOffsetInput;  
    int fSampleBhOdbOffsetOutput; 

    QString fAnalyzerName; 
    QString fFrontendName; 
    QString fTflFeName; 
    QString fSampleFeName; 
    QString fSampleOvenOmegaFeName; 
    QString fWEWFeName; 
    QString fDanfysikFeName; 
    QString fHVFeName;     
    QString fLemvacFeName; 
    bool fAnalyzerRunning; 
    bool fFrontendRunning; 
    bool fTflFeRunning; 
    bool fSampleFeRunning; 
    bool fWEWFeRunning; 
    bool fDanfysikFeRunning; 
    bool fSampleOvenOmegaFeRunning; 
    bool fHVFeRunning;     
    bool fLemvacFeRunning; 

    friend class PLemAutoRunXMLParser;
    friend class PLemSampleCryoXMLParser;

    POdbTagVector *fOdbTagVector;         
    PAutoRunCmdVector *fAutoRunCmdVector; 
    PAutoRunCmdVector::Iterator fAutoRunCurrentIter; 
    int fNoOfAutoRunCmds;                 
    int fCurrentAutoRunCmd;               

    // run related variables
    bool    fRunStopped;        
    RunInfo fRunInfo;           
    bool    fRunCheckEvents;    
    int     fRunNoEventsNeeded; 
    QElapsedTimer fRunStarted;  
    float   fRunTimeout;        


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

    void InitEnabled();
    void SetEnabled(const QString key, bool val);

    bool GetAllKeys();

    float GetEnergyLoss(float mod_hv);

    void CheckClients();
    void CheckMidasAlarms(PAutoRunCmdVector::Iterator iter);

    // temperature stability and handling related functions
    void   CheckTempStability();
    void   CheckTempStabilityOvenOmega();
    double LakeShoreTime(char *str);
    void   SampleTempTrend();
    void   SampleTempAdjustFlow();
    float  SampleTempPrefHeaterOutput(float heaterRange);
    bool   SampleTempStable();
    void   SampleTempConsiderFlow();
    void   SampleTempConsiderNeedleValve();
    void   SampleTempSetNeedleValve(float value);
    void   SetSampleLSZoneSettings();
    float  EmpiricalFlow(float Tset, float rampSpeed);
    float  NeedleValve(float Tset);
    float  SetDemandTempRamping(QString rampParam);
    void   SetFlowAndNeedleValve(QString flowParam, float &rampSpeed, float newDemandTemp, float deltaT, float flowScale); // for Konti's
    void   SetFlow(QString flowParam); // for LowTemp
    void   SetLSMode(AutoRunCmd *arc);
    void   SetLSHeaterRangeAndPIDs(AutoRunCmd *arc);
    void   WaitUntilSampleLSReady();
    void   SetLSSetpoint(float setpoint, float rampSpeed);
    void   SetOmegaSetpoint(float setpoint);
    void   SetFlowTweak(float flow);

    int CheckFieldCmd(QString &errMsg);
    void DegaussWEW(AutoRunCmd *arc);
    void DegaussDanfysik(AutoRunCmd *arc);
    void Degauss(AutoRunCmd *arc);
    void DegaussSpinRot(AutoRunCmd *arc);
    void ExecNext();
    void RunStart(AutoRunCmd *arc);
    void RunStop(AutoRunCmd *arc);
    bool RunStopCheck();
    void SetIgnoreAlarms(AutoRunCmd *arc);
    void SetIgnoreClients(AutoRunCmd *arc);
    void SetDump(AutoRunCmd *arc);    
    void SetFieldWEWL(AutoRunCmd *arc);
    void SetFieldWEWH(AutoRunCmd *arc);
    void SetFieldDanfysik(AutoRunCmd *arc);
    void SetField(AutoRunCmd *arc);
    void SetSpinRot(AutoRunCmd *arc);
    void SetFOM(AutoRunCmd *arc);
    void SetLEMSetup(AutoRunCmd *arc);
    void SetModInfo(AutoRunCmd *arc);
    bool CheckOdbType(INT type, AutoRunCmd *arc);
    void CheckForOdbSetDataCmds();
    void SetOdbData(AutoRunCmd *arc);
    void SetOdbDataArray(AutoRunCmd *arc);
    void SetSampleHV(AutoRunCmd *arc);
    void SetRA_HV(AutoRunCmd *arc);
    void SetTransportHV(AutoRunCmd *arc);
    bool CheckForTransportHvCmd();
    bool LoadHvSettings(PAutoRunCmdVector::Iterator currentIter, QString fln, int lineNo, bool simulated=false);
    void SetHvOff(AutoRunCmd *arc);
    void SetTfl(AutoRunCmd *arc);
    void SetTemp(AutoRunCmd *arc);
    void SetTempOvenOmega(AutoRunCmd *arc);
    void SetTitle(AutoRunCmd *arc);
    void HandleOdbTitleTags(QString &title);
    void SetTof(AutoRunCmd *arc);
    void SetWait(AutoRunCmd *arc);
    void SetBPV(AutoRunCmd *arc);
    bool SetBPV(int valve, int cmd);
    bool GetBPV();
    void GetDemandHVSampleChamber();
    void ChangeSampleChamberHV(bool down);
    void RawVoltageDump();
    void CheckForWarmUpCmd();
    void WarmUp(PAutoRunCmdVector::Iterator iter);
    void GotoLine(PAutoRunCmdVector::Iterator &iter, int max);

    QString GetAutoRunSequence();
    bool ShowComments();
    int GetGotoLine();
    void SetGotoLine(const int line);
    int GetRunState();
    void UpdateRunState(const int state);
    void UpdateWebPage(PAutoRunCmdVector::Iterator currentIter, int tag, int lineNo = 0, QString errMsg = "");
    void CleanLiveData();
    void FeedLiveDataErrors(int noOfErrors, int idx, int /*errorNo*/, int line, QString errorMsg);

    void Wait(int timeout);

    friend void TdHvTripFlagChanged(HNDLE, HNDLE, void*);

  private slots:
    void NetworkConnectionLost(); 
    void ReceivedShutdownCmd();   
    void UpdateStatusMsg(const QString statusMsg);
};

#endif // _PLEMAUTORUN_H_