# Patent

## Title
Dynamic economic dispatch for the management of a power distribution system

## Abstract

A method and system for dispatching available generation resources to supply a given load in a control area. Generating units are each assigned a temporal trajectory of output power over consecutive time intervals. The allocation of available resources are assigned so as to minimize costs associated with meeting changing loads.

## Background
CROSS-REFERENCE TO RELATED APPLICATIONS
This application claims priority to, and incorporates by reference in their entirety, the following pending provisional applications:
Ser. No. 60/470,039, filed 13 May 2003;
Ser. No. 60/470,038, filed 13 May 2003;
Ser. No. 60/470,096, filed 13 May 2003; and
Ser. No. 60/470,095, filed 13 May 2003.


FIELD OF THE INVENTION
The invention is directed to a method and system for economically dispatching available generation resources to a given load in a control area in the most economic manner.
BACKGROUND OF THE INVENTION
Controlling costs in any business is a critical factor in the success or failure of an enterprise. However, in the advent of the restructuring in the power industry, cost control became even more critical. Operational changes from a regulated monopoly to a free market system in which transmission operators are required to operate in a fair manner with all market participants have now place operators under different operational constraints. Often the manner in which market participants are required to operate are in direct conflict with technical and economic constraints. These constraints are imposed by regulatory agencies, economic concerns, and equipment performance limitations.
At the moment, operators provide regulatory agencies with schedule information detailing the quantity of energy and the time that energy will be produced. These schedules of energy vary over the course of a year, month, week, day, hour and other intervals of time such as seasons and special days such as holidays and weekends. Despite knowing that such energy requirements vary considerably at times, operators are often tasked with the burden of meeting demand for real-time and unanticipated shortage in energy. Meeting these unanticipated demands is often the cause of increased energy costs. Alternatively, decreases in energy costs may be the result of having to provide less energy when a glut of unanticipated energy exists in the marketplace.
As readily apparent, there is a significant need for a method and system which optimizes performance by minimizing costs by dispatching resources in the most economical manner. The present invention is a solution to the needs of energy producers which must minimize their costs and optimize profitability.
SUMMARY OF THE INVENTION
The present invention relates to method and system for optimizing the performance of a power generation and distribution system. More specifically, a method and system is disclosed for dispatching available generation resources to supply a given load in a control area by monitoring the performance of a power system, determining the ramping constraints of each of a plurality of committed generating units; receiving very short term load predictions for a set of predetermined and consecutive time intervals, obtaining a temporal trajectory of output power for each of the plurality of generating units over the set of predetermined and consecutive time intervals, such that costs associated with changing power output within the electrical power system is minimized; and
assigning a respective temporal trajectory of output power to each of the plurality of generating units.



BRIEF DESCRIPTION OF THE DRAWINGS
A wide variety of potential embodiments will be more readily understood through the following detailed description, with reference to the accompanying drawings in which:
FIG. 1 is an illustration of an energy management system;
FIG. 2 is an illustration of data flow among the CPS1, CPS2, DCS reporting modules and the AGC and HFD databases;
FIG. 3 illustrates a 10 minute window of ACE variances about a CPS1 control threshold;
FIG. 4 illustrates a 10 minute window of ACE variances about a CPS2 control threshold L10;
FIG. 5 illustrates an overall ANN-based VSTLP Architecture;
FIG. 6 illustrates a daily ANN-based VSTLP;
FIG. 7 illustrates an ANN-based VSTLP for Next Hour;
FIG. 8 illustrates the DED with inputs from energy management modules;
FIG. 9 illustrates the DED in a CPS based AGC;
FIG. 10 is a diagram of the functional relationship of the DED and other energy management modules;
FIG. 11 is a plot of the relationship between a change in the Lagrange Multiplier and corresponding output power; and
FIG. 12 is a plot of the relationship of the vertical adjustment necessary which corresponds to output power.
FIG. 13 and 14 are illustrations of disturbance recovery times.



DETAILED DESCRIPTION OF THE INVENTION
System operators have found it a challenge to readily match changes in load requirements with power generation for their control areas. Nevertheless automatic generation control systems have attempted to control this mismatch between sources of power and uses of power, by balancing real-power and by stabilizing frequency. As a guide to power and load management, NERC has provided control performance standards aimed at minimizing any adverse effects on neighboring control areas. To be in compliance with these NERC requirements, a system operator must balance its generation and interchange schedules with its load.
As a measure of conformity to the control performance standards, a first compliance factor know as ACE (Area Control Error) is applied to the power system's operations. For purposes of illustration, the ACE equation is shown below in a slightly simplified form:

ACE=(IA−IS)−10β(FA−FS)  (1)

where I refers to the algebraic sum of all power (MW) flows on tie-lines between a control area and its surrounding control areas, F is the interconnection frequency (Hz), A is actual, S is scheduled, and β is the control area's frequency bias (MW/0.1 Hz). Frequency bias is the amount of generation needed to respond to a 0.1 Hz change in interconnection frequency. It is normally set to the supply-plus-load response of a control area to a change in interconnection frequency. The first terms shows how well the control area performs in matching its schedules with other control areas. The second term is the individual control area's contribution to the interconnection to maintain frequency at its scheduled value. Accordingly, ACEi is the instantaneous difference between actual and scheduled interchange, taking into account the effects of frequency. It measures how well a control area manages its generation to match time-varying loads and scheduled interchange.

However, as a guide to performance, NERC (North American Reliability Council) has defined minimum Control Performance standards (CPS1, CPS2 & DCS). CPS1 is shown below:




  
    
      
        CPS1
        =
        
          
            
              AVG
              
                12
                -
                month
              
            
            ⁡
            
              [
              
                
                  
                    (
                    
                      
                        ACE
                        i
                      
                      
                        
                          -
                          10
                        
                        ⁢
                        
                          B
                          i
                        
                      
                    
                    )
                  
                  i
                
                ⁢
                Δ
                ⁢
                
                  
                
                ⁢
                
                  F
                  i
                
              
              ]
            
          
          ≤
          
            ɛ
            1
            2
          
        
      
    
    
      
        (
        2
        )
      
    
  




where ACEi is the clock-minute average of ACE (tie-line bias ACE), Bi is the frequency bias of the control area, ΔFi the clock-minute average frequency error, and ε21 is the interconnections' targeted frequency bound. In short, CPS1 measures the relationship between ACE and interconnection frequency on a 1-minute average basis. The equation can be written as follows:





  
    
      
        1
        ≥
        
          
            
              AVG
              
                12
                -
                month
              
            
            ⁡
            
              [
              
                
                  
                    (
                    
                      
                        ACE
                        i
                      
                      
                        
                          -
                          10
                        
                        ⁢
                        
                          B
                          i
                        
                      
                    
                    )
                  
                  i
                
                ⁢
                Δ
                ⁢
                
                  
                
                ⁢
                
                  F
                  i
                
              
              ]
            
          
          /
          
            ɛ
            1
            2
          
        
      
    
    
      
        (
        3
        )
      
    
  




If the above equation is evaluated for the various instantaneous inputs into ACEi, the resultant should be greater than or equal to 1.

The present invention, provides for a method and system by which automatic generation control of a power system is governed by compliance to NERC CPS1, CPS2 and DCS standards on a real-time basis through control of interchange and frequency errors.
Shown in FIG. 1 is a block diagram of an exemplary energy management system 1000 that incorporates the present invention. The energy management system 1000 provides for NERC compliance while minimizing costs associated with load and power management. An automatic generation control database 2010 (FIG. 2) stores all related monitoring and control data and applications related to the power system under operator management. From external monitoring and control devices such as sensors, and actuators and through a monitoring and control network such as a SCADA network, monitoring data is feed to the CPS monitoring module 1200. CPS monitoring Module 1200 (FIG. 2) comprises CPS1 monitoring module 2020 and CPS2 monitoring module 2030 as well as a DCS reporting module 2040. The received data form AGC database 2010 and HFD (Historic & Future data) database 2050 is used to calculate statistical information which will be used to control the system and render the system under NERC CPS1, CPS2 and DCS compliance. In particular, the received data and resultant statistics and/or historical performance data is used for analysis, decision and control management of the power system. Moreover, the data is further archived in the AGC database 2010 for use in future analysis. It should be understood that a reference to a module includes but is not limited to a set of instructions executable by a processor and may take the form of software, firmware or hardware or any combination thereof. Moreover, a processor should be understood to mean one or more computing devices or hardware devices that execute the commands in the set of instructions.
As shown in FIG. 2., the monitoring/reporting modules CPS1 monitoring 2020, CPS2 monitoring 2030, DCS reporting 2040 modules use real-time data from the field (field data 2012) as well as historical and future (expected/predicted) performance data to generate real-time performance statistical displays and calculated statistical displays based on past and/or predicted performance data. Moreover, the CPS monitoring module 1200 takes the net power flow and net interconnection frequency as well frequency bias βi to calculate an instantaneous ACEi value. As noted above, ACEi is the instantaneous difference between actual and scheduled interchange, taking into account the effects of frequency bias.
Because of the operational nature of the power system to be monitored and controlled, real-time monitoring and responses to these illustrated systems must be understood to be a real-time period of time less than or equal to one (1) hour. However from the field is preferably captured and processed in intervals of less than or equal to four (4) seconds. Each of the sampled data within the four (4) second interval is used to generate statistical and historical data for display, storage and future use. The CPS monitoring module 1200 will use the input ranges of frequency and interchange error to construct a CPS compliance plot that shows the CPS regions that are or are not in compliance with NERC compliance standards. In addition to the real-time data received from the field to generate real-time statistic, (frequency and interchange error), calculated statistics are generated by using raw and/or statistical data from previous predetermined intervals. For example, last day, 30 days and one (1) year data may also be used to display statistical performance. Moreover, monitoring module 1200 allows for operator selected target compliance, CPS2 Threshold setting (L10). In addition to statistical display statistical data may be communicated in hardcopy and/or electronic format through CPS reporting module 1300. In particular, CPS reporting module 1300 may be used to directly report performance compliance to NERC. An example of a statistical display is shown below in Table 1.








TABLE 1





CPSI Performance
CPS2 Performance


















Last Hour
140%
Last Hour
  83%


Last Day
158%
Last Day
97.1%


Last Month (30 days)
142%
Last Month (30 days)
  92%


Last Year
141%
Last Year
95.4%


Target Compliance
120%
CPS2 Threshold
50 MW




L10
65 MW









CPS real-time control module 1105 as shown in FIG. 1, comprises CPS1 module 1110, CPS2, DCS, Non-conforming Load, Control Decision and Generation Allocation modules 1110, 1120, 1130, 1140, 1150, 1160. Real-time statistical data and calculated statistical data as well DCS data are all sent to corresponding processing modules as shown in FIG. 1. CPS1 module 1110 processes real-time ACE data, evaluates the current CPS1 compliance factor and calculates necessary corrective action to bring the power system to meet CPS1 target values. More specifically, CPS1 module 1110 retrieves from the AGC database 2010 and/or HFD database 2050 real-time data, and statistics which are generated by the CPS1 monitoring module 2020 such as instantaneous ACEi values. As noted in equations (2) and (3), the compliance factor is dependent on the instantaneous ACEi values, average frequency error, frequency bias and interconnection's targeted frequency bounds. To comply with NERC CPS1 requirements, a one year average of CPS1 values must be greater than or equal to 100% or a compliance factor of 1.
An evaluation of the current 1-minute ACE average is made, and then at each AGC cycle, an instantaneous NERC CPS1 percentage or compliance factor is calculated. Depending on the resultant values as well as other input data to the Control Decision module 1150, corresponding and regulating controls signals are generated. The calculated CPS1 compliance factor is compared to the CPS1 target value set by the system operator. Whenever, the CPS1 falls below 1, a correction signal is generated.
Although the CPS1 target value is normally set to 1 (100%), the system operator may set the CPS1 target value higher or lower depending on the operators prior 12 month performance. For example, as shown in FIG. 3, a control threshold is set for 100% and whenever, the instantaneously calculated CPS1 percentage falls below the 100% threshold, a correction signal is generated. Alternatively, the trend within that 10-minute window or any other period may be used as a basis for determining what action is necessary.
As a secondary NERC requirement, CPS2 performance standard requires that the average ACE for each of the six ten-minute periods during the hour must be within specific limits referred to as L10 and calculated by the following equation:

AVG10-minuteACEi≦L10  (4)





  
    
      
        
          L
          10
        
        =
        
          1.65
          ⁢
          
            ɛ
            10
          
          ⁢
          
            
              (
              
                
                  -
                  10
                
                ⁢
                β
                ⁢
                
                  
                
                ⁢
                i
              
              )
            
          
          ⁢
          
            (
            
              
                -
                10
              
              ⁢
              β
              ⁢
              
                
              
              ⁢
              s
            
            )
          
        
      
    
    
      
        (
        5
        )
      
    
  




where ACEi is the instantaneous tie-line bias ACE value, 1.65 is a constant used to convert the frequency target to 90% probability, ε10 is the constant derived from the targeted frequency bound. The bound ε10 is the same for every control area within an interconnection, βi is the frequency bias of the control area and βs is the sum of frequency bias settings of the control areas in the respective interconnection. Similar to the CSP1 module, the CSP2 module also has an enterable control threshold that can be based on past CPS2 performance. The CPS2 module issues correction signals when the 10-minute average ACE exceeds the control threshold. For example and as shown in FIG. 4, generation of a control signal is necessary when the 10-minute average ACE exceeds the control limits (thresholds). However, it should be understood that because the L10 value is based on the current 10-minute period averaged ACE value, the CPS2 and L10 values are dynamic in nature.

The CPS2 module 1120 uses the time remaining in the 10-minute period to determine the magnitude of the needed correction on the power system. Moreover, the CPS2 module 1120 uses additional considerations, such as historical data to prevent excessive control due to the 10-minute ACE average being based on a small number of sample values. Additionally, the CPS2 module 1120 monitors the MW available during the remainder of the 10-minute period. If insufficient resources are available, an alarm is issued and the CPS2 module 1120 will ignore that ten minute period and focus instead on the next 10-minute period to prevent a consecutive violation. However, the CPS2 module 1120 may alternatively, issue an emergency alarm before the end of a 10-minute average period, when a very large ACE value above the L10 limits is detected. (See FIG. 4). Moreover, the CPS2 module 1120 may optionally also consider the performance trend as shown for example in FIG. 4, as a factor in determining whether an emergency alarm is warranted.
In comparison, it must be understood that CPS1 is a yearly standard that measures impact on frequency error with a compliance factor of 1 as its target value. On the other hand, CPS2 is a monthly standard that limits unscheduled flows within the L10 limits 90% of the time. As shown in FIGS. 3 & 4, maintaining compliance with these performance standards does not require a control area to exactly match, balance generation to load for each and every minute—small imbalances are permissible as are an occasional large imbalance.
The DCS module 1130 monitors the power system NERC defined disturbances such as sudden loss of generation or load, and calculates the necessary control actions necessary to return the system to pre-disturbance levels within the allowable recovery time. For purposes of disturbance compliance, a disturbance according to NERC is defined as an event whose magnitude is greater than or equal to 80% of the magnitude of the control area's most severe single contingency loss. However, load and generation excursions (e.g. pumped storage hydro, arc furnace, and rolling steel mills) that influence ACE are not reportable disturbance conditions. A control area may, at its discretion, measure its compliance based on the ACE measured ten minutes after the disturbance or based on the maximum ACE recovery measured within the ten minutes following the disturbance. Shown in FIGS. 13 and 14 are illustrations of disturbance recovery times.
Operationally, the DCS module preferably takes action on the occurrence of events such as significant or sudden changes in generation, load or tie-line flow. To maintain balance, the DCS module 1130 determines the largest possible contingency loss (i.e., 80% magnitude) or alternatively allows the operator to enter a manual disturbance threshold. When a disturbance occurs, a timer is started which counts down the time remaining according to the DCS standard. The DCS module 1130 monitors and compares the data reported by the DCS reporting module 2040 to determine a course of action. In particular, the DCS module 1130 determines the available ramp rate and the time remaining in order for it to determine if enough resources are available for recovery. If insufficient resources are at hand, an additional alarm will be generated. After each disturbance event, a disturbance log entry is made to chronicle operator performance/information and NERC reporting requirements. When necessary the DCS module will take corrective action to return the ACE to Zero (0) or its pre-disturbance conditions.
DCS compliance generally requires the utilization of contingency reserves so as to recover the ACE value to zero or pre-disturbance value. In determining the course of action, the DCS module calculates the disturbance threshold, pre-disturbance average ACE, the magnitude of MW loss, maximum and minimum ACE during disturbance, ACE value at after a 10-minute period after disturbance, and/or a recovery percentage to attain recovery. Preferably, recovery from a reportable disturbance is completed when a control area's ACE value returns to zero, if its ACE value just prior to the disturbance was positive or equal to zero. If the ACE value just prior to the disturbance is negative, then the ACE value must return to its pre-disturbance value. However, the system operator may set the ACE value to zero or pre-disturbance levels.
The control decision (DC) module 1150 takes real-time input from the separate CPS real-time control modules (DCS, CPS2, and CPS1 modules), and makes decisions based on signal priority, expected future events (from DED 1500) such as interchange and generation schedules, as well as tunable gain factors.
The control signals generated from the DCS, CPS2, and CPS1 modules are used as input signals to decide a course of action and are given priorities, 1(highest), 2(intermediate) and 3(lowest), respectively. The DCS control signal is given the highest consideration and given a priority value of 1, because a DCS violation or disturbance carries the greatest potential penalty to a control area. In the event that no disturbance event exists, the DC module 1150 then processes a CPS2 control signal (priority 2) to carry out CPS2 generation or other CPS2 compliance requirements. If CPS2 corrective requirements are unable to be met, for example due to limited resources or the time remaining within a 10-minute period, the DC module 1150 will ignore the current 10-minute period and focus instead on the next 10-minute period. This strategy is used to prevent excessive maneuvering of units and to minimize the occurrence of a subsequent CPS2 violation. Alternatively, if no DCS or CPS2 event exists, then the DC module 1150 will focus and evaluate CPS1 corrective action—for example, the amount of CPS1 requested MW generation.
After the DC module 1150 has determined the corrective action (i.e., MW generation), the DC module 1150 issues a command to the generation allocation (GA) module 1160 to implement the necessary regulation to available generators. The allocation of MW generation to available generators is based on assigned participation factors which are determined partially by look-ahead generator base point trajectories. As unit base points are adjusted by DED 1500 to accommodate load changes, the regulation requirements are reduced when possible by the CDA 1150 in order to keep the overall unit generation requirement stable and prevent excessive unit maneuvering.
The GA module 1160 distributes the total desired generation allocation to generating units by considering generating unit's operating mode, regulation participation factors assigned, ramping characteristics, prohibited regions, economic dispatch solution and the generating unit desired sustained generation set-point. More specifically, the GA module 1160 uses input data such as the total desired control area generation, unit sustained generation base points, unit actual generation (raw and filtered), as well as unit controller deadbands. The participation factor is based on regulating range and/or sustained rate of AGC controlled generating units. The distribution of regulation will then be done based on the participation factors. When possible however, the regulation will be distributed in increments that are greater than the unit controller deadbands. This will prevent regulation being allocated to units, but not being realized due to controller deadbands.
The non-conforming load processing (NCL) module 1140 is responsible for filtering non-controllable short-term load excursions created from loads such as arc furnaces, pumped storage, hydro, and rolling steel mills and to calculate a total non-conforming load MW value for use by the other CPS real-time control modules. In particular, the NCL module 1140 may utilize NCI telemetered MW values, NCL validity status, NCI shed status, NCL filter reset timer and/or NCL zero value timer to output a NCL filtered MW value, total NCL MW filtered value, total raw NCI MW value, ACE adjustment due to NCL and/or NCL zero value status. The processed non-conforming load may also be applied to the CPS2 and/or CPS1 modules.
The Very Short Term Load Prediction (VSTLP) module 1600 is a tool for predicting short term system loads. VSTLP module 1600 uses a set of neural networks to predict the system load for short term periods and in short term intervals, such as predicting the load of the system for the next 30-minutes, in 1-minute increments. The VSTLP module 1600 uses past load data and Short Term Load Forecast (STLF) data from STFL module 1650 (if available) to anticipate upcoming load trends in the next 15 minutes.
The VSTLP module 1600 uses artificial neural network (ANN) techniques to predict load requirements. Since load differs largely for weekdays and weekends, and varies among different weekdays, and has different dynamics from time to time during individual days, the ANN-based VSTLP module 1600 has the functional capability to among other features, distinguish between different seasons (for instance, summer and winter); distinguish between weekends, holidays and weekdays; distinguish between off-peak times and on-peak times; predict the next period (15 1-minute) load values which conform to the dynamics of recent time period(s) (for instance, the past 15 minutes); and to conform to the hourly average values of load that is forecasted by STLF module 1650 function or equivalent outside sources.
The VSTLP module 1600 will not directly take weather information as a consideration or input since such weather information is already accounted for and modeled by the STLF module 1650. However, it should be understood that day patterns may be obtained from weather adaptive load forecasts and/or manually entered. Nevertheless weather variation information will not be directly used (although other embodiments may) in the ANN-based VSTLP 1600, but the hourly forecasted load values by the STLF are to be used to adjust the minutely forecasted load values by the ANN-based VSTLP 1600.
To account for load changes along with seasons, weekdays/weekends/holidays, off-peak/on-peak times, the neural networks will be trained to capture the load patterns that occur at a specific season, a specific day, and a specific time period of the day. Initially, a year is split up into spring (Months 1 to 3), summer (months 4 to 6), fall (months 7 to 9) and winter (months 10 to 12). This split can be reconfigured according to real-world load characteristics at a specific location where this VSTL module 1600 is intended for use. Load shapes for weekends (Saturdays and Sundays) for example are dissimilar to those of weekdays (Mondays through Fridays). Division between weekdays and weekends may be performed and based on constructed, real world situations. For instance, weekends may include Saturdays, Sundays and Mondays, and weekdays may include Tuesdays through Fridays. Generally, load shapes for both weekdays and weekends are generally recurrent. However, the load shapes of holidays are quite different from those of normal weekdays/weekends. Special care must be given to the treatment of holidays, in particular, big holidays such as Thanksgiving holidays and Christmas holidays. Load shapes of neighboring days preceding holidays and following holidays are also affected. For example, the period from 6:00 pm on the day immediately preceding a holiday to 9:00 pm on the day immediately following the holiday will be regarded as holiday time when collecting data for training neural networks associated with VSTLP 1600.
Shown in FIG. 5, is an ANN-based VSTLP architecture. The Decision Algorithm 5010 in FIG. 5, processes the forecasted load values from respective ANN VSTLP modules 5012 through 5028 (weekdays, months, weekends, and holidays), at the end of each time constraint and minimizes the effects due to ANN VSTLP module 1600 switching. The Decision Algorithm 5010 may be realized through the use of neural networks. Over a smaller time period and as shown in FIG. 6, for each individual day, 6 neural networks (NN1, NN2, NN3, NN4, NN5 and NN6) will be used to cover the 24-hour period (time period). In this embodiment each neural network is responsible for a 4-hour period (sub-period), although other time allocations and number of neural networks may be used. For instance, NN1, NN2, NN3, NN4, NN5 and NN6 cover 12:00 am to 4:00 am, 4:00 am to 8:00 am, 8:00 am to 12:00 pm, 12:00 pm to 16:00 pm, 16:00 pm to 20:00 pm, and 20:00 pm to 12:00 am, respectively. To ensure the smooth transition from one 4-hour period to the next 4-hour period, one additional half-hour is added to both ends of each 4-hour period. For instance, NN1 covers 11:30 pm to 4:30 am, and NN2 covers 3:30 am to 8:30 am. The split of the whole day into 6 different 4-hour periods reflects the fact that loads are dynamic during the day. It should be understood that different allocations of time, overlaps and number of neural networks may be used. The use of multiple neural networks for different periods of the day allows for more accurate predictions. Such a split may be changed to comply with the patterns of real situations. Accordingly, each ANN VSTLP module 5012-5028 shown in FIG. 5, will have several ANN to predict load corresponding to a specific time period—this is also shown in FIG. 6.
The Decision Algorithm 5010 in the Daily ANN-based VSTLP diagram shown in FIG. 6, processes the forecasted load values from respective ANN VSTLP modules at the end of each time constraint and minimizes the effects due to the ANN VSTLP module switching. The Decision Algorithm Block 6010 may also be realized through the use neural networks and may use linear or non-linear decision algorithm and neural network transfer functions. Each NN will be realized with one or two hidden layers depending on the complexity of load dynamics it has to learn. More specifically, one or more neurons may be used in each neural network with varying weights and biases, linear and non-linear transfer functions. It should be understood that the input is affected by the weights and biases assigned to each neuron.
In the equations below, load is denoted by P. The forecast load values for the next 15 minutes can be expressed as a function of the current load and the previous N 1-minute load values:

{circumflex over (P)}n+i=ƒi(n, Pn,Pn−1,Pn−2, . . . ,Pn−N)  (6)

Where {circumflex over (P)}n+i(1≦i≦M) (7) is the predicted load for the future ith step (in minute) from current time n. Pn,Pn−1,Pn−2, . . . ,Pn−N (8) are the actual load values for current time and the previous N minutes. In this illustration, M is assigned a value of 15. The choice of N depends on the complexity of load dynamics, and will be determined through a trial-and-error experimental approach along with any available a priori information on load dynamics.

It is observed that in the above equation, the dynamics is time varying. However, the time-varying effect may be neglected within any of the individual time periods that are properly segmented within a whole day of 24 hours (23 or 25 when DST is present). The load dynamics varies from one individual time period to another. Accordingly, several NNs are used to deal with time-varying load dynamics. Within each individual time period, the load dynamics can be simply represented by

{circumflex over (P)}n+i=ƒi(Pn,Pn−1,Pn−2, . . . ,Pn−N)  (9)

The above equation can be rewritten in vector format as follows:





  
    
      
        
          [
          
            
              
                
                  
                    P
                    ⋒
                  
                  
                    n
                    +
                    1
                  
                
              
            
            
              
                
                  
                    P
                    ⋒
                  
                  
                    n
                    +
                    2
                  
                
              
            
            
              
                ⋮
              
            
            
              
                
                  
                    P
                    ⋒
                  
                  
                    n
                    +
                    M
                  
                
              
            
          
          ]
        
        =
        
          
            [
            
              
                
                  
                    f
                    1
                  
                
              
              
                
                  
                    f
                    2
                  
                
              
              
                
                  ⋮
                
              
              
                
                  
                    f
                    M
                  
                
              
            
            ]
          
          ⁢
          
            (
            
              
                P
                n
              
              ,
              
                P
                
                  n
                  -
                  1
                
              
              ,
              
                P
                
                  n
                  -
                  2
                
              
              ,
              ...
              ⁢
              
                
              
              ,
              
                P
                
                  n
                  -
                  N
                
              
            
            )
          
        
      
    
    
      
        (
        10
        )
      
    
  




Since ƒ1,ƒ2, . . . ,ƒM are all unknown, and the exact forms of these functions are not known, with historical load data available, a feed-forward neural network with proper layers may be trained to approximate such functions.





  
    
      
        
          [
          
            
              
                
                  
                    P
                    ⋒
                  
                  
                    n
                    +
                    1
                  
                
              
            
            
              
                
                  
                    P
                    ⋒
                  
                  
                    n
                    +
                    2
                  
                
              
            
            
              
                ⋮
              
            
            
              
                
                  
                    P
                    ⋒
                  
                  
                    n
                    +
                    M
                  
                
              
            
          
          ]
        
        =
        
          NN
          ⁡
          
            (
            
              
                P
                n
              
              ,
              
                P
                
                  n
                  -
                  1
                
              
              ,
              
                P
                
                  n
                  -
                  2
                
              
              ,
              ...
              ⁢
              
                
              
              ,
              
                
                  P
                  
                    n
                    -
                    N
                  
                
                ;
                
                  θ
                  _
                
              
            
            )
          
        
      
    
    
      
        (
        11
        )
      
    
  




Where θ is a parameter vector that contains weights between neighboring layers, and biases for all the neurons, and is to be tuned in a way such that the discrepancy between the calculated values for the future times and actual values is minimized in terms a performance index.

Neural networks are trained off-line using historical load data. After the completion of neural network training and validation, they are ready to be used on-line. Retraining may be done on a daily basis to tune the weights to take into account the exhibited load characteristics for the just past day. Online update of weights may also be possible.
When actual values Pn,Pn−1,Pn−2, . . . ,Pn−N (12) are available, forecasted load values {circumflex over (P)}n+i(1≦i≦M) (13) can be computed immediately. When some of the actual values for Pn,Pn−1,Pn−2, . . . ,Pn−N (14) are not available, estimates generated from ANN-based VSTLP at previous times will be used instead, and further future loads can be forecast. This can be done iteratively till all the minutely forecasted values for a whole hour are computed—this is shown in FIG. 7.
The Adaptive Scaling Block 7010 in the ANN-based VSTLP for Next Hour diagram FIG. 7 processes the incoming raw minutely forecasted load values from the four ANN-based VSTLP modules 7012-7018. Each of these VSTLP modules 7012-7018 is responsible for 15 minutes long prediction time interval, and for scaling them based on the hourly forecasted load values from the STLF.
It is assumed that the number of inputs, M, will not be larger than 15. Therefore, at any instant time n, and when starting to predict the load values for the next hour, the first ANN-based VSTLP will calculate the load values for the next 15 minutes, namely, {circumflex over (P)}n+i(1≦i≦15) (15), based on the actual previous load values. When predicting the load values for the time period from n+16 to n+30, the second ANN-based VSTLP will use some of the available minutely forecasted load values {circumflex over (P)}n+i (1≦i≦15) (16) since actual load values for this time period are not available yet. In the same manner, the predicted load values from the second ANN-based VSTLP for the time period from n+16 to n+30 are {circumflex over (P)}n+i(16≦i≦30) (17). Similarly, the third and fourth ANN-based VSTLPs will generate the predicted load values for another 15 minutes each, that is, {circumflex over (P)}n+i(31≦i≦45) (18), and {circumflex over (P)}n+i(46≦i ≦60)(19). These four ANN-based VSTLPs all together generate predicted load values for the next 60 minutes. However, some of these forecasted load values will not be used in adaptive scaling if the time stamp associated with them is beyond the current hour. If the current time instant n is i minutes after the hour, then within the hour, for the time period from n−i+1 to n (18), Pn−i+1,Pn−i+2,Pn−i+3, . . . ,Pn (20) actual values are available, and for the rest of the time period within the hour, only predicted values {circumflex over (P)}n+k(1≦k≦60−i) (21) are available. The forecasted load values {circumflex over (P)}n+k(60−i+1≦k≦60)(22) will be discarded or prediction for the corresponding time period will not be performed at all depending on the eventual implementation.
For example, let the scaling factor be sn, and let the hourly forecasted load value from STLF 1650 for the current hour be Pstlf. To make the minutely forecasted load values within the hour conform to the hourly forecasted load value from STLF with satisfactory accuracy, the following relationship is used:




  
    
      
        
          
            
              ∑
              
                k
                =
                
                  i
                  +
                  1
                
              
              0
            
            ⁢
            
              
            
            ⁢
            
              P
              
                n
                +
                k
              
            
          
          +
          
            
              s
              n
            
            ⁢
            
              
                ∑
                
                  k
                  =
                  1
                
                
                  60
                  -
                  i
                
              
              ⁢
              
                
              
              ⁢
              
                
                  P
                  ⋒
                
                
                  n
                  +
                  k
                
              
            
          
        
        =
        
          P
          stlf
        
      
    
    
      
        (
        23
        )
      
    
  




and thus,





  
    
      
        
          s
          n
        
        =
        
          
            
              P
              stlf
            
            -
            
              
                ∑
                
                  k
                  =
                  
                    
                      -
                      i
                    
                    +
                    1
                  
                
                0
              
              ⁢
              
                
              
              ⁢
              
                P
                
                  n
                  +
                  k
                
              
            
          
          
            
              ∑
              
                k
                =
                1
              
              
                60
                -
                i
              
            
            ⁢
            
              
            
            ⁢
            
              
                P
                ⋒
              
              
                n
                +
                k
              
            
          
        
      
    
    
      
        (
        24
        )
      
    
  




Then the modified minutely forecasted load values for the future time period from n+1 to n+60−i (25) within the current hour are sn{circumflex over (P)}n+k (1≦k≦60−i) (26). It should be understood however, that sn is time varying with the minutely update of 15-minute sliding window of prediction. The temporal behavior of sn is also an indicator of ANN-based VSTLP's performance. If sn fluctuates around 1 with a small magnitude (or substantially around 1), it indicates that the ANN-based VSTLP performs reasonably well in the sense that the minutely forecasted load values generated from ANN-based VSTLP conform to the hourly forecasted load values from STLF 1650 with the assumption that STLF 1650 fully captures the hourly load patterns with satisfactory accuracy. In addition, it should be noted that non-conforming load(s) must be dealt and processed separately, or filtered out to minimize or remove its influence on the prediction accuracy of the ANN-based VSTLP. Moreover, in certain instances the STLF 1650 should be greater than the largest prediction interval for which load predictions are made.

The historical load data stored in HFD/HIS 5030 must be formulated in a proper format before it can be used in training neural networks of the ANN-based VSTLP. This can be achieved by an interface program, which retrieves the historical data from HFD/HIS, reformats it and passes it to the main program responsible for neural network training. The historical data is preferably separated into two different sets. The first set of data is used to train the neural networks while the second set of data is used to evaluate the performance of the trained neural networks to avoid the over-training of the neural networks. Based on performance evaluation, the number of training epochs can be specified and final training can be achieved with all available and useful historical data. Information relating to the ANN-based VSTLP 1600, for example, the number of layers, number of neurons in each layer, activation functions, weights and biases, etc., will be saved in a file.
The structural and parametric information about the ANN-based VSTLP 1600 is retrieved to initialize neural networks of the ANN-based VSTLP. Same as for VSTLP offline training, an interface program retrieves historical load data from HFD/HIS 5030 or other online application programs that temporarily stores historical load data and passes it to the initialized neural networks for load forecast. Generated minutely forecasted load values will be used for generation, scheduling, and display purposes. In addition these load values will also be stored for after-the-fact performance evaluation.
Online updating of weights and biases of the neural networks can be done by using the immediately past actual load values and the forecasted load values generated from the neural networks. This is done with the understanding that past load characteristics may be used to improve the accuracy of immediate future load predictions. Beyond a certain time period (e.g., a time segment that is defined for example by the Daily ANN-based VSTLP diagram), the weights and biases are discarded, and the original weights and biases are reloaded. Updating of weights and biases can also be achieved on a weekly or monthly basis depending on real world situations.
The Dynamic Economic Dispatch (DED) module 1500 utilizes ramping constraints of generating units that are dispatchable over a consecutive set of time intervals. The objective of DED 1500 is to produce optimal generation output trajectories for each participating generating unit so that the overall system resource optimization over a period of time spanning a number of consecutive time intervals can be achieved. DED module 1500 utilizes and takes into consideration, system power balance, system spinning reserve requirement, power output limits and ramp rate limits of the generating units for the dispatch time period. DED module 1500 assigns energy and reserve obligations among the committed resources most economically so that the integrated cost of the power production over the specified dispatch time period (e.g. 30 minutes look-ahead time horizon) can be minimized.
As shown in FIGS. 8 & 9, DED module 1500 uses the predicted load profile for the time period of dispatch interest that is generated by the VSTLP module 1600 as the projected system load demand in the near future. Optimal values for power outputs of generating units that are calculated by the DED module 1500 are sent to the Load Frequency Control (LFC) module 8020 as base points for the generating units. The constantly changing ACE caused by the net interchange deviation and interconnection frequency deviation are regulated preferably within a predetermined range around zero, instead of towards zero, in order that regulation efforts may be reduced while NERC mandated CPS criteria are met as well as a reduction in the number of unit reversals.
As shown in FIG. 10, the DED module 1500 comprises a Data Initialization (DI) 1225 and a DED solution module 1230. The DI module 1225 initializes internal data structures (within the DED scope) that include generating unit attributes. DI module 1225 is also responsible for initialization of projected system load profiles, system spinning reserve requirements and net interchange schedules for each time interval of a dispatch time period. Initialization of internal structure of generating unit includes initialization of unit's operating mode, power output limits and ramping rate limits from a generating unit's generation schedule. From the generation schedule, unit parameters such as unit fuel type selection, unit fuel cost for fuel type selected, unit topping fuel cost and MW breakpoint, unit incremental heat rate curve, unit efficiency factor, and unit incremental maintenance cost will be used to construct incremental cost curves for each interval of the dispatch time period as part of initialization.
The DED solution (DS) module 1230 performs dynamic economic dispatch solutions and calculates unit base-point trajectories. The solution approach seeks the feasible solution in a two-level hierarchy. The higher level looks ahead, calculates possible violations, and makes adjustments to correct the violations. The lower level performs economic dispatch with adjusted “generation to be dispatched” to allocate generation and reserve in the most economic manner. This sub-function comprises the following essential functionalities: 1) control area dispatch to coordinate unit level dispatch over a dispatch time horizon and calculate system level economic benefits; 2) unit dispatch to calculating optimal unit generation, optimal unit reserve, and unit production cost; optimization model formulation to create mathematical models for optimization; 3) and optimization computation core to performing minimization of the overall control area total cost integrated over the dispatch time horizon based on the established optimization model.
Operationally, a mechanism is provided to access the AGC database 2010 and retrieve required information and store the information within the application. The required information is also used to initialize the core DED program that performs all optimization calculations. In addition, ICC curves are constructed for each interval of the entire dispatch time horizon. Because a generating unit may have multiple Incremental Heat Rate (IHR) curves associated with it, an operator may individually select the curve to be used for that generating unit. Each generating unit IHR curve is represented piecewise linear monotonically increasing segments. Moreover, several fuel types are supported for each unit and the operator may also select the fuel type to be used. Associated with each fuel type is a fuel cost which may also be changed by the operator. The selected fuel cost becomes the base fuel cost and is applied to the entire range of the IHR curve. For generating units that use topping fuels, the selected base fuel cost only applies to the range of the IHR curve up to the MW breakpoint and the topping fuel is used thereafter. The topping fuel cost must be greater than the base fuel cost to ensure that the resultant incremental cost curve is monotonically increasing. In addition, the operator may modify the incremental maintenance cost or efficiency factor for any unit. The incremental cost curve calculated from the selected incremental heat rate curve is as follows:

ICit=IMCit+IHRit×FCit/EFit  (27)

Where ICit denotes the incremental cost, IMCit the incremental maintenance cost, IHRit the incremental heat rate, FCit the fuel cost, EFit the efficiency factor, respectively; the subscript i is the unit index and the superscript is the index of time intervals.

Functionally, all inputs to the DI module 1225 are preferably read from the AGC database 2010 and ICC curves are constructed while all outputs are sent to the DS module. The DS module 1230 creates an optimization model(s), and performs optimization calculations that include for example, unit level optimization, plant level optimization, control area level optimization while respecting power flow limits, reserve requirements, power balance, ramp rate limits.
In carrying out its tasks, the DS module 1230 preferably operates within determined or select boundaries, establishes a Security Constrained Dynamic Economic Dispatch model, performs cost minimization at both control area level and generating unit level, operates with system level and unit level constraints such as system power balance and spinning reserve requirements for each time interval of the dispatch time horizon, supports piecewise linear and staircase non-decreasing ICCs, generating power limits, power limits, ramp rate limits, spinning reserve limits; calculates optimal system level generation, reserve, and production costs; and calculates optimal unit level generation, reserve and production costs.
To achieve the above functionalities and within these constrains, Lagrange Relaxation approach and Dantzig-Wolfe Decomposition are used. Dantzig-Wolfe Decomposition coupled with a revised simplex method provides a solution to the conventional SCED problem and can be used for solving a number of SCEDs corresponding to individual time intervals. Lagrange Relaxation is used to coordinate the solutions among different SCEDs coupled with ramping constraints. The Dynamic Economic Dispatch problem can be mathematically formulated as follows:
Minimize




  
    
      
        SystemCost
        =
        
          
            ∑
            
              t
              ∈
              T
            
            
              
            
          
          ⁢
          
            
          
          ⁢
          
            
              ∑
              
                unit
                ∈
                
                  U
                  A
                
              
              
                
              
            
            ⁢
            
              
            
            ⁢
            
              (
              
                
                  StatCost
                  unit
                  t
                
                ⁡
                
                  (
                  
                    P
                    unit
                    t
                  
                  )
                
              
              )
            
          
        
      
    
    
      
        (
        28
        )
      
    
  




Subject to the following constraints:

Power balance:





  
    
      
        
          
            
              ∑
              
                unit
                ∈
                
                  U
                  A
                
              
              
                
              
            
            ⁢
            
              
            
            ⁢
            
              (
              
                
                  P
                  unit
                  t
                
                /
                
                  pf
                  unit
                  SE
                
              
              )
            
          
          =
          
            
              P
              load
              t
            
            +
            
              NetInt
              CA
              t
            
          
        
        ;
        
          t
          ⁢
          
            
          
          ∈
          
            
          
          ⁢
          T
        
      
    
    
      
        (
        29
        )
      
    
  




Reserve requirement:





  
    
      
        
          
            
              ∑
              
                unit
                ∈
                
                  U
                  A
                
              
              
                
              
            
            ⁢
            
              R
              unit
              t
            
          
          ≥
          
            R
            req
            t
          
        
        ;
        
          t
          ⁢
          
            
          
          ∈
          
            
          
          ⁢
          T
        
      
    
    
      
        (
        30
        )
      
    
  




Line constraints:





  
    
      
        
          
            
              -
              
                P
                line
                max
              
            
            ≤
            
              P
              line
              t
            
          
          =
          
            
              
                P
                line
                SE
              
              +
              
                
                  ∑
                  
                    unit
                    ⁢
                    
                      
                    
                    ∈
                    
                      
                    
                    ⁢
                    
                      U
                      A
                    
                  
                  
                    
                  
                
                ⁢
                
                  
                
                ⁢
                
                  
                    SF
                    unit
                    SE
                  
                  ·
                  
                    (
                    
                      
                        P
                        unit
                        t
                      
                      -
                      
                        P
                        unit
                        SE
                      
                    
                    )
                  
                
              
            
            ≤
            
              P
              line
              max
            
          
        
        ;
        
          t
          ⁢
          
            
          
          ∈
          
            
          
          ⁢
          T
        
      
    
    
      
        (
        31
        )
      
    
  




Plant limits:





  
    
      
        
          
            P
            plant
            t
          
          =
          
            
              
                ∑
                
                  unitεU
                  P
                
                
                  
                
              
              ⁢
              
                
              
              ⁢
              
                P
                unit
                t
              
            
            ≤
            
              P
              plant
              max
            
          
        
        ;
        
          t
          ⁢
          
            
          
          ∈
          
            
          
          ⁢
          T
        
      
    
    
      
        (
        32
        )
      
    
  




Unit ramp rate limits: ΔPunitDn≦ΔPunitt=Punitt−Punitt−1≦ΔPunitUp; t∈T

Unit power limits: Punit,EffMin≦Punitt≦Punit,EffMax; t∈T (33)

Unit capacity limits: Runitt+Punitt≦Punit,OpMax; t∈T (34)

Unit reserve limits: 0≦Runitt≦Runit,Max; t∈T (35)

Where

    Punitt is unit power generation at time interval t;
    ΔPunitt=Punitt−Punitt−1 is unit ramping at time interval t;
    StatCostunitt(·) is unit operation cost at time interval t;
    t is any time interval of the dispatch time horizon;
    T is the dispatch time horizon that can be represented by T={t|t=t1,t2, . . . ,tN} where t1,t2), . . . ,tN are N consecutive time intervals in the forward time order; for notation convenience, define ti−1=ti−1 where i=1,2, . . . ,N with the understanding that t0 representing the current (real-time) time interval;
    UA is the set of units belonging to a control area;
    UP is the set of units belonging to a power plant;
    Punitt is unit power generation at time interval t;
    pƒunitSE is unit penalty factor (superscript SE stands for State Estimator of NA);
    Runitt is unit spinning reserve at time interval t;
    Ploadt is system load at time interval t;
    NetIntCAt is Control Area net interchange at time interval t;
    Rreqt is spinning reserve requirement at time interval t;
    PunitSE is unit estimated power generation at time interval t;
    Plinet is line power flow at time interval t;
    PlineSE is line estimated power flow at time interval t;
    SFline,unitSE is unit estimated shift factor for line;
    Plinemax is line capacity;
    Pplantt is plant power generation at time interval t;
    Pplantmax is plant power generation limit;
    Punit,EffMin,Punit,EffMax are unit power output effective low/high limits;
    ΔPunitDn, ΔPunitUp are unit Up and Down ramping limits;
    Punit,OpMax is unit Operating Maximal limit;
    Runit,Max is spinning reserve maximal limit.

Lagrange Relaxation



The Lagrange Relaxation methodology is used to dualize ramping constraints using multipliers ρunitt;Up for upward ramping limits and ρunitt;Dn for downward ramping limits. The DED problem can be expressed in the equivalent form:




  
    
      
        
          max
          
            
              ρ
              unit
              
                t
                ;
                Up
              
            
            ;
            
              
                ρ
                unit
                
                  t
                  ;
                  Dn
                
              
              ≥
              0
            
          
        
        ⁢
        
          
            min
            
              P
              unit
              t
            
          
          ⁢
          
            {
            
              
                
                  ∑
                  
                    t
                    ∈
                    
                      
                    
                    ⁢
                    T
                  
                  
                    
                  
                
                ⁢
                
                  
                
                ⁢
                
                  
                    ∑
                    allunits
                    
                      
                    
                  
                  ⁢
                  
                    
                  
                  ⁢
                  
                    
                      C
                      unit
                      t
                    
                    ⁡
                    
                      (
                      
                        P
                        unit
                        t
                      
                      )
                    
                  
                
              
              +
              
                
                  ρ
                  unit
                  
                    t
                    ;
                    Up
                  
                
                ⁡
                
                  (
                  
                    
                      P
                      unit
                      t
                    
                    -
                    
                      P
                      unit
                      
                        t
                        -
                        1
                      
                    
                    -
                    
                      Δ
                      ⁢
                      
                        
                      
                      ⁢
                      
                        P
                        unit
                        Up
                      
                    
                  
                  )
                
              
              -
              
                
                  
                    ρ
                    unit
                    
                      t
                      ;
                      Dn
                    
                  
                  ⁡
                  
                    (
                    
                      
                        P
                        unit
                        t
                      
                      -
                      
                        P
                        unit
                        
                          t
                          -
                          1
                        
                      
                      -
                      
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          P
                          unit
                          Dn
                        
                      
                    
                    )
                  
                
                ⁢
                
                  
                  
                    
                      P
                      unit
                      t
                    
                    ∈
                    
                                            SCED
                      t
                    
                  
                  }
                
              
            
          
        
      
    
    
      
        (
        36
        )
      
    
  




where Punitt∈ISCEDt presents all static SCED constraints at time interval t, and Punitt−1 for t=t1 represents Punitt0 with t0 being the current time interval (actual values associated with t0 are available, for instance, Punitt0 is the actual power output of the unit). Using Lagrange function:





  
    
      
        
          L
          ⁡
          
            (
            
              
                ρ
                unit
                
                  t
                  ;
                  Up
                
              
              ,
              
                ρ
                unit
                
                  t
                  ;
                  Up
                
              
            
            )
          
        
        =
        
          
            
              
                ρ
                unit
                
                  t
                  ;
                  Dn
                
              
              ·
              Δ
            
            ⁢
            
              
            
            ⁢
            
              P
              unit
              Dn
            
          
          -
          
            
              ρ
              unit
              
                t
                ;
                Up
              
            
            ·
            
              P
              unit
              Up
            
          
          +
          
            
              min
              
                P
                unit
                t
              
            
            ⁢
            
              {
              
                
                  
                    ∑
                    
                      t
                      ⁢
                      
                        
                      
                      ∈
                      
                        
                      
                      ⁢
                      T
                    
                    
                      
                    
                  
                  ⁢
                  
                    
                  
                  ⁢
                  
                    
                      ∑
                      allunits
                      
                        
                      
                    
                    ⁢
                    
                      
                    
                    ⁢
                    
                      (
                      
                        
                          
                            C
                            unit
                            t
                          
                          ⁡
                          
                            (
                            
                              P
                              unit
                              t
                            
                            )
                          
                        
                        +
                        
                          
                            ρ
                            unit
                            
                              
                                t
                                ;
                                
                                  
                                
                                ⁢
                                Up
                              
                              ⁢
                              
                                
                              
                            
                          
                          ⁢
                          
                            
                          
                          ⁢
                          
                            (
                            
                              
                                P
                                unit
                                t
                              
                              -
                              
                                P
                                unit
                                
                                  t
                                  -
                                  1
                                
                              
                            
                            )
                          
                        
                        -
                        
                          
                            ρ
                            unit
                            
                              t
                              ;
                              Dn
                            
                          
                          ⁡
                          
                            (
                            
                              
                                P
                                unit
                                t
                              
                              -
                              
                                P
                                unit
                                
                                  t
                                  -
                                  1
                                
                              
                            
                            )
                          
                        
                      
                      )
                    
                  
                
                ❘
                
                  
                    P
                    unit
                    t
                  
                  ∈
                  
                                        SCED
                    t
                  
                
              
              }
            
          
        
      
    
    
      
        (
        37
        )
      
    
  




the DED dual problem becomes simple optimization:





  
    
      
        
          
            max
            
              
                P
                unit
                
                  t
                  ;
                  Up
                
              
              ;
              
                
                  ρ
                  unit
                  
                    t
                    ;
                    Dn
                  
                
                ≥
                0
              
            
          
          ⁢
          
            L
            ⁡
            
              (
              
                
                  ρ
                  unit
                  
                    t
                    ;
                    Up
                  
                
                ;
                
                  ρ
                  unit
                  
                    t
                    ;
                    Dn
                  
                
              
              )
            
          
        
        ;
        
          t
          ⁢
          
            
          
          ∈
          
            
          
          ⁢
          
            T
            .
          
        
      
    
    
      
        (
        38
        )
      
    
  




In formulating the DED problem in this manner, it can be solved by iterative solution of SCED problem and Lagrange dual problem. The SCED problem is:




  
    
      
        
          
            
              
                min
                
                  P
                  unit
                  t
                
              
              ⁢
              
                =
                
                ⁢
                
                  {
                  
                    
                      
                        ∑
                        
                          t
                          ∈
                          T
                        
                        
                          
                        
                      
                      ⁢
                      
                        
                      
                      ⁢
                      
                        
                          ∑
                          allunits
                          
                            
                          
                        
                        ⁢
                        
                          
                        
                        ⁢
                        
                          (
                          
                            
                              
                                C
                                unit
                                t
                              
                              ⁡
                              
                                (
                                
                                  P
                                  unit
                                  t
                                
                                )
                              
                            
                            +
                            
                              
                                ρ
                                unit
                                
                                  t
                                  ;
                                  Up
                                
                              
                              ⁡
                              
                                (
                                
                                  
                                    P
                                    unit
                                    t
                                  
                                  -
                                  
                                    P
                                    unit
                                    
                                      t
                                      -
                                      1
                                    
                                  
                                
                                )
                              
                            
                            -
                            
                              
                                ρ
                                unit
                                
                                  t
                                  ;
                                  Dn
                                
                              
                              ⁡
                              
                                (
                                
                                  
                                    P
                                    unit
                                    t
                                  
                                  -
                                  
                                    P
                                    unit
                                    
                                      t
                                      -
                                      1
                                    
                                  
                                
                                )
                              
                            
                          
                          )
                        
                      
                    
                    ❘
                    
                      
                        P
                        unit
                        t
                      
                      ∈
                      
                                                SCED
                        t
                      
                    
                  
                  }
                
              
            
          
        
        
          
            
              =
              
              ⁢
              
                
                  min
                  
                    P
                    unit
                    t
                  
                
                ⁢
                
                  {
                  
                    
                      
                        ∑
                        
                          t
                          ∈
                          
                            (
                            
                              t
                              N
                            
                            )
                          
                        
                        
                          
                        
                      
                      ⁢
                      
                        
                      
                      ⁢
                      
                        
                          ∑
                          allunits
                          
                            
                          
                        
                        ⁢
                        
                          
                        
                        ⁢
                        
                          
                            C
                            unit
                            t
                          
                          ⁡
                          
                            (
                            
                              P
                              unit
                              t
                            
                            )
                          
                        
                      
                    
                    +
                    
                      
                        ∑
                        
                          t
                          ∈
                          
                            
                          
                          ⁢
                          
                            T
                            -
                            
                              {
                              
                                t
                                N
                              
                              }
                            
                          
                        
                        
                          
                        
                      
                      ⁢
                      
                        
                      
                      ⁢
                      
                        
                          ∑
                          allunits
                          
                            
                          
                        
                        ⁢
                        
                          
                        
                        ⁢
                        
                          (
                          
                            
                              
                                C
                                unit
                                t
                              
                              ⁡
                              
                                (
                                
                                  P
                                  unit
                                  t
                                
                                )
                              
                            
                            +
                            
                              
                                (
                                
                                  
                                    ρ
                                    unit
                                    
                                      t
                                      ;
                                      Up
                                    
                                  
                                  -
                                  
                                    ρ
                                    unit
                                    
                                      
                                        1
                                        +
                                        1
                                      
                                      ;
                                      Up
                                    
                                  
                                
                                )
                              
                              ⁢
                              
                                P
                                unit
                                t
                              
                            
                            -
                          
                        
                      
                    
                  
                
              
            
          
        
        
          
            
              
                
                  
                    
                    ⁢
                    
                      
                        (
                        
                          
                            ρ
                            unit
                            
                              t
                              ;
                              Dn
                            
                          
                          -
                          
                            ρ
                            unit
                            
                              
                                t
                                +
                                1
                              
                              ;
                              Dn
                            
                          
                        
                        )
                      
                      ⁢
                      
                        P
                        unit
                        t
                      
                    
                    )
                  
                  ❘
                  
                    
                      P
                      unit
                      t
                    
                    ∈
                    
                                            SCED
                      t
                    
                  
                
                }
              
              +
              
                
                  (
                  
                    
                      ρ
                      unit
                      
                        
                          t
                          1
                        
                        ;
                        Dn
                      
                    
                    -
                    
                      ρ
                      unit
                      
                        
                          t
                          1
                        
                        ;
                        Up
                      
                    
                  
                  )
                
                ⁢
                
                  P
                  unit
                  
                    t
                    0
                  
                
              
            
          
        
      
    
    
      
        (
        39
        )
      
    
  




i.e.:





  
    
      
        
          min
          
            P
            unit
            t
          
        
        ⁢
        
          {
          
            
              
                
                  ∑
                  
                    t
                    ∈
                    
                      {
                      
                        t
                        N
                      
                      }
                    
                  
                  
                    
                  
                
                ⁢
                
                  
                
                ⁢
                
                  
                    ∑
                    allunits
                    
                      
                    
                  
                  ⁢
                  
                    
                  
                  ⁢
                  
                    
                      C
                      unit
                      t
                    
                    ⁡
                    
                      (
                      
                        P
                        unit
                        t
                      
                      )
                    
                  
                
              
              +
              
                
                  ∑
                  
                    t
                    ∈
                    
                      
                    
                    ⁢
                    
                      T
                      -
                      
                        {
                        
                          t
                          N
                        
                        }
                      
                    
                  
                  
                    
                  
                
                ⁢
                
                  
                
                ⁢
                
                  
                    ∑
                    allunits
                    
                      
                    
                  
                  ⁢
                  
                    
                  
                  ⁢
                  
                    (
                    
                      
                        
                          C
                          unit
                          t
                        
                        ⁡
                        
                          (
                          
                            P
                            unit
                            t
                          
                          )
                        
                      
                      +
                      
                        
                          (
                          
                            
                              ρ
                              unit
                              
                                t
                                ,
                                Up
                              
                            
                            -
                            
                              ρ
                              unit
                              
                                
                                  t
                                  +
                                  1
                                
                                ;
                                Up
                              
                            
                          
                          )
                        
                        ⁢
                        
                          P
                          unit
                          t
                        
                      
                      -
                      
                        
                          (
                          
                            
                              ρ
                              unit
                              
                                t
                                ;
                                Dn
                              
                            
                            -
                            
                              ρ
                              unit
                              
                                
                                  t
                                  +
                                  1
                                
                                ;
                                Dn
                              
                            
                          
                          )
                        
                        ⁢
                        
                          P
                          unit
                          t
                        
                      
                    
                    )
                  
                
              
            
            ❘
            
              
                P
                unit
                t
              
              ∈
              
                                SCED
                t
              
            
          
          }
        
      
    
    
      
        (
        40
        )
      
    
  




This problem consists of time interval independent static SCED problems:





  
    
      
        
          
            min
            
              P
              unit
              t
            
          
          ⁢
          
            {
            
              
                
                  ∑
                  allunits
                  
                    
                  
                
                ⁢
                
                  
                
                ⁢
                
                  (
                  
                    
                      
                        C
                        unit
                        t
                      
                      ⁡
                      
                        (
                        
                          P
                          unit
                          t
                        
                        )
                      
                    
                    +
                    
                      
                        (
                        
                          
                            ρ
                            unit
                            
                              t
                              ;
                              Up
                            
                          
                          -
                          
                            ρ
                            unit
                            
                              
                                t
                                +
                                1
                              
                              ;
                              Up
                            
                          
                        
                        )
                      
                      ⁢
                      
                        P
                        unit
                        t
                      
                    
                    -
                    
                      
                        (
                        
                          
                            ρ
                            unit
                            
                              t
                              ;
                              Dn
                            
                          
                          -
                          
                            ρ
                            unit
                            
                              
                                t
                                +
                                1
                              
                              ;
                              Dn
                            
                          
                        
                        )
                      
                      ⁢
                      
                        P
                        unit
                        t
                      
                    
                  
                  )
                
              
              ❘
              
                
                  P
                  unit
                  t
                
                ∈
                
                                    SCED
                  t
                
              
            
            }
          
        
        ;
        
          t
          ∈
          
            T
            -
            
              
                {
                
                  t
                  N
                
                }
              
              ⁢
              
                
                  min
                  
                    P
                    unit
                    t
                  
                
                ⁢
                
                  {
                  
                    
                      
                        ∑
                        allunits
                        
                          
                        
                      
                      ⁢
                      
                        
                          C
                          unit
                          t
                        
                        ⁡
                        
                          (
                          
                            P
                            unit
                            t
                          
                          )
                        
                      
                    
                    ❘
                    
                      
                        P
                        unit
                        t
                      
                      ∈
                      
                                                SCED
                        t
                      
                    
                  
                  }
                
              
            
          
        
        ;
        
          t
          ∈
          
            {
            
              t
              N
            
            }
          
        
      
    
    
      
        (
        41
        )
      
    
  




Only objective functions for these SCED problems are modified by Lagrange multipliers ρunitt;Up and ρunitt;Dn.

Under these formulations, Lagrange coordination can be performed through the following steps:

    1. Initialization: set all ρunitt;Up and ρunitt;Dn zero
    2. Coordination: for all t∈T solve Lagrange dual problem to update multipliers ρunitt;Up and ρunitt;Dn 
    3. SCED Solution: for all t∈T solve SCED for given ρunit t;Up and ρunitt;Dn 
    4. Optimality: check optimality conditions
    5. Iteration: continue with step 2.

Lagrange Dual Problem Solution Alternatives 1 & 2

Alternative 1

Lagrange dual problem:







  
    
      max
      
        
          ρ
          unit
          
            t
            ;
            Up
          
        
        ;
        
          
            ρ
            unit
            
              t
              ;
              Dn
            
          
          ≥
          0
        
      
    
    ⁢
    
      L
      ⁡
      
        (
        
          
            ρ
            unit
            
              t
              ;
              Up
            
          
          ;
          
            ρ
            unit
            
              t
              ;
              Dn
            
          
        
        )
      
    
  
  ;
  
    t
    ∈
    T
  




is separable by time intervals t∈T. Lagrangian function is concave and piecewise differentiable. The optimal values of multipliers ρunitt;Up and ρunitt;Dn must satisfy the first order condition:

(0,0)∈∂L(ρunitt;Up;ρunitt;Dn);t∈T.

The sub-gradient ∂L contains the violations of ramping limits at each time interval t∈T:

(Punitt−Punitt−1−ΔPunitUp,Punitt−Punitt−1−ΔPunitDn)∈∂L(ρunitt;Up;ρunitt;Dn);t∈T  (42)

Note that at one time interval only one ramping violation can occur. The dual problem optimality conditions become:

Punitt−Punitt−1−ΔPunitUp=0 if ρunitt;Up>0; and Punitt−Punitt−1−ΔPunitUp<0 if ρunitt;Up=0   (43)

Punitt−Punitt−1−ΔPunitDn=0 if ρunitt;Dn>0; and Punitt−Punitt−1−ΔPunitDn>0 if ρunitt;Dn=0   (b 44)

These statements provide that optimal values of Lagrange multipliers force ramping constraints to be critical or redundant. As such, the Lagrange dual problem can be solved using one-dimensional sub-gradient method. In this case sub-gradient method presents the following rules:

    1. if the ramping constraint is violated then increase its Lagrange multiplier
    2. if the Lagrange multiplier is positive and ramping constraint redundant then decrease its Lagrange multiplier; and
    3. if Lagrange multiplier is zero and ramping constraint redundant then keep its Lagrange multiplier at zero.


These rules define only the direction of Lagrange multiplier update, but not amount of change. Instead of the customarily used fixed proportional update known as step length, the direction taken is to use a customized approach.
Lagrange multiplier increasing Δρunitt;Up for upward ramping constraint at time interval t will cause increasing of unit incremental costs at time interval t−1, and decreasing of unit incremental costs at time interval t. The update should eliminate ramping constraint violation. Similarly, Lagrange multiplier increasing Δρunitt;Dn for downward ramping constraint at time interval t will cause increasing of unit incremental costs at time interval t, and decreasing of unit incremental costs at time interval t−1. These relationships are illustrated in the diagram shown in FIG. 11. This solution can be calculated using the following algorithm:

    1. check if there are any violations of ramping constraints.
    2. loop through the set of units for violation of upward ramping constraints,
    3. set Punitt−1;Up=Punitt−1;Punitt;Up=Punitt;
    4. put ΔPunitUp in the middle of segment [Punitt−1;Up;Punitt;Up];
    5. calculate unit incremental costs for t−1 and t time intervals at the end points of segment ΔPunitUp;
    6. select smaller of Δρunitt−1;Up and Δρunitt;Up and reduce segment [Punitt−1;Punitt;Up] using that update;
    7. repeat steps 3 to 5 several times (even one pass can be sufficient) until no violation of the ramping constraint;
    8. update Lagrange multipliers ρunitt;Up+Δρunitt:Up.
    9. loop through the set of units for overly penalization on upward ramping,
    10. set Punitt−1;Up=Punitt−1;Punitt;Up=Punitt;
    11. put ΔPunitUp centered around segment [Punitt−1;Up;Punitt;Up];
    12. calculate unit incremental costs for t−1 and t time intervals at the end points of segment ΔPunitUp;
    13 select smaller of Δρunitt−1;Up and Δρunitt;Up and enlarge segment [Punitt−1;Up;Punitt;Up] using that update;
    14. repeat steps 11 to 13 several times (even one pass can be sufficient) until the ramping constraint is binding;
    15. update Lagrange multipliers ρunitt;Up−Δρunitt;Up.
    16. loop through the set of units for violation of downward ramping constraints,
    17. set Punitt−1;Dn=Punitt−1;Punitt;DnPunitt;
    18. put ΔPunitDn in the middle of segment [Punitt−1;Dn;Punitt;Dn];
    19. calculate unit incremental costs for t−1 and t time intervals at the end points of segment ΔPunitDn;
    20. select smaller of Δρunitt−1;Dn and Δρunit t;Dn and reduce segment [Punitt−1;Dn;Punitt;Dn] using that update;
    21. repeat steps 18 to 20 several times (even one pass can be sufficient);
    22. update Lagrange multipliers ρunitt;Dn+Δρunitt;Dn.

loop through the set of units for overly penalization on downward ramping,

    23. set Punitt−1;Dn=Punitt−1;Punit t;Dn=Punitt;
    24. put ΔPunitDn centered around segment [Punitt−1;Dn;Punitt;Dn]
    25. calculate unit incremental costs for t−1 and t time intervals at the end points of segment ΔPunitDn;
    26. select smaller of Δρunitt−1;Dn and Δρunitt;Dn and enlarge segment [Punitt−1;Dn;Punitt;Dn] using that update;
    27. repeat steps 25 to 27 several times (even one pass can be sufficient) until the ramping constraint is binding; and
    28. update Lagrange multipliers ρunitt;Dn−Δρunitt;Dn.


In the event that Lagrange dual problem is not feasible then its solution algorithms will have a tendency to increase multipliers of ramping constraints infinitely. This situation can be identified and controlled directly because ramping constraint multipliers cannot be higher then the range of unit incremental costs.
Alternative 2:
The following two examples will serve as a basis for discussing the four cases that are presented below. In a cost ($/MW) versus power output (MW) relationship, let P designates unit power output. L (L_up or L_down) is a ramping constraint: L_up is the upward constraint and L_down is the downward constraint which form upward and downward boundaries for ramping. If for example, upward ramp rate R_up is 10 MW/minute, and if the time interval T (for Dynamic Economic Dispatch) is 1 minute, then L_up=R_up*T=10 MW. Suppose that if for the time interval t, at the left boundary point of this interval, the unit power output (of a generating unit X) P_t=20 MW; at the right boundary point of this time interval, the unit power output (of the same generating unit X) P_(t+1)=40 MW, then the unit is ramping up. Note that P_(t+1)−P_t=40−20=20 W>L_up. Therefore, the unit (X) is violating its upward ramping constraint.
Using the same example but with slight change of numbers: Let P_(t+1)=25. Then P_(t+1)−P_t=25−20=5<L_up. So the unit is not violating its upward ramping constraint. For these two cases, the Lagrange multiplier (in $/MWh or same unit of the vertical axis) for this unit and for this time interval can be adjusted to approach the optimal case in which P_(t+1)−P_t=L_up, i.e., so that the constraint is binding.
Now, considering the many possible cases more generally, let Lup designate the upward ramping constraint, Ldown the downward ramping constraint.
In Case I, the unit is ramping up but violating the ramping constraint, so the adjustment to the Lagrange multiplier for this unit and for this time interval can be computed in such a way that the ramping violation is removed but the ramping amount equals the allowed maximum ramping amount Lup for achieving best economics.
In Case II, the unit is ramping up without violating the ramping constraint, so the adjustment to the Lagrange multiplier for this unit and for this time interval can be computed in such a way that the ramping amount equals the allowed maximum ramping amount Lup for achieving best economics but no more.
Case III and Case IV describe similar situations to Case I and Case II but in a downward direction. We detail the algorithms to calculate the adjustment to the Lagrange multiplier for each unit and for any time interval. Note that FIG. 12 illustrates Case I only.
For Case I (See FIG. 12): Ramping up with violation, the following notation is utilized: x2=Punitt+1;up;x1=Punitt;up 

    For ICC curve at time t, a1, a2, a3, . . . represent relevant load changes, and are replaced with Δλ11, Δλ12, . . . in the following equations. The slopes for the corresponding segments are denoted by k11, k12, . . . . The total desired vertical adjustment is Δλ1.
    For ICC curve at time t+1, b1, b2, b3, . . . represent relevant load changes, are replaced with Δλ21, Δλ22, . . . in the following equations. The slopes for the corresponding segments are denoted by k21, k22, . . . . The total desired vertical adjustment is Δλ2.
    For the desired adjustments: Δλ=Δλ1=Δλ2 






  
    
      
        
          
            Δλ
            1
          
          =
          
            
              Δλ
              1
              1
            
            +
            ...
            +
            
              Δλ
              1
              m
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            Δλ
            2
          
          =
          
            
              
                Δλ
                2
                1
              
              +
              ...
              +
              
                
                  Δλ
                  2
                  n
                
                ⁢
                
                  

                
                (
                
                  
                    x
                    2
                  
                  -
                  
                    
                      Δλ
                      2
                      1
                    
                    
                      k
                      2
                      1
                    
                  
                  -
                  ...
                  -
                  
                    
                      Δλ
                      2
                      n
                    
                    
                      k
                      2
                      n
                    
                  
                
                )
              
              -
              
                (
                
                  
                    x
                    1
                  
                  +
                  
                    
                      Δλ
                      1
                      1
                    
                    
                      k
                      1
                      1
                    
                  
                  +
                  
                    
                      Δλ
                      1
                      2
                    
                    
                      k
                      1
                      2
                    
                  
                  +
                  ...
                  +
                  
                    

                  
                  ⁢
                  
                    
                      Δλ
                      1
                      m
                    
                    
                      k
                      1
                      m
                    
                  
                
                )
              
            
            =
            
              
                L
                up
              
              ⁢
              
                

              
              (
              
                
                  
                    x
                    2
                  
                  -
                  
                    
                      Δλ
                      2
                      1
                    
                    
                      k
                      2
                      1
                    
                  
                  -
                  ...
                  -
                  
                    
                      Δλ
                      2
                      
                        n
                        -
                        1
                      
                    
                    
                      k
                      2
                      
                        n
                        -
                        1
                      
                    
                  
                  -
                  
                    
                      Δλ
                      -
                      
                        (
                        
                          
                            Δλ
                            2
                            1
                          
                          +
                          ...
                          +
                          
                            Δλ
                            2
                            
                              n
                              -
                              1
                            
                          
                        
                        )
                      
                    
                    
                      k
                      2
                      n
                    
                  
                  -
                  
                    

                  
                  ⁢
                  
                    (
                    
                      
                        x
                        1
                      
                      +
                      
                        
                          Δλ
                          1
                          1
                        
                        
                          k
                          1
                          1
                        
                      
                      +
                      ...
                      +
                      
                        
                          Δλ
                          1
                          
                            m
                            -
                            1
                          
                        
                        
                          k
                          1
                          
                            m
                            -
                            1
                          
                        
                      
                      +
                      
                        
                          Δλ
                          -
                          
                            (
                            
                              
                                Δλ
                                1
                                1
                              
                              +
                              ...
                              +
                              
                                Δλ
                                1
                                
                                  m
                                  -
                                  1
                                
                              
                            
                            )
                          
                        
                        
                          k
                          1
                          m
                        
                      
                    
                    )
                  
                
                =
                
                  
                    
                      L
                      
                        
                          
                        
                        up
                      
                    
                    ⁢
                    
                      

                    
                    ⇒
                    
                      
                    
                    ⁢
                    
                      
                        (
                        
                          
                            1
                            
                              k
                              2
                              n
                            
                          
                          +
                          
                            1
                            
                              k
                              1
                              m
                            
                          
                        
                        )
                      
                      ⁢
                      Δλ
                    
                  
                  =
                  
                    
                      
                        (
                        
                          
                            x
                            2
                          
                          -
                          
                            x
                            1
                          
                          -
                          
                            L
                            up
                          
                          -
                          
                            
                              (
                              
                                
                                  1
                                  
                                    k
                                    2
                                    1
                                  
                                
                                -
                                
                                  1
                                  
                                    k
                                    2
                                    n
                                  
                                
                              
                              )
                            
                            ⁢
                            
                              Δλ
                              2
                              1
                            
                          
                          -
                          
                            

                          
                          ⁢
                          
                            
                              (
                              
                                
                                  1
                                  
                                    k
                                    2
                                    2
                                  
                                
                                -
                                
                                  1
                                  
                                    k
                                    2
                                    n
                                  
                                
                              
                              )
                            
                            ⁢
                            
                              Δλ
                              2
                              2
                            
                          
                          -
                          ...
                          -
                          
                            
                              (
                              
                                
                                  1
                                  
                                    k
                                    2
                                    
                                      n
                                      -
                                      1
                                    
                                  
                                
                                -
                                
                                  1
                                  
                                    k
                                    2
                                    n
                                  
                                
                              
                              )
                            
                            ⁢
                            
                              Δλ
                              2
                              
                                n
                                -
                                1
                              
                            
                          
                          -
                          
                            

                          
                          ⁢
                          
                            
                              (
                              
                                
                                  1
                                  
                                    k
                                    1
                                    1
                                  
                                
                                -
                                
                                  1
                                  
                                    k
                                    1
                                    m
                                  
                                
                              
                              )
                            
                            ⁢
                            
                              Δλ
                              1
                              1
                            
                          
                          -
                          ...
                          -
                          
                            
                              (
                              
                                
                                  1
                                  
                                    k
                                    1
                                    
                                      m
                                      -
                                      1
                                    
                                  
                                
                                -
                                
                                  1
                                  
                                    k
                                    1
                                    m
                                  
                                
                              
                              )
                            
                            ⁢
                            
                              Δλ
                              1
                              
                                m
                                -
                                1
                              
                            
                          
                        
                        )
                      
                      ⁢
                      
                        

                      
                      ⇒
                      
                        
                      
                      ⁢
                      Δλ
                    
                    =
                    
                      
                        (
                        
                          
                            x
                            2
                          
                          -
                          
                            x
                            1
                          
                          -
                          
                            L
                            up
                          
                          -
                          
                            
                              (
                              
                                
                                  1
                                  
                                    k
                                    2
                                    1
                                  
                                
                                -
                                
                                  1
                                  
                                    k
                                    2
                                    n
                                  
                                
                              
                              )
                            
                            ⁢
                            
                              Δλ
                              2
                              1
                            
                          
                          -
                          
                            

                          
                          ⁢
                          
                            
                              (
                              
                                
                                  1
                                  
                                    k
                                    2
                                    2
                                  
                                
                                -
                                
                                  1
                                  
                                    k
                                    2
                                    n
                                  
                                
                              
                              )
                            
                            ⁢
                            
                              Δλ
                              2
                              2
                            
                          
                          -
                          ...
                          -
                          
                            

                          
                          ⁢
                          
                            
                              (
                              
                                
                                  1
                                  
                                    k
                                    2
                                    
                                      n
                                      -
                                      1
                                    
                                  
                                
                                -
                                
                                  1
                                  
                                    k
                                    2
                                    n
                                  
                                
                              
                              )
                            
                            ⁢
                            
                              Δλ
                              2
                              
                                n
                                -
                                1
                              
                            
                          
                          -
                          
                            
                              (
                              
                                
                                  1
                                  
                                    k
                                    1
                                    1
                                  
                                
                                -
                                
                                  1
                                  
                                    k
                                    1
                                    m
                                  
                                
                              
                              )
                            
                            ⁢
                            
                              Δλ
                              1
                              1
                            
                          
                          -
                          ...
                          -
                          
                            

                          
                          ⁢
                          
                            
                              (
                              
                                
                                  1
                                  
                                    k
                                    1
                                    
                                      m
                                      -
                                      1
                                    
                                  
                                
                                -
                                
                                  1
                                  
                                    k
                                    1
                                    m
                                  
                                
                              
                              )
                            
                            ⁢
                            
                              Δλ
                              1
                              
                                m
                                -
                                1
                              
                            
                          
                        
                        )
                      
                      /
                      
                        (
                        
                          
                            1
                            
                              k
                              2
                              n
                            
                          
                          +
                          
                            1
                            
                              k
                              1
                              m
                            
                          
                        
                        )
                      
                    
                  
                
              
            
          
        
      
    
    
      
        (
        45
        )
      
    
  




For Case II: Ramping up without violation, the following notation is utilized:





  
    
      
        
          
            x
            2
          
          =
          
            P
            unit
            
              
                t
                +
                1
              
              ;
              up
            
          
        
        ;
        
          
            x
            1
          
          =
          
            
              
                
                  P
                  unit
                  
                    t
                    ;
                    up
                  
                
                ⁢
                
                  

                
                (
                
                  
                    x
                    2
                  
                  +
                  
                    
                      Δλ
                      2
                      1
                    
                    
                      k
                      2
                      1
                    
                  
                  +
                  ...
                  +
                  
                    
                      Δλ
                      2
                      n
                    
                    
                      k
                      2
                      n
                    
                  
                
                )
              
              -
              
                

              
              ⁢
              
                (
                
                  
                    x
                    1
                  
                  -
                  
                    
                      Δλ
                      1
                      1
                    
                    
                      k
                      1
                      1
                    
                  
                  -
                  
                    
                      Δλ
                      1
                      2
                    
                    
                      k
                      1
                      2
                    
                  
                  -
                  ...
                  -
                  
                    
                      Δλ
                      1
                      m
                    
                    
                      k
                      1
                      m
                    
                  
                
                )
              
            
            =
            
              
                L
                up
              
              ⁢
              
                

              
              (
              
                
                  
                    x
                    2
                  
                  +
                  
                    
                      Δλ
                      2
                      1
                    
                    
                      k
                      2
                      1
                    
                  
                  +
                  ...
                  +
                  
                    
                      Δλ
                      2
                      
                        n
                        -
                        1
                      
                    
                    
                      k
                      2
                      
                        n
                        -
                        1
                      
                    
                  
                  +
                  
                    

                  
                  ⁢
                  
                    
                      Δλ
                      -
                      
                        (
                        
                          
                            Δλ
                            2
                            1
                          
                          +
                          ...
                          +
                          
                            Δλ
                            2
                            
                              n
                              -
                              1
                            
                          
                        
                        )
                      
                    
                    
                      k
                      2
                      n
                    
                  
                  -
                  
                    (
                    
                      
                        x
                        1
                      
                      -
                      
                        
                          Δλ
                          1
                          1
                        
                        
                          k
                          1
                          1
                        
                      
                      -
                      ...
                      -
                      
                        

                      
                      ⁢
                      
                        
                          Δλ
                          1
                          
                            m
                            -
                            1
                          
                        
                        
                          k
                          1
                          
                            m
                            -
                            1
                          
                        
                      
                      -
                      
                        
                          Δλ
                          -
                          
                            (
                            
                              
                                Δλ
                                1
                                1
                              
                              +
                              ...
                              +
                              
                                Δλ
                                1
                                
                                  m
                                  -
                                  1
                                
                              
                            
                            )
                          
                        
                        
                          k
                          1
                          m
                        
                      
                    
                    )
                  
                
                =
                
                ⁢
                
                  
                    
                      
                        L
                        up
                      
                      ⁡
                      
                        (
                        
                          >
                          0
                        
                        )
                      
                    
                    ⁢
                    
                      

                    
                    ⇒
                    
                      

                    
                    ⁢
                    
                      
                        (
                        
                          
                            1
                            
                              k
                              2
                              n
                            
                          
                          +
                          
                            1
                            
                              k
                              1
                              m
                            
                          
                        
                        )
                      
                      ⁢
                      Δλ
                    
                  
                  =
                  
                    
                      
                        (
                        
                          
                            L
                            up
                          
                          -
                          
                            (
                            
                              
                                x
                                2
                              
                              -
                              
                                x
                                1
                              
                            
                            )
                          
                          -
                          
                            
                              (
                              
                                
                                  1
                                  
                                    k
                                    2
                                    1
                                  
                                
                                -
                                
                                  1
                                  
                                    k
                                    2
                                    n
                                  
                                
                              
                              )
                            
                            ⁢
                            
                              Δλ
                              2
                              1
                            
                          
                          -
                          ...
                          -
                          
                            

                          
                          ⁢
                          
                            
                              (
                              
                                
                                  1
                                  
                                    k
                                    2
                                    
                                      n
                                      -
                                      1
                                    
                                  
                                
                                -
                                
                                  1
                                  
                                    k
                                    2
                                    n
                                  
                                
                              
                              )
                            
                            ⁢
                            
                              Δλ
                              2
                              
                                n
                                -
                                1
                              
                            
                          
                          -
                          
                            
                              (
                              
                                
                                  1
                                  
                                    k
                                    1
                                    1
                                  
                                
                                -
                                
                                  1
                                  
                                    k
                                    1
                                    m
                                  
                                
                              
                              )
                            
                            ⁢
                            
                              Δλ
                              1
                              1
                            
                          
                          -
                          ...
                          -
                          
                            
                              (
                              
                                
                                  1
                                  
                                    k
                                    1
                                    
                                      m
                                      -
                                      1
                                    
                                  
                                
                                -
                                
                                  1
                                  
                                    k
                                    1
                                    m
                                  
                                
                              
                              )
                            
                            ⁢
                            
                              Δλ
                              1
                              
                                m
                                -
                                1
                              
                            
                          
                        
                        )
                      
                      ⁢
                      
                        

                      
                      ⇒
                      
                        

                      
                      ⁢
                      Δλ
                    
                    =
                    
                      
                        (
                        
                          
                            L
                            up
                          
                          -
                          
                            (
                            
                              
                                x
                                2
                              
                              -
                              
                                x
                                1
                              
                            
                            )
                          
                          -
                          
                            
                              (
                              
                                
                                  1
                                  
                                    k
                                    2
                                    1
                                  
                                
                                -
                                
                                  1
                                  
                                    k
                                    2
                                    n
                                  
                                
                              
                              )
                            
                            ⁢
                            
                              Δλ
                              2
                              1
                            
                          
                          -
                          ...
                          -
                          
                            
                              (
                              
                                
                                  1
                                  
                                    k
                                    2
                                    
                                      n
                                      -
                                      1
                                    
                                  
                                
                                -
                                
                                  1
                                  
                                    k
                                    2
                                    n
                                  
                                
                              
                              )
                            
                            ⁢
                            
                              Δλ
                              2
                              
                                n
                                -
                                1
                              
                            
                          
                          -
                          
                            

                          
                          ⁢
                          
                            
                              (
                              
                                
                                  1
                                  
                                    k
                                    1
                                    1
                                  
                                
                                -
                                
                                  1
                                  
                                    k
                                    1
                                    m
                                  
                                
                              
                              )
                            
                            ⁢
                            
                              Δλ
                              1
                              1
                            
                          
                          -
                          ...
                          -
                          
                            
                              (
                              
                                
                                  1
                                  
                                    k
                                    1
                                    
                                      m
                                      -
                                      1
                                    
                                  
                                
                                -
                                
                                  1
                                  
                                    k
                                    1
                                    m
                                  
                                
                              
                              )
                            
                            ⁢
                            
                              Δλ
                              1
                              
                                m
                                -
                                1
                              
                            
                          
                        
                        )
                      
                      /
                      
                        (
                        
                          
                            1
                            
                              k
                              2
                              n
                            
                          
                          +
                          
                            1
                            
                              k
                              1
                              m
                            
                          
                        
                        )
                      
                    
                  
                
              
            
          
        
      
    
    
      
        (
        46
        )
      
    
  




For Case III: Ramping down without violation, the following notation is utilized:

x2=Punitt+1;down;x1=Punitt;down 





  
    
      
        
          
            
              (
              
                
                  x
                  2
                
                -
                
                  
                    Δ
                    ⁢
                    
                      
                    
                    ⁢
                    
                      λ
                      2
                      1
                    
                  
                  
                    k
                    2
                    1
                  
                
                -
                ...
                -
                
                  
                    Δ
                    ⁢
                    
                      
                    
                    ⁢
                    
                      λ
                      2
                      n
                    
                  
                  
                    k
                    2
                    n
                  
                
              
              )
            
            -
            
              (
              
                
                  x
                  1
                
                +
                
                  
                    Δ
                    ⁢
                    
                      
                    
                    ⁢
                    
                      λ
                      1
                      1
                    
                  
                  
                    k
                    1
                    1
                  
                
                +
                
                  
                    Δ
                    ⁢
                    
                      
                    
                    ⁢
                    
                      λ
                      1
                      2
                    
                  
                  
                    k
                    1
                    2
                  
                
                +
                ...
                +
                
                  
                    Δ
                    ⁢
                    
                      
                    
                    ⁢
                    
                      λ
                      1
                      m
                    
                  
                  
                    k
                    1
                    m
                  
                
              
              )
            
          
          =
          
            
              L
              Down
            
            ⁡
            
              (
              
                <
                0
              
              )
            
          
        
        ⁢
        
          

        
        ⁢
        
          (
          
            
              
                x
                2
              
              -
              
                
                  Δ
                  ⁢
                  
                    
                  
                  ⁢
                  
                    λ
                    2
                    1
                  
                
                
                  k
                  2
                  1
                
              
              -
              ...
              -
              
                
                  Δ
                  ⁢
                  
                    
                  
                  ⁢
                  
                    λ
                    2
                    
                      n
                      -
                      1
                    
                  
                
                
                  k
                  2
                  
                    n
                    -
                    1
                  
                
              
              -
              
                
                  
                    Δ
                    ⁢
                    
                      
                    
                    ⁢
                    λ
                  
                  -
                  
                    (
                    
                      
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          λ
                          2
                          1
                        
                      
                      +
                      ...
                      +
                      
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          λ
                          2
                          
                            n
                            -
                            1
                          
                        
                      
                    
                    )
                  
                
                
                  k
                  2
                  n
                
              
              -
              
                (
                
                  
                    x
                    1
                  
                  +
                  
                    
                      Δ
                      ⁢
                      
                        
                      
                      ⁢
                      
                        λ
                        1
                        1
                      
                    
                    
                      k
                      1
                      1
                    
                  
                  +
                  ...
                  +
                  
                    
                      Δ
                      ⁢
                      
                        
                      
                      ⁢
                      
                        λ
                        1
                        
                          m
                          -
                          1
                        
                      
                    
                    
                      k
                      1
                      
                        m
                        -
                        1
                      
                    
                  
                  +
                  
                    
                      
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        λ
                      
                      -
                      
                        (
                        
                          
                            Δ
                            ⁢
                            
                              
                            
                            ⁢
                            
                              λ
                              1
                              1
                            
                          
                          +
                          ...
                          +
                          
                            Δ
                            ⁢
                            
                              
                            
                            ⁢
                            
                              λ
                              1
                              
                                m
                                -
                                1
                              
                            
                          
                        
                        )
                      
                    
                    
                      k
                      1
                      m
                    
                  
                
                )
              
            
            =
            
              
                
                  L
                  Down
                
                ⁢
                
                  

                
                ⇒
                
                  

                
                ⁢
                
                  
                    (
                    
                      
                        1
                        
                          k
                          2
                          n
                        
                      
                      +
                      
                        1
                        
                          k
                          1
                          m
                        
                      
                    
                    )
                  
                  ⁢
                  
                    
                  
                  ⁢
                  Δ
                  ⁢
                  
                    
                  
                  ⁢
                  λ
                
              
              =
              
                
                  
                    
                      
                        (
                        
                          
                            x
                            2
                          
                          -
                          
                            x
                            1
                          
                          -
                          
                            L
                            Down
                          
                          -
                          
                            
                              (
                              
                                
                                  1
                                  
                                    k
                                    2
                                    1
                                  
                                
                                -
                                
                                  1
                                  
                                    k
                                    2
                                    n
                                  
                                
                              
                              )
                            
                            ⁢
                            
                              
                            
                            ⁢
                            Δ
                            ⁢
                            
                              
                            
                            ⁢
                            
                              λ
                              2
                              1
                            
                          
                          -
                          ...
                          -
                          
                            1
                            
                              k
                              2
                              
                                n
                                -
                                1
                              
                            
                          
                          -
                          
                            1
                            
                              k
                              2
                              n
                            
                          
                        
                        )
                      
                      ⁢
                      
                        
                      
                      ⁢
                      Δ
                      ⁢
                      
                        
                      
                      ⁢
                      
                        λ
                        2
                        
                          n
                          -
                          1
                        
                      
                    
                    -
                    
                       
                      
                        
                          
                            (
                            
                              
                                1
                                
                                  k
                                  1
                                  1
                                
                              
                              -
                              
                                1
                                
                                  k
                                  1
                                  m
                                
                              
                            
                            )
                          
                          ⁢
                          
                            
                          
                          ⁢
                          Δ
                          ⁢
                          
                            
                          
                          ⁢
                          
                            λ
                            1
                            1
                          
                        
                        -
                        ...
                        -
                        
                          
                            (
                            
                              
                                1
                                
                                  k
                                  1
                                  
                                    m
                                    -
                                    1
                                  
                                
                              
                              -
                              
                                1
                                
                                  k
                                  1
                                  m
                                
                              
                            
                            )
                          
                          ⁢
                          
                            
                          
                          ⁢
                          Δ
                          ⁢
                          
                            
                          
                          ⁢
                          
                            λ
                            1
                            
                              m
                              -
                              1
                            
                          
                        
                      
                      )
                    
                  
                  ⁢
                  
                    

                  
                  ⇒
                  
                    

                  
                  ⁢
                  
                    Δ
                    ⁢
                    
                      
                    
                    ⁢
                    λ
                  
                
                =
                
                  
                    (
                    
                      
                        x
                        2
                      
                      -
                      
                        x
                        1
                      
                      -
                      
                        L
                        Down
                      
                      -
                      
                        
                          (
                          
                            
                              1
                              
                                k
                                2
                                1
                              
                            
                            -
                            
                              1
                              
                                k
                                2
                                n
                              
                            
                          
                          )
                        
                        ⁢
                        
                          
                        
                        ⁢
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          λ
                          2
                          1
                        
                      
                      -
                      ...
                      -
                      
                        
                          (
                          
                            
                              1
                              
                                k
                                2
                                
                                  n
                                  -
                                  1
                                
                              
                            
                            -
                            
                              1
                              
                                k
                                2
                                n
                              
                            
                          
                          )
                        
                        ⁢
                        
                          
                        
                        ⁢
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          λ
                          2
                          
                            n
                            -
                            1
                          
                        
                      
                      -
                      
                        
                          (
                          
                            
                              1
                              
                                k
                                1
                                1
                              
                            
                            -
                            
                              1
                              
                                k
                                1
                                m
                              
                            
                          
                          )
                        
                        ⁢
                        
                          
                        
                        ⁢
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          λ
                          1
                          1
                        
                      
                      -
                      ...
                      -
                      
                        
                          (
                          
                            
                              1
                              
                                k
                                1
                                
                                  m
                                  -
                                  1
                                
                              
                            
                            -
                            
                              1
                              
                                k
                                1
                                m
                              
                            
                          
                          )
                        
                        ⁢
                        
                          
                        
                        ⁢
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          λ
                          1
                          
                            m
                            -
                            1
                          
                        
                      
                    
                    )
                  
                  /
                  
                    (
                    
                      
                        1
                        
                          k
                          2
                          n
                        
                      
                      +
                      
                        1
                        
                          k
                          1
                          m
                        
                      
                    
                    )
                  
                
              
            
          
        
      
    
    
      
        (
        47
        )
      
    
  




For Case IV: Ramping down with violation, the following notation is utilized:





  
    
      
        
          
            
              x
              2
            
            =
            
              P
              unit
              
                
                  t
                  +
                  1
                
                ;
                down
              
            
          
          ;
          
            
              x
              1
            
            =
            
              
                
                  
                    P
                    unit
                    
                      t
                      ;
                      down
                    
                  
                  ⁢
                  
                    

                  
                  (
                  
                    
                      x
                      2
                    
                    +
                    
                      
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          λ
                          2
                          1
                        
                      
                      
                        k
                        2
                        1
                      
                    
                    +
                    ...
                    +
                    
                      
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          λ
                          2
                          n
                        
                      
                      
                        k
                        2
                        n
                      
                    
                  
                  )
                
                -
                
                  (
                  
                    
                      x
                      1
                    
                    -
                    
                      
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          λ
                          1
                          1
                        
                      
                      
                        k
                        1
                        1
                      
                    
                    -
                    
                      
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          λ
                          1
                          2
                        
                      
                      
                        k
                        1
                        2
                      
                    
                    -
                    ...
                    -
                    
                      
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          λ
                          1
                          m
                        
                      
                      
                        k
                        l
                        m
                      
                    
                  
                  )
                
              
              =
              
                
                  L
                  Down
                
                ⁡
                
                  (
                  
                    <
                    0
                  
                  )
                
              
            
          
        
        ⁢
        
          

        
        ⁢
        
          (
          
            
              
                x
                2
              
              +
              
                
                  Δ
                  ⁢
                  
                    
                  
                  ⁢
                  
                    λ
                    2
                    1
                  
                
                
                  k
                  2
                  1
                
              
              +
              ...
              +
              
                
                  Δ
                  ⁢
                  
                    
                  
                  ⁢
                  
                    λ
                    2
                    
                      n
                      -
                      1
                    
                  
                
                
                  k
                  2
                  
                    n
                    -
                    1
                  
                
              
              +
              
                
                  
                    Δ
                    ⁢
                    
                      
                    
                    ⁢
                    λ
                  
                  -
                  
                    (
                    
                      
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          λ
                          2
                          1
                        
                      
                      +
                      ...
                      +
                      
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          λ
                          2
                          
                            n
                            -
                            1
                          
                        
                      
                    
                    )
                  
                
                
                  k
                  2
                  n
                
              
              -
              
                (
                
                  
                    x
                    1
                  
                  -
                  
                    
                      Δ
                      ⁢
                      
                        
                      
                      ⁢
                      
                        λ
                        1
                        1
                      
                    
                    
                      k
                      1
                      1
                    
                  
                  -
                  ...
                  -
                  
                    
                      Δ
                      ⁢
                      
                        
                      
                      ⁢
                      
                        λ
                        1
                        
                          m
                          -
                          1
                        
                      
                    
                    
                      k
                      1
                      
                        m
                        -
                        1
                      
                    
                  
                  -
                  
                    
                      
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        λ
                      
                      -
                      
                        (
                        
                          
                            Δ
                            ⁢
                            
                              
                            
                            ⁢
                            
                              λ
                              1
                              1
                            
                          
                          +
                          ...
                          +
                          
                            Δ
                            ⁢
                            
                              
                            
                            ⁢
                            
                              λ
                              1
                              
                                m
                                -
                                1
                              
                            
                          
                        
                        )
                      
                    
                    
                      k
                      1
                      m
                    
                  
                
                )
              
            
            =
            
              
                
                  L
                  Down
                
                ⁢
                
                  

                
                ⇒
                
                  

                
                ⁢
                
                  
                    (
                    
                      
                        1
                        
                          k
                          2
                          n
                        
                      
                      +
                      
                        1
                        
                          k
                          1
                          m
                        
                      
                    
                    )
                  
                  ⁢
                  
                    
                  
                  ⁢
                  Δ
                  ⁢
                  
                    
                  
                  ⁢
                  λ
                
              
              =
              
                
                  
                    
                      L
                      Down
                    
                    -
                    
                      (
                      
                        
                          x
                          2
                        
                        -
                        
                          x
                          1
                        
                      
                      )
                    
                    -
                    
                      
                        (
                        
                          
                            1
                            
                              k
                              2
                              1
                            
                          
                          -
                          
                            1
                            
                              k
                              2
                              n
                            
                          
                        
                        )
                      
                      ⁢
                      
                        
                      
                      ⁢
                      Δ
                      ⁢
                      
                        
                      
                      ⁢
                      
                        λ
                        2
                        1
                      
                    
                    -
                    ...
                    -
                    
                      
                        (
                        
                          
                            1
                            
                              k
                              2
                              
                                n
                                -
                                1
                              
                            
                          
                          -
                          
                            1
                            
                              k
                              2
                              n
                            
                          
                        
                        )
                      
                      ⁢
                      
                        
                      
                      ⁢
                      Δ
                      ⁢
                      
                        
                      
                      ⁢
                      
                        λ
                        2
                        
                          n
                          -
                          1
                        
                      
                    
                    -
                    
                      
                        (
                        
                          
                            1
                            
                              k
                              1
                              1
                            
                          
                          -
                          
                            1
                            
                              k
                              1
                              m
                            
                          
                        
                        )
                      
                      ⁢
                      
                        
                      
                      ⁢
                      Δ
                      ⁢
                      
                        
                      
                      ⁢
                      
                        λ
                        1
                        1
                      
                    
                    -
                    
                      
                        (
                        
                          
                            1
                            
                              k
                              1
                              
                                m
                                -
                                1
                              
                            
                          
                          -
                          
                            1
                            
                              k
                              1
                              m
                            
                          
                        
                        )
                      
                      ⁢
                      
                        
                      
                      ⁢
                      Δ
                      ⁢
                      
                        
                      
                      ⁢
                      
                        λ
                        1
                        
                          m
                          -
                          1
                        
                      
                    
                  
                  ⁢
                  
                    

                  
                  ⇒
                  
                    

                  
                  ⁢
                  
                    Δ
                    ⁢
                    
                      
                    
                    ⁢
                    λ
                  
                
                =
                
                  
                    (
                    
                      
                        L
                        Down
                      
                      -
                      
                        (
                        
                          
                            x
                            2
                          
                          -
                          
                            x
                            1
                          
                        
                        )
                      
                      -
                      
                        
                          (
                          
                            
                              1
                              
                                k
                                2
                                1
                              
                            
                            -
                            
                              1
                              
                                k
                                2
                                n
                              
                            
                          
                          )
                        
                        ⁢
                        
                          
                        
                        ⁢
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          λ
                          2
                          1
                        
                      
                      -
                      ...
                      -
                      
                        
                          (
                          
                            
                              1
                              
                                k
                                2
                                
                                  n
                                  -
                                  1
                                
                              
                            
                            -
                            
                              1
                              
                                k
                                2
                                n
                              
                            
                          
                          )
                        
                        ⁢
                        
                          
                        
                        ⁢
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          λ
                          2
                          
                            n
                            -
                            1
                          
                        
                      
                      -
                      
                        
                          (
                          
                            
                              1
                              
                                k
                                1
                                1
                              
                            
                            -
                            
                              1
                              
                                k
                                1
                                m
                              
                            
                          
                          )
                        
                        ⁢
                        
                          
                        
                        ⁢
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          λ
                          1
                          1
                        
                      
                      -
                      
                        
                          (
                          
                            
                              1
                              
                                k
                                1
                                
                                  m
                                  -
                                  1
                                
                              
                            
                            -
                            
                              1
                              
                                k
                                1
                                m
                              
                            
                          
                          )
                        
                        ⁢
                        
                          
                        
                        ⁢
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          λ
                          1
                          
                            m
                            -
                            1
                          
                        
                      
                    
                    )
                  
                  /
                  
                    (
                    
                      
                        1
                        
                          k
                          2
                          n
                        
                      
                      +
                      
                        1
                        
                          k
                          1
                          m
                        
                      
                    
                    )
                  
                
              
            
          
        
      
    
    
      
        (
        48
        )
      
    
  




The Lagrange dual problem,





  
    
      max
      
        
          ρ
          unit
          
            t
            ;
            Up
          
        
        ;
        
          
            ρ
            unit
            
              t
              ;
              Dn
            
          
          ≥
          0
        
      
    
    ⁢
    
      L
      ⁡
      
        (
        
          
            ρ
            unit
            
              t
              ;
              Up
            
          
          ;
          
            ρ
            unit
            
              t
              ;
              Dn
            
          
        
        )
      
    
  
  ;
  
    t
    ∈
    T
  




is separable by time intervals t∈T. The Lagrangian function is concave and piecewise differentiable. The optimal values of multipliers ρunitt,Up and ρunitt;Dn must satisfy the first order condition:

(0,0)∈∂L(ρunitt,Up;ρunitt;Dn);t∈T.

The sub-gradient ∂L contains the violations of ramping limits at each time interval t∈T:

(Punitt−Punitt−1−ΔPunitUp,Punitt−Punitt−1−ΔPunitDn)∈∂L(ρunitt,Up;ρunitt,Dn)t∈T  (49)

Note that at one time interval only one ramping violation can occur.

The dual problem optimality conditions become:

Punitt−Punitt−1−ΔPunitUp=0 if ρunitt;Up>0; and Punitt−Punitt−1−ΔPunitUp<0 if ρunitt;Up=0  (50)

Punitt−Punitt−1−ΔPunitDn=0 if ρunitt;Dn>0; and Punitt−Punitt−1−ΔPunitDn>0 if ρunitt,Dn=0  (51)

Lagrange relaxation modifies only SCED objective functions by adding a linear unit cost term and is equivalent to adding a constant term to unit incremental cost curves.
The structure of SCED problem remains unchanged, the Dantzig-Wolfe algorithm should be adjusted as follows:

    1. Calculate unit shadow ramping costs as difference of Lagrange multipliers for ramping constraints:
    ρunitt,Up−ρunitt+1,Up or ρunitt+1,Dn−ρunitt,Dn for t∈T−{tN}. Note that for t∈{tN} no unit shadow ramping cost is needed.
    2. Include unit shadow ramping costs into Dantzig-Wolfe master problem objective:
    (ρunitt;Up−ρunitt+1;Up)Punitt or (ρunitt+1;Dn−ρunitt;Dn)Punitt for t∈T−{tN}. Note that for t∈{tN} no unit shadow ramping cost related terms should be included in the corresponding Dantzig-Wolfe master problem objective.
    3. Include unit shadow ramping costs into unit energy shadow prices as inputs into Dantzig-Wolfe sub-problems:
    Cunitt(Punitt)+(ρunitt,Up−ρunitt+1;Up)Punitt or Cunitt (Punitt)−(ρunitt;Dn−ρunitt+1;Dn)Punitt for t∈T−{tN}. Note that for t∈{tN} no unit shadow ramping cost related terms should be included in the corresponding Dantzig-Wolfe sub-problems.


If Lagrange dual problems are solved optimally, then all ramping constraints will be satisfied, i.e.:

Punitt−Punitt−1≦ΔPunitUp; and Punitt−Punitt−1≧ΔPunitUp for t∈T.

If in the same time all static SCED problems are solved optimally, then the following relations are satisfied:





  
    
      
        
          
            
              ∂
              
                C
                unit
                t
              
            
            
              ∂
              
                P
                unit
                t
              
            
          
          =
          
            
              -
              
                (
                
                  
                    ρ
                    unit
                    
                      t
                      ;
                      Up
                    
                  
                  -
                  
                    ρ
                    unit
                    
                      
                        t
                        +
                        1
                      
                      ;
                      Up
                    
                  
                
                )
              
            
            +
            
              (
              
                
                  ρ
                  unit
                  
                    t
                    ;
                    Dn
                  
                
                -
                
                  ρ
                  unit
                  
                    
                      t
                      +
                      1
                    
                    ;
                    Dn
                  
                
              
              )
            
            +
            
              λ
              /
              
                pf
                unit
                t
              
            
            -
            μ
            +
            
              η
              plant
              t
            
            +
            
              ∑
              
                
                  SF
                  
                    line
                    ;
                    unit
                  
                  SE
                
                ·
                
                  ζ
                  unit
                  t
                
              
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              for
              ⁢
              
                
              
              ⁢
              t
            
            ∈
            
              T
              -
              
                {
                
                  t
                  N
                
                }
              
            
          
          ;
        
      
    
    
      
        (
        52
        )
      
    
  
  
    
      
        
          
            
              ∂
              
                C
                unit
                t
              
            
            
              ∂
              
                P
                unit
                t
              
            
          
          =
          
            
              λ
              /
              
                pf
                unit
                t
              
            
            -
            μ
            +
            
              η
              plant
              t
            
            +
            
              ∑
              
                
                  SF
                  
                    line
                    ;
                    unit
                  
                  SE
                
                ·
                
                  ζ
                  unit
                  t
                
              
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              for
              ⁢
              
                
              
              ⁢
              t
            
            ∈
            
              {
              
                t
                N
              
              }
            
          
          ;
        
      
    
    
      
        (
        53
        )
      
    
  




and

Punitt∈æSCEDt.

These relations present a Kuhn-Tucker optimality condition for overall Dynamic Dispatch, and therefore, if both Lagrange dual problems and static SCED problems are solved optimally for each time interval, then the overall Dynamic Dispatch is solved optimally, as well.

While the inventive method and system have been particularly shown and described with reference to embodiments hereof, it should be understood by those skilled in the art that various changes in form and detail may be made therein without departing from the spirit and scope of the invention.

## Claims

1. A method of dynamically managing the operations of generating units in an electrical power network, comprising the steps of:
determining ramping constraints of each of a plurality of committed generating units in an electrical power network;
receiving predetermined load predictions for a set of predetermined and consecutive time intervals;
determining a fuel type to be used for generating an allocation of output power;
selecting from a plurality of predetermined incremental heat rate curves associated with predetermined fuel types an incremental heat rate curve representative of the fuel type to be used for generating the allocation of output power;
determining the allocation of output power for each of the plurality of generating units over the set of predetermined and consecutive time intervals and subject to the ramping constraints wherein the respective allocations are configured for minimizing the costs associated with each of the plurality of generating units when producing power according to the respective allocations of output power; and
generating power dispatch instructions responsive to the allocation of output power to each of the plurality of generating units in the electrical power network.

2. The method of claim 1, wherein the step of determining an allocation of output power includes using a Lagrange Relaxation approach comprising a Lagrange Multiplier for determining whether ramping rate limits of the ramping constraints would be violated by the allocation of power;
when at least one of the ramping rate limits of the ramping constraints would be violated by the allocation of power, decreasing the Lagrange Multiplier when the Lagrange Multiplier used for generating the allocation of power is positive and the ramp rate limits are redundant;
else keeping the Lagrange Multiplier at zero when the Lagrange Multiplier used for generating the allocation of power is zero,
else increasing the Lagrange Multiplier used for generating the allocation of power; and
regenerating a new allocation of output power.

3. The method of claim 1, wherein the step of determining an allocation of output power includes the step of creating an optimization model based on optimization calculations which include calculation of generating unit level optimization, plant level optimization, and control area optimization, wherein the optimization model is configured for maintaining power flow limits, reserve requirements, ramp rate limits and power balance.

4. The method of claim 1 further comprising the step of sending the allocation of output power to a Load Frequency Control.

5. The method of claim 1, wherein the step of determining the allocation is constrained by ramp rate limits.

6. The method of claim 1, wherein the step of determining the allocation is constrained by a spinning reserve requirement of at least one of the generating units.

7. The method of claim 1, wherein the step of determining the allocation is constrained by a hierarchical nonlinear optimization technique.

8. The method of claim 1, wherein the step of determining the allocation is constrained by a Lagrange Multiplier.

9. The method of claim 1, wherein the step of determining the allocation is calculated by using a Dantzig-Wolfe based optimization approach.

10. The method of claim 1, further comprising the step of dispatching power to minimize deviation of power interchange in the electrical power network from a scheduled power interchange and an interconnection frequency deviation from a predetermined interconnection frequency.

11. The method of claim 1, further comprising the steps of initializing an operating mode, power output limits, and ramping rate limits from a predetermined generation schedule of each of the plurality of generating units.

12. The method of claim 1, further comprising the steps of predicting load requirements and determining possible constraint violations.

13. The method of claim 1, further comprising the steps of:
calculating an incremental cost curve from the selected heat rate curve according to the formula


ICit=IMCit+IHRit×FCit/EFit


where ICit denotes a unit incremental cost, IMCit denotes an incremental maintenance cost, IHRit denotes an incremental heat rate, FCit denotes a fuel cost, and EFit denotes an efficiency factor, wherein the subscript i denotes a unit index, and the superscript t denotes an index of time intervals.

14. A system for dynamically managing the operations of generating units in an electrical power system, comprising:
a processor for determining ramping constraints of each of a plurality of committed generating units in an electrical power network and receiving predetermined load predictions for a set of predetermined and consecutive time intervals;
wherein the processor calculates an incremental cost according to the formula


ICit=IMCit+IHRit×FCit/EFit


where ICit denotes a unit incremental cost, IMCit denotes an incremental maintenance cost, IHRit denotes an incremental heat rate, FCit denotes a fuel cost, and EFit denotes an efficiency factor, wherein the subscript i denotes a unit index, and the superscript t denotes an index of time intervals;
wherein the processor determines an allocation of output power for each of the plurality of generating units over the set of predetermined arid consecutive time intervals and subject to the ramping constraints wherein the respective allocations are configured for minimizing the costs associated with each of the plurality of generating units changing when producing power according to the respective allocations of output power; and
wherein the processor generates power dispatch instructions responsive to the allocation of output power to each of the plurality of generating units in the electrical power network.

15. The system of claim 14, wherein the processor is operative for determining an allocation of output power by using a Lagrange Relaxation approach comprising a Lagrange Multiplier for determining whether ramping rate limits of the ramping constraints would be violated by the allocation of power;
when at least one of the ramping rate limits of the ramping constraints would be violated by the allocation of power, decreasing the Lagrange Multiplier when the Lagrange Multiplier used for generating the allocation of power is positive and the ramp rate limits are redundant; and
else keeping the Lagrange Multiplier at zero when the Lagrange Multiplier used for generating the allocation of power is zero,
else increasing the Lagrange Multiplier used for generating the allocation of power; and
regenerating a new allocation of output power.

16. The system of claim 14, wherein, wherein the processor is operative for determining a allocation of output power and creating an optimization model based on optimization calculations which include calculation of generating unit level optimization, plant level optimization, and control area optimization, wherein the optimization model is configured for maintaining power flow limits, reserve requirements, ramp rate limits and power balance.

17. The system of claim 14 wherein the processor sends the allocation of output power to a Load Frequency Control.

18. The system of claim 14, wherein the processor is operative for determining the allocation and is constrained by ramp rate limits.

19. The system of claim 14, wherein the processor is operative for determining the allocation and is constrained by a spinning reserve requirement of at least one of the generating units.

20. The system of claim 14, wherein the processor is operative for determining the allocation and is constrained by a hierarchical nonlinear optimization technique.

21. The system of claim 14, wherein the processor is operative for determining the allocation is constrained by a Lagrange Multiplier.

22. The system of claim 14, wherein the processor is operative for determining the allocation is calculated by using a Dantzig-Wolfe based optimization approach.

23. The system of claim 14 wherein the processor is operative for dispatching power to minimize deviation of power interchange in the electrical power network from a scheduled power interchange and an interconnection frequency deviation from a predetermined interconnection frequency.

24. The system of claim 14, the processor is operative for initializing an operating mode, power output limits, and ramping rate limits from a predetermined generation schedule of each of the plurality of generating units.

25. The system of claim 14, the processor is operative for predicting load requirements and determining possible constraint violations.

26. The system of claim 25, wherein the processor is operative for:
determining a fuel type to be used for generating the allocation of output power; and
selecting from a plurality of predetermined incremental heat rate curves associated with predetermined fuel types, an incremental heat rate curve representative of the fuel type to be used for generating the allocation of output power.

27. A computer-readable medium having stored thereon instructions which when executed by a processor, cause the processor to perform the steps of;
determining ramping constraints of each of a plurality of committed generating units in an electrical power network;
receiving predetermined load predictions for a set of predetermined and consecutive time intervals;
determining a fuel type to be used for generating an allocation of output power;
selecting from a plurality of predetermined incremental heat rate curves associated with predetermined fuel types an incremental heat rate curve representative of the fuel type to be used for generating the allocation of output power;
determining the allocation of output power for each of the plurality of generating units over the set of predetermined and consecutive time intervals and subject to the ramping constraints wherein the respective allocations are configured for minimizing the costs associated with each of the plurality of generating units changing when producing power according to the respective allocations of output power; and
generating power dispatch instructions responsive to the allocation of output power to each of the plurality of generating units in the electrical power network.

28. A method for dynamically managing the operations of power generating units in an electrical power network divided into control areas to resolve a power generation deviation from a predetermined operating requirement of the electrical power network and to minimize costs associated with resolving the power generation deviation, comprising:
identifying a condition in an electrical power network indicative of a power generation deviation from a predetermined operating requirement;
determining operating constraints of each of a plurality of committed generating units in the electrical power network;
receiving predetermined load predictions for the electrical power network for a set of predetermined and consecutive time intervals;
determining a fuel type to be used for generating an allocation of output power;
selecting from a plurality of predetermined incremental heat rate curves associated with predetermined fuel types an incremental heat rate curve representative of the fuel type to be used for generating the allocation of output power;
iteratively determining the allocation of output power for each of the plurality of generating units in a control area over the set of predetermined and consecutive time intervals using a Lagrange relaxation approach so that an overall cost associated with each of the plurality of generating units when producing power according to the respective allocations of output power integrated over the consecutive time intervals is minimized according to the relationship:





  
    SystemCast
    =
    
      
        ∑
        
          t
          ∈
          T
        
      
      ⁢
      
        
      
      ⁢
      
        
          ∑
          
            unit
            ∈
            
              U
              A
            
          
        
        ⁢
        
          
        
        ⁢
        
          (
          
            
              StatCost
              unit
              t
            
            ⁡
            
              (
              
                P
                unit
                t
              
              )
            
          
          )
        
      
    
  
  ,



wherein T is a time period of the consecutive time intervals, t is a time interval within the time period of the consecutive time intervals T, UA is a set of power generating units in a control area, unit is a power generating unit in the control area of the power generation network, StatCostunitt is a unit operating cost over time interval t, and Punitt is unit power generation over time interval t; and
generating power dispatch instructions responsive to the allocation of output power to each of the plurality of generating units in the electrical power network for use in controlling the units' respective energy generation to remedy the condition in the electrical power network indicative of a power generation deviation from the predetermined operating requirement.