FurnaceELK/Furnace/FurnaceRT/Equipments/PMs/PMModuleAlarmDefine.cs

using Aitex.Core.RT.Device;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using MECF.Framework.Common.CommonData.EnumData;
using MECF.Framework.Common.Event;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.UI.Client.CenterViews.Dialogs;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Controls.Primitives;

namespace FurnaceRT.Equipments.PMs
{
    public partial class PMModule
    {
        #region 
        public AlarmEventItem SensorAlarmSignalEMO01001powerboxEMO { get; set; }
        public AlarmEventItem SensorAlarmSignalPowerboxfiredetector { get; set; }
        public AlarmEventItem SensorAlarmSignalSMK01001detectoroperator { get; set; }
        public AlarmEventItem SensorAlarmSignalSMK01001detectorfault { get; set; }
        public AlarmEventItem SensorAlarmSignalEMO02001gasboxEMO { get; set; }
        public AlarmEventItem SensorAlarmSignalEMO04001frontbodyEMO { get; set; }
        public AlarmEventItem SensorAlarmSignalLD02001LSCleakalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalLD05001Magneticfluidleak { get; set; }
        public AlarmEventItem SensorAlarmSignalLD05002Coolingwaterleak { get; set; }
        public AlarmEventItem SensorAlarmSignalLD05003RHCleak { get; set; }
        public AlarmEventItem SensorAlarmSignalLD03001exhaustboxwaterleakupside { get; set; }
        public AlarmEventItem SensorAlarmSignalLD03002waterleakdownside { get; set; }
        public AlarmEventItem SensorAlarmSignalExternalEMO { get; set; }
        public AlarmEventItem SensorAlarmSignalFurnacetransformertempsw { get; set; }
        public AlarmEventItem SensorAlarmSignalAC100Vtransformertempsw { get; set; }
        public AlarmEventItem SensorAlarmSignalFurnacepoweronswitch { get; set; }
        public AlarmEventItem SensorAlarmSignalAC100Vtransformerpowerswitch { get; set; }
        public AlarmEventItem SensorAlarmSignalPowerboxinterlockresetbutton { get; set; }
        public AlarmEventItem SensorAlarmSignalVFD01001EDM { get; set; }
        public AlarmEventItem SensorAlarmSignalGasboxinterlockresetbutton { get; set; }
        public AlarmEventItem SensorAlarmSignalSCRONOFFSWITCH { get; set; }
        public AlarmEventItem SensorAlarmSignalGasboxexhaustpressurealarm1st { get; set; }
        public AlarmEventItem SensorAlarmSignalGasboxexhaustpressurealarm2nd { get; set; }
        public AlarmEventItem SensorAlarmSignalFS101waterflowalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalFrontbodyinterlockresetbutton { get; set; }
        public AlarmEventItem SensorAlarmSignalLightcurtainOSSD1 { get; set; }
        public AlarmEventItem SensorAlarmSignalLightcurtainOSSD2 { get; set; }
        public AlarmEventItem SensorAlarmSignalLightcurtainfault { get; set; }
        public AlarmEventItem SensorAlarmSignalFrontbodydoorswitch { get; set; }
        public AlarmEventItem SensorAlarmSignalFrontbodyIOshuttersw { get; set; }
        public AlarmEventItem SensorAlarmSignalFouprobotEMS { get; set; }
        public AlarmEventItem SensorAlarmSignalWaferrobotEMS { get; set; }
        public AlarmEventItem SensorAlarmSignalAxisCRmotorEDM { get; set; }
        public AlarmEventItem SensorAlarmSignalAxisEmotorEDM { get; set; }
        public AlarmEventItem SensorAlarmSignalTS05001FFUtempsw { get; set; }
        public AlarmEventItem SensorAlarmSignalTS05002Capinsidetempsw { get; set; }
        public AlarmEventItem SensorAlarmSignalTS05003Capoutsidetempsw { get; set; }
        public AlarmEventItem SensorAlarmSignalTS05004Raxisrotationtempsw { get; set; }
        public AlarmEventItem SensorAlarmSignalTS05005RHCtempsw { get; set; }
        public AlarmEventItem SensorAlarmSignalTS05006furnacetempsw { get; set; }
        public AlarmEventItem SensorAlarmSignalLoadingareaEMS { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02001HCL1gasleak1stalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02001HCL1gasleak2ndalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02001fault { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02002HCL2gasleak1stalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02002HCL2gasleak2ndalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02002fault { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02003NH31gasleak1stalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02003NH31gasleak2ndalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02003fault { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02004NH32gasleak1stalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02004NH32gasleak2ndalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02004fault { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02005F21gasleak1stalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02005F21gasleak2ndalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02005fault { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02006F22gasleak1stalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02006F22gasleak2ndalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02006fault { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02007NO1gasleak1stalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02007NO1gasleak2ndalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02007fault { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02008NO2gasleak1stalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02008NO2gasleak2ndalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02008fault { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02009C3H61gasleak1stalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02009C3H61gasleak2ndalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02009fault { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02010C3H62gasleak1stalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02010C3H62gasleak2ndalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02010fault { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02011DMA1gasleak1stalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02011DMA1gasleak2ndalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02011fault { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02012DMA2gasleak1stalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02012DMA2gasleak2ndalarm { get; set; }
        public AlarmEventItem SensorAlarmSignalGD02012fault { get; set; }
        public AlarmEventItem SensorAlarmSignalSL02001gasboxdoorsw11 { get; set; }
        public AlarmEventItem SensorAlarmSignalSL02001gasboxdoorsw12 { get; set; }
        public AlarmEventItem SensorAlarmSignalSL02002gasboxdoorsw11 { get; set; }
        public AlarmEventItem SensorAlarmSignalSL02002gasboxdoorsw12 { get; set; }
        public AlarmEventItem SensorAlarmSignalSL05001LAdoorsw1 { get; set; }
        public AlarmEventItem SensorAlarmSignalSL05002LAdoorsw2 { get; set; }
        public AlarmEventItem SensorAlarmSignalSL05004LAfurnacedoorsw { get; set; }
        public AlarmEventItem SensorAlarmSignalFurnacepoweronoff { get; set; }
        public AlarmEventItem SensorAlarmSignalBlowerpoweronoff { get; set; }
        public AlarmEventItem SensorAlarmSignal100Vtransformerpoweron { get; set; }
        public AlarmEventItem SensorAlarmSignalVFDenable { get; set; }
        public AlarmEventItem SensorAlarmSignalHPMvalvepoweronoff { get; set; }
        public AlarmEventItem SensorAlarmSignalAxisCRmotorenable1 { get; set; }
        public AlarmEventItem SensorAlarmSignalAxisCRmotorenable2 { get; set; }
        public AlarmEventItem SensorAlarmSignalAxisEmotorenable1 { get; set; }
        public AlarmEventItem SensorAlarmSignalAxisEmotorenable2 { get; set; }
        public AlarmEventItem SensorAlarmSignalFTRenable1 { get; set; }
        public AlarmEventItem SensorAlarmSignalFTRenable2 { get; set; }
        public AlarmEventItem SensorAlarmSignalFTRinterlockreset { get; set; }
        public AlarmEventItem SensorAlarmSignalWTRenable1 { get; set; }
        public AlarmEventItem SensorAlarmSignalWTRenable2 { get; set; }
        public AlarmEventItem SensorAlarmSignalWTRinterlockreset { get; set; }
        public AlarmEventItem SensorAlarmSignalCapheaterenable { get; set; }
        public AlarmEventItem SensorAlarmSignalLightcurtainidel { get; set; }
        public AlarmEventItem SensorAlarmSignalPowerboxinterlockbuttonled { get; set; }
        public AlarmEventItem SensorAlarmSignalGasboxinterlockbuttonled { get; set; }
        public AlarmEventItem SensorAlarmSignalFrontbodyinterlockbuttonled { get; set; }
        #endregion
        #region AlarmDefine

        public AlarmEventItem RecipeErrorAlarm { get; set; }
        public AlarmEventItem RecipeFinishedAbnormallyAlarm { get; set; }
        public AlarmEventItem TemperatureConvergenceTimeOutAlarm { get; set; }
        public AlarmEventItem PressureConvergenceTimeOutAlarm { get; set; }
        public AlarmEventItem AutoProfileTimeOutAlarm { get; set; }
        public AlarmEventItem FlowConvergenceTimeOutAlarm { get; set; }
        public AlarmEventItem BoatMoveTimeOutAlarm { get; set; }
        public AlarmEventItem InputSignalTimeOutAlarm { get; set; }
        public AlarmEventItem EmergencyAbort { get; set; }
        public AlarmEventItem RecipeExecutionError { get; set; }
        public AlarmEventItem Heater0ToleranceWarning { get; set; }
        public AlarmEventItem Heater0ToleranceAlarm { get; set; }
        public AlarmEventItem HeaterUToleranceWarning { get; set; }
        public AlarmEventItem HeaterUToleranceAlarm { get; set; }
        public AlarmEventItem HeaterCUToleranceWarning { get; set; }
        public AlarmEventItem HeaterCUToleranceAlarm { get; set; }
        public AlarmEventItem HeaterCToleranceWarning { get; set; }
        public AlarmEventItem HeaterCToleranceAlarm { get; set; }
        public AlarmEventItem HeaterCLToleranceWarning { get; set; }
        public AlarmEventItem HeaterCLToleranceAlarm { get; set; }
        public AlarmEventItem HeaterLToleranceWarning { get; set; }
        public AlarmEventItem HeaterLToleranceAlarm { get; set; }
        public AlarmEventItem MfmD1ToleranceWarning { get; set; }
        public AlarmEventItem MfmD1ToleranceAlarm { get; set; }
        public AlarmEventItem MFC1ToleranceWarning { get; set; }
        public AlarmEventItem MFC1ToleranceAlarm { get; set; }
        public AlarmEventItem MFC2ToleranceWarning { get; set; }
        public AlarmEventItem MFC2ToleranceAlarm { get; set; }
        public AlarmEventItem MFC3ToleranceWarning { get; set; }
        public AlarmEventItem MFC3ToleranceAlarm { get; set; }
        public AlarmEventItem MFC4ToleranceWarning { get; set; }
        public AlarmEventItem MFC4ToleranceAlarm { get; set; }
        public AlarmEventItem MFC5ToleranceWarning { get; set; }
        public AlarmEventItem MFC5ToleranceAlarm { get; set; }
        public AlarmEventItem MFC6ToleranceWarning { get; set; }
        public AlarmEventItem MFC6ToleranceAlarm { get; set; }
        public AlarmEventItem MFC7ToleranceWarning { get; set; }
        public AlarmEventItem MFC7ToleranceAlarm { get; set; }
        public AlarmEventItem MFC8ToleranceWarning { get; set; }
        public AlarmEventItem MFC8ToleranceAlarm { get; set; }
        public AlarmEventItem MFC9ToleranceWarning { get; set; }
        public AlarmEventItem MFC9ToleranceAlarm { get; set; }
        public AlarmEventItem MFC10ToleranceWarning { get; set; }
        public AlarmEventItem MFC10ToleranceAlarm { get; set; }
        public AlarmEventItem MFC11ToleranceWarning { get; set; }
        public AlarmEventItem MFC11ToleranceAlarm { get; set; }
        public AlarmEventItem MFC12ToleranceWarning { get; set; }
        public AlarmEventItem MFC12ToleranceAlarm { get; set; }
        public AlarmEventItem APCPressure1ToleranceWarning { get; set; }
        public AlarmEventItem APCPressure1ToleranceAlarm { get; set; }
        public AlarmEventItem APCPressure2ToleranceWarning { get; set; }
        public AlarmEventItem APCPressure2ToleranceAlarm { get; set; }
        public AlarmEventItem APCAngleToleranceWarning { get; set; }
        public AlarmEventItem APCAngleToleranceAlarm { get; set; }
        public AlarmEventItem APCSetModeAlarm { get; set; }
        public AlarmEventItem CheckEnableRunProcessAlarm { get; set; }
        public AlarmEventItem CheckCanDoOperationAlarm { get; set; }
        public AlarmEventItem TubeHomeFailedWarning { get; set; }
        public AlarmEventItem CheckHasAlarmWarning { get; set; }
        public AlarmEventItem PreprocessStartFailedWarning { get; set; }
        public AlarmEventItem ExecuteAbortRecipeWarning { get; set; }
        public AlarmEventItem ExecuteAbortRecipeFailAlarm { get; set; }
        public AlarmEventItem ShutterMoveFailedForInterlock { get; set; }
        public AlarmEventItem N2PurgeFaileAlarm { get; set; }

        public AlarmEventItem GasLineOverTempAlarm { get; set; }
        public AlarmEventItem GasLineTcBrokenAlarm { get; set; }
        public AlarmEventItem GasLineCapsOverFlownAlarm { get; set; }
        public AlarmEventItem GasLineFloorOverFlowAlarm { get; set; }
        public AlarmEventItem ForLineOverTempAlarm { get; set; }
        public AlarmEventItem ForLineTcBrokenAlarm { get; set; }
        public AlarmEventItem ForLineCapsOverFlownAlarm { get; set; }
        public AlarmEventItem ForLineFloorOverFlowAlarm { get; set; }

        #region Sensor alarm       
        public AlarmEventItem SensorTHMCONAlarm { get; set; }
        public AlarmEventItem SensorHeaterMCONAlarm { get; set; }
        public AlarmEventItem SensorTHBreakOKAlarm { get; set; }
        public AlarmEventItem SensorHeaterBreakOKAlarm { get; set; }
        public AlarmEventItem SensorHTRCUPowerONAlarm { get; set; }
        public AlarmEventItem SensorNH3LeakOKAlarm { get; set; }
        public AlarmEventItem SensorSiH2Cl2LeakOKAlarm { get; set; }
        public AlarmEventItem SensorGASDetectorOKAlarm { get; set; }
        public AlarmEventItem SensorEXHFanOKAlarm { get; set; }
        public AlarmEventItem SensorSCRTempOKAlarm { get; set; }
        public AlarmEventItem SensorHeaterTransTempOKAlarm { get; set; }
        public AlarmEventItem SensorSCRFanOKAlarm { get; set; }
        public AlarmEventItem SensorHeaterControllerOKAlarm { get; set; }
        public AlarmEventItem SensorHeaterTempOKAlarm { get; set; }
        public AlarmEventItem SensorHeaterEXHOKAlarm { get; set; }
        public AlarmEventItem SensorFNCWaterLeakDet1OKAlarm { get; set; }
        public AlarmEventItem SensorHeaterWaterFlowOKAlarm { get; set; }
        public AlarmEventItem SensorHeaterWaterFlowOK1Alarm { get; set; }
        public AlarmEventItem SensorMFWaterFlowOKAlarm { get; set; }
        public AlarmEventItem SensorMFWaterFlowOK1Alarm { get; set; }
        public AlarmEventItem SensorCAPWaterFlowOKAlarm { get; set; }
        public AlarmEventItem SensorCAPWaterFlowOK1Alarm { get; set; }
        public AlarmEventItem SensorASWaterFlowOKAlarm { get; set; }
        public AlarmEventItem SensorASWaterFlowOK1Alarm { get; set; }
        public AlarmEventItem SensorSpareWaterFlowOKAlarm { get; set; }
        public AlarmEventItem SensorSpareWaterFlowOK1Alarm { get; set; }
        public AlarmEventItem SensorChamberTempOKAlarm { get; set; }
        public AlarmEventItem SensorFNCPanelCloseAlarm { get; set; }
        public AlarmEventItem SensorTubeOverPressureAlarm { get; set; }
        public AlarmEventItem SensorFNCWaterLeakDet2OKAlarm { get; set; }
        public AlarmEventItem SensorGasLineTHTempOKAlarm { get; set; }
        public AlarmEventItem SensorPipingLineTHTempOKAlarm { get; set; }
        public AlarmEventItem SensorTHControllerOKAlarm { get; set; }
        public AlarmEventItem SensorSCVOKAlarm { get; set; }
        public AlarmEventItem SensorHECDoorClosedAlarm { get; set; }
        public AlarmEventItem SensorHECWaterLeakDetectOKAlarm { get; set; }
        public AlarmEventItem SensorHECWaterLevelOKAlarm { get; set; }
        public AlarmEventItem SensorHECTempOKAlarm { get; set; }
        public AlarmEventItem SensorVG1OKAlarm { get; set; }
        public AlarmEventItem SensorVG2OKAlarm { get; set; }
        public AlarmEventItem SensorPureN2PressureOKAlarm { get; set; }
        public AlarmEventItem SensorNH3PressureOKAlarm { get; set; }
        public AlarmEventItem SensorSiH2CL2PressureOKAlarm { get; set; }
        public AlarmEventItem SensorN2OPressureOKAlarm { get; set; }
        public AlarmEventItem SensorNBPressureOKAlarm { get; set; }
        public AlarmEventItem SensorLV1PressureOKAlarm { get; set; }
        public AlarmEventItem SensorPSW1LOWAlarm { get; set; }
        public AlarmEventItem SensorPSW2LOWAlarm { get; set; }
        public AlarmEventItem SensorGUExhaustOKAlarm { get; set; }

        public AlarmEventItem SensorFBLightCurtainFaultAlarm { get; set; }
        public AlarmEventItem SensorFBLightCurtainOSSD1Alarm { get; set; }
        public AlarmEventItem SensorFBLightCurtainOSSD2Alarm { get; set; }
        public AlarmEventItem LeakCheckAlarm { get; set; }
        public AlarmEventItem SensorPLCConnectedAlarm { get; set; }
        #endregion

        #region interlock alarm
        public AlarmEventItem UserDefineInterlockAlarm { get; set; }
        public AlarmEventItem InterlockAlarm { get; set; }
        public AlarmEventItem BoatMoveToLoadPositionTimeoutWarning { get; set; }
        public AlarmEventItem Mini8ConnectAlarm { get; set; }
        public AlarmEventItem FurnaceTempabnormalAlarm { get; set; }
        #endregion

        #region PLC alarm

        public AlarmEventItem SensorAlarmSignalFIMS1LoadRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS1UnloadRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS1InitRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS2LoadRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS2UnloadRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS2InitRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS1UndockRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS1DockRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS1VacuumOffRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS1VacuumOnRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS1N2Closed { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS1N2Opened { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS1ReleaseRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS1SealRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS1SlideCloseRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS1SlideOpenRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS1LatchKeyOnRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS1LatchKeyOffRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS1N2ReleaseRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS1N2SealRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS2UnDockRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS2DockRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS2VacuumOffRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS2VacuumOnRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS2N2Closed { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS2N2Opened { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS2SealRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS2ReleaseRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS2SlideCloseRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS2SlideOpenRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS2LatchKeyOnRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS2LatchKeyOffRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS2N2ReleaseRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalFIMS2N2SealRunningError { get; set; }
        public AlarmEventItem SensorAlarmSignalBufferA1N2LowPressureError { get; set; }
        public AlarmEventItem SensorAlarmSignalBufferB1N2LowPressureError { get; set; }
        public AlarmEventItem SensorAlarmSignalBufferC1N2LowPressureError { get; set; }
        public AlarmEventItem SensorAlarmSignalBufferD1N2LowPressureError { get; set; }
        public AlarmEventItem SensorAlarmSignalBufferA2N2LowPressureError { get; set; }
        public AlarmEventItem SensorAlarmSignalBufferB2N2LowPressureError { get; set; }
        public AlarmEventItem SensorAlarmSignalBufferC2N2LowPressureError { get; set; }
        public AlarmEventItem SensorAlarmSignalBufferD2N2LowPressureError { get; set; }
        public AlarmEventItem SensorAlarmSignalBufferA3N2LowPressureError { get; set; }
        public AlarmEventItem SensorAlarmSignalBufferB3N2LowPressureError { get; set; }
        public AlarmEventItem SensorAlarmSignalBufferC3N2LowPressureError { get; set; }
        public AlarmEventItem SensorAlarmSignalBufferD3N2LowPressureError { get; set; }
        public AlarmEventItem SensorAlarmSignalBufferA4N2LowPressureError { get; set; }
        public AlarmEventItem SensorAlarmSignalBufferB4N2LowPressureError { get; set; }
        public AlarmEventItem SensorAlarmSignalBufferC4N2LowPressureError { get; set; }
        public AlarmEventItem SensorAlarmSignalBufferD4N2LowPressureError { get; set; }

        #endregion

        public Dictionary<int, Tuple<AlarmEventItem, AlarmEventItem>> AUXAlarmDic { get; set; }
        public Dictionary<IDevice, AlarmEventItem> HWILKAlarmDic { get; set; } = new Dictionary<IDevice, AlarmEventItem>();
        #endregion
        #region MyRegion
        public AlarmEventItem RecipeExecuteFreqAlarm { get; set; }
        public AlarmEventItem RecipeExecuteFreqWarning { get; set; }

        public AlarmEventItem RecipeThicknessAlarm { get; set; }
        public AlarmEventItem RecipeThicknessWarning { get; set; }

        public AlarmEventItem BoatRecipeThicknessAlarm { get; set; }
        public AlarmEventItem BoatRecipeThicknessWarning { get; set; }

        public AlarmEventItem ReatorStepRunFreqWarning { get; set; }
        public AlarmEventItem ReatorStepRunFreqAlarm { get; set; }
        public AlarmEventItem ReatorStepRunTimeWarning { get; set; }
        public AlarmEventItem ReatorStepRunTimeAlarm { get; set; }
        public AlarmEventItem ReatorStepThicknessAlarm { get; set; }
        public AlarmEventItem ReatorStepThicknessWarning { get; set; }
        #endregion

        private void InitAlarmEvent()
        {
            InitScheduleAlarmEvent();
            InitSensorAlarmEvent();
            InitIoAlarmSignalAlarmEvent();
            InitMinicsAlarmEvent();
            FurnaceTempabnormalAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.FurnaceTempabnormalAlarm",
                Description = $"Furnace TempabnormalAlarm",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });


            Mini8ConnectAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.Mini8ConnectAlarm",
                Description = $"{Name} mini8 DisConnect Alarm",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });
            N2PurgeFaileAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.N2PurgeFaileAlarm",
                Description = $"{Name} N2 Purge Faile Alarm",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { ResetRecipeErrorAlarm(); return true; });

            RecipeErrorAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.RecipeErrorAlarm",
                Description = $"{Name} recipe error alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { ResetRecipeErrorAlarm(); return true; });

            RecipeFinishedAbnormallyAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.RecipeFinishedAbnormallyAlarm",
                Description = $"{Name} recipe finished abnormally alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { ResetRecipeFinishedAbnormallyAlarm(); return true; });

            var alarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.TemperatureConvergenceTimeOutAlarm",
                Description = $"{Name} temperature convergence timeout alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { ResetTemperatureConvergenceTimeOutAlarm(); return true; });

            PressureConvergenceTimeOutAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.PressureConvergenceTimeOutAlarm",
                Description = $"{Name} pressure convergence timeout alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { ResetPressureConvergenceTimeOutAlarm(); return true; });

            AutoProfileTimeOutAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.AutoProfileTimeOutAlarm",
                Description = $"{Name} auto profile timeout alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { ResetAutoProfileTimeOutAlarm(); return true; });

            FlowConvergenceTimeOutAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.FlowConvergenceTimeOutAlarm",
                Description = $"{Name} flow convergence timeout alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { ResetFlowConvergenceTimeOutAlarm(); return true; });

            BoatMoveTimeOutAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.BoatMoveTimeOutAlarm",
                Description = $"{Name} boat move timeout alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { ResetBoatMoveTimeOutAlarm(); return true; });

            InputSignalTimeOutAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.InputSignalTimeOutAlarm",
                Description = $"{Name} input signal timeout alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { ResetInputSignalTimeOutAlarm(); return true; });

            EmergencyAbort = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.EmergencyAbort",
                Description = $"{Name} emergency abort ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { ResetEmergencyAbort(); return true; });

            RecipeExecutionError = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.RecipeExecutionError",
                Description = $"{Name} recipe execution error ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { ResetRecipeExecutionError(); return true; });

            HeaterUToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.HeaterUToleranceWarning",
                Description = $"{Name} heaterU tolerance warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });
            HeaterU.AlarmToleranceWarning = HeaterUToleranceWarning;

            HeaterUToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.HeaterUToleranceAlarm",
                Description = $"{Name} heaterU tolerance alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });
            HeaterU.AlarmToleranceAlarm = HeaterUToleranceAlarm;

            HeaterCUToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.HeaterCUToleranceWarning",
                Description = $"{Name} heaterCU tolerance warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });
            HeaterCU.AlarmToleranceWarning = HeaterCUToleranceWarning;

            HeaterCUToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.HeaterCUToleranceAlarm",
                Description = $"{Name} heaterCU tolerance alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });
            HeaterCU.AlarmToleranceAlarm = HeaterCUToleranceAlarm;

            HeaterCToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.HeaterCToleranceWarning",
                Description = $"{Name} heaterC tolerance warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });
            HeaterC.AlarmToleranceWarning = HeaterCToleranceWarning;

            HeaterCToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.HeaterCToleranceAlarm",
                Description = $"{Name} heaterC tolerance alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });
            HeaterC.AlarmToleranceAlarm = HeaterCToleranceAlarm;

            HeaterCLToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.HeaterCLToleranceWarning",
                Description = $"{Name} heaterCL tolerance warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });
            HeaterCL.AlarmToleranceWarning = HeaterCLToleranceWarning;

            HeaterCLToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.HeaterCLToleranceAlarm",
                Description = $"{Name} heaterCL tolerance alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });
            HeaterCL.AlarmToleranceAlarm = HeaterCLToleranceAlarm;

            HeaterLToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.HeaterLToleranceWarning",
                Description = $"{Name} heaterL tolerance warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });
            HeaterL.AlarmToleranceWarning = HeaterLToleranceWarning;

            HeaterLToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.HeaterLToleranceAlarm",
                Description = $"{Name} heaterL tolerance alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });
            HeaterL.AlarmToleranceAlarm = HeaterLToleranceAlarm;


            //MfmD1ToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            //{
            //    EventEnum = $"{Name}.MfmD1ToleranceWarning",
            //    Description = $"{Name} mfmD1 tolerance warning ",
            //    Solution = "No information available. Press[Clear] to delete alarm message.",
            //    Explaination = "No information available.",
            //    AutoRecovery = false,
            //    Level = EventLevel.Warning,
            //    Action = EventAction.Clear,
            //    Category = "TubeAlarm",
            //}, () => { MfmD1.Reset(); return true; });
            //MfmD1.AlarmToleranceWarning = MfmD1ToleranceWarning;

            //MfmD1ToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            //{
            //    EventEnum = $"{Name}.MfmD1ToleranceAlarm",
            //    Description = $"{Name} mfmD1 tolerance alarm ",
            //    Solution = "No information available. Press[Clear] to delete alarm message.",
            //    Explaination = "No information available.",
            //    AutoRecovery = false,
            //    Level = EventLevel.Alarm,
            //    Action = EventAction.Clear,
            //    Category = "TubeAlarm",
            //}, () => { MfmD1.Reset(); return true; });
            //MfmD1.AlarmToleranceAlarm = MfmD1ToleranceAlarm;

            //MFC61ToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            //{
            //    EventEnum = $"{Name}.MFC61ToleranceWarning",
            //    Description = $"MFC61 tolerance warning ",
            //    Solution = "No information available. Press[Clear] to delete alarm message.",
            //    Explaination = "No information available.",
            //    AutoRecovery = false,
            //    Level = EventLevel.Warning,
            //    Action = EventAction.Clear,
            //    Category = "TubeAlarm",
            //}, () => { MFC61.Reset(); return true; });
            //MFC61.AlarmToleranceWarning = MFC61ToleranceWarning;

            MFC1ToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC1ToleranceAlarm",
                Description = $"MFC1 tolerance alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC1.Reset(); return true; });
            MFC1.AlarmToleranceAlarm = MFC1ToleranceAlarm;

            MFC1ToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC1ToleranceWarning",
                Description = $"MFC1 tolerance warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC1.Reset(); return true; });
            MFC1.AlarmToleranceWarning = MFC1ToleranceWarning;

            MFC2ToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC2ToleranceAlarm",
                Description = $"MFC2 tolerance alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC2.Reset(); return true; });
            MFC2.AlarmToleranceAlarm = MFC2ToleranceAlarm;

            MFC2ToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC2ToleranceWarning",
                Description = $"MFC2 tolerance warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC2.Reset(); return true; });
            MFC2.AlarmToleranceWarning = MFC2ToleranceWarning;

            MFC3ToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC3ToleranceAlarm",
                Description = $"MFC3 tolerance alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC3.Reset(); return true; });
            MFC3.AlarmToleranceAlarm = MFC3ToleranceAlarm;

            MFC3ToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC3ToleranceWarning",
                Description = $"MFC3 tolerance warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC3.Reset(); return true; });
            MFC3.AlarmToleranceWarning = MFC3ToleranceWarning;

            MFC4ToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC4ToleranceAlarm",
                Description = $"MFC4 tolerance alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC4.Reset(); return true; });
            MFC4.AlarmToleranceAlarm = MFC4ToleranceAlarm;

            MFC4ToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC4ToleranceWarning",
                Description = $"MFC4 tolerance warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC4.Reset(); return true; });
            MFC4.AlarmToleranceWarning = MFC4ToleranceWarning;

            MFC5ToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC5ToleranceAlarm",
                Description = $"MFC5 tolerance alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC5.Reset(); return true; });
            MFC5.AlarmToleranceAlarm = MFC5ToleranceAlarm;

            MFC5ToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC5ToleranceWarning",
                Description = $"MFC5 tolerance warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC5.Reset(); return true; });
            MFC5.AlarmToleranceWarning = MFC5ToleranceWarning;

            MFC6ToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC6ToleranceAlarm",
                Description = $"MFC6 tolerance alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC6.Reset(); return true; });
            MFC6.AlarmToleranceAlarm = MFC6ToleranceAlarm;

            MFC6ToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC6ToleranceWarning",
                Description = $"MFC6 tolerance warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC6.Reset(); return true; });
            MFC6.AlarmToleranceWarning = MFC6ToleranceWarning;

            MFC7ToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC7ToleranceAlarm",
                Description = $"MFC7 tolerance alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC7.Reset(); return true; });
            MFC7.AlarmToleranceAlarm = MFC7ToleranceAlarm;

            MFC7ToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC7ToleranceWarning",
                Description = $"MFC7 tolerance warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC7.Reset(); return true; });
            MFC7.AlarmToleranceWarning = MFC7ToleranceWarning;

            MFC8ToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC8ToleranceAlarm",
                Description = $"MFC8 tolerance alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC8.Reset(); return true; });
            MFC8.AlarmToleranceAlarm = MFC8ToleranceAlarm;

            MFC8ToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC8ToleranceWarning",
                Description = $"MFC8 tolerance warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC8.Reset(); return true; });
            MFC8.AlarmToleranceWarning = MFC8ToleranceWarning;

            MFC9ToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC9ToleranceAlarm",
                Description = $"MFC9 tolerance alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC9.Reset(); return true; });
            MFC9.AlarmToleranceAlarm = MFC9ToleranceAlarm;

            MFC9ToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC9ToleranceWarning",
                Description = $"MFC9 tolerance warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC9.Reset(); return true; });
            MFC9.AlarmToleranceWarning = MFC9ToleranceWarning;

            MFC10ToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC10ToleranceAlarm",
                Description = $"MFC10 tolerance alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC10.Reset(); return true; });
            MFC10.AlarmToleranceAlarm = MFC10ToleranceAlarm;

            MFC10ToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC10ToleranceWarning",
                Description = $"MFC10 tolerance warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC10.Reset(); return true; });
            MFC10.AlarmToleranceWarning = MFC10ToleranceWarning;

            MFC11ToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC11ToleranceAlarm",
                Description = $"MFC11 tolerance alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC11.Reset(); return true; });
            MFC11.AlarmToleranceAlarm = MFC11ToleranceAlarm;

            MFC11ToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC11ToleranceWarning",
                Description = $"MFC11 tolerance warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC11.Reset(); return true; });
            MFC11.AlarmToleranceWarning = MFC11ToleranceWarning;

            MFC12ToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC12ToleranceAlarm",
                Description = $"MFC12 tolerance alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC12.Reset(); return true; });
            MFC12.AlarmToleranceAlarm = MFC12ToleranceAlarm;

            MFC12ToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.MFC12ToleranceWarning",
                Description = $"MFC12 tolerance warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { MFC12.Reset(); return true; });
            MFC12.AlarmToleranceWarning = MFC12ToleranceWarning;

            if (MFC13 != null)
            {
                var alarm1 = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.MFC13ToleranceAlarm",
                    Description = $"MFC13 tolerance alarm ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { MFC13.Reset(); return true; });
                MFC13.AlarmToleranceAlarm = alarm1;

                var warning = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.MFC13ToleranceWarning",
                    Description = $"MFC13 tolerance warning ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Warning,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { MFC13.Reset(); return true; });
                MFC13.AlarmToleranceWarning = warning;
            }

            if (MFC14 != null)
            {
                var alarm1 = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.MFC14ToleranceAlarm",
                    Description = $"MFC14 tolerance alarm ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { MFC14.Reset(); return true; });
                MFC14.AlarmToleranceAlarm = alarm1;

                var warning = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.MFC14ToleranceWarning",
                    Description = $"MFC14 tolerance warning ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Warning,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { MFC14.Reset(); return true; });
                MFC14.AlarmToleranceWarning = warning;
            }

            if (MFC15 != null)
            {
                var alarm1 = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.MFC15ToleranceAlarm",
                    Description = $"MFC15 tolerance alarm ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { MFC15.Reset(); return true; });
                MFC15.AlarmToleranceAlarm = alarm1;

                var warning = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.MFC15ToleranceWarning",
                    Description = $"MFC15 tolerance warning ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Warning,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { MFC15.Reset(); return true; });
                MFC15.AlarmToleranceWarning = warning;
            }

            if (MFC16 != null)
            {
                var alarm1 = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.MFC16ToleranceAlarm",
                    Description = $"MFC16 tolerance alarm ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { MFC16.Reset(); return true; });
                MFC16.AlarmToleranceAlarm = alarm1;

                var warning = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.MFC16ToleranceWarning",
                    Description = $"MFC16 tolerance warning ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Warning,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { MFC16.Reset(); return true; });
                MFC16.AlarmToleranceWarning = warning;
            }

            APCPressure1ToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.APCPressure1ToleranceWarning",
                Description = $"{Name} APC Pressure1 tolerance warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { APC.Reset(); return true; });
            APC.APCPressure1ToleranceWarning = APCPressure1ToleranceWarning;

            APCPressure1ToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.APCPressure1ToleranceAlarm",
                Description = $"{Name} APC Pressure1 tolerance alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { APC.Reset(); return true; });
            APC.APCPressure1ToleranceAlarm = APCPressure1ToleranceAlarm;

            APCPressure2ToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.APCPressure2ToleranceWarning",
                Description = $"{Name} APC Pressure2 tolerance warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { APC.Reset(); return true; });
            APC.APCPressure2ToleranceWarning = APCPressure2ToleranceWarning;

            APCPressure2ToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.APCPressure2ToleranceAlarm",
                Description = $"{Name} APC Pressure1 tolerance alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { APC.Reset(); return true; });
            APC.APCPressure2ToleranceAlarm = APCPressure2ToleranceAlarm;

            APCAngleToleranceWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.APCAngleToleranceWarning",
                Description = $"{Name} APC Angle tolerance warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { APC.Reset(); return true; });
            APC.APCAngleToleranceWarning = APCAngleToleranceWarning;

            APCAngleToleranceAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.APCAngleToleranceAlarm",
                Description = $"{Name} APC Angle tolerance alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { APC.Reset(); return true; });
            APC.APCAngleToleranceAlarm = APCAngleToleranceAlarm;

            APCSetModeAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.APCSetModeAlarm",
                Description = $"{Name} APC alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { APC.Reset(); return true; });
            APC.APCSetModeAlarm = APCSetModeAlarm;

            CheckEnableRunProcessAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.CheckEnableRunProcessAlarm",
                Description = $"{Name} check enable run process failed ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });

            CheckCanDoOperationAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.CheckCanDoOperationAlarm",
                Description = $"{Name} check can do operation failed ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });

            TubeHomeFailedWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.TubeHomeFailedWarning",
                Description = $"{Name} tube home failed ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });

            CheckHasAlarmWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.CheckHasAlarmWarning",
                Description = $"{Name} tube has alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });

            PreprocessStartFailedWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.PreprocessStartFailedWarning",
                Description = $"{Name} preprocess start failed ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });

            ExecuteAbortRecipeWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.ExecuteAbortRecipeWarning",
                Description = $"{Name} execute abort recipe warning ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });

            ExecuteAbortRecipeFailAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.ExecuteAbortRecipeFailAlarm",
                Description = $"{Name} execute abort recipe fail alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });

            SensorPLCConnectedAlarm = SubscribeAlarm(
                       new AlarmEventItem()
                       {
                           EventEnum = $"{Name}.SensorPLCConnectedAlarm",
                           Description = $"{Name} Sensor PLC Connected Alarm ",
                           Solution = "No information available. Press[Clear] to delete alarm message.",
                           Explaination = "Electric Signal [SensorbHeartBeatPMCPLCMonitor] Has No Change For Setting Time.",
                           AutoRecovery = true,
                           Level = EventLevel.Alarm,
                           Action = EventAction.Clear,
                           Category = "TubeAlarm",
                       }, () => { return true; });

            if (AlarmSignalFBLightCurtainFault != null)
            {
                SensorFBLightCurtainFaultAlarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.SensorFBLightCurtainFaultAlarm",
                    Description = $"FB Light Curtain Fault ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFBLightCurtainFault.Reset(); return true; });
                AlarmSignalFBLightCurtainFault.AlarmTriggered = SensorFBLightCurtainFaultAlarm;
            }
            if (AlarmSignalFBLightCurtainOSSD1 != null)
            {
                SensorFBLightCurtainOSSD1Alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.SensorFBLightCurtainOSSD1Alarm",
                    Description = $"FB Light Curtain OSSD1 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFBLightCurtainOSSD1.Reset(); return true; });
                AlarmSignalFBLightCurtainOSSD1.AlarmTriggered = SensorFBLightCurtainOSSD1Alarm;
            }

            if (AlarmSignalFBLightCurtainOSSD2 != null)
            {
                SensorFBLightCurtainOSSD2Alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.SensorFBLightCurtainOSSD2Alarm",
                    Description = $"FB Light Curtain OSSD2 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFBLightCurtainOSSD2.Reset(); return true; });
                AlarmSignalFBLightCurtainOSSD2.AlarmTriggered = SensorFBLightCurtainOSSD2Alarm;
            }

            if (AlarmSignalO2ConcentrationHI != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalO2ConcentrationHI",
                    Description = $"O2 Concentration High Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalO2ConcentrationHI.Reset(); return true; });
                AlarmSignalO2ConcentrationHI.AlarmTriggered = alarm;
            }

            if (AlarmSignalO2ConcentrationLow != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalO2ConcentrationLow",
                    Description = $"O2 Concentration Low Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalO2ConcentrationLow.Reset(); return true; });
                AlarmSignalO2ConcentrationLow.AlarmTriggered = alarm;
            }

            if (AlarmSignalO2ConcentrationEcho1 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalO2ConcentrationEcho1",
                    Description = $"O2 Concentration Echo1 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalO2ConcentrationEcho1.Reset(); return true; });
                AlarmSignalO2ConcentrationEcho1.AlarmTriggered = alarm;
            }

            if (AlarmSignalO2ConcentrationEcho2 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalO2ConcentrationEcho2",
                    Description = $"O2 Concentration Echo2 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalO2ConcentrationEcho2.Reset(); return true; });
                AlarmSignalO2ConcentrationEcho2.AlarmTriggered = alarm;
            }

            if (AlarmSignalSMK1DetectorSensorOperates != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalSMK1DetectorSensorOperates",
                    Description = $"SMK1 Detector Sensor Operates Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalSMK1DetectorSensorOperates.Reset(); return true; });
                AlarmSignalSMK1DetectorSensorOperates.AlarmTriggered = alarm;
            }

            if (AlarmSignalSMK1DetectorSensorFireAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalSMK1DetectorSensorFireAlarm",
                    Description = $"SMK1 Detector Sensor Fire Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalSMK1DetectorSensorFireAlarm.Reset(); return true; });
                AlarmSignalSMK1DetectorSensorFireAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalSMK1DetectorSensorFault != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalSMK1DetectorSensorFault",
                    Description = $"SMK1 Detector SensorFault Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalSMK1DetectorSensorFault.Reset(); return true; });
                AlarmSignalSMK1DetectorSensorFault.AlarmTriggered = alarm;
            }

            if (AlarmSignalHCLGasLeak1stAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHCLGasLeak1stAlarm",
                    Description = $"HCL Gas Leak 1st Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHCLGasLeak1stAlarm.Reset(); return true; });
                AlarmSignalHCLGasLeak1stAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalHCLGasLeak2ndAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHCLGasLeak2ndAlarm",
                    Description = $"HCL Gas Leak 2nd Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHCLGasLeak2ndAlarm.Reset(); return true; });
                AlarmSignalHCLGasLeak2ndAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalNH3GasLeak1stAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalNH3GasLeak1stAlarm",
                    Description = $"NH3 Gas Leak 1stTriger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalNH3GasLeak1stAlarm.Reset(); return true; });
                AlarmSignalNH3GasLeak1stAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalNH3GasLeak2ndAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalNH3GasLeak2ndAlarm",
                    Description = $"NH3 Gas Leak 2ndTriger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalNH3GasLeak2ndAlarm.Reset(); return true; });
                AlarmSignalNH3GasLeak2ndAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalF2GasLeak1stAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalF2GasLeak1stAlarm",
                    Description = $"F2 Gas Leak 1st Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalF2GasLeak1stAlarm.Reset(); return true; });
                AlarmSignalF2GasLeak1stAlarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalF2GasLeak2ndAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalF2GasLeak2ndAlarm",
                    Description = $"F2 Gas Leak 2nd Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalF2GasLeak2ndAlarm.Reset(); return true; });
                AlarmSignalF2GasLeak2ndAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalGasLeakFault != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGasLeakFault",
                    Description = $"Gas Leak Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGasLeakFault.Reset(); return true; });
                AlarmSignalGasLeakFault.AlarmTriggered = alarm;
            }

            if (AlarmSignalFurnaceMainCircuitBreakerStatusMonitor != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFurnaceMainCircuitBreakerStatusMonitor",
                    Description = $"Furnace Main Circuit Breaker Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFurnaceMainCircuitBreakerStatusMonitor.Reset(); return true; });
                AlarmSignalFurnaceMainCircuitBreakerStatusMonitor.AlarmTriggered = alarm;
            }

            if (AlarmSignalTS34RotationTempSW != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalTS34RotationTempSW",
                    Description = $"TS34 Rotation Temp Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalTS34RotationTempSW.Reset(); return true; });
                AlarmSignalTS34RotationTempSW.AlarmTriggered = alarm;
            }

            if (AlarmSignalTS30CapInsideTempSW != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalTS30CapInsideTempSW",
                    Description = $"TS30 Cap Inside Temp Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalTS30CapInsideTempSW.Reset(); return true; });
                AlarmSignalTS30CapInsideTempSW.AlarmTriggered = alarm;
            }

            if (AlarmSignalTS31CapOutsideTempSW != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalTS31CapOutsideTempSW",
                    Description = $"TS31 Cap Outside Temp Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalTS31CapOutsideTempSW.Reset(); return true; });
                AlarmSignalTS31CapOutsideTempSW.AlarmTriggered = alarm;
            }
            if (AlarmSignalGasBoxLowerDoorSW != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGasBoxLowerDoorSW",
                    Description = $"Gas Box Lower Door Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGasBoxLowerDoorSW.Reset(); return true; });
                AlarmSignalGasBoxLowerDoorSW.AlarmTriggered = alarm;
            }
            if (AlarmSignalGasBoxUpperDoorSW != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGasBoxUpperDoorSW",
                    Description = $"Gas Box Upper Door Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGasBoxUpperDoorSW.Reset(); return true; });
                AlarmSignalGasBoxUpperDoorSW.AlarmTriggered = alarm;
            }
            if (AlarmSignalEXHBoxWaterLeak != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalEXHBoxWaterLeak",
                    Description = $"EXH Box Water Leak Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalEXHBoxWaterLeak.Reset(); return true; });
                AlarmSignalEXHBoxWaterLeak.AlarmTriggered = alarm;
            }
            if (AlarmSignalOPPanelEMO1 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalOPPanelEMO1",
                    Description = $"OP Panel EMO1 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalOPPanelEMO1.Reset(); return true; });
                AlarmSignalOPPanelEMO1.AlarmTriggered = alarm;
            }
            if (AlarmSignalOPPanelEMO2 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalOPPanelEMO2",
                    Description = $"OP Panel EMO2 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalOPPanelEMO2.Reset(); return true; });
                AlarmSignalOPPanelEMO2.AlarmTriggered = alarm;
            }
            if (AlarmSignalMainFurnaceCellingTS306 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalMainFurnaceCellingTS306",
                    Description = $"Main Furnace Celling TS306 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalMainFurnaceCellingTS306.Reset(); return true; });
                AlarmSignalMainFurnaceCellingTS306.AlarmTriggered = alarm;
            }
            if (AlarmSignalHeaterRoomSWS11S12 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHeaterRoomSWS11S12",
                    Description = $"Heater Room SW S11 S12 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHeaterRoomSWS11S12.Reset(); return true; });
                AlarmSignalHeaterRoomSWS11S12.AlarmTriggered = alarm;
            }
            if (AlarmSignalFilterBox1DoorSwitch != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFilterBox1DoorSwitch",
                    Description = $"Filter Box1 Door Switch",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFilterBox1DoorSwitch.Reset(); return true; });
                AlarmSignalFilterBox1DoorSwitch.AlarmTriggered = alarm;
            }
            if (AlarmSignalRHCTS305 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalRHCTS305",
                    Description = $"RHC TS305 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalRHCTS305.Reset(); return true; });
                AlarmSignalRHCTS305.AlarmTriggered = alarm;
            }
            if (AlarmSignalGasBoxExhaust1stAlarmMS2 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGasBoxExhaust1stAlarmMS2",
                    Description = $"Gas Box Exhaust 1st Alarm MS2 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGasBoxExhaust1stAlarmMS2.Reset(); return true; });
                AlarmSignalGasBoxExhaust1stAlarmMS2.AlarmTriggered = alarm;
            }
            if (AlarmSignalGasBoxExhaust2ndAlarmMS2 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGasBoxExhaust2ndAlarmMS2",
                    Description = $"Gas Box Exhaust 2nd Alarm MS2 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGasBoxExhaust2ndAlarmMS2.Reset(); return true; });
                AlarmSignalGasBoxExhaust2ndAlarmMS2.AlarmTriggered = alarm;
            }
            if (AlarmSignalMachineEMO1 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalMachineEMO1",
                    Description = $"Machine EMO1 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalMachineEMO1.Reset(); return true; });
                AlarmSignalMachineEMO1.AlarmTriggered = alarm;
            }

            if (AlarmSignalMachineEMO2 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalMachineEMO2",
                    Description = $"Machine EMO2 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalMachineEMO2.Reset(); return true; });
                AlarmSignalMachineEMO2.AlarmTriggered = alarm;
            }

            if (AlarmSignalT101TempStatus != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalT101TempStatus",
                    Description = $"T101 Temp Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalT101TempStatus.Reset(); return true; });
                AlarmSignalT101TempStatus.AlarmTriggered = alarm;
            }
            if (AlarmSignalT102TempStatus != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalT102TempStatus",
                    Description = $"T102 Temp Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalT102TempStatus.Reset(); return true; });
                AlarmSignalT102TempStatus.AlarmTriggered = alarm;

            }
            if (AlarmSignalT103TempStatus != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalT103TempStatus",
                    Description = $"T103 Temp Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalT103TempStatus.Reset(); return true; });
                AlarmSignalT103TempStatus.AlarmTriggered = alarm;
            }

            if (AlarmSignalBufferMotorHardwareInterlockAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalBufferMotorHardwareInterlockAlarm",
                    Description = $"Buffer Motor Hardware Interlock Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalBufferMotorHardwareInterlockAlarm.Reset(); return true; });
                AlarmSignalBufferMotorHardwareInterlockAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalBoatLiftMotorHardwareInterlockAlarm != null)
            {

                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalBoatLiftMotorHardwareInterlockAlarm",
                    Description = $"Boat Lift Motor Hardware Interlock Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalBoatLiftMotorHardwareInterlockAlarm.Reset(); return true; });
                AlarmSignalBoatLiftMotorHardwareInterlockAlarm.AlarmTriggered = alarm;
            }




            if (AlarmSignalHFReconciliationPressureMinAbnormal != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHFReconciliationPressureMinAbnormal",
                    Description = $"HF Reconciliation Pressure Min Abnormal Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHFReconciliationPressureMinAbnormal.Reset(); return true; });
                AlarmSignalHFReconciliationPressureMinAbnormal.AlarmTriggered = alarm;
            }
            if (AlarmSignalMagneticFluidLeak != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalMagneticFluidLeak",
                    Description = $"Magnetic Fluid Leak Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalMagneticFluidLeak.Reset(); return true; });
                AlarmSignalMagneticFluidLeak.AlarmTriggered = alarm;
            }
            if (AlarmSignalCoolingWaterLeak != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalCoolingWaterLeak",
                    Description = $"Cooling Water Leak Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalCoolingWaterLeak.Reset(); return true; });
                AlarmSignalCoolingWaterLeak.AlarmTriggered = alarm;
            }

            if (AlarmSignalMachineEMS1 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalMachineEMS1",
                    Description = $"Machine EMS1 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalMachineEMS1.Reset(); return true; });
                AlarmSignalMachineEMS1.AlarmTriggered = alarm;
            }

            if (AlarmSignalMachineEMS2 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalMachineEMS2",
                    Description = $"Machine EMS2 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalMachineEMS2.Reset(); return true; });
                AlarmSignalMachineEMS2.AlarmTriggered = alarm;//AlarmSignalFilterBox1Fan1Alarm
            }
            if (AlarmSignalFilterBox1Fan1Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFilterBox1Fan1Alarm",
                    Description = $"Filter Box1 Fan1 Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFilterBox1Fan1Alarm.Reset(); return true; });
                AlarmSignalFilterBox1Fan1Alarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalFBEMO1 != null)
            {

                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFBEMO1",
                    Description = $"FB EMO1 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFBEMO1.Reset(); return true; });
                AlarmSignalFBEMO1.AlarmTriggered = alarm;
            }
            if (AlarmSignalFBEMO2 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFBEMO2",
                    Description = $"FB EMO2 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFBEMO2.Reset(); return true; });
                AlarmSignalFBEMO2.AlarmTriggered = alarm;
            }


            if (AlarmSignalDoorOverride != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalDoorOverride",
                    Description = $"Door Override Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalDoorOverride.Reset(); return true; });
                AlarmSignalDoorOverride.AlarmTriggered = alarm;
            }
            if (AlarmSignalFBFrontDoorSwitch != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFBFrontDoorSwitch",
                    Description = $"FB Front Door Switch Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFBFrontDoorSwitch.Reset(); return true; });
                AlarmSignalFBFrontDoorSwitch.AlarmTriggered = alarm;
            }
            if (AlarmSignalGLBoxPG1CNT1Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG1CNT1Alarm",
                    Description = $"GL Box PG1 CNT1 Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG1CNT1Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG1CNT1Alarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalGLBoxPG1CNT2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG1CNT2Alarm",
                    Description = $"GL Box PG1 CNT2 Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG1CNT2Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG1CNT2Alarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalGLBoxPG2CNT1Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG2CNT1Alarm",
                    Description = $"GL Box PG2 CNT1 Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG2CNT1Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG2CNT1Alarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalGLBoxPG2CNT2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG2CNT2Alarm",
                    Description = $"GL Box PG2 CNT2 Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG2CNT2Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG2CNT2Alarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalGLBoxPG3CNT1Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG3CNT1Alarm",
                    Description = $"GL Box PG3 CNT1 Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG3CNT1Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG3CNT1Alarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalGLBoxPG3CNT2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG3CNT2Alarm",
                    Description = $"GL Box PG3 CNT2 Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG3CNT2Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG3CNT2Alarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalGLBoxPG4CNT1Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG4CNT1Alarm",
                    Description = $"GL Box PG4 CNT1 Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG4CNT1Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG4CNT1Alarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalGLBoxPG4CNT2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG4CNT2Alarm",
                    Description = $"GL Box PG4 CNT2 Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG4CNT2Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG4CNT2Alarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalGLBoxPG5CNT1Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG5CNT1Alarm",
                    Description = $"GL Box PG5 CNT1 Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG5CNT1Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG5CNT1Alarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalGLBoxPG5CNT2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG5CNT2Alarm",
                    Description = $"GL Box PG5 CNT2 Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG5CNT2Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG5CNT2Alarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalGLBoxPG6CNT1Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG6CNT1Alarm",
                    Description = $"GL Box PG6 CNT1 Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG6CNT1Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG6CNT1Alarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalGLBoxPG6CNT2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG6CNT2Alarm",
                    Description = $"GL Box PG6 CNT2 Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG6CNT2Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG6CNT2Alarm.AlarmTriggered = alarm;
            }


            if (AlarmSignalGLBoxVG21Output1 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxVG21Output1",
                    Description = $"GL Box VG21 Output1 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxVG21Output1.Reset(); return true; });
                AlarmSignalGLBoxVG21Output1.AlarmTriggered = alarm;
            }

            if (AlarmSignalGLBoxVG21Output2 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxVG21Output2",
                    Description = $"GL Box VG21 Output2 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxVG21Output2.Reset(); return true; });
                AlarmSignalGLBoxVG21Output2.AlarmTriggered = alarm;
            }

            if (AlarmSignalGLBoxVG22Output1 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxVG22Output1",
                    Description = $"GL Box VG22 Output1 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxVG22Output1.Reset(); return true; });
                AlarmSignalGLBoxVG22Output1.AlarmTriggered = alarm;
            }
            if (AlarmSignalGLBoxVG22Output2 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxVG22Output2",
                    Description = $"GL Box VG22 Output2 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxVG22Output2.Reset(); return true; });
                AlarmSignalGLBoxVG22Output2.AlarmTriggered = alarm;
            }

            if (AlarmSignalGLBoxVG32Output1 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxVG32Output1",
                    Description = $"GL Box VG32 Output1 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxVG32Output1.Reset(); return true; });
                AlarmSignalGLBoxVG32Output1.AlarmTriggered = alarm;
            }

            if (AlarmSignalGLBoxVG32Output2 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxVG32Output2",
                    Description = $"GL Box VG32 Output2 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxVG32Output2.Reset(); return true; });
                AlarmSignalGLBoxVG32Output2.AlarmTriggered = alarm;
            }
            if (AlarmSignalGLBoxVG33Output1 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxVG33Output1",
                    Description = $"GL Box VG33 Output1 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxVG33Output1.Reset(); return true; });
                AlarmSignalGLBoxVG33Output1.AlarmTriggered = alarm;
            }

            if (AlarmSignalGLBoxVG33Output2 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxVG33Output2",
                    Description = $"GL Box VG33 Output2 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxVG33Output2.Reset(); return true; });
                AlarmSignalGLBoxVG33Output2.AlarmTriggered = alarm;
            }
            if (AlarmSignalHeatingExhaust1stAlarmMS1 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHeatingExhaust1stAlarmMS1",
                    Description = $"Heating Exhaust 1st Alarm MS1 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHeatingExhaust1stAlarmMS1.Reset(); return true; });
                AlarmSignalHeatingExhaust1stAlarmMS1.AlarmTriggered = alarm;
            }
            if (AlarmSignalHeatingExhaust2ndAlarmMS1 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHeatingExhaust2ndAlarmMS1",
                    Description = $"Heating Exhaust 2nd Alarm MS1 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHeatingExhaust2ndAlarmMS1.Reset(); return true; });
                AlarmSignalHeatingExhaust2ndAlarmMS1.AlarmTriggered = alarm;
            }

            if (AlarmSignalScavengeExhaust1stAlarmMS3 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalScavengeExhaust1stAlarmMS3",
                    Description = $"Scavenge Exhaust 1st Alarm MS3 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalScavengeExhaust1stAlarmMS3.Reset(); return true; });
                AlarmSignalScavengeExhaust1stAlarmMS3.AlarmTriggered = alarm;
            }

            if (AlarmSignalScavengeExhaust2ndAlarmMS3 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalScavengeExhaust2ndAlarmMS3",
                    Description = $"Scavenge Exhaust 2nd Alarm MS3 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalScavengeExhaust2ndAlarmMS3.Reset(); return true; });
                AlarmSignalScavengeExhaust2ndAlarmMS3.AlarmTriggered = alarm;
            }

            if (AlarmSignalValveBoxExhaust1stAlarmMS4 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalValveBoxExhaust1stAlarmMS4",
                    Description = $"Valve Box Exhaust 1st Alarm MS4 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalValveBoxExhaust1stAlarmMS4.Reset(); return true; });
                AlarmSignalValveBoxExhaust1stAlarmMS4.AlarmTriggered = alarm;
            }

            if (AlarmSignalValveBoxExhaust2ndAlarmMS4 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalValveBoxExhaust2ndAlarmMS4",
                    Description = $"Valve Box Exhaust 2nd Alarm MS4 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalValveBoxExhaust2ndAlarmMS4.Reset(); return true; });
                AlarmSignalValveBoxExhaust2ndAlarmMS4.AlarmTriggered = alarm;
            }

            if (AlarmSignalLoadingAreaExhaust1stAlarmMS5 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLoadingAreaExhaust1stAlarmMS5",
                    Description = $"Loading Area Exhaust 1st Alarm MS5 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLoadingAreaExhaust1stAlarmMS5.Reset(); return true; });
                AlarmSignalLoadingAreaExhaust1stAlarmMS5.AlarmTriggered = alarm;

            }
            if (AlarmSignalLoadingAreaExhaust2ndAlarmMS5 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLoadingAreaExhaust2ndAlarmMS5",
                    Description = $"Loading Area Exhaust 2nd Alarm MS5 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLoadingAreaExhaust2ndAlarmMS5.Reset(); return true; });
                AlarmSignalLoadingAreaExhaust2ndAlarmMS5.AlarmTriggered = alarm;
            }



            if (AlarmSignalFrontBodyExhaust1stAlarmMS6 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFrontBodyExhaust1stAlarmMS6",
                    Description = $"Front Body Exhaust 1st Alarm MS6 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFrontBodyExhaust1stAlarmMS6.Reset(); return true; });
                AlarmSignalFrontBodyExhaust1stAlarmMS6.AlarmTriggered = alarm;
            }
            if (AlarmSignalFrontBodyExhaust2ndAlarmMS6 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFrontBodyExhaust2ndAlarmMS6",
                    Description = $"Front Body Exhaust 2nd Alarm MS6 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFrontBodyExhaust2ndAlarmMS6.Reset(); return true; });
                AlarmSignalFrontBodyExhaust2ndAlarmMS6.AlarmTriggered = alarm;
            }
            if (AlarmSignalLAExhaust1stAlarmMS321 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLAExhaust1stAlarmMS321",
                    Description = $"L/A Exhaust 1st Alarm MS321 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLAExhaust1stAlarmMS321.Reset(); return true; });
                AlarmSignalLAExhaust1stAlarmMS321.AlarmTriggered = alarm;
            }
            if (AlarmSignalLAExhaust2ndAlarmMS321 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLAExhaust2ndAlarmMS321",
                    Description = $"L/A Exhaust 2nd Alarm MS321 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLAExhaust2ndAlarmMS321.Reset(); return true; });
                AlarmSignalLAExhaust2ndAlarmMS321.AlarmTriggered = alarm;
            }
            if (AlarmSignalRHC1stAlarmMS8 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalRHC1stAlarmMS8",
                    Description = $"RHC 1st Alarm MS8 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalRHC1stAlarmMS8.Reset(); return true; });
                AlarmSignalRHC1stAlarmMS8.AlarmTriggered = alarm;
            }
            if (AlarmSignalRHC2ndAlarmMS8 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalRHC2ndAlarmMS8",
                    Description = $"RHC 2nd Alarm MS8 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalRHC2ndAlarmMS8.Reset(); return true; });
                AlarmSignalRHC2ndAlarmMS8.AlarmTriggered = alarm;
            }
            if (AlarmSignalREV1stAlarmMS9 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalREV1stAlarmMS9",
                    Description = $"REV 1st Alarm MS9 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalREV1stAlarmMS9.Reset(); return true; });
                AlarmSignalREV1stAlarmMS9.AlarmTriggered = alarm;
            }

            if (AlarmSignalREV2ndAlarmMS9 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalREV2ndAlarmMS9",
                    Description = $"REV 2nd Alarm MS9 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalREV2ndAlarmMS9.Reset(); return true; });
                AlarmSignalREV2ndAlarmMS9.AlarmTriggered = alarm;
            }
            if (AlarmSignalREV1stAlarmMS13 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalREV1stAlarmMS13",
                    Description = $"REV 1st Alarm MS13 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalREV1stAlarmMS13.Reset(); return true; });
                AlarmSignalREV1stAlarmMS13.AlarmTriggered = alarm;
            }
            if (AlarmSignalREV2ndAlarmMS13 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalREV2ndAlarmMS13",
                    Description = $"REV 2nd Alarm MS13 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalREV2ndAlarmMS13.Reset(); return true; });
                AlarmSignalREV2ndAlarmMS13.AlarmTriggered = alarm;
            }

            if (AlarmSignalOPBoxPS11Out1 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalOPBoxPS11Out1",
                    Description = $"{AlarmSignalOPBoxPS11Out1.Display} Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalOPBoxPS11Out1.Reset(); return true; });
                AlarmSignalOPBoxPS11Out1.AlarmTriggered = alarm;
            }




            if (AlarmSignalOPBoxPS11Out2 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalOPBoxPS11Out2",
                    Description = $"OP Box PS11 Out2 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalOPBoxPS11Out2.Reset(); return true; });
                AlarmSignalOPBoxPS11Out2.AlarmTriggered = alarm;
            }
            if (AlarmSignalRHCFlowAlarmFL901 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalRHCFlowAlarmFL901",
                    Description = $"RHC Flow Alarm FL901 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalRHCFlowAlarmFL901.Reset(); return true; });
                AlarmSignalRHCFlowAlarmFL901.AlarmTriggered = alarm;
            }

            if (AlarmSignalCoolingWaterFlowAlarmOfFurnaceFL902 != null)
            {

                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalCoolingWaterFlowAlarmOfFurnaceFL902",
                    Description = $"Cooling Water Flow Alarm Of Furnace FL902 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalCoolingWaterFlowAlarmOfFurnaceFL902.Reset(); return true; });
                AlarmSignalCoolingWaterFlowAlarmOfFurnaceFL902.AlarmTriggered = alarm;
            }

            if (AlarmSignalCoolingWaterFlowAlarmOfShuttleFL903 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalCoolingWaterFlowAlarmOfShuttleFL903",
                    Description = $"Cooling Water Flow Alarm Of Furnace FL903 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalCoolingWaterFlowAlarmOfShuttleFL903.Reset(); return true; });
                AlarmSignalCoolingWaterFlowAlarmOfShuttleFL903.AlarmTriggered = alarm;
            }

            if (AlarmSignalCoolingWaterFlowAlarmOfBoatRotationFL904 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalCoolingWaterFlowAlarmOfBoatRotationFL904",
                    Description = $"Cooling Water Flow Alarm Of Boat Rotation FL904 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalCoolingWaterFlowAlarmOfBoatRotationFL904.Reset(); return true; });
                AlarmSignalCoolingWaterFlowAlarmOfBoatRotationFL904.AlarmTriggered = alarm;
            }

            if (AlarmSignalCoolingWaterFlowAlarmOfFlangeFL905 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalCoolingWaterFlowAlarmOfFlangeFL905",
                    Description = $"Cooling Water Flow Alarm Of Flang eFL905 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalCoolingWaterFlowAlarmOfFlangeFL905.Reset(); return true; });
                AlarmSignalCoolingWaterFlowAlarmOfFlangeFL905.AlarmTriggered = alarm;
            }
            if (AlarmSignalCoolingWaterFlowAlarmOfLoadingAreaFS116 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalCoolingWaterFlowAlarmOfLoadingAreaFS116",
                    Description = $"Cooling Water Flow Alarm Of Loading Area FS116 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalCoolingWaterFlowAlarmOfLoadingAreaFS116.Reset(); return true; });
                AlarmSignalCoolingWaterFlowAlarmOfLoadingAreaFS116.AlarmTriggered = alarm;

            }
            if (AlarmSignalVG11LowAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalVG11LowAlarm",
                    Description = $"VG11 Low Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalVG11LowAlarm.Reset(); return true; });
                AlarmSignalVG11LowAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalVG11HighAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalVG11HighAlarm",
                    Description = $"VG11 High Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalVG11HighAlarm.Reset(); return true; });
                AlarmSignalVG11HighAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalVG12LowAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalVG12LowAlarm",
                    Description = $"VG12 Low Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalVG12LowAlarm.Reset(); return true; });
                AlarmSignalVG12LowAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalVG12HighAlarm != null)
            {

                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalVG12HighAlarm",
                    Description = $"VG12 High Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalVG12HighAlarm.Reset(); return true; });
                AlarmSignalVG12HighAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalVG13LowAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalVG13LowAlarm",
                    Description = $"VG13 Low Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalVG13LowAlarm.Reset(); return true; });
                AlarmSignalVG13LowAlarm.AlarmTriggered = alarm;

            }

            if (AlarmSignalVG13HighAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalVG13HighAlarm",
                    Description = $"VG13 High Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalVG13HighAlarm.Reset(); return true; });
                AlarmSignalVG13HighAlarm.AlarmTriggered = alarm;

            }

            if (AlarmSignalPG12OUT1 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalPG12OUT1",
                    Description = $"PG12 OUT1 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalPG12OUT1.Reset(); return true; });
                AlarmSignalPG12OUT1.AlarmTriggered = alarm;
            }
            if (AlarmSignalPG12OUT2 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalPG12OUT2",
                    Description = $"PG12 OUT2 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalPG12OUT2.Reset(); return true; });
                AlarmSignalPG12OUT2.AlarmTriggered = alarm;
            }

            if (AlarmSignalPG13OUT1 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalPG13OUT1",
                    Description = $"PG13 OUT1 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalPG13OUT1.Reset(); return true; });
                AlarmSignalPG13OUT1.AlarmTriggered = alarm;
            }
            if (AlarmSignalPG13OUT2 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalPG13OUT2",
                    Description = $"PG13 OUT Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalPG13OUT2.Reset(); return true; });
                AlarmSignalPG13OUT2.AlarmTriggered = alarm;
            }
            if (AlarmSignalPS14OUT1 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalPS14OUT1",
                    Description = $"PS14 OUT1 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalPS14OUT1.Reset(); return true; });
                AlarmSignalPS14OUT1.AlarmTriggered = alarm;
            }
            if (AlarmSignalPS14OUT2 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalPS14OUT2",
                    Description = $"PS14 OUT2 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalPS14OUT2.Reset(); return true; });
                AlarmSignalPS14OUT2.AlarmTriggered = alarm;
            }
            if (AlarmSignalCoolingWaterPressureOut1 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalCoolingWaterPressureOut1",
                    Description = $"Cooling Water Pressure Out1 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalCoolingWaterPressureOut1.Reset(); return true; });
                AlarmSignalCoolingWaterPressureOut1.AlarmTriggered = alarm;
            }
            if (AlarmSignalCoolingWaterPressureOut2 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalCoolingWaterPressureOut2",
                    Description = $"Cooling Water Pressure Out2 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalCoolingWaterPressureOut2.Reset(); return true; });
                AlarmSignalCoolingWaterPressureOut2.AlarmTriggered = alarm;
            }
            if (AlarmSignalAirFlowFL70 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalAirFlowFL70",
                    Description = $"Air Flow FL70 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalAirFlowFL70.Reset(); return true; });
                AlarmSignalAirFlowFL70.AlarmTriggered = alarm;
            }
            if (AlarmSignalAirFlowFL71 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalAirFlowFL71",
                    Description = $"Air Flow FL71 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalAirFlowFL71.Reset(); return true; });
                AlarmSignalAirFlowFL71.AlarmTriggered = alarm;
            }
            if (AlarmSignalAirFlowFL72 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalAirFlowFL72",
                    Description = $"Air Flow FL72 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalAirFlowFL72.Reset(); return true; });
                AlarmSignalAirFlowFL72.AlarmTriggered = alarm;
            }
            if (AlarmSignalWaterFlowFL62 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalWaterFlowFL62",
                    Description = $"Water Flow FL62 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalWaterFlowFL62.Reset(); return true; });
                AlarmSignalWaterFlowFL62.AlarmTriggered = alarm;
            }
            if (AlarmSignalUPSFault != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalUPSFault",
                    Description = $"UPS Fault Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalUPSFault.Reset(); return true; });
                AlarmSignalUPSFault.AlarmTriggered = alarm;
            }
            if (AlarmSignalUPSAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalUPSAlarm",
                    Description = $"UPS Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalUPSAlarm.Reset(); return true; });
                AlarmSignalUPSAlarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalK141UPSAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalK141UPSAlarm",
                    Description = $"K 141 UPS Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalK141UPSAlarm.Reset(); return true; });
                AlarmSignalK141UPSAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalK169UPSAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalK169UPSAlarm",
                    Description = $"K 169 UPS Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalK169UPSAlarm.Reset(); return true; });
                AlarmSignalK169UPSAlarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalN2PurgeBOXPG14CNT1 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalN2PurgeBOXPG14CNT1",
                    Description = $"N2 Purge BOX PG14 CNT1 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalN2PurgeBOXPG14CNT1.Reset(); return true; });
                AlarmSignalN2PurgeBOXPG14CNT1.AlarmTriggered = alarm;
            }
            if (AlarmSignalN2PurgeBOXPG14CNT2 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalN2PurgeBOXPG14CNT2",
                    Description = $"N2 Purge BOX PG14 CNT2 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalN2PurgeBOXPG14CNT2.Reset(); return true; });
                AlarmSignalN2PurgeBOXPG14CNT2.AlarmTriggered = alarm;
            }
            if (AlarmSignalN2PurgeBOXPG15CNT1 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalN2PurgeBOXPG15CNT1",
                    Description = $"N2 Purge BOX PG15 CNT1 Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalN2PurgeBOXPG15CNT1.Reset(); return true; });
                AlarmSignalN2PurgeBOXPG15CNT1.AlarmTriggered = alarm;
            }

            alarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.AlarmSignalN2PurgeBOXPG15CNT2",
                Description = $"N2 Purge BOX PG15 CNT2 Trigger ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { AlarmSignalN2PurgeBOXPG15CNT2.Reset(); return true; });
            AlarmSignalN2PurgeBOXPG15CNT2.AlarmTriggered = alarm;

            alarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.AlarmSignalN2PurgeBOXPG16CNT1",
                Description = $"N2 Purge BOX PG16 CNT1 Trigger ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { AlarmSignalN2PurgeBOXPG16CNT1.Reset(); return true; });
            AlarmSignalN2PurgeBOXPG16CNT1.AlarmTriggered = alarm;

            alarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.AlarmSignalN2PurgeBOXPG16CNT2",
                Description = $"N2 Purge BOX PG16 CNT2 Trigger ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { AlarmSignalN2PurgeBOXPG16CNT2.Reset(); return true; });
            AlarmSignalN2PurgeBOXPG16CNT2.AlarmTriggered = alarm;

            alarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.AlarmSignalN2PurgeBOXPG70CNT1",
                Description = $"N2 Purge BOX PG70 CNT1 Trigger ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { AlarmSignalN2PurgeBOXPG70CNT1.Reset(); return true; });
            AlarmSignalN2PurgeBOXPG70CNT1.AlarmTriggered = alarm;

            alarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.AlarmSignalN2PurgeBOXPG70CNT2",
                Description = $"N2 Purge BOX PG70 CNT2 Trigger ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { AlarmSignalN2PurgeBOXPG70CNT2.Reset(); return true; });
            AlarmSignalN2PurgeBOXPG70CNT2.AlarmTriggered = alarm;

            alarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.AlarmSignalPS17ValueLowLimitAlarm",
                Description = $"PS17 Value Low Limit Trigger ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { AlarmSignalPS17ValueLowLimitAlarm.Reset(); return true; });
            AlarmSignalPS17ValueLowLimitAlarm.AlarmTriggered = alarm;

            if (AlarmSignalVaccumPumpWarning != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalVaccumPumpWarning",
                    Description = $"Vaccum Pump Warning Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Warning,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalVaccumPumpWarning.Reset(); return true; });
                AlarmSignalVaccumPumpWarning.AlarmTriggered = alarm;
            }
            if (AlarmSignalVaccumPumpAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalVaccumPumpAlarm",
                    Description = $"Vaccum Pump Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalVaccumPumpAlarm.Reset(); return true; });
                AlarmSignalVaccumPumpAlarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalFilterBox1Fan1Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFilterBox1Fan1Alarm",
                    Description = $"Filter Box1 Fan1 Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFilterBox1Fan1Alarm.Reset(); return true; });
                AlarmSignalFilterBox1Fan1Alarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalFilterBox1Fan2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFilterBox1Fan2Alarm",
                    Description = $"Filter Box1 Fan2 Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFilterBox1Fan2Alarm.Reset(); return true; });
                AlarmSignalFilterBox1Fan2Alarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalStepperMotorAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalStepperMotorAlarm",
                    Description = $"Stepper Motor Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalStepperMotorAlarm.Reset(); return true; });
                AlarmSignalStepperMotorAlarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalRFAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalRFAlarm",
                    Description = $"RF Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalRFAlarm.Reset(); return true; });
                AlarmSignalRFAlarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalForelineHeaterJacketLightAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalForelineHeaterJacketLightAlarm",
                    Description = $"Foreline Heater Jacket Light Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalForelineHeaterJacketLightAlarm.Reset(); return true; });
                AlarmSignalForelineHeaterJacketLightAlarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalForelineHeaterJacketHeavyAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalForelineHeaterJacketHeavyAlarm",
                    Description = $"Foreline Heater Jacket Heavy Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalForelineHeaterJacketHeavyAlarm.Reset(); return true; });
                AlarmSignalForelineHeaterJacketHeavyAlarm.AlarmTriggered = alarm;
            }

            alarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.AlarmSignalScrubberWarning",
                Description = $"Scrubber Warning Trigger ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { AlarmSignalScrubberWarning.Reset(); return true; });
            AlarmSignalScrubberWarning.AlarmTriggered = alarm;

            alarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.AlarmSignalNegLmtPosBoatZAxis",
                Description = $"Neg Lmt Pos Boat ZAxis ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { AlarmSignalNegLmtPosBoatZAxis.Reset(); return true; });
            AlarmSignalNegLmtPosBoatZAxis.AlarmTriggered = alarm;

            alarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.AlarmSignalPotLmtPosBoatZAxis",
                Description = $"Pot Lmt Pos Boat ZAxis ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { AlarmSignalPotLmtPosBoatZAxis.Reset(); return true; });
            AlarmSignalPotLmtPosBoatZAxis.AlarmTriggered = alarm;

            alarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.AlarmSignalScrubberAlarm",
                Description = $"Scrubber Alarm Trigger ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { AlarmSignalScrubberAlarm.Reset(); return true; });
            AlarmSignalScrubberAlarm.AlarmTriggered = alarm;

            alarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.AlarmSignalLAFFUCommAlarm",
                Description = $"LA FFU Comm Alarm Trigger ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { AlarmSignalLAFFUCommAlarm.Reset(); return true; });
            AlarmSignalLAFFUCommAlarm.AlarmTriggered = alarm;

            if (AlarmSignaAPCCommAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignaAPCCommAlarm",
                    Description = $"APC Comm Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignaAPCCommAlarm.Reset(); return true; });
                AlarmSignaAPCCommAlarm.AlarmTriggered = alarm;
            }

            alarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.AlarmSignalMINI8CommAlarm",
                Description = $"MINI8 Comm Alarm Trigger ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { AlarmSignalMINI8CommAlarm.Reset(); return true; });
            AlarmSignalMINI8CommAlarm.AlarmTriggered = alarm;

            alarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.AlarmSignaMainWaterFlowAlarm",
                Description = $"Main Water Flow Trigger ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { AlarmSignaMainWaterFlowAlarm.Reset(); return true; });
            AlarmSignaMainWaterFlowAlarm.AlarmTriggered = alarm;

            if (AlarmSignalPumpDown != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalPumpDown",
                    Description = $"Pump Down Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalPumpDown.Reset(); return true; });
                AlarmSignalPumpDown.AlarmTriggered = alarm;
            }

            if (AlarmSignalPS13HStatus != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalPS13HStatus",
                    Description = $"O.PRS Too High Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalPS13HStatus.Reset(); return true; });
                AlarmSignalPS13HStatus.AlarmTriggered = alarm;
            }

            if (AlarmSignalPS13LStatus != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalPS13LStatus",
                    Description = $"PS13 L Status ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalPS13LStatus.Reset(); return true; });
                AlarmSignalPS13LStatus.AlarmTriggered = alarm;
            }


            if (AlarmSignalDG1Output1 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalDG1Output1",
                    Description = $"P.CNT Pressure NG Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalDG1Output1.Reset(); return true; });
                AlarmSignalDG1Output1.AlarmTriggered = alarm;
            }

            if (AlarmSignalDG1Output2 != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalDG1Output2",
                    Description = $"P.CNT Pressure NG Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalDG1Output2.Reset(); return true; });
                AlarmSignalDG1Output2.AlarmTriggered = alarm;
            }

            if (AlarmSignalAV91_1RHCAirInOpened != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalAV91_1RHCAirInOpened",
                    Description = $"RHC.DMR Abnormal Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalAV91_1RHCAirInOpened.Reset(); return true; });
                AlarmSignalAV91_1RHCAirInOpened.AlarmTriggered = alarm;
            }

            if (AlarmSignalAV91_2RHCAirInOpened != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalAV91_2RHCAirInOpened",
                    Description = $"RHC.DMR Abnormal Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalAV91_2RHCAirInOpened.Reset(); return true; });
                AlarmSignalAV91_2RHCAirInOpened.AlarmTriggered = alarm;
            }

            if (AlarmSignalAV91_3RHCAirInOpened != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalAV91_3RHCAirInOpened",
                    Description = $"RHC.DMR Abnormal Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalAV91_3RHCAirInOpened.Reset(); return true; });
                AlarmSignalAV91_3RHCAirInOpened.AlarmTriggered = alarm;
            }

            if (AlarmSignalAV91_4RHCAirInOpened != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalAV91_4RHCAirInOpened",
                    Description = $"RHC.DMR Abnormal Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalAV91_4RHCAirInOpened.Reset(); return true; });
                AlarmSignalAV91_4RHCAirInOpened.AlarmTriggered = alarm;
            }

            if (AlarmSignalBlowerPower != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalBlowerPower",
                    Description = $"BlowerPower Overload Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalBlowerPower.Reset(); return true; });
                AlarmSignalBlowerPower.AlarmTriggered = alarm;
            }

            if (AlarmSignalRFSetPowerReached != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalRFSetPowerReached",
                    Description = $"RF Output Abnormal Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalRFSetPowerReached.Reset(); return true; });
                AlarmSignalRFSetPowerReached.AlarmTriggered = alarm;
            }

            if (AlarmSignalN2FlowInFOUPAbnormal != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalN2FlowInFOUPAbnormal",
                    Description = $"N2-6 purge pressure Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalN2FlowInFOUPAbnormal.Reset(); return true; });
                AlarmSignalN2FlowInFOUPAbnormal.AlarmTriggered = alarm;
            }

            if (AlarmSignalCapHeaterAbnormal != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalCapHeaterAbnormal",
                    Description = $"Cap Heater Abnormal Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalCapHeaterAbnormal.Reset(); return true; });
                AlarmSignalCapHeaterAbnormal.AlarmTriggered = alarm;
            }

            if (AlarmSignalHeaterUOverTemp != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHeaterUOverTemp",
                    Description = $"HeaterU OverTemp Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHeaterUOverTemp.Reset(); return true; });
                AlarmSignalHeaterUOverTemp.AlarmTriggered = alarm;
            }

            if (AlarmSignalHeaterCUOverTemp != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHeaterCUOverTemp",
                    Description = $"HeaterCU OverTemp Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHeaterCUOverTemp.Reset(); return true; });
                AlarmSignalHeaterCUOverTemp.AlarmTriggered = alarm;
            }

            if (AlarmSignalHeaterCOverTemp != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHeaterCOverTemp",
                    Description = $"HeaterC OverTemp Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHeaterCOverTemp.Reset(); return true; });
                AlarmSignalHeaterCOverTemp.AlarmTriggered = alarm;
            }

            if (AlarmSignalHeaterCLOverTemp != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHeaterCLOverTemp",
                    Description = $"HeaterCL OverTemp Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHeaterCLOverTemp.Reset(); return true; });
                AlarmSignalHeaterCLOverTemp.AlarmTriggered = alarm;
            }

            if (AlarmSignalHeaterLOverTemp != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHeaterLOverTemp",
                    Description = $"HeaterL OverTemp Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHeaterLOverTemp.Reset(); return true; });
                AlarmSignalHeaterLOverTemp.AlarmTriggered = alarm;
            }

            if (AlarmSignaBoatRAxisAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignaBoatRAxisAlarm",
                    Description = $"Boat RAxis Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignaBoatRAxisAlarm.Reset(); return true; });
                AlarmSignaBoatRAxisAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignaBoatRAxisWarning != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignaBoatRAxisWarning",
                    Description = $"Boat RAxis Warning Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Warning,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignaBoatRAxisWarning.Reset(); return true; });
                AlarmSignaBoatRAxisWarning.AlarmTriggered = alarm;
            }

            if (AlarmSignaBoatZAxisWarning != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignaBoatZAxisWarning",
                    Description = $"Boat ZAxis Warning Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Warning,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignaBoatZAxisWarning.Reset(); return true; });
                AlarmSignaBoatZAxisWarning.AlarmTriggered = alarm;
            }

            if (AlarmSignaBoatZAxisAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignaBoatZAxisAlarm",
                    Description = $"Boat ZAxis Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignaBoatZAxisAlarm.Reset(); return true; });
                AlarmSignaBoatZAxisAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignaGasHeaterSensorBreakOutAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignaGasHeaterSensorBreakOutAlarm",
                    Description = $"Gas Heater Sensor Break Out Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignaGasHeaterSensorBreakOutAlarm.Reset(); return true; });
                AlarmSignaGasHeaterSensorBreakOutAlarm.AlarmTriggered = alarm;
            }
            #region 
            if (AlarmSignalEMO01001powerboxEMO != null)
            {
                SensorAlarmSignalEMO01001powerboxEMO = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalEMO01001powerboxEMO",
                    Description = "EMO01001 power box EMO",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalEMO01001powerboxEMO.Reset(); return true; });
                AlarmSignalEMO01001powerboxEMO.AlarmTriggered = SensorAlarmSignalEMO01001powerboxEMO;
            }

            if (AlarmSignalPowerboxfiredetector != null)
            {
                SensorAlarmSignalPowerboxfiredetector = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalPowerboxfiredetector",
                    Description = "Power box fire detector",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalPowerboxfiredetector.Reset(); return true; });
                AlarmSignalPowerboxfiredetector.AlarmTriggered = SensorAlarmSignalPowerboxfiredetector;
            }

            if (AlarmSignalSMK01001detectoroperator != null)
            {
                SensorAlarmSignalSMK01001detectoroperator = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalSMK01001detectoroperator",
                    Description = "SMK01001 detector operator",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalSMK01001detectoroperator.Reset(); return true; });
                AlarmSignalSMK01001detectoroperator.AlarmTriggered = SensorAlarmSignalSMK01001detectoroperator;
            }

            if (AlarmSignalSMK01001detectorfault != null)
            {
                SensorAlarmSignalSMK01001detectorfault = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalSMK01001detectorfault",
                    Description = "SMK01001 detector fault",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalSMK01001detectorfault.Reset(); return true; });
                AlarmSignalSMK01001detectorfault.AlarmTriggered = SensorAlarmSignalSMK01001detectorfault;
            }

            if (AlarmSignalEMO02001gasboxEMO != null)
            {
                SensorAlarmSignalEMO02001gasboxEMO = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalEMO02001gasboxEMO",
                    Description = "EMO02001 gas box EMO",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalEMO02001gasboxEMO.Reset(); return true; });
                AlarmSignalEMO02001gasboxEMO.AlarmTriggered = SensorAlarmSignalEMO02001gasboxEMO;
            }

            if (AlarmSignalEMO04001frontbodyEMO != null)
            {
                SensorAlarmSignalEMO04001frontbodyEMO = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalEMO04001frontbodyEMO",
                    Description = "EMO04001 frontbody EMO",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalEMO04001frontbodyEMO.Reset(); return true; });
                AlarmSignalEMO04001frontbodyEMO.AlarmTriggered = SensorAlarmSignalEMO04001frontbodyEMO;
            }

            if (AlarmSignalLD02001LSCleakalarm != null)
            {
                SensorAlarmSignalLD02001LSCleakalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLD02001LSCleakalarm",
                    Description = "LD02001 LSC leak alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLD02001LSCleakalarm.Reset(); return true; });
                AlarmSignalLD02001LSCleakalarm.AlarmTriggered = SensorAlarmSignalLD02001LSCleakalarm;
            }

            if (AlarmSignalLD05001Magneticfluidleak != null)
            {
                SensorAlarmSignalLD05001Magneticfluidleak = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLD05001Magneticfluidleak",
                    Description = "LD05001 Magnetic fluid leak",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLD05001Magneticfluidleak.Reset(); return true; });
                AlarmSignalLD05001Magneticfluidleak.AlarmTriggered = SensorAlarmSignalLD05001Magneticfluidleak;
            }

            if (AlarmSignalLD05002Coolingwaterleak != null)
            {
                SensorAlarmSignalLD05002Coolingwaterleak = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLD05002Coolingwaterleak",
                    Description = "LD05002 Cooling water leak",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLD05002Coolingwaterleak.Reset(); return true; });
                AlarmSignalLD05002Coolingwaterleak.AlarmTriggered = SensorAlarmSignalLD05002Coolingwaterleak;
            }

            if (AlarmSignalLD05003RHCleak != null)
            {
                SensorAlarmSignalLD05003RHCleak = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLD05003RHCleak",
                    Description = "LD05003 RHC leak",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLD05003RHCleak.Reset(); return true; });
                AlarmSignalLD05003RHCleak.AlarmTriggered = SensorAlarmSignalLD05003RHCleak;
            }

            if (AlarmSignalLD03001exhaustboxwaterleakupside != null)
            {
                SensorAlarmSignalLD03001exhaustboxwaterleakupside = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLD03001exhaustboxwaterleakupside",
                    Description = "LD03001 exhaust box water leak (up-side)",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLD03001exhaustboxwaterleakupside.Reset(); return true; });
                AlarmSignalLD03001exhaustboxwaterleakupside.AlarmTriggered = SensorAlarmSignalLD03001exhaustboxwaterleakupside;
            }

            if (AlarmSignalLD03002waterleakdownside != null)
            {
                SensorAlarmSignalLD03002waterleakdownside = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLD03002waterleakdownside",
                    Description = "LD03002 water leak (down-side)",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLD03002waterleakdownside.Reset(); return true; });
                AlarmSignalLD03002waterleakdownside.AlarmTriggered = SensorAlarmSignalLD03002waterleakdownside;
            }

            if (AlarmSignalExternalEMO != null)
            {
                SensorAlarmSignalExternalEMO = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalExternalEMO",
                    Description = "External EMO",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalExternalEMO.Reset(); return true; });
                AlarmSignalExternalEMO.AlarmTriggered = SensorAlarmSignalExternalEMO;
            }

            if (AlarmSignalFurnacetransformertempsw != null)
            {
                SensorAlarmSignalFurnacetransformertempsw = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFurnacetransformertempsw",
                    Description = "Furnace transformer temp sw",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFurnacetransformertempsw.Reset(); return true; });
                AlarmSignalFurnacetransformertempsw.AlarmTriggered = SensorAlarmSignalFurnacetransformertempsw;
            }

            if (AlarmSignalAC100Vtransformertempsw != null)
            {
                SensorAlarmSignalAC100Vtransformertempsw = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalAC100Vtransformertempsw",
                    Description = "AC100V transformer temp sw",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalAC100Vtransformertempsw.Reset(); return true; });
                AlarmSignalAC100Vtransformertempsw.AlarmTriggered = SensorAlarmSignalAC100Vtransformertempsw;
            }

            if (AlarmSignalFurnacepoweronswitch != null)
            {
                SensorAlarmSignalFurnacepoweronswitch = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFurnacepoweronswitch",
                    Description = "Furnace power on switch",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFurnacepoweronswitch.Reset(); return true; });
                AlarmSignalFurnacepoweronswitch.AlarmTriggered = SensorAlarmSignalFurnacepoweronswitch;
            }

            if (AlarmSignalAC100Vtransformerpowerswitch != null)
            {
                SensorAlarmSignalAC100Vtransformerpowerswitch = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalAC100Vtransformerpowerswitch",
                    Description = "AC100V transformer power switch",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalAC100Vtransformerpowerswitch.Reset(); return true; });
                AlarmSignalAC100Vtransformerpowerswitch.AlarmTriggered = SensorAlarmSignalAC100Vtransformerpowerswitch;
            }

            if (AlarmSignalPowerboxinterlockresetbutton != null)
            {
                SensorAlarmSignalPowerboxinterlockresetbutton = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalPowerboxinterlockresetbutton",
                    Description = "Power box interlock reset button",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalPowerboxinterlockresetbutton.Reset(); return true; });
                AlarmSignalPowerboxinterlockresetbutton.AlarmTriggered = SensorAlarmSignalPowerboxinterlockresetbutton;
            }

            if (AlarmSignalVFD01001EDM != null)
            {
                SensorAlarmSignalVFD01001EDM = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalVFD01001EDM",
                    Description = "VFD01001 EDM",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalVFD01001EDM.Reset(); return true; });
                AlarmSignalVFD01001EDM.AlarmTriggered = SensorAlarmSignalVFD01001EDM;
            }

            if (AlarmSignalGasboxinterlockresetbutton != null)
            {
                SensorAlarmSignalGasboxinterlockresetbutton = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGasboxinterlockresetbutton",
                    Description = "Gas box interlock reset button",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGasboxinterlockresetbutton.Reset(); return true; });
                AlarmSignalGasboxinterlockresetbutton.AlarmTriggered = SensorAlarmSignalGasboxinterlockresetbutton;
            }

            if (AlarmSignalSCRONOFFSWITCH != null)
            {
                SensorAlarmSignalSCRONOFFSWITCH = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalSCRONOFFSWITCH",
                    Description = "SCR ON/OFF SWITCH",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalSCRONOFFSWITCH.Reset(); return true; });
                AlarmSignalSCRONOFFSWITCH.AlarmTriggered = SensorAlarmSignalSCRONOFFSWITCH;
            }

            if (AlarmSignalGasboxexhaustpressurealarm1st != null)
            {
                SensorAlarmSignalGasboxexhaustpressurealarm1st = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGasboxexhaustpressurealarm1st",
                    Description = "Gas box exhaust pressure alarm 1st",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGasboxexhaustpressurealarm1st.Reset(); return true; });
                AlarmSignalGasboxexhaustpressurealarm1st.AlarmTriggered = SensorAlarmSignalGasboxexhaustpressurealarm1st;
            }

            if (AlarmSignalGasboxexhaustpressurealarm2nd != null)
            {
                SensorAlarmSignalGasboxexhaustpressurealarm2nd = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGasboxexhaustpressurealarm2nd",
                    Description = "Gas box exhaust pressure alarm 2nd",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGasboxexhaustpressurealarm2nd.Reset(); return true; });
                AlarmSignalGasboxexhaustpressurealarm2nd.AlarmTriggered = SensorAlarmSignalGasboxexhaustpressurealarm2nd;
            }

            if (AlarmSignalFS101waterflowalarm != null)
            {
                SensorAlarmSignalFS101waterflowalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFS101waterflowalarm",
                    Description = "FS101 water flow alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFS101waterflowalarm.Reset(); return true; });
                AlarmSignalFS101waterflowalarm.AlarmTriggered = SensorAlarmSignalFS101waterflowalarm;
            }

            if (AlarmSignalFrontbodyinterlockresetbutton != null)
            {
                SensorAlarmSignalFrontbodyinterlockresetbutton = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFrontbodyinterlockresetbutton",
                    Description = "Front body interlock reset button",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFrontbodyinterlockresetbutton.Reset(); return true; });
                AlarmSignalFrontbodyinterlockresetbutton.AlarmTriggered = SensorAlarmSignalFrontbodyinterlockresetbutton;
            }

            if (AlarmSignalLightcurtainOSSD1 != null)
            {
                SensorAlarmSignalLightcurtainOSSD1 = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLightcurtainOSSD1",
                    Description = "Light curtain OSSD1",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLightcurtainOSSD1.Reset(); return true; });
                AlarmSignalLightcurtainOSSD1.AlarmTriggered = SensorAlarmSignalLightcurtainOSSD1;
            }

            if (AlarmSignalLightcurtainOSSD2 != null)
            {
                SensorAlarmSignalLightcurtainOSSD2 = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLightcurtainOSSD2",
                    Description = "Light curtain OSSD2",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLightcurtainOSSD2.Reset(); return true; });
                AlarmSignalLightcurtainOSSD2.AlarmTriggered = SensorAlarmSignalLightcurtainOSSD2;
            }

            if (AlarmSignalLightcurtainfault != null)
            {
                SensorAlarmSignalLightcurtainfault = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLightcurtainfault",
                    Description = "Light curtain fault",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLightcurtainfault.Reset(); return true; });
                AlarmSignalLightcurtainfault.AlarmTriggered = SensorAlarmSignalLightcurtainfault;
            }

            if (AlarmSignalFrontbodydoorswitch != null)
            {
                SensorAlarmSignalFrontbodydoorswitch = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFrontbodydoorswitch",
                    Description = "Front body door switch",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFrontbodydoorswitch.Reset(); return true; });
                AlarmSignalFrontbodydoorswitch.AlarmTriggered = SensorAlarmSignalFrontbodydoorswitch;
            }

            if (AlarmSignalFrontbodyIOshuttersw != null)
            {
                SensorAlarmSignalFrontbodyIOshuttersw = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFrontbodyIOshuttersw",
                    Description = "Front body I/O shutter sw",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFrontbodyIOshuttersw.Reset(); return true; });
                AlarmSignalFrontbodyIOshuttersw.AlarmTriggered = SensorAlarmSignalFrontbodyIOshuttersw;
            }

            if (AlarmSignalFouprobotEMS != null)
            {
                SensorAlarmSignalFouprobotEMS = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFouprobotEMS",
                    Description = "Foup robot EMS",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFouprobotEMS.Reset(); return true; });
                AlarmSignalFouprobotEMS.AlarmTriggered = SensorAlarmSignalFouprobotEMS;
            }

            if (AlarmSignalWaferrobotEMS != null)
            {
                SensorAlarmSignalWaferrobotEMS = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalWaferrobotEMS",
                    Description = "Wafer robot EMS",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalWaferrobotEMS.Reset(); return true; });
                AlarmSignalWaferrobotEMS.AlarmTriggered = SensorAlarmSignalWaferrobotEMS;
            }

            if (AlarmSignalAxisCRmotorEDM != null)
            {
                SensorAlarmSignalAxisCRmotorEDM = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalAxisCRmotorEDM",
                    Description = "Axis-CR motor EDM",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalAxisCRmotorEDM.Reset(); return true; });
                AlarmSignalAxisCRmotorEDM.AlarmTriggered = SensorAlarmSignalAxisCRmotorEDM;
            }

            if (AlarmSignalAxisEmotorEDM != null)
            {
                SensorAlarmSignalAxisEmotorEDM = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalAxisEmotorEDM",
                    Description = "Axis-E motor EDM",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalAxisEmotorEDM.Reset(); return true; });
                AlarmSignalAxisEmotorEDM.AlarmTriggered = SensorAlarmSignalAxisEmotorEDM;
            }

            if (AlarmSignalTS05001FFUtempsw != null)
            {
                SensorAlarmSignalTS05001FFUtempsw = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalTS05001FFUtempsw",
                    Description = "TS05001 FFU temp sw",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalTS05001FFUtempsw.Reset(); return true; });
                AlarmSignalTS05001FFUtempsw.AlarmTriggered = SensorAlarmSignalTS05001FFUtempsw;
            }

            if (AlarmSignalTS05002Capinsidetempsw != null)
            {
                SensorAlarmSignalTS05002Capinsidetempsw = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalTS05002Capinsidetempsw",
                    Description = "TS05002 Cap inside temp sw",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalTS05002Capinsidetempsw.Reset(); return true; });
                AlarmSignalTS05002Capinsidetempsw.AlarmTriggered = SensorAlarmSignalTS05002Capinsidetempsw;
            }

            if (AlarmSignalTS05003Capoutsidetempsw != null)
            {
                SensorAlarmSignalTS05003Capoutsidetempsw = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalTS05003Capoutsidetempsw",
                    Description = "TS05003 Cap outside temp sw",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalTS05003Capoutsidetempsw.Reset(); return true; });
                AlarmSignalTS05003Capoutsidetempsw.AlarmTriggered = SensorAlarmSignalTS05003Capoutsidetempsw;
            }

            if (AlarmSignalTS05004Raxisrotationtempsw != null)
            {
                SensorAlarmSignalTS05004Raxisrotationtempsw = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalTS05004Raxisrotationtempsw",
                    Description = "TS05004 R axis rotation temp sw",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalTS05004Raxisrotationtempsw.Reset(); return true; });
                AlarmSignalTS05004Raxisrotationtempsw.AlarmTriggered = SensorAlarmSignalTS05004Raxisrotationtempsw;
            }

            if (AlarmSignalTS05005RHCtempsw != null)
            {
                SensorAlarmSignalTS05005RHCtempsw = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalTS05005RHCtempsw",
                    Description = "TS05005 RHC temp sw",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalTS05005RHCtempsw.Reset(); return true; });
                AlarmSignalTS05005RHCtempsw.AlarmTriggered = SensorAlarmSignalTS05005RHCtempsw;
            }

            if (AlarmSignalTS05006furnacetempsw != null)
            {
                SensorAlarmSignalTS05006furnacetempsw = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalTS05006furnacetempsw",
                    Description = "TS05006 furnace temp sw",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalTS05006furnacetempsw.Reset(); return true; });
                AlarmSignalTS05006furnacetempsw.AlarmTriggered = SensorAlarmSignalTS05006furnacetempsw;
            }

            if (AlarmSignalLoadingareaEMS != null)
            {
                SensorAlarmSignalLoadingareaEMS = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLoadingareaEMS",
                    Description = "Loading area EMS",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLoadingareaEMS.Reset(); return true; });
                AlarmSignalLoadingareaEMS.AlarmTriggered = SensorAlarmSignalLoadingareaEMS;
            }

            if (AlarmSignalGD02001HCL1gasleak1stalarm != null)
            {
                SensorAlarmSignalGD02001HCL1gasleak1stalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02001HCL1gasleak1stalarm",
                    Description = "GD02001 HCL-1 gas leak 1st alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02001HCL1gasleak1stalarm.Reset(); return true; });
                AlarmSignalGD02001HCL1gasleak1stalarm.AlarmTriggered = SensorAlarmSignalGD02001HCL1gasleak1stalarm;
            }

            if (AlarmSignalGD02001HCL1gasleak2ndalarm != null)
            {
                SensorAlarmSignalGD02001HCL1gasleak2ndalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02001HCL1gasleak2ndalarm",
                    Description = "GD02001 HCL-1 gas leak 2nd alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02001HCL1gasleak2ndalarm.Reset(); return true; });
                AlarmSignalGD02001HCL1gasleak2ndalarm.AlarmTriggered = SensorAlarmSignalGD02001HCL1gasleak2ndalarm;
            }

            if (AlarmSignalGD02001fault != null)
            {
                SensorAlarmSignalGD02001fault = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02001fault",
                    Description = "GD02001 fault",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02001fault.Reset(); return true; });
                AlarmSignalGD02001fault.AlarmTriggered = SensorAlarmSignalGD02001fault;
            }

            if (AlarmSignalGD02002HCL2gasleak1stalarm != null)
            {
                SensorAlarmSignalGD02002HCL2gasleak1stalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02002HCL2gasleak1stalarm",
                    Description = "GD02002 HCL-2 gas leak 1st alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02002HCL2gasleak1stalarm.Reset(); return true; });
                AlarmSignalGD02002HCL2gasleak1stalarm.AlarmTriggered = SensorAlarmSignalGD02002HCL2gasleak1stalarm;
            }

            if (AlarmSignalGD02002HCL2gasleak2ndalarm != null)
            {
                SensorAlarmSignalGD02002HCL2gasleak2ndalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02002HCL2gasleak2ndalarm",
                    Description = "GD02002 HCL-2 gas leak 2nd alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02002HCL2gasleak2ndalarm.Reset(); return true; });
                AlarmSignalGD02002HCL2gasleak2ndalarm.AlarmTriggered = SensorAlarmSignalGD02002HCL2gasleak2ndalarm;
            }

            if (AlarmSignalGD02002fault != null)
            {
                SensorAlarmSignalGD02002fault = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02002fault",
                    Description = "GD02002 fault",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02002fault.Reset(); return true; });
                AlarmSignalGD02002fault.AlarmTriggered = SensorAlarmSignalGD02002fault;
            }

            if (AlarmSignalGD02003NH31gasleak1stalarm != null)
            {
                SensorAlarmSignalGD02003NH31gasleak1stalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02003NH31gasleak1stalarm",
                    Description = "GD02003 NH3-1 gas leak 1st alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02003NH31gasleak1stalarm.Reset(); return true; });
                AlarmSignalGD02003NH31gasleak1stalarm.AlarmTriggered = SensorAlarmSignalGD02003NH31gasleak1stalarm;
            }

            if (AlarmSignalGD02003NH31gasleak2ndalarm != null)
            {
                SensorAlarmSignalGD02003NH31gasleak2ndalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02003NH31gasleak2ndalarm",
                    Description = "GD02003 NH3-1 gas leak 2nd alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02003NH31gasleak2ndalarm.Reset(); return true; });
                AlarmSignalGD02003NH31gasleak2ndalarm.AlarmTriggered = SensorAlarmSignalGD02003NH31gasleak2ndalarm;
            }

            if (AlarmSignalGD02003fault != null)
            {
                SensorAlarmSignalGD02003fault = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02003fault",
                    Description = "GD02003 fault",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02003fault.Reset(); return true; });
                AlarmSignalGD02003fault.AlarmTriggered = SensorAlarmSignalGD02003fault;
            }

            if (AlarmSignalGD02004NH32gasleak1stalarm != null)
            {
                SensorAlarmSignalGD02004NH32gasleak1stalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02004NH32gasleak1stalarm",
                    Description = "GD02004 NH3-2 gas leak 1st alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02004NH32gasleak1stalarm.Reset(); return true; });
                AlarmSignalGD02004NH32gasleak1stalarm.AlarmTriggered = SensorAlarmSignalGD02004NH32gasleak1stalarm;
            }

            if (AlarmSignalGD02004NH32gasleak2ndalarm != null)
            {
                SensorAlarmSignalGD02004NH32gasleak2ndalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02004NH32gasleak2ndalarm",
                    Description = "GD02004 NH3-2 gas leak 2nd alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02004NH32gasleak2ndalarm.Reset(); return true; });
                AlarmSignalGD02004NH32gasleak2ndalarm.AlarmTriggered = SensorAlarmSignalGD02004NH32gasleak2ndalarm;
            }

            if (AlarmSignalGD02004fault != null)
            {
                SensorAlarmSignalGD02004fault = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02004fault",
                    Description = "GD02004 fault",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02004fault.Reset(); return true; });
                AlarmSignalGD02004fault.AlarmTriggered = SensorAlarmSignalGD02004fault;
            }

            if (AlarmSignalGD02005F21gasleak1stalarm != null)
            {
                SensorAlarmSignalGD02005F21gasleak1stalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02005F21gasleak1stalarm",
                    Description = "GD02005 F2-1 gas leak 1st alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02005F21gasleak1stalarm.Reset(); return true; });
                AlarmSignalGD02005F21gasleak1stalarm.AlarmTriggered = SensorAlarmSignalGD02005F21gasleak1stalarm;
            }

            if (AlarmSignalGD02005F21gasleak2ndalarm != null)
            {
                SensorAlarmSignalGD02005F21gasleak2ndalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02005F21gasleak2ndalarm",
                    Description = "GD02005 F2-1 gas leak 2nd alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02005F21gasleak2ndalarm.Reset(); return true; });
                AlarmSignalGD02005F21gasleak2ndalarm.AlarmTriggered = SensorAlarmSignalGD02005F21gasleak2ndalarm;
            }

            if (AlarmSignalGD02005fault != null)
            {
                SensorAlarmSignalGD02005fault = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02005fault",
                    Description = "GD02005 fault",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02005fault.Reset(); return true; });
                AlarmSignalGD02005fault.AlarmTriggered = SensorAlarmSignalGD02005fault;
            }

            if (AlarmSignalGD02006F22gasleak1stalarm != null)
            {
                SensorAlarmSignalGD02006F22gasleak1stalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02006F22gasleak1stalarm",
                    Description = "GD02006 F2-2 gas leak 1st alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02006F22gasleak1stalarm.Reset(); return true; });
                AlarmSignalGD02006F22gasleak1stalarm.AlarmTriggered = SensorAlarmSignalGD02006F22gasleak1stalarm;
            }

            if (AlarmSignalGD02006F22gasleak2ndalarm != null)
            {
                SensorAlarmSignalGD02006F22gasleak2ndalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02006F22gasleak2ndalarm",
                    Description = "GD02006 F2-2 gas leak 2nd alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02006F22gasleak2ndalarm.Reset(); return true; });
                AlarmSignalGD02006F22gasleak2ndalarm.AlarmTriggered = SensorAlarmSignalGD02006F22gasleak2ndalarm;
            }

            if (AlarmSignalGD02006fault != null)
            {
                SensorAlarmSignalGD02006fault = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02006fault",
                    Description = "GD02006 fault",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02006fault.Reset(); return true; });
                AlarmSignalGD02006fault.AlarmTriggered = SensorAlarmSignalGD02006fault;
            }

            if (AlarmSignalGD02007NO1gasleak1stalarm != null)
            {
                SensorAlarmSignalGD02007NO1gasleak1stalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02007NO1gasleak1stalarm",
                    Description = "GD02007 NO-1 gas leak 1st alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02007NO1gasleak1stalarm.Reset(); return true; });
                AlarmSignalGD02007NO1gasleak1stalarm.AlarmTriggered = SensorAlarmSignalGD02007NO1gasleak1stalarm;
            }

            if (AlarmSignalGD02007NO1gasleak2ndalarm != null)
            {
                SensorAlarmSignalGD02007NO1gasleak2ndalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02007NO1gasleak2ndalarm",
                    Description = "GD02007 NO-1 gas leak 2nd alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02007NO1gasleak2ndalarm.Reset(); return true; });
                AlarmSignalGD02007NO1gasleak2ndalarm.AlarmTriggered = SensorAlarmSignalGD02007NO1gasleak2ndalarm;
            }

            if (AlarmSignalGD02007fault != null)
            {
                SensorAlarmSignalGD02007fault = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02007fault",
                    Description = "GD02007 fault",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02007fault.Reset(); return true; });
                AlarmSignalGD02007fault.AlarmTriggered = SensorAlarmSignalGD02007fault;
            }

            if (AlarmSignalGD02008NO2gasleak1stalarm != null)
            {
                SensorAlarmSignalGD02008NO2gasleak1stalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02008NO2gasleak1stalarm",
                    Description = "GD02008 NO-2 gas leak 1st alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02008NO2gasleak1stalarm.Reset(); return true; });
                AlarmSignalGD02008NO2gasleak1stalarm.AlarmTriggered = SensorAlarmSignalGD02008NO2gasleak1stalarm;
            }

            if (AlarmSignalGD02008NO2gasleak2ndalarm != null)
            {
                SensorAlarmSignalGD02008NO2gasleak2ndalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02008NO2gasleak2ndalarm",
                    Description = "GD02008 NO-2 gas leak 2nd alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02008NO2gasleak2ndalarm.Reset(); return true; });
                AlarmSignalGD02008NO2gasleak2ndalarm.AlarmTriggered = SensorAlarmSignalGD02008NO2gasleak2ndalarm;
            }

            if (AlarmSignalGD02008fault != null)
            {
                SensorAlarmSignalGD02008fault = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02008fault",
                    Description = "GD02008 fault",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02008fault.Reset(); return true; });
                AlarmSignalGD02008fault.AlarmTriggered = SensorAlarmSignalGD02008fault;
            }

            if (AlarmSignalGD02009C3H61gasleak1stalarm != null)
            {
                SensorAlarmSignalGD02009C3H61gasleak1stalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02009C3H61gasleak1stalarm",
                    Description = "GD02009 C3H6-1 gas leak 1st alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02009C3H61gasleak1stalarm.Reset(); return true; });
                AlarmSignalGD02009C3H61gasleak1stalarm.AlarmTriggered = SensorAlarmSignalGD02009C3H61gasleak1stalarm;
            }

            if (AlarmSignalGD02009C3H61gasleak2ndalarm != null)
            {
                SensorAlarmSignalGD02009C3H61gasleak2ndalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02009C3H61gasleak2ndalarm",
                    Description = "GD02009 C3H6-1 gas leak 2nd alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02009C3H61gasleak2ndalarm.Reset(); return true; });
                AlarmSignalGD02009C3H61gasleak2ndalarm.AlarmTriggered = SensorAlarmSignalGD02009C3H61gasleak2ndalarm;
            }

            if (AlarmSignalGD02009fault != null)
            {
                SensorAlarmSignalGD02009fault = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02009fault",
                    Description = "GD02009 fault",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02009fault.Reset(); return true; });
                AlarmSignalGD02009fault.AlarmTriggered = SensorAlarmSignalGD02009fault;
            }

            if (AlarmSignalGD02010C3H62gasleak1stalarm != null)
            {
                SensorAlarmSignalGD02010C3H62gasleak1stalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02010C3H62gasleak1stalarm",
                    Description = "GD02010 C3H6-2 gas leak 1st alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02010C3H62gasleak1stalarm.Reset(); return true; });
                AlarmSignalGD02010C3H62gasleak1stalarm.AlarmTriggered = SensorAlarmSignalGD02010C3H62gasleak1stalarm;
            }

            if (AlarmSignalGD02010C3H62gasleak2ndalarm != null)
            {
                SensorAlarmSignalGD02010C3H62gasleak2ndalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02010C3H62gasleak2ndalarm",
                    Description = "GD02010 C3H6-2 gas leak 2nd alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02010C3H62gasleak2ndalarm.Reset(); return true; });
                AlarmSignalGD02010C3H62gasleak2ndalarm.AlarmTriggered = SensorAlarmSignalGD02010C3H62gasleak2ndalarm;
            }

            if (AlarmSignalGD02010fault != null)
            {
                SensorAlarmSignalGD02010fault = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02010fault",
                    Description = "GD02010 fault",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02010fault.Reset(); return true; });
                AlarmSignalGD02010fault.AlarmTriggered = SensorAlarmSignalGD02010fault;
            }

            if (AlarmSignalGD02011DMA1gasleak1stalarm != null)
            {
                SensorAlarmSignalGD02011DMA1gasleak1stalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02011DMA1gasleak1stalarm",
                    Description = "GD02011 DMA-1 gas leak 1st alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02011DMA1gasleak1stalarm.Reset(); return true; });
                AlarmSignalGD02011DMA1gasleak1stalarm.AlarmTriggered = SensorAlarmSignalGD02011DMA1gasleak1stalarm;
            }

            if (AlarmSignalGD02011DMA1gasleak2ndalarm != null)
            {
                SensorAlarmSignalGD02011DMA1gasleak2ndalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02011DMA1gasleak2ndalarm",
                    Description = "GD02011 DMA-1 gas leak 2nd alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02011DMA1gasleak2ndalarm.Reset(); return true; });
                AlarmSignalGD02011DMA1gasleak2ndalarm.AlarmTriggered = SensorAlarmSignalGD02011DMA1gasleak2ndalarm;
            }

            if (AlarmSignalGD02011fault != null)
            {
                SensorAlarmSignalGD02011fault = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02011fault",
                    Description = "GD02011 fault",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02011fault.Reset(); return true; });
                AlarmSignalGD02011fault.AlarmTriggered = SensorAlarmSignalGD02011fault;
            }

            if (AlarmSignalGD02012DMA2gasleak1stalarm != null)
            {
                SensorAlarmSignalGD02012DMA2gasleak1stalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02012DMA2gasleak1stalarm",
                    Description = "GD02012 DMA-2 gas leak 1st alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02012DMA2gasleak1stalarm.Reset(); return true; });
                AlarmSignalGD02012DMA2gasleak1stalarm.AlarmTriggered = SensorAlarmSignalGD02012DMA2gasleak1stalarm;
            }

            if (AlarmSignalGD02012DMA2gasleak2ndalarm != null)
            {
                SensorAlarmSignalGD02012DMA2gasleak2ndalarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02012DMA2gasleak2ndalarm",
                    Description = "GD02012 DMA-2 gas leak 2nd alarm",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02012DMA2gasleak2ndalarm.Reset(); return true; });
                AlarmSignalGD02012DMA2gasleak2ndalarm.AlarmTriggered = SensorAlarmSignalGD02012DMA2gasleak2ndalarm;
            }

            if (AlarmSignalGD02012fault != null)
            {
                SensorAlarmSignalGD02012fault = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGD02012fault",
                    Description = "GD02012 fault",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGD02012fault.Reset(); return true; });
                AlarmSignalGD02012fault.AlarmTriggered = SensorAlarmSignalGD02012fault;
            }

            if (AlarmSignalSL02001gasboxdoorsw11 != null)
            {
                SensorAlarmSignalSL02001gasboxdoorsw11 = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalSL02001gasboxdoorsw11",
                    Description = "SL02001 gas box door sw1-1",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalSL02001gasboxdoorsw11.Reset(); return true; });
                AlarmSignalSL02001gasboxdoorsw11.AlarmTriggered = SensorAlarmSignalSL02001gasboxdoorsw11;
            }

            if (AlarmSignalSL02001gasboxdoorsw12 != null)
            {
                SensorAlarmSignalSL02001gasboxdoorsw12 = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalSL02001gasboxdoorsw12",
                    Description = "SL02001 gas box door sw1-2",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalSL02001gasboxdoorsw12.Reset(); return true; });
                AlarmSignalSL02001gasboxdoorsw12.AlarmTriggered = SensorAlarmSignalSL02001gasboxdoorsw12;
            }

            if (AlarmSignalSL02002gasboxdoorsw11 != null)
            {
                SensorAlarmSignalSL02002gasboxdoorsw11 = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalSL02002gasboxdoorsw11",
                    Description = "SL02002 gas box door sw1-1",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalSL02002gasboxdoorsw11.Reset(); return true; });
                AlarmSignalSL02002gasboxdoorsw11.AlarmTriggered = SensorAlarmSignalSL02002gasboxdoorsw11;
            }

            if (AlarmSignalSL02002gasboxdoorsw12 != null)
            {
                SensorAlarmSignalSL02002gasboxdoorsw12 = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalSL02002gasboxdoorsw12",
                    Description = "SL02002 gas box door sw1-2",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalSL02002gasboxdoorsw12.Reset(); return true; });
                AlarmSignalSL02002gasboxdoorsw12.AlarmTriggered = SensorAlarmSignalSL02002gasboxdoorsw12;
            }

            if (AlarmSignalSL05001LAdoorsw1 != null)
            {
                SensorAlarmSignalSL05001LAdoorsw1 = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalSL05001LAdoorsw1",
                    Description = "SL05001 LA door sw1",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalSL05001LAdoorsw1.Reset(); return true; });
                AlarmSignalSL05001LAdoorsw1.AlarmTriggered = SensorAlarmSignalSL05001LAdoorsw1;
            }

            if (AlarmSignalSL05002LAdoorsw2 != null)
            {
                SensorAlarmSignalSL05002LAdoorsw2 = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalSL05002LAdoorsw2",
                    Description = "SL05002 LA door sw2",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalSL05002LAdoorsw2.Reset(); return true; });
                AlarmSignalSL05002LAdoorsw2.AlarmTriggered = SensorAlarmSignalSL05002LAdoorsw2;
            }

            if (AlarmSignalSL05004LAfurnacedoorsw != null)
            {
                SensorAlarmSignalSL05004LAfurnacedoorsw = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalSL05004LAfurnacedoorsw",
                    Description = "SL05004 LA furnace door sw",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalSL05004LAfurnacedoorsw.Reset(); return true; });
                AlarmSignalSL05004LAfurnacedoorsw.AlarmTriggered = SensorAlarmSignalSL05004LAfurnacedoorsw;
            }

            if (AlarmSignalFurnacepoweronoff != null)
            {
                SensorAlarmSignalFurnacepoweronoff = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFurnacepoweronoff",
                    Description = "Furnace power on/off",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFurnacepoweronoff.Reset(); return true; });
                AlarmSignalFurnacepoweronoff.AlarmTriggered = SensorAlarmSignalFurnacepoweronoff;
            }

            if (AlarmSignalBlowerpoweronoff != null)
            {
                SensorAlarmSignalBlowerpoweronoff = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalBlowerpoweronoff",
                    Description = "Blower power on/off",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalBlowerpoweronoff.Reset(); return true; });
                AlarmSignalBlowerpoweronoff.AlarmTriggered = SensorAlarmSignalBlowerpoweronoff;
            }

            if (AlarmSignal100Vtransformerpoweron != null)
            {
                SensorAlarmSignal100Vtransformerpoweron = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignal100Vtransformerpoweron",
                    Description = "100V transformer power on",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignal100Vtransformerpoweron.Reset(); return true; });
                AlarmSignal100Vtransformerpoweron.AlarmTriggered = SensorAlarmSignal100Vtransformerpoweron;
            }

            if (AlarmSignalVFDenable != null)
            {
                SensorAlarmSignalVFDenable = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalVFDenable",
                    Description = "VFD enable",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalVFDenable.Reset(); return true; });
                AlarmSignalVFDenable.AlarmTriggered = SensorAlarmSignalVFDenable;
            }

            if (AlarmSignalHPMvalvepoweronoff != null)
            {
                SensorAlarmSignalHPMvalvepoweronoff = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHPMvalvepoweronoff",
                    Description = "HPM valve power on/off",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHPMvalvepoweronoff.Reset(); return true; });
                AlarmSignalHPMvalvepoweronoff.AlarmTriggered = SensorAlarmSignalHPMvalvepoweronoff;
            }

            if (AlarmSignalAxisCRmotorenable1 != null)
            {
                SensorAlarmSignalAxisCRmotorenable1 = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalAxisCRmotorenable1",
                    Description = "Axis-CR motor enable1",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalAxisCRmotorenable1.Reset(); return true; });
                AlarmSignalAxisCRmotorenable1.AlarmTriggered = SensorAlarmSignalAxisCRmotorenable1;
            }

            if (AlarmSignalAxisCRmotorenable2 != null)
            {
                SensorAlarmSignalAxisCRmotorenable2 = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalAxisCRmotorenable2",
                    Description = "Axis-CR motor enable2",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalAxisCRmotorenable2.Reset(); return true; });
                AlarmSignalAxisCRmotorenable2.AlarmTriggered = SensorAlarmSignalAxisCRmotorenable2;
            }

            if (AlarmSignalAxisEmotorenable1 != null)
            {
                SensorAlarmSignalAxisEmotorenable1 = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalAxisEmotorenable1",
                    Description = "Axis-E motor enable1",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalAxisEmotorenable1.Reset(); return true; });
                AlarmSignalAxisEmotorenable1.AlarmTriggered = SensorAlarmSignalAxisEmotorenable1;
            }

            if (AlarmSignalAxisEmotorenable2 != null)
            {
                SensorAlarmSignalAxisEmotorenable2 = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalAxisEmotorenable2",
                    Description = "Axis-E motor enable2",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalAxisEmotorenable2.Reset(); return true; });
                AlarmSignalAxisEmotorenable2.AlarmTriggered = SensorAlarmSignalAxisEmotorenable2;
            }

            if (AlarmSignalFTRenable1 != null)
            {
                SensorAlarmSignalFTRenable1 = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFTRenable1",
                    Description = "FTR enable1",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFTRenable1.Reset(); return true; });
                AlarmSignalFTRenable1.AlarmTriggered = SensorAlarmSignalFTRenable1;
            }

            if (AlarmSignalFTRenable2 != null)
            {
                SensorAlarmSignalFTRenable2 = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFTRenable2",
                    Description = "FTR enable2",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFTRenable2.Reset(); return true; });
                AlarmSignalFTRenable2.AlarmTriggered = SensorAlarmSignalFTRenable2;
            }

            if (AlarmSignalFTRinterlockreset != null)
            {
                SensorAlarmSignalFTRinterlockreset = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFTRinterlockreset",
                    Description = "FTR interlock reset",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFTRinterlockreset.Reset(); return true; });
                AlarmSignalFTRinterlockreset.AlarmTriggered = SensorAlarmSignalFTRinterlockreset;
            }

            if (AlarmSignalWTRenable1 != null)
            {
                SensorAlarmSignalWTRenable1 = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalWTRenable1",
                    Description = "WTR enable1",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalWTRenable1.Reset(); return true; });
                AlarmSignalWTRenable1.AlarmTriggered = SensorAlarmSignalWTRenable1;
            }

            if (AlarmSignalWTRenable2 != null)
            {
                SensorAlarmSignalWTRenable2 = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalWTRenable2",
                    Description = "WTR enable2",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalWTRenable2.Reset(); return true; });
                AlarmSignalWTRenable2.AlarmTriggered = SensorAlarmSignalWTRenable2;
            }

            if (AlarmSignalWTRinterlockreset != null)
            {
                SensorAlarmSignalWTRinterlockreset = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalWTRinterlockreset",
                    Description = "WTR interlock reset",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalWTRinterlockreset.Reset(); return true; });
                AlarmSignalWTRinterlockreset.AlarmTriggered = SensorAlarmSignalWTRinterlockreset;
            }

            if (AlarmSignalCapheaterenable != null)
            {
                SensorAlarmSignalCapheaterenable = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalCapheaterenable",
                    Description = "Cap heater enable",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalCapheaterenable.Reset(); return true; });
                AlarmSignalCapheaterenable.AlarmTriggered = SensorAlarmSignalCapheaterenable;
            }

            if (AlarmSignalLightcurtainidel != null)
            {
                SensorAlarmSignalLightcurtainidel = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLightcurtainidel",
                    Description = "Light curtain idel",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLightcurtainidel.Reset(); return true; });
                AlarmSignalLightcurtainidel.AlarmTriggered = SensorAlarmSignalLightcurtainidel;
            }

            if (AlarmSignalPowerboxinterlockbuttonled != null)
            {
                SensorAlarmSignalPowerboxinterlockbuttonled = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalPowerboxinterlockbuttonled",
                    Description = "Power box interlock button led",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalPowerboxinterlockbuttonled.Reset(); return true; });
                AlarmSignalPowerboxinterlockbuttonled.AlarmTriggered = SensorAlarmSignalPowerboxinterlockbuttonled;
            }

            if (AlarmSignalGasboxinterlockbuttonled != null)
            {
                SensorAlarmSignalGasboxinterlockbuttonled = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGasboxinterlockbuttonled",
                    Description = "Gas box interlock button led",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGasboxinterlockbuttonled.Reset(); return true; });
                AlarmSignalGasboxinterlockbuttonled.AlarmTriggered = SensorAlarmSignalGasboxinterlockbuttonled;
            }

            if (AlarmSignalFrontbodyinterlockbuttonled != null)
            {
                SensorAlarmSignalFrontbodyinterlockbuttonled = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFrontbodyinterlockbuttonled",
                    Description = "Frontbody interlock button led",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFrontbodyinterlockbuttonled.Reset(); return true; });
                AlarmSignalFrontbodyinterlockbuttonled.AlarmTriggered = SensorAlarmSignalFrontbodyinterlockbuttonled;
            }

            #endregion
            if (AlarmSignaTempLimitAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignaTempLimitAlarm",
                    Description = $"Temp Limit Alarm Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignaTempLimitAlarm.Reset(); return true; });
                AlarmSignaTempLimitAlarm.AlarmTriggered = alarm;
            }

            InterlockAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.InterlockAlarm",
                Description = $"Interlock occur alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "InterlockAlarm",
            }, () => { return true; });
            Singleton<InterlockManager>.Instance.InterlockAlarmKey = "InterlockAlarm";
            Singleton<InterlockManager>.Instance.InterlockAlarms.Add("InterlockAlarm", InterlockAlarm);

            UserDefineInterlockAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.UserDefineInterlockAlarm",
                Description = $"{Name} user define interlock occur alarm ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "InterlockAlarm",
            }, () => { return true; });
            Singleton<InterlockManager>.Instance.UserDefineInterlockAlarmKey = "UserDefineInterlockAlarm";
            Singleton<InterlockManager>.Instance.InterlockAlarms.Add("UserDefineInterlockAlarm", UserDefineInterlockAlarm);
            if (!SC.ContainsItem("Minics.EnableMinics") || !SC.GetValue<bool>("Minics.EnableMinics"))
            {
                AUXAlarmDic = new Dictionary<int, Tuple<AlarmEventItem, AlarmEventItem>>();
                for (int index = 0; index < 512; index++)
                {
                    if (!SC.ContainsItem($"PM1.RecipeEditParameter.AUX.{index}.AI") || AUXAlarmDic.ContainsKey(index))
                        continue;
                    var auxAlarm = SubscribeAlarm(new AlarmEventItem()
                    {
                        EventEnum = $"{Name}.AUX{index}Alarm",
                        Description = $"{SC.ContainsItem($"PM1.RecipeEditParameter.AUX.{index}.Display")} alarm Trigger ",
                        Solution = "No information available. Press[Clear] to delete alarm message.",
                        Explaination = "No information available.",
                        AutoRecovery = false,
                        Level = EventLevel.Alarm,
                        Action = EventAction.Clear,
                        Category = "TubeAlarm",
                    }, () => { return true; });
                    var auxWarning = SubscribeAlarm(new AlarmEventItem()
                    {
                        EventEnum = $"{Name}.AUX{index}Warning",
                        Description = $"{SC.ContainsItem($"PM1.RecipeEditParameter.AUX.{index}.Display")} warning Trigger ",
                        Solution = "No information available. Press[Clear] to delete alarm message.",
                        Explaination = "No information available.",
                        AutoRecovery = false,
                        Level = EventLevel.Alarm,
                        Action = EventAction.Clear,
                        Category = "TubeAlarm",
                    }, () => { return true; });

                    AUXAlarmDic.Add(index, Tuple.Create(auxWarning, auxAlarm));
                }


            }

            LeakCheckAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.LeakCheckAlarm",
                Description = $"Leak Check alarm Trigger ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });

            ShutterMoveFailedForInterlock = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.ShutterMoveFailedForInterlock",
                Description = $"Shutter Move Failed For Interlock Trigger ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });

            BoatMoveToLoadPositionTimeoutWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.BoatMoveToLoadPositionTimeoutWarning",
                Description = $"Boat Move To Load Position Timeout Warning Trigger ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });

            if (AlarmSignalLAO2CheckOTWarning != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLAO2CheckOTWarning",
                    Description = $"LA O2 Check OT Warning Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Warning,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLAO2CheckOTWarning.Reset(); return true; });
                AlarmSignalLAO2CheckOTWarning.AlarmTriggered = alarm;
            }

            if (AlarmSignalFIMS1O2CheckOTWarning != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS1O2CheckOTWarning",
                    Description = $"FIMS1 O2 Check OT Warning Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Warning,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS1O2CheckOTWarning.Reset(); return true; });
                AlarmSignalFIMS1O2CheckOTWarning.AlarmTriggered = alarm;
            }

            if (AlarmSignalFIMS2O2CheckOTWarning != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS2O2CheckOTWarning",
                    Description = $"FIMS2 O2 Check OT Warning Trigger ",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Warning,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS2O2CheckOTWarning.Reset(); return true; });
                AlarmSignalFIMS2O2CheckOTWarning.AlarmTriggered = alarm;
            }


            if (AlarmSignalHeaterUCascadePVSBrk != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHeaterUCascadePVSBrk",
                    Description = $"HeaterU Cascade Tc Break Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHeaterUCascadePVSBrk.Reset(); return true; });
                AlarmSignalHeaterUCascadePVSBrk.AlarmTriggered = alarm;
            }


            if (AlarmSignalHeaterUHeaterPVSBrk != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHeaterUHeaterPVSBrk",
                    Description = $"HeaterU Heater Tc Break Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHeaterUHeaterPVSBrk.Reset(); return true; });
                AlarmSignalHeaterUHeaterPVSBrk.AlarmTriggered = alarm;
            }


            if (AlarmSignalHeaterCUCascadePVSBrk != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHeaterCUCascadePVSBrk",
                    Description = $"HeaterCU Cascade Tc Break Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHeaterCUCascadePVSBrk.Reset(); return true; });
                AlarmSignalHeaterCUCascadePVSBrk.AlarmTriggered = alarm;
            }

            if (AlarmSignalHeaterCUHeaterPVSBrk != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHeaterCUHeaterPVSBrk",
                    Description = $"HeaterCU Heater Tc Break Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHeaterCUHeaterPVSBrk.Reset(); return true; });
                AlarmSignalHeaterCUHeaterPVSBrk.AlarmTriggered = alarm;
            }


            if (AlarmSignalHeaterCCascadePVSBrk != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHeaterCCascadePVSBrk",
                    Description = $"HeaterC Cascade Tc Break Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHeaterCCascadePVSBrk.Reset(); return true; });
                AlarmSignalHeaterCCascadePVSBrk.AlarmTriggered = alarm;
            }

            if (AlarmSignalHeaterCHeaterPVSBrk != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHeaterCHeaterPVSBrk",
                    Description = $"HeaterC Heater Tc Break Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHeaterCHeaterPVSBrk.Reset(); return true; });
                AlarmSignalHeaterCHeaterPVSBrk.AlarmTriggered = alarm;
            }

            if (AlarmSignalHeaterCLCascadePVSBrk != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHeaterCLCascadePVSBrk",
                    Description = $"HeaterCL Cascade Tc Break Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHeaterCLCascadePVSBrk.Reset(); return true; });
                AlarmSignalHeaterCLCascadePVSBrk.AlarmTriggered = alarm;
            }

            if (AlarmSignalHeaterCLHeaterPVSBrk != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHeaterCLHeaterPVSBrk",
                    Description = $"HeaterCL Heater Tc Break Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHeaterCLHeaterPVSBrk.Reset(); return true; });
                AlarmSignalHeaterCLHeaterPVSBrk.AlarmTriggered = alarm;
            }


            if (AlarmSignalHeaterLCascadePVSBrk != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHeaterLCascadePVSBrk",
                    Description = $"HeaterL Cascade Tc Break Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHeaterLCascadePVSBrk.Reset(); return true; });
                AlarmSignalHeaterLCascadePVSBrk.AlarmTriggered = alarm;
            }

            if (AlarmSignalHeaterLHeaterPVSBrk != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHeaterLHeaterPVSBrk",
                    Description = $"HeaterL Heater Tc Break Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHeaterLHeaterPVSBrk.Reset(); return true; });
                AlarmSignalHeaterLHeaterPVSBrk.AlarmTriggered = alarm;
            }

            if (GasLine1AlarmSignalTempOutRange != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.GasLine1GasLine1AlarmSignalTempOutRange",
                    Description = $"GasLine1 Temp Out Range Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { GasLine1AlarmSignalTempOutRange.Reset(); return true; });
                GasLine1AlarmSignalTempOutRange.AlarmTriggered = alarm;
            }

            if (GasLine2AlarmSignalTempOutRange != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.GasLine2AlarmSignalTempOutRange",
                    Description = $"GasLine2 Temp Out Range Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { GasLine2AlarmSignalTempOutRange.Reset(); return true; });
                GasLine2AlarmSignalTempOutRange.AlarmTriggered = alarm;
            }

            if (GasLine3AlarmSignalTempOutRange != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.GasLine3AlarmSignalTempOutRange",
                    Description = $"GasLine3 Temp Out Range Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { GasLine3AlarmSignalTempOutRange.Reset(); return true; });
                GasLine3AlarmSignalTempOutRange.AlarmTriggered = alarm;
            }

            if (GasLine4AlarmSignalTempOutRange != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.GasLine4AlarmSignalTempOutRange",
                    Description = $"GasLine4 Temp Out Range Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { GasLine4AlarmSignalTempOutRange.Reset(); return true; });
                GasLine4AlarmSignalTempOutRange.AlarmTriggered = alarm;
            }

            if (GasLine6AlarmSignalTempOutRange != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.GasLine6AlarmSignalTempOutRange",
                    Description = $"GasLine6 Temp Out Range Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { GasLine6AlarmSignalTempOutRange.Reset(); return true; });
                GasLine6AlarmSignalTempOutRange.AlarmTriggered = alarm;
            }

            if (GasLine7AlarmSignalTempOutRange != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.GasLine7AlarmSignalTempOutRange",
                    Description = $"GasLine7 Temp Out Range Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { GasLine6AlarmSignalTempOutRange.Reset(); return true; });
                GasLine7AlarmSignalTempOutRange.AlarmTriggered = alarm;
            }

            if (GasLine1AlarmSignalCLN != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.GasLine1AlarmSignalCLN",
                    Description = $"GasLine1 cln alarm trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { GasLine1AlarmSignalCLN.Reset(); return true; });
                GasLine1AlarmSignalCLN.AlarmTriggered = alarm;
            }

            if (GasLine2AlarmSignalCLN != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.GasLine2AlarmSignalCLN",
                    Description = $"GasLine2 cln alarm trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { GasLine2AlarmSignalCLN.Reset(); return true; });
                GasLine2AlarmSignalCLN.AlarmTriggered = alarm;
            }

            if (GasLine3AlarmSignalCLN != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.GasLine3AlarmSignalCLN",
                    Description = $"GasLine3 cln alarm trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { GasLine3AlarmSignalCLN.Reset(); return true; });
                GasLine3AlarmSignalCLN.AlarmTriggered = alarm;
            }

            if (GasLine4AlarmSignalCLN != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.GasLine4AlarmSignalCLN",
                    Description = $"GasLine4 cln alarm trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { GasLine4AlarmSignalCLN.Reset(); return true; });
                GasLine4AlarmSignalCLN.AlarmTriggered = alarm;
            }

            if (GasLine6AlarmSignalCLN != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.GasLine6AlarmSignalCLN",
                    Description = $"GasLine6 cln alarm trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { GasLine6AlarmSignalCLN.Reset(); return true; });
                GasLine6AlarmSignalCLN.AlarmTriggered = alarm;
            }

            if (GasLine7AlarmSignalCLN != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.GasLine7AlarmSignalCLN",
                    Description = $"GasLine7 cln alarm trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { GasLine7AlarmSignalCLN.Reset(); return true; });
                GasLine7AlarmSignalCLN.AlarmTriggered = alarm;
            }

            if (AlarmSignalHCL1GasLeak1stAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHCL1GasLeak1stAlarm",
                    Description = $"HCL-1 gas leak 1st alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHCL1GasLeak1stAlarm.Reset(); return true; });
                AlarmSignalHCL1GasLeak1stAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalHCL1GasLeak2ndAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHCL1GasLeak2ndAlarm",
                    Description = $"HCL-1 gas leak 2nd alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHCL1GasLeak2ndAlarm.Reset(); return true; });
                AlarmSignalHCL1GasLeak2ndAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalHCL2GasLeak1stAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHCL2GasLeak1stAlarm",
                    Description = $"HCL-2gas leak 1st alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHCL2GasLeak1stAlarm.Reset(); return true; });
                AlarmSignalHCL2GasLeak1stAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalHCL2GasLeak2ndAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHCL2GasLeak2ndAlarm",
                    Description = $"HCL-2gas leak 2nd alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHCL2GasLeak2ndAlarm.Reset(); return true; });
                AlarmSignalHCL2GasLeak2ndAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalNH31GasLeak1stAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalNH31GasLeak1stAlarm",
                    Description = $"H3-1gas leak 1st alarm  Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalNH31GasLeak1stAlarm.Reset(); return true; });
                AlarmSignalNH31GasLeak1stAlarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalNH31GasLeak2ndAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalNH31GasLeak2ndAlarm",
                    Description = $"NH3-1gas leak 2nd alarm  Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalNH31GasLeak2ndAlarm.Reset(); return true; });
                AlarmSignalNH31GasLeak2ndAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalNH32GasLeak1stAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalNH32GasLeak1stAlarm",
                    Description = $"NH3-2gas leak 1st alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalNH32GasLeak1stAlarm.Reset(); return true; });
                AlarmSignalNH32GasLeak1stAlarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalNH32GasLeak2ndAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalNH32GasLeak2ndAlarm",
                    Description = $"NH3-2 gas leak 2nd alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalNH32GasLeak2ndAlarm.Reset(); return true; });
                AlarmSignalNH32GasLeak2ndAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalF21GasLeak1stAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalF21GasLeak1stAlarm",
                    Description = $"F2-1 gas leak 1st alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalF21GasLeak1stAlarm.Reset(); return true; });
                AlarmSignalF21GasLeak1stAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalF21GasLeak2ndAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalF21GasLeak2ndAlarm",
                    Description = $"F2-1 gas leak 2nd alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalF21GasLeak2ndAlarm.Reset(); return true; });
                AlarmSignalF21GasLeak2ndAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalF22GasLeak1stAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalF22GasLeak1stAlarm",
                    Description = $"F2-2 gas leak 1st alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalF22GasLeak1stAlarm.Reset(); return true; });
                AlarmSignalF22GasLeak1stAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalF22GasLeak2ndAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalF22GasLeak2ndAlarm",
                    Description = $"F2-2 gas leak 2nd alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalF22GasLeak2ndAlarm.Reset(); return true; });
                AlarmSignalF22GasLeak2ndAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalNO1GasLeak1stAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalNO1GasLeak1stAlarm",
                    Description = $"NO-1 gas leak 1st alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalNO1GasLeak1stAlarm.Reset(); return true; });
                AlarmSignalNO1GasLeak1stAlarm.AlarmTriggered = alarm;
            }


            if (AlarmSignalNO1GasLeak2ndAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalNO1GasLeak2ndAlarm",
                    Description = $"NO-1 gas leak 2nd alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalNO1GasLeak2ndAlarm.Reset(); return true; });
                AlarmSignalNO1GasLeak2ndAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalNO2GasLeak1stAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalNO2GasLeak1stAlarm",
                    Description = $"NO-2 gas leak 1st alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalNO2GasLeak1stAlarm.Reset(); return true; });
                AlarmSignalNO2GasLeak1stAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalNO2GasLeak2ndAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalNO2GasLeak2ndAlarm",
                    Description = $"NO-2 gas leak 2nd alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalNO2GasLeak2ndAlarm.Reset(); return true; });
                AlarmSignalNO2GasLeak2ndAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalC3H61GasLeak1stAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalC3H61GasLeak1stAlarm",
                    Description = $"C3H6-1 gas leak 1st alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalC3H61GasLeak1stAlarm.Reset(); return true; });
                AlarmSignalC3H61GasLeak1stAlarm.AlarmTriggered = alarm;
            }


            if (AlarmSignalC3H61GasLeak2ndAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalC3H61GasLeak2ndAlarm",
                    Description = $"C3H6 - 1 gas leak 2nd alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalC3H61GasLeak2ndAlarm.Reset(); return true; });
                AlarmSignalC3H61GasLeak2ndAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalC3H62GasLeak1stAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalC3H62GasLeak1stAlarm",
                    Description = $"C3H6-2 gas leak 1st alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalC3H62GasLeak1stAlarm.Reset(); return true; });
                AlarmSignalC3H62GasLeak1stAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalC3H62GasLeak2ndAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalC3H62GasLeak2ndAlarm",
                    Description = $"C3H6-2 gas leak 1st alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalC3H62GasLeak2ndAlarm.Reset(); return true; });
                AlarmSignalC3H62GasLeak2ndAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalDMA1GasLeak1stAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalDMA1GasLeak1stAlarm",
                    Description = $"DMA - 1 gas leak 1st alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalDMA1GasLeak1stAlarm.Reset(); return true; });
                AlarmSignalDMA1GasLeak1stAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalDMA1GasLeak2ndAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalDMA1GasLeak2ndAlarm",
                    Description = $"DMA-1 gas leak 2nd alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalDMA1GasLeak2ndAlarm.Reset(); return true; });
                AlarmSignalDMA1GasLeak2ndAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalDMA2GasLeak1stAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalDMA2GasLeak1stAlarm",
                    Description = $"DMA-2gas leak 1st alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalDMA2GasLeak1stAlarm.Reset(); return true; });
                AlarmSignalDMA2GasLeak1stAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalDMA2GasLeak2ndAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalDMA2GasLeak2ndAlarm",
                    Description = $"DMA-2 gas leak 2nd alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalDMA2GasLeak2ndAlarm.Reset(); return true; });
                AlarmSignalDMA2GasLeak2ndAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalGLBoxPG7CNT1Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG7CNT1Alarm",
                    Description = $"Gas box PG7 CNT1 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG7CNT1Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG7CNT1Alarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalGLBoxPG7CNT2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG7CNT2Alarm",
                    Description = $"Gas box PG7 CNT2 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG7CNT2Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG7CNT2Alarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalGLBoxPG8CNT2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG8CNT2Alarm",
                    Description = $"Gas box PG8 CNT1 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG8CNT2Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG8CNT2Alarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalGLBoxPG9CNT2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG9CNT2Alarm",
                    Description = $"Gas box PG8 CNT2 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG9CNT2Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG9CNT2Alarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalHEXOverTemperatureAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHEXOverTemperatureAlarm",
                    Description = $"H-EX over temperature alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHEXOverTemperatureAlarm.Reset(); return true; });
                AlarmSignalHEXOverTemperatureAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalGLBoxPG21CNT1Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG21CNT1Alarm",
                    Description = $"MP/PS20 alarm",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG21CNT1Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG21CNT1Alarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalGLBoxPG21CNT2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG21CNT2Alarm",
                    Description = $"GL box PG21 CNT2 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG21CNT2Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG21CNT2Alarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalGLBoxPG22CNT1Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG22CNT1Alarm",
                    Description = $"GL box PG22 CNT1 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG22CNT1Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG22CNT1Alarm.AlarmTriggered = alarm;
            }


            if (AlarmSignalGLBoxPG22CNT2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG22CNT2Alarm",
                    Description = $"GL box PG22 CNT2 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG22CNT2Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG22CNT2Alarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalGLBoxPG23CNT1Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG23CNT1Alarm",
                    Description = $"GL box PG23 CNT1 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG23CNT1Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG23CNT1Alarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalGLBoxPG23CNT2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG23CNT2Alarm",
                    Description = $"GL box PG23 CNT2 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG23CNT2Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG23CNT2Alarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalGLBoxPG24CNT1Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG24CNT1Alarm",
                    Description = $"GL box PG24 CNT1 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG24CNT1Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG24CNT1Alarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalGLBoxPG24CNT2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG24CNT2Alarm",
                    Description = $"GL box PG24 CNT2 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG24CNT2Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG24CNT2Alarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalGLBoxPG25CNT1Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG25CNT1Alarm",
                    Description = $"GL box PG25 CNT1 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG25CNT1Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG25CNT1Alarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalGLBoxPG25CNT2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG25CNT2Alarm",
                    Description = $"GL box PG25 CNT2 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG25CNT2Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG25CNT2Alarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalGLBoxPG31CNT1Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG31CNT1Alarm",
                    Description = $"GL box PG31 CNT1 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG31CNT1Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG31CNT1Alarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalGLBoxPG31CNT2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG31CNT2Alarm",
                    Description = $"GL box PG31 CNT2 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG31CNT2Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG31CNT2Alarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalMS6Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalMS6Alarm",
                    Description = $"MS6 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalMS6Alarm.Reset(); return true; });
                AlarmSignalMS6Alarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalGLBoxPG32CNT1Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG32CNT1Alarm",
                    Description = $"GL box PG32 CNT1 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG32CNT1Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG32CNT1Alarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalGLBoxPG32CNT2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalGLBoxPG32CNT2Alarm",
                    Description = $"GL box PG32 CNT2 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalGLBoxPG32CNT2Alarm.Reset(); return true; });
                AlarmSignalGLBoxPG32CNT2Alarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalPG12CNT1Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalPG12CNT1Alarm",
                    Description = $"PG12 CNT1 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalPG12CNT1Alarm.Reset(); return true; });
                AlarmSignalPG12CNT1Alarm.AlarmTriggered = alarm;
            }
            if (AlarmSignalPG12CNT2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalPG12CNT1Alarm",
                    Description = $"PG12 CNT2 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalPG12CNT2Alarm.Reset(); return true; });
                AlarmSignalPG12CNT2Alarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalPG13CNT1Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalPG13CNT1Alarm",
                    Description = $"PG13 CNT1 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalPG13CNT1Alarm.Reset(); return true; });
                AlarmSignalPG13CNT1Alarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalPG13CNT2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalPG13CNT2Alarm",
                    Description = $"PG13 CNT2 alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalPG13CNT2Alarm.Reset(); return true; });
                AlarmSignalPG13CNT2Alarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalVaccum1PumpWarning != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalVaccum1PumpWarning",
                    Description = $"Vaccum1 Pump Warning Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Warning,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalVaccum1PumpWarning.Reset(); return true; });
                AlarmSignalVaccum1PumpWarning.AlarmTriggered = alarm;
            }

            if (AlarmSignalVaccum1PumpAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalVaccum1PumpAlarm",
                    Description = $"Vaccum1 Pump Alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalVaccum1PumpAlarm.Reset(); return true; });
                AlarmSignalVaccum1PumpAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalVaccum2PumpWarning != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalVaccum2PumpWarning",
                    Description = $"Vaccum2 Pump Warning Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Warning,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalVaccum2PumpWarning.Reset(); return true; });
                AlarmSignalVaccum2PumpWarning.AlarmTriggered = alarm;
            }

            if (AlarmSignalVaccum2PumpAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalVaccum2PumpAlarm",
                    Description = $"Vaccum2 Pump Alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalVaccum2PumpAlarm.Reset(); return true; });
                AlarmSignalVaccum2PumpAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalHotN2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalHotN2Alarm",
                    Description = $"HOT N2 ALARM Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalHotN2Alarm.Reset(); return true; });
                AlarmSignalHotN2Alarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalLDS1MajorAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLDS1MajorAlarm",
                    Description = $"LDS1 major alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLDS1MajorAlarm.Reset(); return true; });
                AlarmSignalLDS1MajorAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalLDS1MinorWarning != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLDS1MinorWarning",
                    Description = $"LDS1 minor warning Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Warning,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLDS1MinorWarning.Reset(); return true; });
                AlarmSignalLDS1MinorWarning.AlarmTriggered = alarm;
            }

            if (AlarmSignalLDS1liquidLowWarning != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLDS1liquidLowWarning",
                    Description = $"LDS1 liquid low warning Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Warning,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLDS1liquidLowWarning.Reset(); return true; });
                AlarmSignalLDS1liquidLowWarning.AlarmTriggered = alarm;
            }


            if (AlarmSignalLDS1TankBlankAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLDS1TankBlankAlarm",
                    Description = $"LDS1 tank blank alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLDS1TankBlankAlarm.Reset(); return true; });
                AlarmSignalLDS1TankBlankAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalLDS2MajorAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLDS2MajorAlarm",
                    Description = $"LDS2 major alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLDS2MajorAlarm.Reset(); return true; });
                AlarmSignalLDS2MajorAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalLDS2MinorWarning != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLDS2MinorWarning",
                    Description = $"LDS2 minor warning Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Warning,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLDS2MinorWarning.Reset(); return true; });
                AlarmSignalLDS2MinorWarning.AlarmTriggered = alarm;
            }

            if (AlarmSignalLDS2LiquidLowWarning != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLDS2LiquidLowWarning",
                    Description = $"LDS2 liquid low warning Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Warning,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLDS2LiquidLowWarning.Reset(); return true; });
                AlarmSignalLDS2LiquidLowWarning.AlarmTriggered = alarm;
            }

            if (AlarmSignalLDS2TankBlankAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalLDS2TankBlankAlarm",
                    Description = $"LDS2 tank blank alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalLDS2TankBlankAlarm.Reset(); return true; });
                AlarmSignalLDS2TankBlankAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalPOD1FOUPVacuumSuckingAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalPOD1FOUPVacuumSuckingAlarm",
                    Description = $"POD1 FOUP vacuum sucking alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalPOD1FOUPVacuumSuckingAlarm.Reset(); return true; });
                AlarmSignalPOD1FOUPVacuumSuckingAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSignalPOD2FOUPVacuumSuckingAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalPOD2FOUPVacuumSuckingAlarm",
                    Description = $"POD2 FOUP vacuum sucking alarm Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalPOD2FOUPVacuumSuckingAlarm.Reset(); return true; });
                AlarmSignalPOD2FOUPVacuumSuckingAlarm.AlarmTriggered = alarm;
            }

            if (AlarmTS34RRotationTempSwAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmTS34RRotationTempSwAlarm",
                    Description = $"TS34 R rotation temp. sw Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmTS34RRotationTempSwAlarm.Reset(); return true; });
                AlarmTS34RRotationTempSwAlarm.AlarmTriggered = alarm;
            }

            if (AlarmTS30CapInsideTempSwAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmTS30CapInsideTempSwAlarm",
                    Description = $"TS30 cap inside temp.sw Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmTS30CapInsideTempSwAlarm.Reset(); return true; });
                AlarmTS30CapInsideTempSwAlarm.AlarmTriggered = alarm;
            }

            if (AlarmTS31capoutsidetemSwAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmTS31capoutsidetemSwAlarm",
                    Description = $"TS31 cap outside temp.sw Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmTS31capoutsidetemSwAlarm.Reset(); return true; });
                AlarmTS31capoutsidetemSwAlarm.AlarmTriggered = alarm;
            }
            if (AlarmGasboxlowerdoorSwAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmGasboxlowerdoorSwAlarm",
                    Description = $"gas box lower door sw Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmGasboxlowerdoorSwAlarm.Reset(); return true; });
                AlarmGasboxlowerdoorSwAlarm.AlarmTriggered = alarm;
            }
            if (AlarmGasboxupperdoorSwAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmGasboxupperdoorSwAlarm",
                    Description = $"gas box upper door sw Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmGasboxupperdoorSwAlarm.Reset(); return true; });
                AlarmGasboxupperdoorSwAlarm.AlarmTriggered = alarm;
            }
            if (AlarmEXHboxwaterleakAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmEXHboxwaterleakAlarm",
                    Description = $"EXH box water leak Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmEXHboxwaterleakAlarm.Reset(); return true; });
                AlarmEXHboxwaterleakAlarm.AlarmTriggered = alarm;
            }

            if (AlarmOPpanelEMO1Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmOPpanelEMO1Alarm",
                    Description = $"OP panel EMO 1 Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmOPpanelEMO1Alarm.Reset(); return true; });
                AlarmOPpanelEMO1Alarm.AlarmTriggered = alarm;
            }

            if (AlarmOPpanelEMO2Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmOPpanelEMO2Alarm",
                    Description = $"OP panel EMO 2 Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmOPpanelEMO2Alarm.Reset(); return true; });
                AlarmOPpanelEMO2Alarm.AlarmTriggered = alarm;
            }


            if (AlarmMainFurnaceTS306Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmMainFurnaceTS306Alarm",
                    Description = $"main furnace TS306 Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmMainFurnaceTS306Alarm.Reset(); return true; });
                AlarmMainFurnaceTS306Alarm.AlarmTriggered = alarm;
            }

            if (AlarmHeaterRoomSWS11S12Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmHeaterRoomSWS11S12Alarm",
                    Description = $"heater room SW S11/S12 Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmHeaterRoomSWS11S12Alarm.Reset(); return true; });
                AlarmHeaterRoomSWS11S12Alarm.AlarmTriggered = alarm;
            }

            if (AlarmHeaterBbacksidePanelSWS112Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmHeaterBbacksidePanelSWS112Alarm",
                    Description = $"heater backside panel SW S112 Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmHeaterBbacksidePanelSWS112Alarm.Reset(); return true; });
                AlarmHeaterBbacksidePanelSWS112Alarm.AlarmTriggered = alarm;
            }

            if (AlarmRHCTS305Alarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmRHCTS305Alarm",
                    Description = $"RHC TS305 Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmRHCTS305Alarm.Reset(); return true; });
                AlarmRHCTS305Alarm.AlarmTriggered = alarm;
            }

            if (AlarmGasLeakFaultAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmGasLeakFaultAlarm",
                    Description = $"gas leak fault Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmGasLeakFaultAlarm.Reset(); return true; });
                AlarmGasLeakFaultAlarm.AlarmTriggered = alarm;
            }

            if (AlarmMagneticFluidLeakAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmMagneticFluidLeakAlarm",
                    Description = $"Magnetic fluid leak Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmMagneticFluidLeakAlarm.Reset(); return true; });
                AlarmMagneticFluidLeakAlarm.AlarmTriggered = alarm;
            }


            if (AlarmCoolingWaterLeakAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmCoolingWaterLeakAlarm",
                    Description = $"Cooling water leak Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmCoolingWaterLeakAlarm.Reset(); return true; });
                AlarmCoolingWaterLeakAlarm.AlarmTriggered = alarm;
            }

            if (AlarmLSCWaterLeakAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmLSCWaterLeakAlarm",
                    Description = $"LSC water leak Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmLSCWaterLeakAlarm.Reset(); return true; });
                AlarmLSCWaterLeakAlarm.AlarmTriggered = alarm;
            }

            if (AlarmLABacksideDoorSwitchAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmLABacksideDoorSwitchAlarm",
                    Description = $"LA backside door switch Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmLABacksideDoorSwitchAlarm.Reset(); return true; });
                AlarmLABacksideDoorSwitchAlarm.AlarmTriggered = alarm;
            }


            if (AlarmSiSourceTANKHeater1INHIBITHIAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSiSourceTANKHeater1INHIBITHIAlarm",
                    Description = $"Si-Source TANK heater1 INHIBIT HI ALARM Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSiSourceTANKHeater1INHIBITHIAlarm.Reset(); return true; });
                AlarmSiSourceTANKHeater1INHIBITHIAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSiSourceTANKHeater1INHIBITLOWAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSiSourceTANKHeater1INHIBITLOWAlarm",
                    Description = $"Si-Source TANK heater1 INHIBIT LOW ALARM Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSiSourceTANKHeater1INHIBITLOWAlarm.Reset(); return true; });
                AlarmSiSourceTANKHeater1INHIBITLOWAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSiSourceTANKHeater2INHIBITHIAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSiSourceTANKHeater2INHIBITHIAlarm",
                    Description = $"Si-Source TANK heater2 INHIBIT HI ALARM Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSiSourceTANKHeater2INHIBITHIAlarm.Reset(); return true; });
                AlarmSiSourceTANKHeater2INHIBITHIAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSiSourceTANKHeater2INHIBITLOWAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSiSourceTANKHeater2INHIBITLOWAlarm",
                    Description = $"Si-Source TANK heater2 INHIBIT LOW ALARM Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSiSourceTANKHeater2INHIBITLOWAlarm.Reset(); return true; });
                AlarmSiSourceTANKHeater2INHIBITLOWAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSiSourceTANKHeater3INHIBITHIAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSiSourceTANKHeater3INHIBITHIAlarm",
                    Description = $"Si-Source TANK heater3 INHIBIT HI ALARM Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSiSourceTANKHeater3INHIBITHIAlarm.Reset(); return true; });
                AlarmSiSourceTANKHeater3INHIBITHIAlarm.AlarmTriggered = alarm;
            }


            if (AlarmSiSourceTANKHeater3INHIBITLOWAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSiSourceTANKHeater3INHIBITLOWAlarm",
                    Description = $"Si-Source TANK heater3 INHIBIT LOW ALARM Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSiSourceTANKHeater3INHIBITLOWAlarm.Reset(); return true; });
                AlarmSiSourceTANKHeater3INHIBITLOWAlarm.AlarmTriggered = alarm;
            }
            if (AlarmSiSourceAVMFCHeaterINHIBITHIAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSiSourceAVMFCHeaterINHIBITHIAlarm",
                    Description = $"Si-Source AV&MFC heater INHIBIT HI ALARM Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSiSourceAVMFCHeaterINHIBITHIAlarm.Reset(); return true; });
                AlarmSiSourceAVMFCHeaterINHIBITHIAlarm.AlarmTriggered = alarm;
            }

            if (AlarmSiSourceAVMFCHeaterINHIBITLOWAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSiSourceAVMFCHeaterINHIBITLOWAlarm",
                    Description = $"Si-Source AV&MFC heater INHIBIT LOW ALARM Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSiSourceAVMFCHeaterINHIBITLOWAlarm.Reset(); return true; });
                AlarmSiSourceAVMFCHeaterINHIBITLOWAlarm.AlarmTriggered = alarm;
            }

            if (AlarmCSourceTANKHeater1INHIBITHIAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmCSourceTANKHeater1INHIBITHIAlarm",
                    Description = $"C-Source TANK heater1 INHIBIT HI ALARM Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmCSourceTANKHeater1INHIBITHIAlarm.Reset(); return true; });
                AlarmCSourceTANKHeater1INHIBITHIAlarm.AlarmTriggered = alarm;
            }
            if (AlarmCSourceTANKHeater1INHIBITLOWAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmCSourceTANKHeater1INHIBITLOWAlarm",
                    Description = $"C-Source TANK heater1 INHIBIT LOW ALARM Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmCSourceTANKHeater1INHIBITLOWAlarm.Reset(); return true; });
                AlarmCSourceTANKHeater1INHIBITLOWAlarm.AlarmTriggered = alarm;
            }

            if (AlarmCSourceTANKHeater2INHIBITHIAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmCSourceTANKHeater2INHIBITHIAlarm",
                    Description = $"C-Source TANK heater2 INHIBIT HI ALARM Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmCSourceTANKHeater2INHIBITHIAlarm.Reset(); return true; });
                AlarmCSourceTANKHeater2INHIBITHIAlarm.AlarmTriggered = alarm;
            }

            if (AlarmCSourceTANKHeater2INHIBITLOWAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmCSourceTANKHeater2INHIBITLOWAlarm",
                    Description = $"C-Source TANK heater2 INHIBIT LOW ALARM Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmCSourceTANKHeater2INHIBITLOWAlarm.Reset(); return true; });
                AlarmCSourceTANKHeater2INHIBITLOWAlarm.AlarmTriggered = alarm;
            }

            if (AlarmCSourceTANKHeater3INHIBITHIAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmCSourceTANKHeater3INHIBITHIAlarm",
                    Description = $"C-Source TANK heater3 INHIBIT HI ALARM Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmCSourceTANKHeater3INHIBITHIAlarm.Reset(); return true; });
                AlarmCSourceTANKHeater3INHIBITHIAlarm.AlarmTriggered = alarm;
            }
            if (AlarmCSourceTANKHeater3INHIBITLOWAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmCSourceTANKHeater3INHIBITLOWAlarm",
                    Description = $"C-Source TANK heater3 INHIBIT LOW ALARM Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmCSourceTANKHeater3INHIBITLOWAlarm.Reset(); return true; });
                AlarmCSourceTANKHeater3INHIBITLOWAlarm.AlarmTriggered = alarm;
            }

            if (AlarmCSourceAVMFCHeaterINHIBITHIAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmCSourceAVMFCHeaterINHIBITHIAlarm",
                    Description = $"C-Source AV&MFC heater INHIBIT HI ALARM Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmCSourceAVMFCHeaterINHIBITHIAlarm.Reset(); return true; });
                AlarmCSourceAVMFCHeaterINHIBITHIAlarm.AlarmTriggered = alarm;
            }
            if (AlarmCSourceAVMFCHeaterINHIBITLOWAlarm != null)
            {
                alarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmCSourceAVMFCHeaterINHIBITLOWAlarm",
                    Description = $"C-Source AV&MFC heater INHIBIT LOW ALARM Trigger",
                    Solution = "No information available. Press[Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = false,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmCSourceAVMFCHeaterINHIBITLOWAlarm.Reset(); return true; });
                AlarmCSourceAVMFCHeaterINHIBITLOWAlarm.AlarmTriggered = alarm;
            }
        }
        public Tuple<AlarmEventItem, AlarmEventItem, AlarmEventItem> AddMini8ChannelAlarm(int mini8Index, int ChannelIndex)
        {
            var auxAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.GasLineHeaterUnit{mini8Index}CH{ChannelIndex}Alarm",
                Description = $"",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "GasLineAlarm",
            }, () => { return true; });
            var auxWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.GasLineHeaterUnit{mini8Index}CH{ChannelIndex}Warning",
                Description = "",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "GasLineAlarm",
            }, () => { return true; });
            var tcAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.GasLineHeaterUnit{mini8Index}CH{ChannelIndex}TcBrokenAlarm",
                Description = "",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "GasLineAlarm",
            }, () => { return true; });

            return Tuple.Create(auxWarning, auxAlarm, tcAlarm);
        }
        private void InitMinicsAlarmEvent()
        {
            GasLineCapsOverFlownAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.GasLineCapsOverFlownAlarm",
                Description = $"GasLine CapsOverFlown Alarm",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = true,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });
            GasLineFloorOverFlowAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.GasLineFloorOverFlowAlarm",
                Description = $"GasLine FloorOverFlow Alarm",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = true,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });
            GasLineTcBrokenAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.GasLineTcBrokenAlarm",
                Description = $"GasLine TcBroken Alarm",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = true,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });
            GasLineOverTempAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.GasLineOverTempAlarm",
                Description = $"GasLine OverTemp Alarm",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = true,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });
            ForLineOverTempAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.ForLineOverTempAlarm",
                Description = $"ForLine OverTemp Alarm",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = true,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });
            ForLineCapsOverFlownAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.ForLineCapsOverFlownAlarm",
                Description = $"ForLine Caps OverFlown Alarm",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = true,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });
            ForLineFloorOverFlowAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.ForLineFloorOverFlowAlarm",
                Description = $"ForLine FloorOverFlow Alarm",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = true,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });
            ForLineTcBrokenAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.ForLineTcBrokenAlarm",
                Description = $"ForLine TcBroken Alarm",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = true,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "TubeAlarm",
            }, () => { return true; });
        }
        private void InitScheduleAlarmEvent()
        {

            RecipeExecuteFreqWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.RecipeExecuteFreqWarning",
                Description = $"",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "SystemAlarm",
            }, () => { return true; });
            RecipeExecuteFreqAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.RecipeExecuteFreqAlarm",
                Description = $"",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "SystemAlarm",
            }, () => { return true; });

            RecipeThicknessWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.RecipeThicknessWarning",
                Description = $"",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "SystemAlarm",
            }, () => { return true; });
            RecipeThicknessAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.RecipeThicknessAlarm",
                Description = $"",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "SystemAlarm",
            }, () => { return true; });
            BoatRecipeThicknessWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.BoatRecipeThicknessWarning",
                Description = $"BoatRecipeThicknessWarning",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "SystemAlarm",
            }, () => { return true; });
            BoatRecipeThicknessAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.BoatRecipeThicknessAlarm",
                Description = $"BoatRecipeThicknessAlarm",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "SystemAlarm",
            }, () => { return true; });
            ReatorStepRunTimeWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.ReatorStepRunTimeWarning",
                Description = $"ReatorStepRunTimeWarning",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "SystemAlarm",
            }, () => { return true; });

            ReatorStepRunTimeAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.ReatorStepRunTimeAlarm",
                Description = $"ReatorStepRunTimeAlarm",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "SystemAlarm",
            }, () => { return true; });

            ReatorStepRunFreqWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.ReatorStepRunFreqWarning",
                Description = $"ReatorStepRunFreqWarning",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "SystemAlarm",
            }, () => { return true; });
            ReatorStepRunFreqAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.ReatorStepRunFreqAlarm",
                Description = $"ReatorStepRunFreqAlarm",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "SystemAlarm",
            }, () => { return true; });
            ReatorStepThicknessWarning = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.ReatorStepThicknessWarning",
                Description = $"ReatorStepThicknessWarning",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Warning,
                Action = EventAction.Clear,
                Category = "SystemAlarm",
            }, () => { return true; });
            ReatorStepThicknessAlarm = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.ReatorStepThicknessAlarm",
                Description = $"ReatorStepThicknessAlarm",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "SystemAlarm",
            }, () => { return true; });

        }
        private void InitSensorAlarmEvent()
        {
            foreach (var item in _sensors)
            {
                if (item.Value == null)
                    continue;

                if (item.Value.SensorCategoryKey != ((int)SensorCategoryEnum.HWILK).ToString())
                    continue;

                CreateAlarmEventByIoSensor(item.Value);


            }

        }
        private void CreateAlarmEventByIoSensor(IoSensor ioSensor)
        {
            if (ioSensor != null)
            {
                var evenum = ioSensor.Name.Replace("Sensor", "AlarmSignal");
                var sensorAlarm = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.{evenum}",
                    Description = $"{ioSensor.Display}",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { return true; });

                HWILKAlarmDic.Add(ioSensor, sensorAlarm);

            }
        }
        private void InitIoAlarmSignalAlarmEvent()
        {
            if (AlarmSignalBufferA1N2LowPressureError != null)
            {
                SensorAlarmSignalBufferA1N2LowPressureError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalBufferA1N2LowPressureError",
                    Description = "Buffer A1 N2 Low Pressure Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalBufferA1N2LowPressureError.Reset(); return true; });
                AlarmSignalBufferA1N2LowPressureError.AlarmTriggered = SensorAlarmSignalBufferA1N2LowPressureError;
            }

            if (AlarmSignalBufferB1N2LowPressureError != null)
            {
                SensorAlarmSignalBufferB1N2LowPressureError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalBufferB1N2LowPressureError",
                    Description = "Buffer B1 N2 Low Pressure Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalBufferB1N2LowPressureError.Reset(); return true; });
                AlarmSignalBufferB1N2LowPressureError.AlarmTriggered = SensorAlarmSignalBufferB1N2LowPressureError;
            }

            if (AlarmSignalBufferC1N2LowPressureError != null)
            {
                SensorAlarmSignalBufferC1N2LowPressureError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalBufferC1N2LowPressureError",
                    Description = "Buffer C1 N2 Low Pressure Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalBufferC1N2LowPressureError.Reset(); return true; });
                AlarmSignalBufferC1N2LowPressureError.AlarmTriggered = SensorAlarmSignalBufferC1N2LowPressureError;
            }

            if (AlarmSignalBufferD1N2LowPressureError != null)
            {
                SensorAlarmSignalBufferD1N2LowPressureError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalBufferD1N2LowPressureError",
                    Description = "Buffer D1 N2 Low Pressure Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalBufferD1N2LowPressureError.Reset(); return true; });
                AlarmSignalBufferD1N2LowPressureError.AlarmTriggered = SensorAlarmSignalBufferD1N2LowPressureError;
            }

            if (AlarmSignalBufferA2N2LowPressureError != null)
            {
                SensorAlarmSignalBufferA2N2LowPressureError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalBufferA2N2LowPressureError",
                    Description = "Buffer A2 N2 Low Pressure Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalBufferA2N2LowPressureError.Reset(); return true; });
                AlarmSignalBufferA2N2LowPressureError.AlarmTriggered = SensorAlarmSignalBufferA2N2LowPressureError;
            }

            if (AlarmSignalBufferB2N2LowPressureError != null)
            {
                SensorAlarmSignalBufferB2N2LowPressureError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalBufferB2N2LowPressureError",
                    Description = "Buffer B2 N2 Low Pressure Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalBufferB2N2LowPressureError.Reset(); return true; });
                AlarmSignalBufferB2N2LowPressureError.AlarmTriggered = SensorAlarmSignalBufferB2N2LowPressureError;
            }

            if (AlarmSignalBufferC2N2LowPressureError != null)
            {
                SensorAlarmSignalBufferC2N2LowPressureError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalBufferC2N2LowPressureError",
                    Description = "Buffer C2 N2 Low Pressure Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalBufferC2N2LowPressureError.Reset(); return true; });
                AlarmSignalBufferC2N2LowPressureError.AlarmTriggered = SensorAlarmSignalBufferC2N2LowPressureError;
            }

            if (AlarmSignalBufferD2N2LowPressureError != null)
            {
                SensorAlarmSignalBufferD2N2LowPressureError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalBufferD2N2LowPressureError",
                    Description = "Buffer D2 N2 Low Pressure Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalBufferD2N2LowPressureError.Reset(); return true; });
                AlarmSignalBufferD2N2LowPressureError.AlarmTriggered = SensorAlarmSignalBufferD2N2LowPressureError;
            }

            if (AlarmSignalBufferA3N2LowPressureError != null)
            {
                SensorAlarmSignalBufferA3N2LowPressureError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalBufferA3N2LowPressureError",
                    Description = "Buffer A3 N2 Low Pressure Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalBufferA3N2LowPressureError.Reset(); return true; });
                AlarmSignalBufferA3N2LowPressureError.AlarmTriggered = SensorAlarmSignalBufferA3N2LowPressureError;
            }

            if (AlarmSignalBufferB3N2LowPressureError != null)
            {
                SensorAlarmSignalBufferB3N2LowPressureError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalBufferB3N2LowPressureError",
                    Description = "Buffer B3 N2 Low Pressure Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalBufferB3N2LowPressureError.Reset(); return true; });
                AlarmSignalBufferB3N2LowPressureError.AlarmTriggered = SensorAlarmSignalBufferB3N2LowPressureError;
            }

            if (AlarmSignalBufferC3N2LowPressureError != null)
            {
                SensorAlarmSignalBufferC3N2LowPressureError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalBufferC3N2LowPressureError",
                    Description = "Buffer C3 N2 Low Pressure Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalBufferC3N2LowPressureError.Reset(); return true; });
                AlarmSignalBufferC3N2LowPressureError.AlarmTriggered = SensorAlarmSignalBufferC3N2LowPressureError;
            }

            if (AlarmSignalBufferD3N2LowPressureError != null)
            {
                SensorAlarmSignalBufferD3N2LowPressureError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalBufferD3N2LowPressureError",
                    Description = "Buffer D3 N2 Low Pressure Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalBufferD3N2LowPressureError.Reset(); return true; });
                AlarmSignalBufferD3N2LowPressureError.AlarmTriggered = SensorAlarmSignalBufferD3N2LowPressureError;
            }

            if (AlarmSignalBufferA4N2LowPressureError != null)
            {
                SensorAlarmSignalBufferA4N2LowPressureError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalBufferA4N2LowPressureError",
                    Description = "Buffer A4 N2 Low Pressure Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalBufferA4N2LowPressureError.Reset(); return true; });
                AlarmSignalBufferA4N2LowPressureError.AlarmTriggered = SensorAlarmSignalBufferA4N2LowPressureError;
            }

            if (AlarmSignalBufferB4N2LowPressureError != null)
            {
                SensorAlarmSignalBufferB4N2LowPressureError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalBufferB4N2LowPressureError",
                    Description = "Buffer B4 N2 Low Pressure Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalBufferB4N2LowPressureError.Reset(); return true; });
                AlarmSignalBufferB4N2LowPressureError.AlarmTriggered = SensorAlarmSignalBufferB4N2LowPressureError;
            }

            if (AlarmSignalBufferC4N2LowPressureError != null)
            {
                SensorAlarmSignalBufferC4N2LowPressureError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalBufferC4N2LowPressureError",
                    Description = "Buffer C4 N2 Low Pressure Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalBufferC4N2LowPressureError.Reset(); return true; });
                AlarmSignalBufferC4N2LowPressureError.AlarmTriggered = SensorAlarmSignalBufferC4N2LowPressureError;
            }

            if (AlarmSignalBufferD4N2LowPressureError != null)
            {
                SensorAlarmSignalBufferD4N2LowPressureError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalBufferD4N2LowPressureError",
                    Description = "Buffer D4 N2 Low Pressure Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalBufferD4N2LowPressureError.Reset(); return true; });
                AlarmSignalBufferD4N2LowPressureError.AlarmTriggered = SensorAlarmSignalBufferD4N2LowPressureError;
            }


            if (AlarmSignalFIMS1LoadRunningError != null)
            {
                SensorAlarmSignalFIMS1LoadRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS1LoadRunningError",
                    Description = "E0000）FIMS1 Load Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS1LoadRunningError.Reset(); return true; });
                AlarmSignalFIMS1LoadRunningError.AlarmTriggered = SensorAlarmSignalFIMS1LoadRunningError;
            }

            if (AlarmSignalFIMS1UnloadRunningError != null)
            {
                SensorAlarmSignalFIMS1UnloadRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS1UnloadRunningError",
                    Description = "E0001）FIMS1 Unload Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS1UnloadRunningError.Reset(); return true; });
                AlarmSignalFIMS1UnloadRunningError.AlarmTriggered = SensorAlarmSignalFIMS1UnloadRunningError;
            }

            if (AlarmSignalFIMS1InitRunningError != null)
            {
                SensorAlarmSignalFIMS1InitRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS1InitRunningError",
                    Description = "E0002）FIMS1 Init Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS1InitRunningError.Reset(); return true; });
                AlarmSignalFIMS1InitRunningError.AlarmTriggered = SensorAlarmSignalFIMS1InitRunningError;
            }

            if (AlarmSignalFIMS2LoadRunningError != null)
            {
                SensorAlarmSignalFIMS2LoadRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS2LoadRunningError",
                    Description = "E0003）FIMS2 Load Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS2LoadRunningError.Reset(); return true; });
                AlarmSignalFIMS2LoadRunningError.AlarmTriggered = SensorAlarmSignalFIMS2LoadRunningError;
            }

            if (AlarmSignalFIMS2UnloadRunningError != null)
            {
                SensorAlarmSignalFIMS2UnloadRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS2UnloadRunningError",
                    Description = "E0004）FIMS2 Unload Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS2UnloadRunningError.Reset(); return true; });
                AlarmSignalFIMS2UnloadRunningError.AlarmTriggered = SensorAlarmSignalFIMS2UnloadRunningError;
            }

            if (AlarmSignalFIMS2InitRunningError != null)
            {
                SensorAlarmSignalFIMS2InitRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS2InitRunningError",
                    Description = "E0005）FIMS2 Init Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS2InitRunningError.Reset(); return true; });
                AlarmSignalFIMS2InitRunningError.AlarmTriggered = SensorAlarmSignalFIMS2InitRunningError;
            }

            if (AlarmSignalFIMS1UndockRunningError != null)
            {
                SensorAlarmSignalFIMS1UndockRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS1UndockRunningError",
                    Description = "E0006）FIMS1 Undock Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS1UndockRunningError.Reset(); return true; });
                AlarmSignalFIMS1UndockRunningError.AlarmTriggered = SensorAlarmSignalFIMS1UndockRunningError;
            }

            if (AlarmSignalFIMS1DockRunningError != null)
            {
                SensorAlarmSignalFIMS1DockRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS1DockRunningError",
                    Description = "E0007）FIMS1 Dock Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS1DockRunningError.Reset(); return true; });
                AlarmSignalFIMS1DockRunningError.AlarmTriggered = SensorAlarmSignalFIMS1DockRunningError;
            }

            if (AlarmSignalFIMS1VacuumOffRunningError != null)
            {
                SensorAlarmSignalFIMS1VacuumOffRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS1VacuumOffRunningError",
                    Description = "E0008）FIMS1 Vacuum Off Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS1VacuumOffRunningError.Reset(); return true; });
                AlarmSignalFIMS1VacuumOffRunningError.AlarmTriggered = SensorAlarmSignalFIMS1VacuumOffRunningError;
            }

            if (AlarmSignalFIMS1VacuumOnRunningError != null)
            {
                SensorAlarmSignalFIMS1VacuumOnRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS1VacuumOnRunningError",
                    Description = "E0009）FIMS1 Vacuum On Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS1VacuumOnRunningError.Reset(); return true; });
                AlarmSignalFIMS1VacuumOnRunningError.AlarmTriggered = SensorAlarmSignalFIMS1VacuumOnRunningError;
            }

            if (AlarmSignalFIMS1N2Closed != null)
            {
                SensorAlarmSignalFIMS1N2Closed = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS1N2Closed",
                    Description = "E0010）FIMS1 N2 Closed",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS1N2Closed.Reset(); return true; });
                AlarmSignalFIMS1N2Closed.AlarmTriggered = SensorAlarmSignalFIMS1N2Closed;
            }

            if (AlarmSignalFIMS1N2Opened != null)
            {
                SensorAlarmSignalFIMS1N2Opened = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS1N2Opened",
                    Description = "E0011）FIMS1 N2 Opened",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS1N2Opened.Reset(); return true; });
                AlarmSignalFIMS1N2Opened.AlarmTriggered = SensorAlarmSignalFIMS1N2Opened;
            }

            if (AlarmSignalFIMS1ReleaseRunningError != null)
            {
                SensorAlarmSignalFIMS1ReleaseRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS1ReleaseRunningError",
                    Description = "E0012）FIMS1 Release Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS1ReleaseRunningError.Reset(); return true; });
                AlarmSignalFIMS1ReleaseRunningError.AlarmTriggered = SensorAlarmSignalFIMS1ReleaseRunningError;
            }

            if (AlarmSignalFIMS1SealRunningError != null)
            {
                SensorAlarmSignalFIMS1SealRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS1SealRunningError",
                    Description = "E0013）FIMS1 Seal Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS1SealRunningError.Reset(); return true; });
                AlarmSignalFIMS1SealRunningError.AlarmTriggered = SensorAlarmSignalFIMS1SealRunningError;
            }

            if (AlarmSignalFIMS1SlideCloseRunningError != null)
            {
                SensorAlarmSignalFIMS1SlideCloseRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS1SlideCloseRunningError",
                    Description = "E0014）FIMS1 Slide Close Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS1SlideCloseRunningError.Reset(); return true; });
                AlarmSignalFIMS1SlideCloseRunningError.AlarmTriggered = SensorAlarmSignalFIMS1SlideCloseRunningError;
            }

            if (AlarmSignalFIMS1SlideOpenRunningError != null)
            {
                SensorAlarmSignalFIMS1SlideOpenRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS1SlideOpenRunningError",
                    Description = "E0015）FIMS1 Slide Open Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS1SlideOpenRunningError.Reset(); return true; });
                AlarmSignalFIMS1SlideOpenRunningError.AlarmTriggered = SensorAlarmSignalFIMS1SlideOpenRunningError;
            }

            if (AlarmSignalFIMS1LatchKeyOnRunningError != null)
            {
                SensorAlarmSignalFIMS1LatchKeyOnRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS1LatchKeyOnRunningError",
                    Description = "E0016）FIMS1 Latch Key On Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS1LatchKeyOnRunningError.Reset(); return true; });
                AlarmSignalFIMS1LatchKeyOnRunningError.AlarmTriggered = SensorAlarmSignalFIMS1LatchKeyOnRunningError;
            }

            if (AlarmSignalFIMS1LatchKeyOffRunningError != null)
            {
                SensorAlarmSignalFIMS1LatchKeyOffRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS1LatchKeyOffRunningError",
                    Description = "E0017）FIMS1 Latch Key Off Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS1LatchKeyOffRunningError.Reset(); return true; });
                AlarmSignalFIMS1LatchKeyOffRunningError.AlarmTriggered = SensorAlarmSignalFIMS1LatchKeyOffRunningError;
            }

            if (AlarmSignalFIMS1N2ReleaseRunningError != null)
            {
                SensorAlarmSignalFIMS1N2ReleaseRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS1N2ReleaseRunningError",
                    Description = "E0018）FIMS1 N2 Release Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS1N2ReleaseRunningError.Reset(); return true; });
                AlarmSignalFIMS1N2ReleaseRunningError.AlarmTriggered = SensorAlarmSignalFIMS1N2ReleaseRunningError;
            }

            if (AlarmSignalFIMS1N2SealRunningError != null)
            {
                SensorAlarmSignalFIMS1N2SealRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS1N2SealRunningError",
                    Description = "E0019）FIMS1 N2 Seal Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS1N2SealRunningError.Reset(); return true; });
                AlarmSignalFIMS1N2SealRunningError.AlarmTriggered = SensorAlarmSignalFIMS1N2SealRunningError;
            }

            if (AlarmSignalFIMS2UnDockRunningError != null)
            {
                SensorAlarmSignalFIMS2UnDockRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS2UnDockRunningError",
                    Description = "E0020）FIMS2 UnDock Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS2UnDockRunningError.Reset(); return true; });
                AlarmSignalFIMS2UnDockRunningError.AlarmTriggered = SensorAlarmSignalFIMS2UnDockRunningError;
            }

            if (AlarmSignalFIMS2DockRunningError != null)
            {
                SensorAlarmSignalFIMS2DockRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS2DockRunningError",
                    Description = "E0021）FIMS2 Dock Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS2DockRunningError.Reset(); return true; });
                AlarmSignalFIMS2DockRunningError.AlarmTriggered = SensorAlarmSignalFIMS2DockRunningError;
            }

            if (AlarmSignalFIMS2VacuumOffRunningError != null)
            {
                SensorAlarmSignalFIMS2VacuumOffRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS2VacuumOffRunningError",
                    Description = "E0022）FIMS2 Vacuum Off Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS2VacuumOffRunningError.Reset(); return true; });
                AlarmSignalFIMS2VacuumOffRunningError.AlarmTriggered = SensorAlarmSignalFIMS2VacuumOffRunningError;
            }

            if (AlarmSignalFIMS2VacuumOnRunningError != null)
            {
                SensorAlarmSignalFIMS2VacuumOnRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS2VacuumOnRunningError",
                    Description = "E0023）FIMS2 Vacuum On Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS2VacuumOnRunningError.Reset(); return true; });
                AlarmSignalFIMS2VacuumOnRunningError.AlarmTriggered = SensorAlarmSignalFIMS2VacuumOnRunningError;
            }

            if (AlarmSignalFIMS2N2Closed != null)
            {
                SensorAlarmSignalFIMS2N2Closed = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS2N2Closed",
                    Description = "E0024）FIMS2 N2 Closed",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS2N2Closed.Reset(); return true; });
                AlarmSignalFIMS2N2Closed.AlarmTriggered = SensorAlarmSignalFIMS2N2Closed;
            }

            if (AlarmSignalFIMS2N2Opened != null)
            {
                SensorAlarmSignalFIMS2N2Opened = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS2N2Opened",
                    Description = "E0025）FIMS2 N2 Opened",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS2N2Opened.Reset(); return true; });
                AlarmSignalFIMS2N2Opened.AlarmTriggered = SensorAlarmSignalFIMS2N2Opened;
            }

            if (AlarmSignalFIMS2SealRunningError != null)
            {
                SensorAlarmSignalFIMS2SealRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS2SealRunningError",
                    Description = "E0026）FIMS2 Seal Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS2SealRunningError.Reset(); return true; });
                AlarmSignalFIMS2SealRunningError.AlarmTriggered = SensorAlarmSignalFIMS2SealRunningError;
            }

            if (AlarmSignalFIMS2ReleaseRunningError != null)
            {
                SensorAlarmSignalFIMS2ReleaseRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS2ReleaseRunningError",
                    Description = "E0027）FIMS2 Release Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS2ReleaseRunningError.Reset(); return true; });
                AlarmSignalFIMS2ReleaseRunningError.AlarmTriggered = SensorAlarmSignalFIMS2ReleaseRunningError;
            }

            if (AlarmSignalFIMS2SlideCloseRunningError != null)
            {
                SensorAlarmSignalFIMS2SlideCloseRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS2SlideCloseRunningError",
                    Description = "E0028）FIMS2 Slide Close Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS2SlideCloseRunningError.Reset(); return true; });
                AlarmSignalFIMS2SlideCloseRunningError.AlarmTriggered = SensorAlarmSignalFIMS2SlideCloseRunningError;
            }

            if (AlarmSignalFIMS2SlideOpenRunningError != null)
            {
                SensorAlarmSignalFIMS2SlideOpenRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS2SlideOpenRunningError",
                    Description = "E0029）FIMS2 Slide Open Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS2SlideOpenRunningError.Reset(); return true; });
                AlarmSignalFIMS2SlideOpenRunningError.AlarmTriggered = SensorAlarmSignalFIMS2SlideOpenRunningError;
            }

            if (AlarmSignalFIMS2LatchKeyOnRunningError != null)
            {
                SensorAlarmSignalFIMS2LatchKeyOnRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS2LatchKeyOnRunningError",
                    Description = "E0030）FIMS2 Latch Key On Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS2LatchKeyOnRunningError.Reset(); return true; });
                AlarmSignalFIMS2LatchKeyOnRunningError.AlarmTriggered = SensorAlarmSignalFIMS2LatchKeyOnRunningError;
            }

            if (AlarmSignalFIMS2LatchKeyOffRunningError != null)
            {
                SensorAlarmSignalFIMS2LatchKeyOffRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS2LatchKeyOffRunningError",
                    Description = "E0031）FIMS2 Latch Key Off Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS2LatchKeyOffRunningError.Reset(); return true; });
                AlarmSignalFIMS2LatchKeyOffRunningError.AlarmTriggered = SensorAlarmSignalFIMS2LatchKeyOffRunningError;
            }

            if (AlarmSignalFIMS2N2ReleaseRunningError != null)
            {
                SensorAlarmSignalFIMS2N2ReleaseRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS2N2ReleaseRunningError",
                    Description = "E0032）FIMS2 N2 Release Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS2N2ReleaseRunningError.Reset(); return true; });
                AlarmSignalFIMS2N2ReleaseRunningError.AlarmTriggered = SensorAlarmSignalFIMS2N2ReleaseRunningError;
            }

            if (AlarmSignalFIMS2N2SealRunningError != null)
            {
                SensorAlarmSignalFIMS2N2SealRunningError = SubscribeAlarm(new AlarmEventItem()
                {
                    EventEnum = $"{Name}.AlarmSignalFIMS2N2SealRunningError",
                    Description = "E0033）FIMS2 N2 Seal Running Error",
                    Solution = "No information available. Press [Clear] to delete alarm message.",
                    Explaination = "No information available.",
                    AutoRecovery = true,
                    Level = EventLevel.Alarm,
                    Action = EventAction.Clear,
                    Category = "TubeAlarm",
                }, () => { AlarmSignalFIMS2N2SealRunningError.Reset(); return true; });
                AlarmSignalFIMS2N2SealRunningError.AlarmTriggered = SensorAlarmSignalFIMS2N2SealRunningError;
            }


        }

        private bool ResetRecipeErrorAlarm()
        {
            return true;
        }
        private bool ResetRecipeFinishedAbnormallyAlarm()
        {
            return true;
        }
        private bool ResetTemperatureConvergenceTimeOutAlarm()
        {
            return true;
        }
        private bool ResetPressureConvergenceTimeOutAlarm()
        {
            return true;
        }
        private bool ResetAutoProfileTimeOutAlarm()
        {
            return true;
        }
        private bool ResetFlowConvergenceTimeOutAlarm()
        {
            return true;
        }
        private bool ResetBoatMoveTimeOutAlarm()
        {
            return true;
        }
        private bool ResetInputSignalTimeOutAlarm()
        {
            return true;
        }

        private bool ResetEmergencyAbort()
        {
            return true;
        }

        private bool ResetRecipeExecutionError()
        {
            return true;
        }
    }
}