//------------------------------------------------------------------------------
// <auto-generated>
//     Dieser Code wurde von einem Tool generiert.
//     Laufzeitversion:4.0.30319.42000
//
//     Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn
//     der Code erneut generiert wird.
// </auto-generated>
//------------------------------------------------------------------------------

using NMF.Collections.Generic;
using NMF.Collections.ObjectModel;
using NMF.Expressions;
using NMF.Expressions.Linq;
using NMF.Models;
using NMF.Models.Collections;
using NMF.Models.Expressions;
using NMF.Models.Meta;
using NMF.Models.Repository;
using NMF.Serialization;
using NMF.Utilities;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using TTC2017.SmartGrids.CIM.IEC61970.Core;
using TTC2017.SmartGrids.CIM.IEC61970.Generation.Production;
using TTC2017.SmartGrids.CIM.IEC61970.Wires;

namespace TTC2017.SmartGrids.CIM.IEC61970.Generation.GenerationDynamics
{
    
    
    /// <summary>
    /// The default implementation of the FossilSteamSupply class
    /// </summary>
    [XmlNamespaceAttribute("http://iec.ch/TC57/2009/CIM-schema-cim14#GenerationDynamics")]
    [XmlNamespacePrefixAttribute("cimGenerationDynamics")]
    [ModelRepresentationClassAttribute("http://iec.ch/TC57/2009/CIM-schema-cim14#//IEC61970/Generation/GenerationDynamics" +
        "/FossilSteamSupply")]
    [DebuggerDisplayAttribute("FossilSteamSupply {UUID}")]
    public partial class FossilSteamSupply : SteamSupply, IFossilSteamSupply, IModelElement
    {
        
        /// <summary>
        /// The backing field for the PressureCtrlPG property
        /// </summary>
        private float _pressureCtrlPG;
        
        private static Lazy<ITypedElement> _pressureCtrlPGAttribute = new Lazy<ITypedElement>(RetrievePressureCtrlPGAttribute);
        
        /// <summary>
        /// The backing field for the SuperHeater1Capacity property
        /// </summary>
        private float _superHeater1Capacity;
        
        private static Lazy<ITypedElement> _superHeater1CapacityAttribute = new Lazy<ITypedElement>(RetrieveSuperHeater1CapacityAttribute);
        
        /// <summary>
        /// The backing field for the FeedWaterPG property
        /// </summary>
        private float _feedWaterPG;
        
        private static Lazy<ITypedElement> _feedWaterPGAttribute = new Lazy<ITypedElement>(RetrieveFeedWaterPGAttribute);
        
        /// <summary>
        /// The backing field for the ControlTC property
        /// </summary>
        private float _controlTC;
        
        private static Lazy<ITypedElement> _controlTCAttribute = new Lazy<ITypedElement>(RetrieveControlTCAttribute);
        
        /// <summary>
        /// The backing field for the MechPowerSensorLag property
        /// </summary>
        private float _mechPowerSensorLag;
        
        private static Lazy<ITypedElement> _mechPowerSensorLagAttribute = new Lazy<ITypedElement>(RetrieveMechPowerSensorLagAttribute);
        
        /// <summary>
        /// The backing field for the ThrottlePressureSP property
        /// </summary>
        private float _throttlePressureSP;
        
        private static Lazy<ITypedElement> _throttlePressureSPAttribute = new Lazy<ITypedElement>(RetrieveThrottlePressureSPAttribute);
        
        /// <summary>
        /// The backing field for the MaxErrorRateP property
        /// </summary>
        private float _maxErrorRateP;
        
        private static Lazy<ITypedElement> _maxErrorRatePAttribute = new Lazy<ITypedElement>(RetrieveMaxErrorRatePAttribute);
        
        /// <summary>
        /// The backing field for the ControlIC property
        /// </summary>
        private float _controlIC;
        
        private static Lazy<ITypedElement> _controlICAttribute = new Lazy<ITypedElement>(RetrieveControlICAttribute);
        
        /// <summary>
        /// The backing field for the MinErrorRateP property
        /// </summary>
        private float _minErrorRateP;
        
        private static Lazy<ITypedElement> _minErrorRatePAttribute = new Lazy<ITypedElement>(RetrieveMinErrorRatePAttribute);
        
        /// <summary>
        /// The backing field for the FuelDemandLimit property
        /// </summary>
        private float _fuelDemandLimit;
        
        private static Lazy<ITypedElement> _fuelDemandLimitAttribute = new Lazy<ITypedElement>(RetrieveFuelDemandLimitAttribute);
        
        /// <summary>
        /// The backing field for the SuperHeaterPipePD property
        /// </summary>
        private float _superHeaterPipePD;
        
        private static Lazy<ITypedElement> _superHeaterPipePDAttribute = new Lazy<ITypedElement>(RetrieveSuperHeaterPipePDAttribute);
        
        /// <summary>
        /// The backing field for the PressureCtrlDG property
        /// </summary>
        private float _pressureCtrlDG;
        
        private static Lazy<ITypedElement> _pressureCtrlDGAttribute = new Lazy<ITypedElement>(RetrievePressureCtrlDGAttribute);
        
        /// <summary>
        /// The backing field for the AuxPowerVersusVoltage property
        /// </summary>
        private float _auxPowerVersusVoltage;
        
        private static Lazy<ITypedElement> _auxPowerVersusVoltageAttribute = new Lazy<ITypedElement>(RetrieveAuxPowerVersusVoltageAttribute);
        
        /// <summary>
        /// The backing field for the ControlPC property
        /// </summary>
        private float _controlPC;
        
        private static Lazy<ITypedElement> _controlPCAttribute = new Lazy<ITypedElement>(RetrieveControlPCAttribute);
        
        /// <summary>
        /// The backing field for the FeedWaterTC property
        /// </summary>
        private float _feedWaterTC;
        
        private static Lazy<ITypedElement> _feedWaterTCAttribute = new Lazy<ITypedElement>(RetrieveFeedWaterTCAttribute);
        
        /// <summary>
        /// The backing field for the ControlErrorBiasP property
        /// </summary>
        private float _controlErrorBiasP;
        
        private static Lazy<ITypedElement> _controlErrorBiasPAttribute = new Lazy<ITypedElement>(RetrieveControlErrorBiasPAttribute);
        
        /// <summary>
        /// The backing field for the FeedWaterIG property
        /// </summary>
        private float _feedWaterIG;
        
        private static Lazy<ITypedElement> _feedWaterIGAttribute = new Lazy<ITypedElement>(RetrieveFeedWaterIGAttribute);
        
        /// <summary>
        /// The backing field for the PressureCtrlIG property
        /// </summary>
        private float _pressureCtrlIG;
        
        private static Lazy<ITypedElement> _pressureCtrlIGAttribute = new Lazy<ITypedElement>(RetrievePressureCtrlIGAttribute);
        
        /// <summary>
        /// The backing field for the FuelSupplyTC property
        /// </summary>
        private float _fuelSupplyTC;
        
        private static Lazy<ITypedElement> _fuelSupplyTCAttribute = new Lazy<ITypedElement>(RetrieveFuelSupplyTCAttribute);
        
        /// <summary>
        /// The backing field for the AuxPowerVersusFrequency property
        /// </summary>
        private float _auxPowerVersusFrequency;
        
        private static Lazy<ITypedElement> _auxPowerVersusFrequencyAttribute = new Lazy<ITypedElement>(RetrieveAuxPowerVersusFrequencyAttribute);
        
        /// <summary>
        /// The backing field for the PressureFeedback property
        /// </summary>
        private int _pressureFeedback;
        
        private static Lazy<ITypedElement> _pressureFeedbackAttribute = new Lazy<ITypedElement>(RetrievePressureFeedbackAttribute);
        
        /// <summary>
        /// The backing field for the FuelSupplyDelay property
        /// </summary>
        private float _fuelSupplyDelay;
        
        private static Lazy<ITypedElement> _fuelSupplyDelayAttribute = new Lazy<ITypedElement>(RetrieveFuelSupplyDelayAttribute);
        
        /// <summary>
        /// The backing field for the BoilerControlMode property
        /// </summary>
        private Nullable<BoilerControlMode> _boilerControlMode;
        
        private static Lazy<ITypedElement> _boilerControlModeAttribute = new Lazy<ITypedElement>(RetrieveBoilerControlModeAttribute);
        
        /// <summary>
        /// The backing field for the SuperHeater2Capacity property
        /// </summary>
        private float _superHeater2Capacity;
        
        private static Lazy<ITypedElement> _superHeater2CapacityAttribute = new Lazy<ITypedElement>(RetrieveSuperHeater2CapacityAttribute);
        
        /// <summary>
        /// The backing field for the ControlPEB property
        /// </summary>
        private float _controlPEB;
        
        private static Lazy<ITypedElement> _controlPEBAttribute = new Lazy<ITypedElement>(RetrieveControlPEBAttribute);
        
        /// <summary>
        /// The backing field for the ControlPED property
        /// </summary>
        private float _controlPED;
        
        private static Lazy<ITypedElement> _controlPEDAttribute = new Lazy<ITypedElement>(RetrieveControlPEDAttribute);
        
        private static IClass _classInstance;
        
        /// <summary>
        /// The pressureCtrlPG property
        /// </summary>
        [XmlElementNameAttribute("pressureCtrlPG")]
        [XmlAttributeAttribute(true)]
        public virtual float PressureCtrlPG
        {
            get
            {
                return this._pressureCtrlPG;
            }
            set
            {
                if ((this._pressureCtrlPG != value))
                {
                    float old = this._pressureCtrlPG;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnPressureCtrlPGChanging(e);
                    this.OnPropertyChanging("PressureCtrlPG", e, _pressureCtrlPGAttribute);
                    this._pressureCtrlPG = value;
                    this.OnPressureCtrlPGChanged(e);
                    this.OnPropertyChanged("PressureCtrlPG", e, _pressureCtrlPGAttribute);
                }
            }
        }
        
        /// <summary>
        /// The superHeater1Capacity property
        /// </summary>
        [XmlElementNameAttribute("superHeater1Capacity")]
        [XmlAttributeAttribute(true)]
        public virtual float SuperHeater1Capacity
        {
            get
            {
                return this._superHeater1Capacity;
            }
            set
            {
                if ((this._superHeater1Capacity != value))
                {
                    float old = this._superHeater1Capacity;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnSuperHeater1CapacityChanging(e);
                    this.OnPropertyChanging("SuperHeater1Capacity", e, _superHeater1CapacityAttribute);
                    this._superHeater1Capacity = value;
                    this.OnSuperHeater1CapacityChanged(e);
                    this.OnPropertyChanged("SuperHeater1Capacity", e, _superHeater1CapacityAttribute);
                }
            }
        }
        
        /// <summary>
        /// The feedWaterPG property
        /// </summary>
        [XmlElementNameAttribute("feedWaterPG")]
        [XmlAttributeAttribute(true)]
        public virtual float FeedWaterPG
        {
            get
            {
                return this._feedWaterPG;
            }
            set
            {
                if ((this._feedWaterPG != value))
                {
                    float old = this._feedWaterPG;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnFeedWaterPGChanging(e);
                    this.OnPropertyChanging("FeedWaterPG", e, _feedWaterPGAttribute);
                    this._feedWaterPG = value;
                    this.OnFeedWaterPGChanged(e);
                    this.OnPropertyChanged("FeedWaterPG", e, _feedWaterPGAttribute);
                }
            }
        }
        
        /// <summary>
        /// The controlTC property
        /// </summary>
        [XmlElementNameAttribute("controlTC")]
        [XmlAttributeAttribute(true)]
        public virtual float ControlTC
        {
            get
            {
                return this._controlTC;
            }
            set
            {
                if ((this._controlTC != value))
                {
                    float old = this._controlTC;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnControlTCChanging(e);
                    this.OnPropertyChanging("ControlTC", e, _controlTCAttribute);
                    this._controlTC = value;
                    this.OnControlTCChanged(e);
                    this.OnPropertyChanged("ControlTC", e, _controlTCAttribute);
                }
            }
        }
        
        /// <summary>
        /// The mechPowerSensorLag property
        /// </summary>
        [XmlElementNameAttribute("mechPowerSensorLag")]
        [XmlAttributeAttribute(true)]
        public virtual float MechPowerSensorLag
        {
            get
            {
                return this._mechPowerSensorLag;
            }
            set
            {
                if ((this._mechPowerSensorLag != value))
                {
                    float old = this._mechPowerSensorLag;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnMechPowerSensorLagChanging(e);
                    this.OnPropertyChanging("MechPowerSensorLag", e, _mechPowerSensorLagAttribute);
                    this._mechPowerSensorLag = value;
                    this.OnMechPowerSensorLagChanged(e);
                    this.OnPropertyChanged("MechPowerSensorLag", e, _mechPowerSensorLagAttribute);
                }
            }
        }
        
        /// <summary>
        /// The throttlePressureSP property
        /// </summary>
        [XmlElementNameAttribute("throttlePressureSP")]
        [XmlAttributeAttribute(true)]
        public virtual float ThrottlePressureSP
        {
            get
            {
                return this._throttlePressureSP;
            }
            set
            {
                if ((this._throttlePressureSP != value))
                {
                    float old = this._throttlePressureSP;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnThrottlePressureSPChanging(e);
                    this.OnPropertyChanging("ThrottlePressureSP", e, _throttlePressureSPAttribute);
                    this._throttlePressureSP = value;
                    this.OnThrottlePressureSPChanged(e);
                    this.OnPropertyChanged("ThrottlePressureSP", e, _throttlePressureSPAttribute);
                }
            }
        }
        
        /// <summary>
        /// The maxErrorRateP property
        /// </summary>
        [XmlElementNameAttribute("maxErrorRateP")]
        [XmlAttributeAttribute(true)]
        public virtual float MaxErrorRateP
        {
            get
            {
                return this._maxErrorRateP;
            }
            set
            {
                if ((this._maxErrorRateP != value))
                {
                    float old = this._maxErrorRateP;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnMaxErrorRatePChanging(e);
                    this.OnPropertyChanging("MaxErrorRateP", e, _maxErrorRatePAttribute);
                    this._maxErrorRateP = value;
                    this.OnMaxErrorRatePChanged(e);
                    this.OnPropertyChanged("MaxErrorRateP", e, _maxErrorRatePAttribute);
                }
            }
        }
        
        /// <summary>
        /// The controlIC property
        /// </summary>
        [XmlElementNameAttribute("controlIC")]
        [XmlAttributeAttribute(true)]
        public virtual float ControlIC
        {
            get
            {
                return this._controlIC;
            }
            set
            {
                if ((this._controlIC != value))
                {
                    float old = this._controlIC;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnControlICChanging(e);
                    this.OnPropertyChanging("ControlIC", e, _controlICAttribute);
                    this._controlIC = value;
                    this.OnControlICChanged(e);
                    this.OnPropertyChanged("ControlIC", e, _controlICAttribute);
                }
            }
        }
        
        /// <summary>
        /// The minErrorRateP property
        /// </summary>
        [XmlElementNameAttribute("minErrorRateP")]
        [XmlAttributeAttribute(true)]
        public virtual float MinErrorRateP
        {
            get
            {
                return this._minErrorRateP;
            }
            set
            {
                if ((this._minErrorRateP != value))
                {
                    float old = this._minErrorRateP;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnMinErrorRatePChanging(e);
                    this.OnPropertyChanging("MinErrorRateP", e, _minErrorRatePAttribute);
                    this._minErrorRateP = value;
                    this.OnMinErrorRatePChanged(e);
                    this.OnPropertyChanged("MinErrorRateP", e, _minErrorRatePAttribute);
                }
            }
        }
        
        /// <summary>
        /// The fuelDemandLimit property
        /// </summary>
        [XmlElementNameAttribute("fuelDemandLimit")]
        [XmlAttributeAttribute(true)]
        public virtual float FuelDemandLimit
        {
            get
            {
                return this._fuelDemandLimit;
            }
            set
            {
                if ((this._fuelDemandLimit != value))
                {
                    float old = this._fuelDemandLimit;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnFuelDemandLimitChanging(e);
                    this.OnPropertyChanging("FuelDemandLimit", e, _fuelDemandLimitAttribute);
                    this._fuelDemandLimit = value;
                    this.OnFuelDemandLimitChanged(e);
                    this.OnPropertyChanged("FuelDemandLimit", e, _fuelDemandLimitAttribute);
                }
            }
        }
        
        /// <summary>
        /// The superHeaterPipePD property
        /// </summary>
        [XmlElementNameAttribute("superHeaterPipePD")]
        [XmlAttributeAttribute(true)]
        public virtual float SuperHeaterPipePD
        {
            get
            {
                return this._superHeaterPipePD;
            }
            set
            {
                if ((this._superHeaterPipePD != value))
                {
                    float old = this._superHeaterPipePD;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnSuperHeaterPipePDChanging(e);
                    this.OnPropertyChanging("SuperHeaterPipePD", e, _superHeaterPipePDAttribute);
                    this._superHeaterPipePD = value;
                    this.OnSuperHeaterPipePDChanged(e);
                    this.OnPropertyChanged("SuperHeaterPipePD", e, _superHeaterPipePDAttribute);
                }
            }
        }
        
        /// <summary>
        /// The pressureCtrlDG property
        /// </summary>
        [XmlElementNameAttribute("pressureCtrlDG")]
        [XmlAttributeAttribute(true)]
        public virtual float PressureCtrlDG
        {
            get
            {
                return this._pressureCtrlDG;
            }
            set
            {
                if ((this._pressureCtrlDG != value))
                {
                    float old = this._pressureCtrlDG;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnPressureCtrlDGChanging(e);
                    this.OnPropertyChanging("PressureCtrlDG", e, _pressureCtrlDGAttribute);
                    this._pressureCtrlDG = value;
                    this.OnPressureCtrlDGChanged(e);
                    this.OnPropertyChanged("PressureCtrlDG", e, _pressureCtrlDGAttribute);
                }
            }
        }
        
        /// <summary>
        /// The auxPowerVersusVoltage property
        /// </summary>
        [XmlElementNameAttribute("auxPowerVersusVoltage")]
        [XmlAttributeAttribute(true)]
        public virtual float AuxPowerVersusVoltage
        {
            get
            {
                return this._auxPowerVersusVoltage;
            }
            set
            {
                if ((this._auxPowerVersusVoltage != value))
                {
                    float old = this._auxPowerVersusVoltage;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnAuxPowerVersusVoltageChanging(e);
                    this.OnPropertyChanging("AuxPowerVersusVoltage", e, _auxPowerVersusVoltageAttribute);
                    this._auxPowerVersusVoltage = value;
                    this.OnAuxPowerVersusVoltageChanged(e);
                    this.OnPropertyChanged("AuxPowerVersusVoltage", e, _auxPowerVersusVoltageAttribute);
                }
            }
        }
        
        /// <summary>
        /// The controlPC property
        /// </summary>
        [XmlElementNameAttribute("controlPC")]
        [XmlAttributeAttribute(true)]
        public virtual float ControlPC
        {
            get
            {
                return this._controlPC;
            }
            set
            {
                if ((this._controlPC != value))
                {
                    float old = this._controlPC;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnControlPCChanging(e);
                    this.OnPropertyChanging("ControlPC", e, _controlPCAttribute);
                    this._controlPC = value;
                    this.OnControlPCChanged(e);
                    this.OnPropertyChanged("ControlPC", e, _controlPCAttribute);
                }
            }
        }
        
        /// <summary>
        /// The feedWaterTC property
        /// </summary>
        [XmlElementNameAttribute("feedWaterTC")]
        [XmlAttributeAttribute(true)]
        public virtual float FeedWaterTC
        {
            get
            {
                return this._feedWaterTC;
            }
            set
            {
                if ((this._feedWaterTC != value))
                {
                    float old = this._feedWaterTC;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnFeedWaterTCChanging(e);
                    this.OnPropertyChanging("FeedWaterTC", e, _feedWaterTCAttribute);
                    this._feedWaterTC = value;
                    this.OnFeedWaterTCChanged(e);
                    this.OnPropertyChanged("FeedWaterTC", e, _feedWaterTCAttribute);
                }
            }
        }
        
        /// <summary>
        /// The controlErrorBiasP property
        /// </summary>
        [XmlElementNameAttribute("controlErrorBiasP")]
        [XmlAttributeAttribute(true)]
        public virtual float ControlErrorBiasP
        {
            get
            {
                return this._controlErrorBiasP;
            }
            set
            {
                if ((this._controlErrorBiasP != value))
                {
                    float old = this._controlErrorBiasP;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnControlErrorBiasPChanging(e);
                    this.OnPropertyChanging("ControlErrorBiasP", e, _controlErrorBiasPAttribute);
                    this._controlErrorBiasP = value;
                    this.OnControlErrorBiasPChanged(e);
                    this.OnPropertyChanged("ControlErrorBiasP", e, _controlErrorBiasPAttribute);
                }
            }
        }
        
        /// <summary>
        /// The feedWaterIG property
        /// </summary>
        [XmlElementNameAttribute("feedWaterIG")]
        [XmlAttributeAttribute(true)]
        public virtual float FeedWaterIG
        {
            get
            {
                return this._feedWaterIG;
            }
            set
            {
                if ((this._feedWaterIG != value))
                {
                    float old = this._feedWaterIG;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnFeedWaterIGChanging(e);
                    this.OnPropertyChanging("FeedWaterIG", e, _feedWaterIGAttribute);
                    this._feedWaterIG = value;
                    this.OnFeedWaterIGChanged(e);
                    this.OnPropertyChanged("FeedWaterIG", e, _feedWaterIGAttribute);
                }
            }
        }
        
        /// <summary>
        /// The pressureCtrlIG property
        /// </summary>
        [XmlElementNameAttribute("pressureCtrlIG")]
        [XmlAttributeAttribute(true)]
        public virtual float PressureCtrlIG
        {
            get
            {
                return this._pressureCtrlIG;
            }
            set
            {
                if ((this._pressureCtrlIG != value))
                {
                    float old = this._pressureCtrlIG;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnPressureCtrlIGChanging(e);
                    this.OnPropertyChanging("PressureCtrlIG", e, _pressureCtrlIGAttribute);
                    this._pressureCtrlIG = value;
                    this.OnPressureCtrlIGChanged(e);
                    this.OnPropertyChanged("PressureCtrlIG", e, _pressureCtrlIGAttribute);
                }
            }
        }
        
        /// <summary>
        /// The fuelSupplyTC property
        /// </summary>
        [XmlElementNameAttribute("fuelSupplyTC")]
        [XmlAttributeAttribute(true)]
        public virtual float FuelSupplyTC
        {
            get
            {
                return this._fuelSupplyTC;
            }
            set
            {
                if ((this._fuelSupplyTC != value))
                {
                    float old = this._fuelSupplyTC;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnFuelSupplyTCChanging(e);
                    this.OnPropertyChanging("FuelSupplyTC", e, _fuelSupplyTCAttribute);
                    this._fuelSupplyTC = value;
                    this.OnFuelSupplyTCChanged(e);
                    this.OnPropertyChanged("FuelSupplyTC", e, _fuelSupplyTCAttribute);
                }
            }
        }
        
        /// <summary>
        /// The auxPowerVersusFrequency property
        /// </summary>
        [XmlElementNameAttribute("auxPowerVersusFrequency")]
        [XmlAttributeAttribute(true)]
        public virtual float AuxPowerVersusFrequency
        {
            get
            {
                return this._auxPowerVersusFrequency;
            }
            set
            {
                if ((this._auxPowerVersusFrequency != value))
                {
                    float old = this._auxPowerVersusFrequency;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnAuxPowerVersusFrequencyChanging(e);
                    this.OnPropertyChanging("AuxPowerVersusFrequency", e, _auxPowerVersusFrequencyAttribute);
                    this._auxPowerVersusFrequency = value;
                    this.OnAuxPowerVersusFrequencyChanged(e);
                    this.OnPropertyChanged("AuxPowerVersusFrequency", e, _auxPowerVersusFrequencyAttribute);
                }
            }
        }
        
        /// <summary>
        /// The pressureFeedback property
        /// </summary>
        [XmlElementNameAttribute("pressureFeedback")]
        [XmlAttributeAttribute(true)]
        public virtual int PressureFeedback
        {
            get
            {
                return this._pressureFeedback;
            }
            set
            {
                if ((this._pressureFeedback != value))
                {
                    int old = this._pressureFeedback;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnPressureFeedbackChanging(e);
                    this.OnPropertyChanging("PressureFeedback", e, _pressureFeedbackAttribute);
                    this._pressureFeedback = value;
                    this.OnPressureFeedbackChanged(e);
                    this.OnPropertyChanged("PressureFeedback", e, _pressureFeedbackAttribute);
                }
            }
        }
        
        /// <summary>
        /// The fuelSupplyDelay property
        /// </summary>
        [XmlElementNameAttribute("fuelSupplyDelay")]
        [XmlAttributeAttribute(true)]
        public virtual float FuelSupplyDelay
        {
            get
            {
                return this._fuelSupplyDelay;
            }
            set
            {
                if ((this._fuelSupplyDelay != value))
                {
                    float old = this._fuelSupplyDelay;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnFuelSupplyDelayChanging(e);
                    this.OnPropertyChanging("FuelSupplyDelay", e, _fuelSupplyDelayAttribute);
                    this._fuelSupplyDelay = value;
                    this.OnFuelSupplyDelayChanged(e);
                    this.OnPropertyChanged("FuelSupplyDelay", e, _fuelSupplyDelayAttribute);
                }
            }
        }
        
        /// <summary>
        /// The boilerControlMode property
        /// </summary>
        [XmlElementNameAttribute("boilerControlMode")]
        [XmlAttributeAttribute(true)]
        public virtual Nullable<BoilerControlMode> BoilerControlMode
        {
            get
            {
                return this._boilerControlMode;
            }
            set
            {
                if ((this._boilerControlMode != value))
                {
                    Nullable<BoilerControlMode> old = this._boilerControlMode;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnBoilerControlModeChanging(e);
                    this.OnPropertyChanging("BoilerControlMode", e, _boilerControlModeAttribute);
                    this._boilerControlMode = value;
                    this.OnBoilerControlModeChanged(e);
                    this.OnPropertyChanged("BoilerControlMode", e, _boilerControlModeAttribute);
                }
            }
        }
        
        /// <summary>
        /// The superHeater2Capacity property
        /// </summary>
        [XmlElementNameAttribute("superHeater2Capacity")]
        [XmlAttributeAttribute(true)]
        public virtual float SuperHeater2Capacity
        {
            get
            {
                return this._superHeater2Capacity;
            }
            set
            {
                if ((this._superHeater2Capacity != value))
                {
                    float old = this._superHeater2Capacity;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnSuperHeater2CapacityChanging(e);
                    this.OnPropertyChanging("SuperHeater2Capacity", e, _superHeater2CapacityAttribute);
                    this._superHeater2Capacity = value;
                    this.OnSuperHeater2CapacityChanged(e);
                    this.OnPropertyChanged("SuperHeater2Capacity", e, _superHeater2CapacityAttribute);
                }
            }
        }
        
        /// <summary>
        /// The controlPEB property
        /// </summary>
        [XmlElementNameAttribute("controlPEB")]
        [XmlAttributeAttribute(true)]
        public virtual float ControlPEB
        {
            get
            {
                return this._controlPEB;
            }
            set
            {
                if ((this._controlPEB != value))
                {
                    float old = this._controlPEB;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnControlPEBChanging(e);
                    this.OnPropertyChanging("ControlPEB", e, _controlPEBAttribute);
                    this._controlPEB = value;
                    this.OnControlPEBChanged(e);
                    this.OnPropertyChanged("ControlPEB", e, _controlPEBAttribute);
                }
            }
        }
        
        /// <summary>
        /// The controlPED property
        /// </summary>
        [XmlElementNameAttribute("controlPED")]
        [XmlAttributeAttribute(true)]
        public virtual float ControlPED
        {
            get
            {
                return this._controlPED;
            }
            set
            {
                if ((this._controlPED != value))
                {
                    float old = this._controlPED;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnControlPEDChanging(e);
                    this.OnPropertyChanging("ControlPED", e, _controlPEDAttribute);
                    this._controlPED = value;
                    this.OnControlPEDChanged(e);
                    this.OnPropertyChanged("ControlPED", e, _controlPEDAttribute);
                }
            }
        }
        
        /// <summary>
        /// Gets the Class model for this type
        /// </summary>
        public new static IClass ClassInstance
        {
            get
            {
                if ((_classInstance == null))
                {
                    _classInstance = ((IClass)(MetaRepository.Instance.Resolve("http://iec.ch/TC57/2009/CIM-schema-cim14#//IEC61970/Generation/GenerationDynamics" +
                            "/FossilSteamSupply")));
                }
                return _classInstance;
            }
        }
        
        /// <summary>
        /// Gets fired before the PressureCtrlPG property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> PressureCtrlPGChanging;
        
        /// <summary>
        /// Gets fired when the PressureCtrlPG property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> PressureCtrlPGChanged;
        
        /// <summary>
        /// Gets fired before the SuperHeater1Capacity property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> SuperHeater1CapacityChanging;
        
        /// <summary>
        /// Gets fired when the SuperHeater1Capacity property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> SuperHeater1CapacityChanged;
        
        /// <summary>
        /// Gets fired before the FeedWaterPG property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> FeedWaterPGChanging;
        
        /// <summary>
        /// Gets fired when the FeedWaterPG property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> FeedWaterPGChanged;
        
        /// <summary>
        /// Gets fired before the ControlTC property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> ControlTCChanging;
        
        /// <summary>
        /// Gets fired when the ControlTC property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> ControlTCChanged;
        
        /// <summary>
        /// Gets fired before the MechPowerSensorLag property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> MechPowerSensorLagChanging;
        
        /// <summary>
        /// Gets fired when the MechPowerSensorLag property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> MechPowerSensorLagChanged;
        
        /// <summary>
        /// Gets fired before the ThrottlePressureSP property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> ThrottlePressureSPChanging;
        
        /// <summary>
        /// Gets fired when the ThrottlePressureSP property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> ThrottlePressureSPChanged;
        
        /// <summary>
        /// Gets fired before the MaxErrorRateP property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> MaxErrorRatePChanging;
        
        /// <summary>
        /// Gets fired when the MaxErrorRateP property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> MaxErrorRatePChanged;
        
        /// <summary>
        /// Gets fired before the ControlIC property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> ControlICChanging;
        
        /// <summary>
        /// Gets fired when the ControlIC property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> ControlICChanged;
        
        /// <summary>
        /// Gets fired before the MinErrorRateP property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> MinErrorRatePChanging;
        
        /// <summary>
        /// Gets fired when the MinErrorRateP property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> MinErrorRatePChanged;
        
        /// <summary>
        /// Gets fired before the FuelDemandLimit property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> FuelDemandLimitChanging;
        
        /// <summary>
        /// Gets fired when the FuelDemandLimit property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> FuelDemandLimitChanged;
        
        /// <summary>
        /// Gets fired before the SuperHeaterPipePD property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> SuperHeaterPipePDChanging;
        
        /// <summary>
        /// Gets fired when the SuperHeaterPipePD property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> SuperHeaterPipePDChanged;
        
        /// <summary>
        /// Gets fired before the PressureCtrlDG property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> PressureCtrlDGChanging;
        
        /// <summary>
        /// Gets fired when the PressureCtrlDG property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> PressureCtrlDGChanged;
        
        /// <summary>
        /// Gets fired before the AuxPowerVersusVoltage property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> AuxPowerVersusVoltageChanging;
        
        /// <summary>
        /// Gets fired when the AuxPowerVersusVoltage property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> AuxPowerVersusVoltageChanged;
        
        /// <summary>
        /// Gets fired before the ControlPC property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> ControlPCChanging;
        
        /// <summary>
        /// Gets fired when the ControlPC property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> ControlPCChanged;
        
        /// <summary>
        /// Gets fired before the FeedWaterTC property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> FeedWaterTCChanging;
        
        /// <summary>
        /// Gets fired when the FeedWaterTC property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> FeedWaterTCChanged;
        
        /// <summary>
        /// Gets fired before the ControlErrorBiasP property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> ControlErrorBiasPChanging;
        
        /// <summary>
        /// Gets fired when the ControlErrorBiasP property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> ControlErrorBiasPChanged;
        
        /// <summary>
        /// Gets fired before the FeedWaterIG property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> FeedWaterIGChanging;
        
        /// <summary>
        /// Gets fired when the FeedWaterIG property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> FeedWaterIGChanged;
        
        /// <summary>
        /// Gets fired before the PressureCtrlIG property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> PressureCtrlIGChanging;
        
        /// <summary>
        /// Gets fired when the PressureCtrlIG property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> PressureCtrlIGChanged;
        
        /// <summary>
        /// Gets fired before the FuelSupplyTC property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> FuelSupplyTCChanging;
        
        /// <summary>
        /// Gets fired when the FuelSupplyTC property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> FuelSupplyTCChanged;
        
        /// <summary>
        /// Gets fired before the AuxPowerVersusFrequency property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> AuxPowerVersusFrequencyChanging;
        
        /// <summary>
        /// Gets fired when the AuxPowerVersusFrequency property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> AuxPowerVersusFrequencyChanged;
        
        /// <summary>
        /// Gets fired before the PressureFeedback property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> PressureFeedbackChanging;
        
        /// <summary>
        /// Gets fired when the PressureFeedback property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> PressureFeedbackChanged;
        
        /// <summary>
        /// Gets fired before the FuelSupplyDelay property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> FuelSupplyDelayChanging;
        
        /// <summary>
        /// Gets fired when the FuelSupplyDelay property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> FuelSupplyDelayChanged;
        
        /// <summary>
        /// Gets fired before the BoilerControlMode property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> BoilerControlModeChanging;
        
        /// <summary>
        /// Gets fired when the BoilerControlMode property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> BoilerControlModeChanged;
        
        /// <summary>
        /// Gets fired before the SuperHeater2Capacity property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> SuperHeater2CapacityChanging;
        
        /// <summary>
        /// Gets fired when the SuperHeater2Capacity property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> SuperHeater2CapacityChanged;
        
        /// <summary>
        /// Gets fired before the ControlPEB property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> ControlPEBChanging;
        
        /// <summary>
        /// Gets fired when the ControlPEB property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> ControlPEBChanged;
        
        /// <summary>
        /// Gets fired before the ControlPED property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> ControlPEDChanging;
        
        /// <summary>
        /// Gets fired when the ControlPED property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> ControlPEDChanged;
        
        private static ITypedElement RetrievePressureCtrlPGAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("pressureCtrlPG")));
        }
        
        /// <summary>
        /// Raises the PressureCtrlPGChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnPressureCtrlPGChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.PressureCtrlPGChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the PressureCtrlPGChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnPressureCtrlPGChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.PressureCtrlPGChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveSuperHeater1CapacityAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("superHeater1Capacity")));
        }
        
        /// <summary>
        /// Raises the SuperHeater1CapacityChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnSuperHeater1CapacityChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.SuperHeater1CapacityChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the SuperHeater1CapacityChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnSuperHeater1CapacityChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.SuperHeater1CapacityChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveFeedWaterPGAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("feedWaterPG")));
        }
        
        /// <summary>
        /// Raises the FeedWaterPGChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnFeedWaterPGChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.FeedWaterPGChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the FeedWaterPGChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnFeedWaterPGChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.FeedWaterPGChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveControlTCAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("controlTC")));
        }
        
        /// <summary>
        /// Raises the ControlTCChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnControlTCChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.ControlTCChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the ControlTCChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnControlTCChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.ControlTCChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveMechPowerSensorLagAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("mechPowerSensorLag")));
        }
        
        /// <summary>
        /// Raises the MechPowerSensorLagChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnMechPowerSensorLagChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.MechPowerSensorLagChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the MechPowerSensorLagChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnMechPowerSensorLagChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.MechPowerSensorLagChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveThrottlePressureSPAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("throttlePressureSP")));
        }
        
        /// <summary>
        /// Raises the ThrottlePressureSPChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnThrottlePressureSPChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.ThrottlePressureSPChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the ThrottlePressureSPChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnThrottlePressureSPChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.ThrottlePressureSPChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveMaxErrorRatePAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("maxErrorRateP")));
        }
        
        /// <summary>
        /// Raises the MaxErrorRatePChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnMaxErrorRatePChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.MaxErrorRatePChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the MaxErrorRatePChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnMaxErrorRatePChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.MaxErrorRatePChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveControlICAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("controlIC")));
        }
        
        /// <summary>
        /// Raises the ControlICChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnControlICChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.ControlICChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the ControlICChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnControlICChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.ControlICChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveMinErrorRatePAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("minErrorRateP")));
        }
        
        /// <summary>
        /// Raises the MinErrorRatePChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnMinErrorRatePChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.MinErrorRatePChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the MinErrorRatePChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnMinErrorRatePChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.MinErrorRatePChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveFuelDemandLimitAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("fuelDemandLimit")));
        }
        
        /// <summary>
        /// Raises the FuelDemandLimitChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnFuelDemandLimitChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.FuelDemandLimitChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the FuelDemandLimitChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnFuelDemandLimitChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.FuelDemandLimitChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveSuperHeaterPipePDAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("superHeaterPipePD")));
        }
        
        /// <summary>
        /// Raises the SuperHeaterPipePDChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnSuperHeaterPipePDChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.SuperHeaterPipePDChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the SuperHeaterPipePDChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnSuperHeaterPipePDChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.SuperHeaterPipePDChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrievePressureCtrlDGAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("pressureCtrlDG")));
        }
        
        /// <summary>
        /// Raises the PressureCtrlDGChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnPressureCtrlDGChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.PressureCtrlDGChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the PressureCtrlDGChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnPressureCtrlDGChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.PressureCtrlDGChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveAuxPowerVersusVoltageAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("auxPowerVersusVoltage")));
        }
        
        /// <summary>
        /// Raises the AuxPowerVersusVoltageChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnAuxPowerVersusVoltageChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.AuxPowerVersusVoltageChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the AuxPowerVersusVoltageChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnAuxPowerVersusVoltageChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.AuxPowerVersusVoltageChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveControlPCAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("controlPC")));
        }
        
        /// <summary>
        /// Raises the ControlPCChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnControlPCChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.ControlPCChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the ControlPCChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnControlPCChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.ControlPCChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveFeedWaterTCAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("feedWaterTC")));
        }
        
        /// <summary>
        /// Raises the FeedWaterTCChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnFeedWaterTCChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.FeedWaterTCChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the FeedWaterTCChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnFeedWaterTCChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.FeedWaterTCChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveControlErrorBiasPAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("controlErrorBiasP")));
        }
        
        /// <summary>
        /// Raises the ControlErrorBiasPChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnControlErrorBiasPChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.ControlErrorBiasPChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the ControlErrorBiasPChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnControlErrorBiasPChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.ControlErrorBiasPChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveFeedWaterIGAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("feedWaterIG")));
        }
        
        /// <summary>
        /// Raises the FeedWaterIGChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnFeedWaterIGChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.FeedWaterIGChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the FeedWaterIGChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnFeedWaterIGChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.FeedWaterIGChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrievePressureCtrlIGAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("pressureCtrlIG")));
        }
        
        /// <summary>
        /// Raises the PressureCtrlIGChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnPressureCtrlIGChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.PressureCtrlIGChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the PressureCtrlIGChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnPressureCtrlIGChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.PressureCtrlIGChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveFuelSupplyTCAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("fuelSupplyTC")));
        }
        
        /// <summary>
        /// Raises the FuelSupplyTCChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnFuelSupplyTCChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.FuelSupplyTCChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the FuelSupplyTCChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnFuelSupplyTCChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.FuelSupplyTCChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveAuxPowerVersusFrequencyAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("auxPowerVersusFrequency")));
        }
        
        /// <summary>
        /// Raises the AuxPowerVersusFrequencyChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnAuxPowerVersusFrequencyChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.AuxPowerVersusFrequencyChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the AuxPowerVersusFrequencyChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnAuxPowerVersusFrequencyChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.AuxPowerVersusFrequencyChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrievePressureFeedbackAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("pressureFeedback")));
        }
        
        /// <summary>
        /// Raises the PressureFeedbackChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnPressureFeedbackChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.PressureFeedbackChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the PressureFeedbackChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnPressureFeedbackChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.PressureFeedbackChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveFuelSupplyDelayAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("fuelSupplyDelay")));
        }
        
        /// <summary>
        /// Raises the FuelSupplyDelayChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnFuelSupplyDelayChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.FuelSupplyDelayChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the FuelSupplyDelayChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnFuelSupplyDelayChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.FuelSupplyDelayChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveBoilerControlModeAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("boilerControlMode")));
        }
        
        /// <summary>
        /// Raises the BoilerControlModeChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnBoilerControlModeChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.BoilerControlModeChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the BoilerControlModeChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnBoilerControlModeChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.BoilerControlModeChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveSuperHeater2CapacityAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("superHeater2Capacity")));
        }
        
        /// <summary>
        /// Raises the SuperHeater2CapacityChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnSuperHeater2CapacityChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.SuperHeater2CapacityChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the SuperHeater2CapacityChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnSuperHeater2CapacityChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.SuperHeater2CapacityChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveControlPEBAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("controlPEB")));
        }
        
        /// <summary>
        /// Raises the ControlPEBChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnControlPEBChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.ControlPEBChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the ControlPEBChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnControlPEBChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.ControlPEBChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        private static ITypedElement RetrieveControlPEDAttribute()
        {
            return ((ITypedElement)(((ModelElement)(FossilSteamSupply.ClassInstance)).Resolve("controlPED")));
        }
        
        /// <summary>
        /// Raises the ControlPEDChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnControlPEDChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.ControlPEDChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Raises the ControlPEDChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnControlPEDChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.ControlPEDChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }
        
        /// <summary>
        /// Resolves the given attribute name
        /// </summary>
        /// <returns>The attribute value or null if it could not be found</returns>
        /// <param name="attribute">The requested attribute name</param>
        /// <param name="index">The index of this attribute</param>
        protected override object GetAttributeValue(string attribute, int index)
        {
            if ((attribute == "PRESSURECTRLPG"))
            {
                return this.PressureCtrlPG;
            }
            if ((attribute == "SUPERHEATER1CAPACITY"))
            {
                return this.SuperHeater1Capacity;
            }
            if ((attribute == "FEEDWATERPG"))
            {
                return this.FeedWaterPG;
            }
            if ((attribute == "CONTROLTC"))
            {
                return this.ControlTC;
            }
            if ((attribute == "MECHPOWERSENSORLAG"))
            {
                return this.MechPowerSensorLag;
            }
            if ((attribute == "THROTTLEPRESSURESP"))
            {
                return this.ThrottlePressureSP;
            }
            if ((attribute == "MAXERRORRATEP"))
            {
                return this.MaxErrorRateP;
            }
            if ((attribute == "CONTROLIC"))
            {
                return this.ControlIC;
            }
            if ((attribute == "MINERRORRATEP"))
            {
                return this.MinErrorRateP;
            }
            if ((attribute == "FUELDEMANDLIMIT"))
            {
                return this.FuelDemandLimit;
            }
            if ((attribute == "SUPERHEATERPIPEPD"))
            {
                return this.SuperHeaterPipePD;
            }
            if ((attribute == "PRESSURECTRLDG"))
            {
                return this.PressureCtrlDG;
            }
            if ((attribute == "AUXPOWERVERSUSVOLTAGE"))
            {
                return this.AuxPowerVersusVoltage;
            }
            if ((attribute == "CONTROLPC"))
            {
                return this.ControlPC;
            }
            if ((attribute == "FEEDWATERTC"))
            {
                return this.FeedWaterTC;
            }
            if ((attribute == "CONTROLERRORBIASP"))
            {
                return this.ControlErrorBiasP;
            }
            if ((attribute == "FEEDWATERIG"))
            {
                return this.FeedWaterIG;
            }
            if ((attribute == "PRESSURECTRLIG"))
            {
                return this.PressureCtrlIG;
            }
            if ((attribute == "FUELSUPPLYTC"))
            {
                return this.FuelSupplyTC;
            }
            if ((attribute == "AUXPOWERVERSUSFREQUENCY"))
            {
                return this.AuxPowerVersusFrequency;
            }
            if ((attribute == "PRESSUREFEEDBACK"))
            {
                return this.PressureFeedback;
            }
            if ((attribute == "FUELSUPPLYDELAY"))
            {
                return this.FuelSupplyDelay;
            }
            if ((attribute == "BOILERCONTROLMODE"))
            {
                return this.BoilerControlMode;
            }
            if ((attribute == "SUPERHEATER2CAPACITY"))
            {
                return this.SuperHeater2Capacity;
            }
            if ((attribute == "CONTROLPEB"))
            {
                return this.ControlPEB;
            }
            if ((attribute == "CONTROLPED"))
            {
                return this.ControlPED;
            }
            return base.GetAttributeValue(attribute, index);
        }
        
        /// <summary>
        /// Sets a value to the given feature
        /// </summary>
        /// <param name="feature">The requested feature</param>
        /// <param name="value">The value that should be set to that feature</param>
        protected override void SetFeature(string feature, object value)
        {
            if ((feature == "PRESSURECTRLPG"))
            {
                this.PressureCtrlPG = ((float)(value));
                return;
            }
            if ((feature == "SUPERHEATER1CAPACITY"))
            {
                this.SuperHeater1Capacity = ((float)(value));
                return;
            }
            if ((feature == "FEEDWATERPG"))
            {
                this.FeedWaterPG = ((float)(value));
                return;
            }
            if ((feature == "CONTROLTC"))
            {
                this.ControlTC = ((float)(value));
                return;
            }
            if ((feature == "MECHPOWERSENSORLAG"))
            {
                this.MechPowerSensorLag = ((float)(value));
                return;
            }
            if ((feature == "THROTTLEPRESSURESP"))
            {
                this.ThrottlePressureSP = ((float)(value));
                return;
            }
            if ((feature == "MAXERRORRATEP"))
            {
                this.MaxErrorRateP = ((float)(value));
                return;
            }
            if ((feature == "CONTROLIC"))
            {
                this.ControlIC = ((float)(value));
                return;
            }
            if ((feature == "MINERRORRATEP"))
            {
                this.MinErrorRateP = ((float)(value));
                return;
            }
            if ((feature == "FUELDEMANDLIMIT"))
            {
                this.FuelDemandLimit = ((float)(value));
                return;
            }
            if ((feature == "SUPERHEATERPIPEPD"))
            {
                this.SuperHeaterPipePD = ((float)(value));
                return;
            }
            if ((feature == "PRESSURECTRLDG"))
            {
                this.PressureCtrlDG = ((float)(value));
                return;
            }
            if ((feature == "AUXPOWERVERSUSVOLTAGE"))
            {
                this.AuxPowerVersusVoltage = ((float)(value));
                return;
            }
            if ((feature == "CONTROLPC"))
            {
                this.ControlPC = ((float)(value));
                return;
            }
            if ((feature == "FEEDWATERTC"))
            {
                this.FeedWaterTC = ((float)(value));
                return;
            }
            if ((feature == "CONTROLERRORBIASP"))
            {
                this.ControlErrorBiasP = ((float)(value));
                return;
            }
            if ((feature == "FEEDWATERIG"))
            {
                this.FeedWaterIG = ((float)(value));
                return;
            }
            if ((feature == "PRESSURECTRLIG"))
            {
                this.PressureCtrlIG = ((float)(value));
                return;
            }
            if ((feature == "FUELSUPPLYTC"))
            {
                this.FuelSupplyTC = ((float)(value));
                return;
            }
            if ((feature == "AUXPOWERVERSUSFREQUENCY"))
            {
                this.AuxPowerVersusFrequency = ((float)(value));
                return;
            }
            if ((feature == "PRESSUREFEEDBACK"))
            {
                this.PressureFeedback = ((int)(value));
                return;
            }
            if ((feature == "FUELSUPPLYDELAY"))
            {
                this.FuelSupplyDelay = ((float)(value));
                return;
            }
            if ((feature == "BOILERCONTROLMODE"))
            {
                this.BoilerControlMode = ((BoilerControlMode)(value));
                return;
            }
            if ((feature == "SUPERHEATER2CAPACITY"))
            {
                this.SuperHeater2Capacity = ((float)(value));
                return;
            }
            if ((feature == "CONTROLPEB"))
            {
                this.ControlPEB = ((float)(value));
                return;
            }
            if ((feature == "CONTROLPED"))
            {
                this.ControlPED = ((float)(value));
                return;
            }
            base.SetFeature(feature, value);
        }
        
        /// <summary>
        /// Gets the Class for this model element
        /// </summary>
        public override IClass GetClass()
        {
            if ((_classInstance == null))
            {
                _classInstance = ((IClass)(MetaRepository.Instance.Resolve("http://iec.ch/TC57/2009/CIM-schema-cim14#//IEC61970/Generation/GenerationDynamics" +
                        "/FossilSteamSupply")));
            }
            return _classInstance;
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the pressureCtrlPG property
        /// </summary>
        private sealed class PressureCtrlPGProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public PressureCtrlPGProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "pressureCtrlPG")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.PressureCtrlPG;
                }
                set
                {
                    this.ModelElement.PressureCtrlPG = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the superHeater1Capacity property
        /// </summary>
        private sealed class SuperHeater1CapacityProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public SuperHeater1CapacityProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "superHeater1Capacity")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.SuperHeater1Capacity;
                }
                set
                {
                    this.ModelElement.SuperHeater1Capacity = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the feedWaterPG property
        /// </summary>
        private sealed class FeedWaterPGProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public FeedWaterPGProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "feedWaterPG")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.FeedWaterPG;
                }
                set
                {
                    this.ModelElement.FeedWaterPG = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the controlTC property
        /// </summary>
        private sealed class ControlTCProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public ControlTCProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "controlTC")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.ControlTC;
                }
                set
                {
                    this.ModelElement.ControlTC = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the mechPowerSensorLag property
        /// </summary>
        private sealed class MechPowerSensorLagProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public MechPowerSensorLagProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "mechPowerSensorLag")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.MechPowerSensorLag;
                }
                set
                {
                    this.ModelElement.MechPowerSensorLag = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the throttlePressureSP property
        /// </summary>
        private sealed class ThrottlePressureSPProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public ThrottlePressureSPProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "throttlePressureSP")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.ThrottlePressureSP;
                }
                set
                {
                    this.ModelElement.ThrottlePressureSP = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the maxErrorRateP property
        /// </summary>
        private sealed class MaxErrorRatePProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public MaxErrorRatePProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "maxErrorRateP")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.MaxErrorRateP;
                }
                set
                {
                    this.ModelElement.MaxErrorRateP = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the controlIC property
        /// </summary>
        private sealed class ControlICProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public ControlICProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "controlIC")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.ControlIC;
                }
                set
                {
                    this.ModelElement.ControlIC = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the minErrorRateP property
        /// </summary>
        private sealed class MinErrorRatePProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public MinErrorRatePProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "minErrorRateP")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.MinErrorRateP;
                }
                set
                {
                    this.ModelElement.MinErrorRateP = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the fuelDemandLimit property
        /// </summary>
        private sealed class FuelDemandLimitProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public FuelDemandLimitProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "fuelDemandLimit")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.FuelDemandLimit;
                }
                set
                {
                    this.ModelElement.FuelDemandLimit = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the superHeaterPipePD property
        /// </summary>
        private sealed class SuperHeaterPipePDProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public SuperHeaterPipePDProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "superHeaterPipePD")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.SuperHeaterPipePD;
                }
                set
                {
                    this.ModelElement.SuperHeaterPipePD = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the pressureCtrlDG property
        /// </summary>
        private sealed class PressureCtrlDGProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public PressureCtrlDGProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "pressureCtrlDG")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.PressureCtrlDG;
                }
                set
                {
                    this.ModelElement.PressureCtrlDG = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the auxPowerVersusVoltage property
        /// </summary>
        private sealed class AuxPowerVersusVoltageProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public AuxPowerVersusVoltageProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "auxPowerVersusVoltage")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.AuxPowerVersusVoltage;
                }
                set
                {
                    this.ModelElement.AuxPowerVersusVoltage = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the controlPC property
        /// </summary>
        private sealed class ControlPCProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public ControlPCProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "controlPC")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.ControlPC;
                }
                set
                {
                    this.ModelElement.ControlPC = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the feedWaterTC property
        /// </summary>
        private sealed class FeedWaterTCProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public FeedWaterTCProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "feedWaterTC")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.FeedWaterTC;
                }
                set
                {
                    this.ModelElement.FeedWaterTC = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the controlErrorBiasP property
        /// </summary>
        private sealed class ControlErrorBiasPProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public ControlErrorBiasPProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "controlErrorBiasP")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.ControlErrorBiasP;
                }
                set
                {
                    this.ModelElement.ControlErrorBiasP = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the feedWaterIG property
        /// </summary>
        private sealed class FeedWaterIGProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public FeedWaterIGProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "feedWaterIG")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.FeedWaterIG;
                }
                set
                {
                    this.ModelElement.FeedWaterIG = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the pressureCtrlIG property
        /// </summary>
        private sealed class PressureCtrlIGProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public PressureCtrlIGProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "pressureCtrlIG")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.PressureCtrlIG;
                }
                set
                {
                    this.ModelElement.PressureCtrlIG = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the fuelSupplyTC property
        /// </summary>
        private sealed class FuelSupplyTCProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public FuelSupplyTCProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "fuelSupplyTC")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.FuelSupplyTC;
                }
                set
                {
                    this.ModelElement.FuelSupplyTC = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the auxPowerVersusFrequency property
        /// </summary>
        private sealed class AuxPowerVersusFrequencyProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public AuxPowerVersusFrequencyProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "auxPowerVersusFrequency")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.AuxPowerVersusFrequency;
                }
                set
                {
                    this.ModelElement.AuxPowerVersusFrequency = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the pressureFeedback property
        /// </summary>
        private sealed class PressureFeedbackProxy : ModelPropertyChange<IFossilSteamSupply, int>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public PressureFeedbackProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "pressureFeedback")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override int Value
            {
                get
                {
                    return this.ModelElement.PressureFeedback;
                }
                set
                {
                    this.ModelElement.PressureFeedback = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the fuelSupplyDelay property
        /// </summary>
        private sealed class FuelSupplyDelayProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public FuelSupplyDelayProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "fuelSupplyDelay")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.FuelSupplyDelay;
                }
                set
                {
                    this.ModelElement.FuelSupplyDelay = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the boilerControlMode property
        /// </summary>
        private sealed class BoilerControlModeProxy : ModelPropertyChange<IFossilSteamSupply, Nullable<BoilerControlMode>>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public BoilerControlModeProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "boilerControlMode")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override Nullable<BoilerControlMode> Value
            {
                get
                {
                    return this.ModelElement.BoilerControlMode;
                }
                set
                {
                    this.ModelElement.BoilerControlMode = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the superHeater2Capacity property
        /// </summary>
        private sealed class SuperHeater2CapacityProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public SuperHeater2CapacityProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "superHeater2Capacity")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.SuperHeater2Capacity;
                }
                set
                {
                    this.ModelElement.SuperHeater2Capacity = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the controlPEB property
        /// </summary>
        private sealed class ControlPEBProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public ControlPEBProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "controlPEB")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.ControlPEB;
                }
                set
                {
                    this.ModelElement.ControlPEB = value;
                }
            }
        }
        
        /// <summary>
        /// Represents a proxy to represent an incremental access to the controlPED property
        /// </summary>
        private sealed class ControlPEDProxy : ModelPropertyChange<IFossilSteamSupply, float>
        {
            
            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public ControlPEDProxy(IFossilSteamSupply modelElement) : 
                    base(modelElement, "controlPED")
            {
            }
            
            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override float Value
            {
                get
                {
                    return this.ModelElement.ControlPED;
                }
                set
                {
                    this.ModelElement.ControlPED = value;
                }
            }
        }
    }
}

