//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Tango Observables Generator
// 
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated. Do not modify!
// </auto-generated>
//------------------------------------------------------------------------------

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Xml.Serialization;
using Newtonsoft.Json;
using System.Linq;
using Tango.DAL.Remote.DB;
using Tango.Core;
using System.ComponentModel;
using Tango.Core.CustomAttributes;

namespace Tango.BL.Entities
{
    [Table("HARDWARE_PID_CONTROLS")]
    public abstract class HardwarePidControlBase : ObservableEntity<HardwarePidControl>
    {

        public event EventHandler<Double> OutputProportionalPowerLimitChanged;

        public event EventHandler<Double> OutputProportionalBandChanged;

        public event EventHandler<Double> IntegralTimeChanged;

        public event EventHandler<Double> DerivativeTimeChanged;

        public event EventHandler<Double> SensorCorrectionAdjustmentChanged;

        public event EventHandler<Double> SensorMinValueChanged;

        public event EventHandler<Double> SensorMaxValueChanged;

        public event EventHandler<Double> SetPointRampRateorSoftStartRampChanged;

        public event EventHandler<Double> SetPointControlOutputRateChanged;

        public event EventHandler<Double> ControlOutputTypeChanged;

        public event EventHandler<Double> SsrControlOutputTypeChanged;

        public event EventHandler<Double> OutputOnOffHysteresisValueChanged;

        public event EventHandler<Double> ProcessVariableSamplingRateChanged;

        public event EventHandler<Double> PvInputFilterFactorModeChanged;

        public event EventHandler<Int32> OutputProportionalCycleTimeChanged;

        public event EventHandler<Int32> AcHeatersHalfCycleTimeChanged;

        public event EventHandler<Double> ProportionalGainChanged;

        public event EventHandler<Boolean> PidActiveChanged;

        public event EventHandler<Double> EpsilonChanged;

        public event EventHandler<Boolean> ActiveChanged;

        public event EventHandler<HardwarePidControlType> HardwarePidControlTypeChanged;

        public event EventHandler<HardwareVersion> HardwareVersionChanged;

        protected String _hardwarepidcontroltypeguid;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase hardware pid control type guid.
        /// </summary>

        [Column("HARDWARE_PID_CONTROL_TYPE_GUID")]
        [ForeignKey("HardwarePidControlType")]

        public  String HardwarePidControlTypeGuid
        {
            get 
            {
                return _hardwarepidcontroltypeguid; 
            }

            set 
            {
                if (_hardwarepidcontroltypeguid != value)
                {
                    _hardwarepidcontroltypeguid = value;

                }
            }
        }

        protected String _hardwareversionguid;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase hardware version guid.
        /// </summary>

        [Column("HARDWARE_VERSION_GUID")]
        [ForeignKey("HardwareVersion")]

        public  String HardwareVersionGuid
        {
            get 
            {
                return _hardwareversionguid; 
            }

            set 
            {
                if (_hardwareversionguid != value)
                {
                    _hardwareversionguid = value;

                }
            }
        }

        protected Double _outputproportionalpowerlimit;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase output proportional power limit.
        /// </summary>

        [Column("OUTPUT_PROPORTIONAL_POWER_LIMIT")]

        public  Double OutputProportionalPowerLimit
        {
            get 
            {
                return _outputproportionalpowerlimit; 
            }

            set 
            {
                if (_outputproportionalpowerlimit != value)
                {
                    _outputproportionalpowerlimit = value;

                    OnOutputProportionalPowerLimitChanged(value);

                }
            }
        }

        protected Double _outputproportionalband;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase output proportional band.
        /// </summary>

        [Column("OUTPUT_PROPORTIONAL_BAND")]

        public  Double OutputProportionalBand
        {
            get 
            {
                return _outputproportionalband; 
            }

            set 
            {
                if (_outputproportionalband != value)
                {
                    _outputproportionalband = value;

                    OnOutputProportionalBandChanged(value);

                }
            }
        }

        protected Double _integraltime;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase integral time.
        /// </summary>

        [Column("INTEGRAL_TIME")]

        public  Double IntegralTime
        {
            get 
            {
                return _integraltime; 
            }

            set 
            {
                if (_integraltime != value)
                {
                    _integraltime = value;

                    OnIntegralTimeChanged(value);

                }
            }
        }

        protected Double _derivativetime;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase derivative time.
        /// </summary>

        [Column("DERIVATIVE_TIME")]

        public  Double DerivativeTime
        {
            get 
            {
                return _derivativetime; 
            }

            set 
            {
                if (_derivativetime != value)
                {
                    _derivativetime = value;

                    OnDerivativeTimeChanged(value);

                }
            }
        }

        protected Double _sensorcorrectionadjustment;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase sensor correction adjustment.
        /// </summary>

        [Column("SENSOR_CORRECTION_ADJUSTMENT")]

        public  Double SensorCorrectionAdjustment
        {
            get 
            {
                return _sensorcorrectionadjustment; 
            }

            set 
            {
                if (_sensorcorrectionadjustment != value)
                {
                    _sensorcorrectionadjustment = value;

                    OnSensorCorrectionAdjustmentChanged(value);

                }
            }
        }

        protected Double _sensorminvalue;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase sensor min value.
        /// </summary>

        [Column("SENSOR_MIN_VALUE")]

        public  Double SensorMinValue
        {
            get 
            {
                return _sensorminvalue; 
            }

            set 
            {
                if (_sensorminvalue != value)
                {
                    _sensorminvalue = value;

                    OnSensorMinValueChanged(value);

                }
            }
        }

        protected Double _sensormaxvalue;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase sensor max value.
        /// </summary>

        [Column("SENSOR_MAX_VALUE")]

        public  Double SensorMaxValue
        {
            get 
            {
                return _sensormaxvalue; 
            }

            set 
            {
                if (_sensormaxvalue != value)
                {
                    _sensormaxvalue = value;

                    OnSensorMaxValueChanged(value);

                }
            }
        }

        protected Double _setpointramprateorsoftstartramp;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase set point ramp rateor soft start ramp.
        /// </summary>

        [Column("SET_POINT_RAMP_RATEOR_SOFT_START_RAMP")]

        public  Double SetPointRampRateorSoftStartRamp
        {
            get 
            {
                return _setpointramprateorsoftstartramp; 
            }

            set 
            {
                if (_setpointramprateorsoftstartramp != value)
                {
                    _setpointramprateorsoftstartramp = value;

                    OnSetPointRampRateorSoftStartRampChanged(value);

                }
            }
        }

        protected Double _setpointcontroloutputrate;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase set point control output rate.
        /// </summary>

        [Column("SET_POINT_CONTROL_OUTPUT_RATE")]

        public  Double SetPointControlOutputRate
        {
            get 
            {
                return _setpointcontroloutputrate; 
            }

            set 
            {
                if (_setpointcontroloutputrate != value)
                {
                    _setpointcontroloutputrate = value;

                    OnSetPointControlOutputRateChanged(value);

                }
            }
        }

        protected Double _controloutputtype;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase control output type.
        /// </summary>

        [Column("CONTROL_OUTPUT_TYPE")]

        public  Double ControlOutputType
        {
            get 
            {
                return _controloutputtype; 
            }

            set 
            {
                if (_controloutputtype != value)
                {
                    _controloutputtype = value;

                    OnControlOutputTypeChanged(value);

                }
            }
        }

        protected Double _ssrcontroloutputtype;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase ssr control output type.
        /// </summary>

        [Column("SSR_CONTROL_OUTPUT_TYPE")]

        public  Double SsrControlOutputType
        {
            get 
            {
                return _ssrcontroloutputtype; 
            }

            set 
            {
                if (_ssrcontroloutputtype != value)
                {
                    _ssrcontroloutputtype = value;

                    OnSsrControlOutputTypeChanged(value);

                }
            }
        }

        protected Double _outputonoffhysteresisvalue;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase output on off hysteresis value.
        /// </summary>

        [Column("OUTPUT_ON_OFF_HYSTERESIS_VALUE")]

        public  Double OutputOnOffHysteresisValue
        {
            get 
            {
                return _outputonoffhysteresisvalue; 
            }

            set 
            {
                if (_outputonoffhysteresisvalue != value)
                {
                    _outputonoffhysteresisvalue = value;

                    OnOutputOnOffHysteresisValueChanged(value);

                }
            }
        }

        protected Double _processvariablesamplingrate;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase process variable sampling rate.
        /// </summary>

        [Column("PROCESS_VARIABLE_SAMPLING_RATE")]

        public  Double ProcessVariableSamplingRate
        {
            get 
            {
                return _processvariablesamplingrate; 
            }

            set 
            {
                if (_processvariablesamplingrate != value)
                {
                    _processvariablesamplingrate = value;

                    OnProcessVariableSamplingRateChanged(value);

                }
            }
        }

        protected Double _pvinputfilterfactormode;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase pv input filter factor mode.
        /// </summary>

        [Column("PV_INPUT_FILTER_FACTOR_MODE")]

        public  Double PvInputFilterFactorMode
        {
            get 
            {
                return _pvinputfilterfactormode; 
            }

            set 
            {
                if (_pvinputfilterfactormode != value)
                {
                    _pvinputfilterfactormode = value;

                    OnPvInputFilterFactorModeChanged(value);

                }
            }
        }

        protected Int32 _outputproportionalcycletime;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase output proportional cycle time.
        /// </summary>

        [Column("OUTPUT_PROPORTIONAL_CYCLE_TIME")]

        public  Int32 OutputProportionalCycleTime
        {
            get 
            {
                return _outputproportionalcycletime; 
            }

            set 
            {
                if (_outputproportionalcycletime != value)
                {
                    _outputproportionalcycletime = value;

                    OnOutputProportionalCycleTimeChanged(value);

                }
            }
        }

        protected Int32 _acheatershalfcycletime;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase ac heaters  half cycle time.
        /// </summary>

        [Column("AC_HEATERS__HALF_CYCLE_TIME")]

        public  Int32 AcHeatersHalfCycleTime
        {
            get 
            {
                return _acheatershalfcycletime; 
            }

            set 
            {
                if (_acheatershalfcycletime != value)
                {
                    _acheatershalfcycletime = value;

                    OnAcHeatersHalfCycleTimeChanged(value);

                }
            }
        }

        protected Double _proportionalgain;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase proportional gain.
        /// </summary>

        [Column("PROPORTIONAL_GAIN")]

        public  Double ProportionalGain
        {
            get 
            {
                return _proportionalgain; 
            }

            set 
            {
                if (_proportionalgain != value)
                {
                    _proportionalgain = value;

                    OnProportionalGainChanged(value);

                }
            }
        }

        protected Boolean _pidactive;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase pid active.
        /// </summary>

        [Column("PID_ACTIVE")]

        public  Boolean PidActive
        {
            get 
            {
                return _pidactive; 
            }

            set 
            {
                if (_pidactive != value)
                {
                    _pidactive = value;

                    OnPidActiveChanged(value);

                }
            }
        }

        protected Double _epsilon;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase epsilon.
        /// </summary>

        [Column("EPSILON")]

        public  Double Epsilon
        {
            get 
            {
                return _epsilon; 
            }

            set 
            {
                if (_epsilon != value)
                {
                    _epsilon = value;

                    OnEpsilonChanged(value);

                }
            }
        }

        protected Boolean _active;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase active.
        /// </summary>

        [Column("ACTIVE")]

        public  Boolean Active
        {
            get 
            {
                return _active; 
            }

            set 
            {
                if (_active != value)
                {
                    _active = value;

                    OnActiveChanged(value);

                }
            }
        }

        protected HardwarePidControlType _hardwarepidcontroltype;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase hardware pid control types.
        /// </summary>

        [XmlIgnore]
        [JsonIgnore]
        public virtual HardwarePidControlType HardwarePidControlType
        {
            get 
            {
                return _hardwarepidcontroltype; 
            }

            set 
            {
                if (_hardwarepidcontroltype != value)
                {
                    _hardwarepidcontroltype = value;

                    if (HardwarePidControlType != null)
                    {
                        HardwarePidControlTypeGuid = HardwarePidControlType.Guid;
                    }

                    OnHardwarePidControlTypeChanged(value);

                }
            }
        }

        protected HardwareVersion _hardwareversion;

        /// <summary>
        /// Gets or sets the hardwarepidcontrolbase hardware versions.
        /// </summary>

        [XmlIgnore]
        [JsonIgnore]
        public virtual HardwareVersion HardwareVersion
        {
            get 
            {
                return _hardwareversion; 
            }

            set 
            {
                if (_hardwareversion != value)
                {
                    _hardwareversion = value;

                    if (HardwareVersion != null)
                    {
                        HardwareVersionGuid = HardwareVersion.Guid;
                    }

                    OnHardwareVersionChanged(value);

                }
            }
        }

        /// <summary>
        /// Called when the OutputProportionalPowerLimit has changed.
        /// </summary>
        protected virtual void OnOutputProportionalPowerLimitChanged(Double outputproportionalpowerlimit)
        {
            OutputProportionalPowerLimitChanged?.Invoke(this, outputproportionalpowerlimit);
            RaisePropertyChanged(nameof(OutputProportionalPowerLimit));
        }

        /// <summary>
        /// Called when the OutputProportionalBand has changed.
        /// </summary>
        protected virtual void OnOutputProportionalBandChanged(Double outputproportionalband)
        {
            OutputProportionalBandChanged?.Invoke(this, outputproportionalband);
            RaisePropertyChanged(nameof(OutputProportionalBand));
        }

        /// <summary>
        /// Called when the IntegralTime has changed.
        /// </summary>
        protected virtual void OnIntegralTimeChanged(Double integraltime)
        {
            IntegralTimeChanged?.Invoke(this, integraltime);
            RaisePropertyChanged(nameof(IntegralTime));
        }

        /// <summary>
        /// Called when the DerivativeTime has changed.
        /// </summary>
        protected virtual void OnDerivativeTimeChanged(Double derivativetime)
        {
            DerivativeTimeChanged?.Invoke(this, derivativetime);
            RaisePropertyChanged(nameof(DerivativeTime));
        }

        /// <summary>
        /// Called when the SensorCorrectionAdjustment has changed.
        /// </summary>
        protected virtual void OnSensorCorrectionAdjustmentChanged(Double sensorcorrectionadjustment)
        {
            SensorCorrectionAdjustmentChanged?.Invoke(this, sensorcorrectionadjustment);
            RaisePropertyChanged(nameof(SensorCorrectionAdjustment));
        }

        /// <summary>
        /// Called when the SensorMinValue has changed.
        /// </summary>
        protected virtual void OnSensorMinValueChanged(Double sensorminvalue)
        {
            SensorMinValueChanged?.Invoke(this, sensorminvalue);
            RaisePropertyChanged(nameof(SensorMinValue));
        }

        /// <summary>
        /// Called when the SensorMaxValue has changed.
        /// </summary>
        protected virtual void OnSensorMaxValueChanged(Double sensormaxvalue)
        {
            SensorMaxValueChanged?.Invoke(this, sensormaxvalue);
            RaisePropertyChanged(nameof(SensorMaxValue));
        }

        /// <summary>
        /// Called when the SetPointRampRateorSoftStartRamp has changed.
        /// </summary>
        protected virtual void OnSetPointRampRateorSoftStartRampChanged(Double setpointramprateorsoftstartramp)
        {
            SetPointRampRateorSoftStartRampChanged?.Invoke(this, setpointramprateorsoftstartramp);
            RaisePropertyChanged(nameof(SetPointRampRateorSoftStartRamp));
        }

        /// <summary>
        /// Called when the SetPointControlOutputRate has changed.
        /// </summary>
        protected virtual void OnSetPointControlOutputRateChanged(Double setpointcontroloutputrate)
        {
            SetPointControlOutputRateChanged?.Invoke(this, setpointcontroloutputrate);
            RaisePropertyChanged(nameof(SetPointControlOutputRate));
        }

        /// <summary>
        /// Called when the ControlOutputType has changed.
        /// </summary>
        protected virtual void OnControlOutputTypeChanged(Double controloutputtype)
        {
            ControlOutputTypeChanged?.Invoke(this, controloutputtype);
            RaisePropertyChanged(nameof(ControlOutputType));
        }

        /// <summary>
        /// Called when the SsrControlOutputType has changed.
        /// </summary>
        protected virtual void OnSsrControlOutputTypeChanged(Double ssrcontroloutputtype)
        {
            SsrControlOutputTypeChanged?.Invoke(this, ssrcontroloutputtype);
            RaisePropertyChanged(nameof(SsrControlOutputType));
        }

        /// <summary>
        /// Called when the OutputOnOffHysteresisValue has changed.
        /// </summary>
        protected virtual void OnOutputOnOffHysteresisValueChanged(Double outputonoffhysteresisvalue)
        {
            OutputOnOffHysteresisValueChanged?.Invoke(this, outputonoffhysteresisvalue);
            RaisePropertyChanged(nameof(OutputOnOffHysteresisValue));
        }

        /// <summary>
        /// Called when the ProcessVariableSamplingRate has changed.
        /// </summary>
        protected virtual void OnProcessVariableSamplingRateChanged(Double processvariablesamplingrate)
        {
            ProcessVariableSamplingRateChanged?.Invoke(this, processvariablesamplingrate);
            RaisePropertyChanged(nameof(ProcessVariableSamplingRate));
        }

        /// <summary>
        /// Called when the PvInputFilterFactorMode has changed.
        /// </summary>
        protected virtual void OnPvInputFilterFactorModeChanged(Double pvinputfilterfactormode)
        {
            PvInputFilterFactorModeChanged?.Invoke(this, pvinputfilterfactormode);
            RaisePropertyChanged(nameof(PvInputFilterFactorMode));
        }

        /// <summary>
        /// Called when the OutputProportionalCycleTime has changed.
        /// </summary>
        protected virtual void OnOutputProportionalCycleTimeChanged(Int32 outputproportionalcycletime)
        {
            OutputProportionalCycleTimeChanged?.Invoke(this, outputproportionalcycletime);
            RaisePropertyChanged(nameof(OutputProportionalCycleTime));
        }

        /// <summary>
        /// Called when the AcHeatersHalfCycleTime has changed.
        /// </summary>
        protected virtual void OnAcHeatersHalfCycleTimeChanged(Int32 acheatershalfcycletime)
        {
            AcHeatersHalfCycleTimeChanged?.Invoke(this, acheatershalfcycletime);
            RaisePropertyChanged(nameof(AcHeatersHalfCycleTime));
        }

        /// <summary>
        /// Called when the ProportionalGain has changed.
        /// </summary>
        protected virtual void OnProportionalGainChanged(Double proportionalgain)
        {
            ProportionalGainChanged?.Invoke(this, proportionalgain);
            RaisePropertyChanged(nameof(ProportionalGain));
        }

        /// <summary>
        /// Called when the PidActive has changed.
        /// </summary>
        protected virtual void OnPidActiveChanged(Boolean pidactive)
        {
            PidActiveChanged?.Invoke(this, pidactive);
            RaisePropertyChanged(nameof(PidActive));
        }

        /// <summary>
        /// Called when the Epsilon has changed.
        /// </summary>
        protected virtual void OnEpsilonChanged(Double epsilon)
        {
            EpsilonChanged?.Invoke(this, epsilon);
            RaisePropertyChanged(nameof(Epsilon));
        }

        /// <summary>
        /// Called when the Active has changed.
        /// </summary>
        protected virtual void OnActiveChanged(Boolean active)
        {
            ActiveChanged?.Invoke(this, active);
            RaisePropertyChanged(nameof(Active));
        }

        /// <summary>
        /// Called when the HardwarePidControlType has changed.
        /// </summary>
        protected virtual void OnHardwarePidControlTypeChanged(HardwarePidControlType hardwarepidcontroltype)
        {
            HardwarePidControlTypeChanged?.Invoke(this, hardwarepidcontroltype);
            RaisePropertyChanged(nameof(HardwarePidControlType));
        }

        /// <summary>
        /// Called when the HardwareVersion has changed.
        /// </summary>
        protected virtual void OnHardwareVersionChanged(HardwareVersion hardwareversion)
        {
            HardwareVersionChanged?.Invoke(this, hardwareversion);
            RaisePropertyChanged(nameof(HardwareVersion));
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HardwarePidControlBase" /> class.
        /// </summary>
        public HardwarePidControlBase() : base()
        {
        }
    }
}