Abstract:
A method and apparatus for intelligently controlling continuous process variables. An automatic controller comprises an Intelligent Engine mechanism and a number of Model-Free Adaptive (MFA) controllers, each of which is suitable to control a process with specific behaviors. The Intelligent Engine can automatically select the appropriate MFA controller and its parameters so that the automatic controller can be easily used by people with limited control experience and those who do not have the time to commission, tune, and maintain automatic controllers.

Description:
[0001]    This application is a divisional of U.S. application Ser. No. 12/853,832, filed on Aug. 10, 2010, which is herein incorporated by reference. 
     
    
       [0002]    This invention was made with government support under SBIR grant DE-FG02-08ER84944 awarded by the U.S. Department of Energy. The government has certain rights to the invention. 
     
    
       [0003]    The subject of this patent relates to automatic control of simple to complex systems including industrial processes, equipment, facilities, buildings, devices, boilers, valve positioners, motion stages, drives, motors, turbines, compressors, engines, robotics, vehicles, and appliances, and more particularly to a method and apparatus for intelligently controlling continuous process variables. 
         [0004]    The inventive Dream Controller can automatically select the appropriate controller type and its parameters based on the process information entered by the user. It consists of different types of Model-Free Adaptive (MFA) controllers, many of which have been disclosed and patented. The Dream Controller has sufficient adaptive and robust capability to control simple to complex processes providing consistent control performance without re-tuning of its parameters. It is able to deal with changes in process dynamics, load, disturbances, and other uncertainties. 
         [0005]    Developed almost 70 years ago, the PID (Proportional-Integral-Derivative) controller is still the most widely used controller today. PID is simple, easy to understand and implement, and does not require a precise process model to launch. However, PID has many shortcomings: (1) PID works well for simple processes that are basically linear and time-invariant. (2) PID must be tuned properly. When the process dynamics or operating conditions change, PID may need re-tuning. In practice, tuning PID is often a frustrating experience. (3) PID has trouble controlling complex systems no matter how it is tuned. 
         [0006]    PID controllers were originally developed on pneumatic systems that cannot really produce the Integral and Derivative functions. Approximation formulas were used. PID went through the technology advances from pneumatic to analog, digital, and software based control systems. Different manufacturers may use different forms of PID formula and units. For instance, PID proportional gain is the controller gain but PID proportional band is the reciprocal of the PID gain in percent, which is not only confusing but also dangerous if the user does not pay attention to the difference. It is desirable to develop a general-purpose yet smart controller that can be easily used by people with limited control experience and those who do not have the time to commission, tune, and maintain automatic controllers. 
         [0007]    First introduced in 1997, the Model-Free Adaptive (MFA) control technology overcomes the shortcomings of PID control and is able to control various complex processes that may have one or more of the following behaviors: (1) nonlinear, (2) time-varying, (3) large time delay, (4) multi-input-multi-output, (5) frequent dynamic changes, (6) open-loop oscillating, (7) pH process, and (8) processes with large load changes and disturbances. 
         [0008]    Since MFA is “Model-Free”, it also overcomes the shortcomings of model-based advanced control methods. MFA is an adaptive and robust control technology but it does not require (1) precise process models, (2) process identification, (3) controller design, and (4) complicated manual tuning of controller parameters. A series of U.S. patents and related international patents fir Model-Free Adaptive (MFA) control and optimization technologies have been issued. Some of them are listed in Table 1. 
         [0000]    
       
         
               
               
             
           
               
                 TABLE 1 
               
               
                   
               
               
                 U.S. Patent 
                 Patent Name 
               
               
                   
               
             
             
               
                 6,055,524 
                 Model-Free Adaptive Process Control 
               
               
                 6,556,980 
                 Model-Free Adaptive Control for Industrial Processes 
               
               
                 6,360,131 
                 Model-Free Adaptive Control for Flexible Production 
               
               
                   
                 Systems 
               
               
                 6,684,115 
                 Model-Free Adaptive Control of Quality Variables (1) 
               
               
                 6,684,112 
                 Robust Model-Free Adaptive Control 
               
               
                 7,016,743 
                 Model-Free Adaptive Control of Quality Variables (2) 
               
               
                 7,142,626 
                 Apparatus and Method of Controlling Multi-Input-Single- 
               
               
                   
                 Output Systems 
               
               
                 7,152,052 
                 Apparatus and Method of Controlling Single-Input-Multi- 
               
               
                   
                 Output Systems 
               
               
                 7,415,446 
                 Model-Free Adaptive Optimization 
               
               
                   
               
             
          
         
       
     
         [0009]    Commercial hardware and software products with Model-Free Adaptive control have been successfully installed in most industries and deployed on a large scale for process control, building control, and equipment control. However, in most cases, the user still has to select the appropriate MFA controller and enter certain parameters. 
         [0010]    In this patent, we introduce a novel general-purpose yet smart MFA controller (the Dream Controller) designed to overcome the shortcomings of the prior art. The Dream Controller includes an Intelligent Engine and a number of MFA controllers, each of which is suitable to control a process with specific behaviors. The Intelligent Engine can automatically select the appropriate MFA controller and its parameters. Therefore, the Dream Controller can be easily used by people with limited control experience and those who do not have the time to commission, tune, and maintain automatic controllers. 
     
    
     
         [0011]    In the accompanying drawing: 
           [0012]      FIG. 1  is a block diagram illustrating a single-loop automatic control system comprising the Dream Controller according to this invention. 
           [0013]      FIG. 2  is a block diagram illustrating the architecture of the Dream Controller in the basic form of a Model-Free Adaptive (MFA) controller. 
           [0014]      FIG. 3  is a flow chart describing the steps in an Intelligent Engine mechanism according to this invention. 
           [0015]      FIG. 4  is a flow chart describing the steps for the Process Qualification mechanism according to this invention. 
           [0016]      FIG. 5  is a flow chart describing the steps for the Process Type Selection mechanism according to this invention. 
           [0017]      FIG. 6  is a flow chart describing the steps for the Controller Selection and Auto-configuration mechanism according to this invention. 
           [0018]      FIG. 7  is a flow chart describing the steps for the Flow Control Configuration mechanism according to this invention. 
           [0019]      FIG. 8  is a flow chart describing the steps for the Pressure Control Configuration mechanism according to this invention. 
           [0020]      FIG. 9  is a flow chart describing the steps for the Temperature Control Configuration mechanism according to this invention. 
           [0021]      FIG. 10  is a flow chart describing the steps for the Level Control Configuration mechanism according to this invention. 
           [0022]      FIG. 11  is a flow chart describing the steps for the pH Control Configuration mechanism according to this invention. 
           [0023]      FIG. 12  is a flow chart describing the steps for the Control System Inspection mechanism according to this invention. 
       
    
    
       [0024]    In this patent, the term “mechanism” is used to represent hardware, software, or any combination thereof. The term “process” is used to represent a physical system or process with inputs and outputs that have dynamic relationships. The term “program” is used to represent a sequence of instructions that a computer can interpret and execute. The term “initialization” is used to represent the procedure to set or prepare a mechanism to a starting position, value, or configuration. The term “routine” is used to represent a sequence of steps that can be executed repeatedly in a program. The term “Dream Controller” is used to represent the novel general-purpose Model-Free Adaptive (MFA) controller as part of the Intelligent MFA control system of this invention. 
         [0025]    Without losing generality, all numerical values given in controller parameter configuration in this patent are examples. Other values can be used without departing from the spirit or scope of our invention 
       DESCRIPTION 
       [0026]      FIG. 1  is a block diagram illustrating a single-loop automatic control system comprising the Dream Controller according to this invention. It comprises the Dream Controller  10 , an actuator  6 , a single-input-single-output (SISO) process  12 , and signal adders  14  and  16 . The Dream Controller consists of a SISO MFA controller  8  and an Intelligent Engine  9 . The signals shown in  FIG. 1  are as follows: 
         [0027]    r(t)—Setpoint, 
         [0028]    y(t)—Measured Variable or the Process Variable, y(t)=x(t)+d(t). 
         [0029]    x(t)—Process Output, 
         [0030]    u(t)—Controller Output 
         [0031]    d(t)—Disturbance, the disturbance caused by noise or load changes. 
         [0032]    e(t)—Error between the Setpoint and Measured Variable, e(t)=r(t)−y(t). 
         [0033]    The control objective is for the controller to produce an output u(t) to manipulate the actuator  6  so that the process variable y(t) tracks the given trajectory of its setpoint r(t) under variations of setpoint, disturbance, and process dynamics. In other words, the task of the MFA controller is to minimize the error e(t) in an online fashion. 
         [0034]    The control objective function for the MFA control system is selected as 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                             E 
                             s 
                           
                            
                           
                             ( 
                             t 
                             ) 
                           
                         
                         = 
                           
                          
                         
                           
                             1 
                             2 
                           
                            
                           
                             
                               e 
                                
                               
                                 ( 
                                 t 
                                 ) 
                               
                             
                             2 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             
                               
                                 1 
                                 2 
                               
                                
                               
                                 [ 
                                 
                                   
                                     r 
                                      
                                     
                                       ( 
                                       t 
                                       ) 
                                     
                                   
                                   - 
                                   
                                     y 
                                      
                                     
                                       ( 
                                       t 
                                       ) 
                                     
                                   
                                 
                                 ] 
                               
                             
                             2 
                           
                           . 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   1 
                   ) 
                 
               
             
           
         
       
     
         [0035]    The minimization of F(t) is achieved by (i) the regulatory control capability of the MFA controller, whose output u(t) manipulates the actuator forcing the process variable y(t) to track its setpoint r(t); and (ii) the adjustment of the MFA controller weighting factors that allow the controller to deal with the dynamic changes, large disturbances, and other uncertainties. 
         [0036]      FIG. 2  is a block diagram illustrating the architecture of the Dream Controller of this invention in the basic form of a Model-Free Adaptive (MFA) controller. A linear multilayer neural network  18  is used as a key component of the controller. The neural network has one input layer  20 , one hidden layer  22  with N neurons, and one output layer  24  with one neuron. 
         [0037]    The input signal e(t) to the input layer  20  is first converted to a normalized error signal E 1  with a range of −1 to 1 by using the normalization unit  26 , where N(·) denotes a normalization function. The output of the normalization unit  26  is then scaled by a scaling function L x (·)  25 : 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       L 
                       x 
                     
                      
                     
                       ( 
                       . 
                       ) 
                     
                   
                   = 
                   
                     
                       
                         K 
                         cx 
                       
                       
                         T 
                         cx 
                       
                     
                     . 
                   
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
           
         
       
     
         [0000]    The value of E 1  at time t is computed with function L x (·) and N(·): 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       E 
                       1 
                     
                     = 
                     
                       
                         
                           K 
                           cx 
                         
                         
                           T 
                           cx 
                         
                       
                        
                       
                         N 
                          
                         
                           ( 
                           
                             e 
                              
                             
                               ( 
                               t 
                               ) 
                             
                           
                           ) 
                         
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where K cx &gt;0 is defined as controller gain and T cx  is the defined process time constant. K cx  is used to compensate for the process steady-state gain and provides information for the dynamic behavior of the process. When the error signal is scaled with these parameters, the controller&#39;s behavior can be manipulated by adjusting the parameters. 
         [0038]    The E 1  signal then goes iteratively through a series of delay units  28 , where z −1  denotes the unit delay operator. A set of normalized and scaled error signals E 2  to E N  is then generated. In this way, a continuous signal e(t) is converted to a series of discrete signals, which are used as the inputs to the neural network. These delayed error signals E i , i=1, . . . N, are then conveyed to the hidden layer through the neural network connections. This is equivalent to adding a feedback structure to the neural network. Then the regular static multilayer neural network becomes a dynamic neural network. A dynamic block is just another name for a dynamic system, whose inputs and outputs have dynamic relationships. 
         [0039]    Each input signal can be conveyed separately to each of the neurons in the hidden layer  22  via a path weighted by an individual weighting factor w ij , where i=1, 2, . . . N, and j=1, 2, . . . N. The inputs to each of the neurons in the hidden layer are summed by adder  30  to produce signal p j . Then the signal p j  is filtered by an activation function  32  to produce q j , where j denotes the jth neuron in the hidden layer. 
         [0040]    A piecewise continuous linear function ƒ(x) mapping real numbers to [0,1] is used as the activation function in the neural network as defined by 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       f 
                        
                       
                         ( 
                         x 
                         ) 
                       
                     
                     = 
                     0 
                   
                   , 
                   
                     
                       if 
                        
                       
                           
                       
                        
                       x 
                     
                     &lt; 
                     
                       - 
                       
                         b 
                         a 
                       
                     
                   
                 
               
               
                 
                   ( 
                   
                     4 
                      
                     a 
                   
                   ) 
                 
               
             
             
               
                 
                   
                     
                       f 
                        
                       
                         ( 
                         x 
                         ) 
                       
                     
                     = 
                     
                       ax 
                       + 
                       b 
                     
                   
                   , 
                   
                     
                       if 
                       - 
                       
                         b 
                         a 
                       
                     
                     ≤ 
                     x 
                     ≤ 
                     
                       b 
                       a 
                     
                   
                 
               
               
                 
                   ( 
                   
                     4 
                      
                     b 
                   
                   ) 
                 
               
             
             
               
                 
                   
                     
                       f 
                        
                       
                         ( 
                         x 
                         ) 
                       
                     
                     = 
                     1 
                   
                   , 
                   
                     
                       if 
                        
                       
                           
                       
                        
                       x 
                     
                     &gt; 
                     
                       b 
                       a 
                     
                   
                 
               
               
                 
                   ( 
                   
                     4 
                      
                     c 
                   
                   ) 
                 
               
             
           
         
       
     
         [0000]    where a is an arbitrary constant and b=1/2. 
         [0041]    Each output signal from the hidden layer is conveyed to the single neuron in the output layer  24  via a path weighted by an individual weighting factor h j , where j=1, 2, . . . N. These signals are summed in adder  34  to produce signal z(·), and then filtered by activation function  36  to produce the output o(·) of the neural network  18  with a range of 0 to 1. 
         [0042]    A de-normalization function  38  defined by 
         [0000]        D ( x )=100 x,   (5)
 
         [0000]    maps the o(·) signal back to the real space to produce the controller signal u(t). 
         [0043]    The algorithm governing the input-output of the controller consists of the following difference equations: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         p 
                         j 
                       
                        
                       
                         ( 
                         n 
                         ) 
                       
                     
                     = 
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         N 
                       
                        
                       
                         
                           
                             w 
                             ij 
                           
                            
                           
                             ( 
                             n 
                             ) 
                           
                         
                          
                         
                           
                             E 
                             i 
                           
                            
                           
                             ( 
                             n 
                             ) 
                           
                         
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   6 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       
                         q 
                         j 
                       
                        
                       
                         ( 
                         n 
                         ) 
                       
                     
                     = 
                     
                       f 
                        
                       
                         ( 
                         
                           
                             p 
                             j 
                           
                            
                           
                             ( 
                             n 
                             ) 
                           
                         
                         ) 
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   7 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       
                         
                           
                             o 
                              
                             
                               ( 
                               n 
                               ) 
                             
                           
                           = 
                             
                            
                           
                             f 
                              
                             
                               ( 
                               
                                 
                                   ∑ 
                                   
                                     j 
                                     = 
                                     1 
                                   
                                   N 
                                 
                                  
                                 
                                   
                                     
                                       h 
                                       j 
                                     
                                      
                                     
                                       ( 
                                       n 
                                       ) 
                                     
                                   
                                    
                                   
                                     
                                       q 
                                       j 
                                     
                                      
                                     
                                       ( 
                                       n 
                                       ) 
                                     
                                   
                                 
                               
                               ) 
                             
                           
                         
                         , 
                       
                     
                   
                   
                     
                       
                         
                           = 
                             
                            
                           
                             
                               a 
                                
                               
                                 
                                   ∑ 
                                   
                                     j 
                                     = 
                                     1 
                                   
                                   N 
                                 
                                  
                                 
                                   
                                     
                                       h 
                                       j 
                                     
                                      
                                     
                                       ( 
                                       n 
                                       ) 
                                     
                                   
                                    
                                   
                                     
                                       q 
                                       j 
                                     
                                      
                                     
                                       ( 
                                       n 
                                       ) 
                                     
                                   
                                 
                               
                             
                             + 
                             b 
                           
                         
                         , 
                       
                     
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where the variable of function f(·) is in the range specified in Equation (4b), and o(n) is bounded by the limits specified in Equations (4a) and (4c). The controller signal u(t) becomes 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           u 
                            
                           
                             ( 
                             t 
                             ) 
                           
                         
                         = 
                           
                          
                         
                           
                             
                               
                                 K 
                                 cx 
                               
                                
                               
                                 ( 
                                 . 
                                 ) 
                               
                             
                              
                             
                               e 
                                
                               
                                 ( 
                                 t 
                                 ) 
                               
                             
                           
                           + 
                           
                             D 
                              
                             
                               ( 
                               
                                 o 
                                  
                                 
                                   ( 
                                   t 
                                   ) 
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         
                           = 
                             
                            
                           
                             
                               
                                 
                                   K 
                                   cx 
                                 
                                  
                                 
                                   ( 
                                   . 
                                   ) 
                                 
                               
                                
                               
                                 e 
                                  
                                 
                                   ( 
                                   t 
                                   ) 
                                 
                               
                             
                             + 
                             
                               100 
                                
                               
                                 [ 
                                 
                                   
                                     a 
                                      
                                     
                                       
                                         ∑ 
                                         
                                           j 
                                           = 
                                           1 
                                         
                                         N 
                                       
                                        
                                       
                                         
                                           
                                             h 
                                             j 
                                           
                                            
                                           
                                             ( 
                                             n 
                                             ) 
                                           
                                         
                                          
                                         
                                           
                                             q 
                                             j 
                                           
                                            
                                           
                                             ( 
                                             n 
                                             ) 
                                           
                                         
                                       
                                     
                                   
                                   + 
                                   b 
                                 
                                 ] 
                               
                             
                           
                         
                         , 
                       
                     
                   
                 
               
               
                 
                   ( 
                   9 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where n denotes the nth iteration; o(t) is the continuous function of o(n); D(·) is the de-normalization function; and K cx (·)&gt;0, the controller gain  42 , is a variable used to adjust the magnitude of the control signal. This is the same variable as in the scaling function L x (·)  25  and is useful to fine tune the controller performance or keep the system stable. 
         [0044]    An online learning algorithm as described in the U.S. Pat. No. 6,556,980 B1 is an example of one algorithm that can be used to continuously update the values of the weighting factors of the MFA controller as follows: 
         [0000]      Δ w   ij ( n )= a   2   ηe ( n ) E   i ( n ) h   j ( n ),  (10)
 
         [0000]      Δ h   j ( n )= aηe ( n ) q   j ( n ).  (11)
 
         [0045]    The equations (1) through (11) work for both process direct-acting or reverse acting types. Direct-acting means that an increase in the process input will cause its output to increase, and vice versa. Reverse-acting means that an increase in the process input will cause its output to decrease, and vice versa. To keep the above equations working for both direct and reverse acting cases, e(t) is calculated differently based on the acting type of the process as follows: 
         [0000]        e ( t )= r ( t )− y ( t ), if direct acting  (12a)
 
         [0000]        e ( t )=−[ r ( t )− y ( t )]. if reverse acting  (12b)
 
         [0046]    Based on user entered information such as Process Type and Control Problems, the Intelligent Engine  46  can automatically enter the pre-determined controller gain K c    42  and time constant T c  inside the scaling function L x (·)  25 . 
         [0047]      FIG. 3  is a flow chart describing the steps in the Intelligent Engine mechanism according to this invention. At Block  50 , initialization is taking place, which sets the mechanism to a starting position, value, and configuration. 
         [0048]    At Block  52 , a Process Qualification mechanism is designed to eliminate the potential misuse of the control system. Its detailed design is described in  FIG. 4  At Block  54 , a Process Type Selection mechanism allows the user to enter the process type for the control loop. Its detailed design is described in  FIG. 5 . At Block  56 , a Controller Selection and Auto-configuration mechanism is designed to automatically select the appropriate MFA controller and its parameters. Its detailed design is described in  FIG. 6 . At Block  58 , a Control System Inspection mechanism is used to check all the controller configuration and signal connections of the control system. Its detailed design is described in  FIG. 12 . At Block  60 , the user is asked if it is ready to launch the controller. If yes, it will proceed to Block  62  and a Controller Ready Flag is set. This flag can also be interlocked with the Auto/Manual flag of the controller to turn the controller to automatic control mode. Otherwise, if the user is not ready to launch the controller or wants to make changes, the routine returns to the entry of Block  52 . 
         [0049]      FIG. 4  is a flow chart describing the steps in the Process Qualification mechanism according to this invention. At Block  64 , initialization is taking place. At Block  66 , the user needs to verify that the process is (1) controllable, (2) open-loop stable, and (3) either direct-acting or reverse-acting. These three basic conditions are defined in the following. Controllable means that the controller output u(t) used as the process input is capable of moving the process output x(t) to any position within its pre-defined range in a finite time. Open-loop stable means that for any bounded process input, the process output is also bounded. Either direct-acting or reverse-acting means that the process does not change its sign within the operating range. 
         [0050]    At Block  68 , if the user cannot verify that the process meets the three basic conditions, the routine goes to Block  74  telling the user that the process is not controllable using this controller and then exits the Intelligent Engine mechanism. Otherwise, it will continue to Block  70 , where more process verification is taking place. Based on the safety and suitability considerations, the Dream Controller should not be used for certain processes. Therefore, the user needs to verify that the process is not (1) a reactor process, (2) a run-away process, and (3) a seriously coupled multivariable process. The temperature of a chemical reactor is typically a run-away process that is not only difficult to control but also dangerous. A multivariable process where its variables are seriously coupled could be controlled by using MIMO MFA controllers. At Block  72 , the answers are checked. If the user can verify that the process meets the conditions, the routine ends successfully. Otherwise, it goes to Block  74  and then exits the Intelligent Engine mechanism. 
         [0051]      FIG. 5  is a flow chart describing the steps for the Process Type Selection mechanism according to this invention. At Block  76 , initialization is taking place. At Block  78 , the user is asked to select the process type that includes (1) Flow, (2) Pressure, (3) Temperature, (4) Level, (5) pH, and (6) Other. At Block  80 , the selection is checked. If selection “Other” is made, the routine goes to Block  84 , where the user is directed to use other types of MFA controllers. Then the routine exits the Intelligent Engine mechanism. When a selection for (1) to (5) is made, at Block  82 , the user needs to enter the Range of the Process Variable and Engineering Unit. For instance, for a temperature process, PV Low Limit and PV High Limit are entered and the unit of C (Celsius) or F (Fahrenheit) is specified. At Block  86 , the user needs to select whether the process is (1) Direct-acting, or (2) Reverse-acting. Then the Process Acting Type is saved as part of the controller configuration. 
         [0052]      FIG. 6  is a flow chart describing the steps for the Controller Selection and Auto-configuration mechanism according to this invention. At Block  88 , initialization is taking place. At Blocks  90 ,  94 ,  98 ,  102 , and  106 , the routine branches to the corresponding control configuration mechanisms  92 ,  96 ,  100 ,  104 , and  108  for flow, pressure, temperature, level, and pH processes, respectively. After running the selected Control Configuration mechanism routine, the program exits the Controller Selection and Auto-configuration mechanism routine. 
         [0053]    We now describe the detailed controller selection and configuration for each of the process types in the following. 
       1. Flow Control 
       [0054]    Comparing flow, pressure, temperature, level, and pH, the flow loop is probably the least difficult to control but has the largest number of loops because a continuous process is about moving material flows from the beginning of the process to the end. Typically, the flow loop is controlled by manipulating a valve, a variable frequency drive (VFD), or a pump. 
         [0055]    It is relatively easy to control a flow loop because it is naturally a first-order process with a small delay time. However, in flow control, the commonly used actuators are all nonlinear components by nature. (1) A control valve is almost never a linear component. It can have a concave, convex, or S-shaped nonlinear relationship between its input and output. Some even have hysteresis behavior making the problem much worse; (2) A variable frequency drive (VFD) saves energy but is naturally a nonlinear device; and (3) A flow pump driven by a pulse-width modulator (PWM) based on the duty cycles does not necessarily have a linear relationship with the flow. In addition, the inevitable wear and tear of the actuator can make the nonlinear behavior worse. Therefore, the challenge for flow control is mainly how to control a nonlinear process with stringent control performance requirements. 
         [0056]      FIG. 7  is a flow chart describing the steps for the Flow Control Configuration mechanism according to this invention. At Block  110 , initialization is taking place. At Block  112 , the user specifies whether or not the flow process is nonlinear. If nonlinear, the Nonlinear MFA controller is selected at Block  114 . Otherwise, the SISO MFA controller is selected at Block  116 . At Block  118 , the user is asked to enter a value that describes the degree of nonlinearity on a scale from 0 to 10, 0 being linear, and 10 being extremely nonlinear. This parameter is called Linearity Factor for the Nonlinear MFA controller. At Block  120 , the MFA controller is configured with Kc=2 and Tc=8 seconds, where Kc is the MFA controller gain, and Tc is the time constant. After that, the routine exits. 
       2. Pressure Control 
       [0057]    Pressure is an important process variable because it provides a critical condition for boiling, chemical reaction, distillation, extrusion, vacuuming, and air conditioning. Poor pressure control can cause major safety, quality, and productivity problems. Overly high pressure inside a sealed vessel can cause an explosion. Therefore, it is desirable to keep pressure in good control and maintained within its safety limits. 
         [0058]    A pressure loop may include bad behavior such as: (1) nonlinear, (2) open-loop oscillating, (3) multivariable with serious coupling to other process variables, (4) large time delay, and (5) large load changes. The Dream Controller is not suitable to control a pressure process that is multivariable or has large time delays. A MIMO (Multi-input-multi-output) MFA controller is suitable to control a multivariable process, and the Anti-delay MFA controller is suitable to control a process with large time delays. 
         [0059]      FIG. 8  is a flow chart describing the steps for the Pressure Control Configuration mechanism according to this invention. At Block  122 , initialization is taking place. At Block  124 , the user is asked if the pressure loop has a large time delay or requires feedforward control. If yes, at Block  128 , the user is advised to use the Anti-delay MFA controller or Feedforward MFA controller which are not part of the Dream Controller. In these cases, more detailed configuration and design are required. For instance, a controller for controlling the steam pressure of a boiler for power generation requires careful design and configuration. The routine then exits the Intelligent Engine mechanism 
         [0060]    At Block  126 , the user specifies whether or not the pressure process is nonlinear. If yes, the Nonlinear MFA controller is selected at Block  130 . At Block  132 , the user enters the Linearity Factor for the Nonlinear MFA controller. If the pressure process is not nonlinear, at Block  134 , the user specifies whether or not the process is open-loop oscillating. If yes, the Flex-phase MFA controller is selected at Block  136  and its Anti-overshoot constant Ks is configured with a value of 0.2 at Block  140 . If the pressure process is neither nonlinear nor open-loop oscillating, a regular SISO MFA is selected at Block  138 . At last, the MFA controller is configured with Kc=2 and Tc=8 seconds at Block  142 , and then the routine exits. 
       3. Temperature Control 
       [0061]    Temperature is an important process variable because it provides a critical condition for combustion, chemical reaction, fermentation, drying, calcination, distillation, concentration, extrusion, crystallization, and air conditioning. Poor temperature control can cause major safety, quality, and productivity problems. Although highly desirable, it is often difficult to control the temperature due to one or more of the following reasons: (1) very slow, (2) time-varying, (3) large time delay, (4) multivariable with serious coupling to other process variables, (5) large load changes, (6) dynamical changes due to fuel change and other uncertainties, (7) nonlinear, (8) high-speed, (9) single-input-multi-output (SIMO), (10) multi-input-single-output (MISO), (11) run-away, etc. Various MFA controllers have been developed to deal with these difficulties. However, as a general-purpose controller, the Dream Controller is not suitable to control the most problematic temperature processes. Therefore, extra screening is necessary when selecting and configuring a temperature controller. 
         [0062]      FIG. 9  is a flow chart describing the steps for the Temperature Control Configuration mechanism according to this invention. At Block  144 , initialization is taking place. At Block  146 , the user is asked to verify that the temperature process is not a single-input-multi-output (SIMO) process, or a multi-input-single-output (MISO) process, or a run-away process. At Block  148 , this verification is checked. If the result is negative, at Block  150 , the user is advised that the process cannot be controlled using this controller and a special MFA controller is required. Then the routine exits the Intelligent Engine mechanism. 
         [0063]    After the screening, at Block  152 , the user is asked if the temperature process is nonlinear. If yes, the Nonlinear MFA controller is selected at Block  154 . Otherwise, a SISO MFA controller is selected at Block  156 . At Block  158 , the user enters the Linearity Factor for the Nonlinear MFA controller. At Block  160 , the user needs to select if the process is (1) very fast, (2) fast, (3) medium, (4) slow, and (5) very slow. Based on the selections of (1) to (5), the corresponding time constant Tc as listed in Block  160  is configured for the MFA controller. For option (6), the user needs to enter the estimate time constant of the process. For instance, the temperature loop of a rapid thermal processing (RTP) system may have a 0.5 second time constant, and the temperature loop of a large HVAC system may have a time constant of several hours. At Block  162 , the controller is configured with Kc=2, and then the routine exits. 
       4. Level Control 
       [0064]    When compared to other control loops, the importance of the level loop is often over-looked. Typically, the level loop is controlled by manipulating the inflow or outflow of the operating unit, and is considered an easy loop to control. In general, it is not easy to properly tune a PID controller to achieve good level control under all operating conditions due to the potential inflow and outflow variations of the operating unit. Overly tight level control will result in too much movement of the flow loop, which can cause excessive disturbances to the downstream operating unit. Thus, a PID level controller is usually detuned to allow the level to fluctuate; so the variations of the outflow are minimized. However, the detuned PID cannot provide prompt control against large disturbances, which may result in safety problems during a plant upset. In addition, oscillations in level can cause the process to swing, which also results in a lower yield. The Robust MFA controller is well suited to control the level loop. It allows smooth material and energy transfers between the operating units; and also protects the levels from overflowing or becoming too dry during abnormal conditions. 
         [0065]      FIG. 10  is a flow chart describing the steps for the Level Control Configuration mechanism according to this invention. At Block  164 , initialization is taking place. At Block  166 , the user is asked if it is a boiler steam drum level. If yes, at Block  168 , the user is advised to use the 3-element MIA control solution. Then the routine exits the Intelligent Engine mechanism. Otherwise, at Block  170 , the SISO MFA controller is selected. At Block  172 , the user specifies if the level process is non-self-regulating. Non-self-regulating means that the level will continue to go up or down under a constant process input. If yes, the MFA controller is configured with Kc=10, and Tc=300 seconds at Block  174 . If not, the MFA controller is configured with Kc=2, and Tc=50 seconds at Block  176 . At Block  178 , the user is asked if protection of level from running too high or too low is needed. If yes, at Block  179 , the Robust MFA control feature is enabled. The Level Upper Bound and Level Lower Bound are entered at Block  180  for the Robust MFA controller. The Upper and Lower Bound are based on the level setpoint in its engineering unit. Recall that the PV Engineering Unit has been entered in the Process Selection mechanism. At Block  182 , the Robust MFA controller is configured with Upper Gain Ratio=Lower Gain Ratio=3 and then the routine ends. If the level protection is not required, the routine goes directly to the end. 
       5. PH Control 
       [0066]    Most industrial plants and municipal facilities generate a wastewater effluent that must be neutralized prior to discharge or reuse. Consequently, pH control is needed everywhere and yet most pH loops perform poorly. Results are inferior product quality, environmental pollution, and material waste. With ever increasing pressure to improve plant efficiency and tighter regulations in environmental protection, effective and continuous pH control is highly desirable. 
         [0067]    Nevertheless, a pH loop is usually difficult to control because it is highly nonlinear. The pH value versus the reagent flow has a logarithmic relationship. Away from neutrality, the process gain is relatively small. Near neutrality where pH=7, the process gain can be a few thousand times higher. It is impossible for a fixed controller like PID to effectively control this process. In practice, most pH loops are in a “bang-bang” type of control with pumps cycling on and off, which causes large oscillations. Since acid and caustic neutralize each other, over-dosing acid and caustic is prohibitively expensive. Statistics show that a poorly controlled pH process can cost tens of thousands of dollars in chemical usage each month, not counting the penalties imposed by violating government discharge codes. 
         [0068]    The MFA pH controller can effectively control a wide range of pH processes within the full pH range. It is useful for wastewater neutralization and also enables automatic control of acid or alkaline concentration, both of which are critical quality variables for the chemical process industry. 
         [0069]      FIG. 11  is a flow chart describing the steps for the pH Control Configuration mechanism according to this invention. At Block  184 , initialization is taking place. At Block  186 , the user is asked if the pH process has large time delays. If yes, the Anti-delay MFA pH controller is selected at Block  188 . If not, the regular MFA pH controller is selected at Block  190 . At Block  192 , the user is asked to enter the Minimum Delay Time and Maximum Delay Time of the pH process. Since it is just a range of the delay time, it is easy to make the estimation. At Block  194 , the user selects if the pH process is (1) Strong-acid-strong-base, (2) Strong-acid-weak-base, (3) Weak-acid-strong-base, (4) Weak-acid-weak-base, and (5) Uncertain. At Block  196 , MFA pH controller parameters are configured based on the selection in Block  194 . The parameters include the titration break point A and B, steep gain, flat gain, and time constant. As an example, these parameters can be configured with the values listed in Table 2. 
         [0000]    
       
         
               
               
               
             
           
               
                   
                 TABLE 2 
               
               
                   
                   
               
               
                   
                 pH Process 
                 MFA pH Controller Parameters 
               
               
                   
                   
               
             
             
               
                   
                 Strong-acid-strong-base 
                 Break A = 11, Break B = 3, Kc1 = 1, 
               
               
                   
                   
                 Kc2 = 0.001, Tc = 10 sec. 
               
               
                   
                 Strong-acid-weak-base 
                 Break A = 8, Break B = 3, Kc1 = 1, 
               
               
                   
                   
                 Kc2 = 0.003, Tc = 10 sec. 
               
               
                   
                 Weak-acid-strong-base 
                 Break A = 11, Break B = 6, Kc1 = 1, 
               
               
                   
                   
                 Kc2 = 0.003, Tc = 10 sec. 
               
               
                   
                 Weak-acid-weak-base 
                 Break A = 8, Break B = 6, Kc1 = 1, 
               
               
                   
                   
                 Kc2 = 0.01, Tc = 20 sec. 
               
               
                   
                 Uncertain 
                 Break A = 9, Break B = 5, Kc1 = 1, 
               
               
                   
                   
                 Kc2 = 0.001, Tc = 10 sec. 
               
               
                   
                   
               
             
          
         
       
     
         [0070]    From  FIG. 7  to  FIG. 11 , the control selection and configuration steps for flow, pressure, temperature, level, and pH processes are described, respectively. The controller selection based on the process type and control challenge is summarized in Table 3. 
         [0000]    
       
         
               
               
               
             
           
               
                 TABLE 3 
               
               
                   
               
               
                 Process Type 
                 Control Challenge 
                 Pre-configured MFA 
               
               
                   
               
             
             
               
                 1. Flow 
                 a. Regular 
                 a. SISO MFA controller 
               
               
                   
                 b. Nonlinear 
                 b. Nonlinear MFA controller 
               
               
                 2. Pressure 
                 a. Regular 
                 a. SISO MFA controller 
               
               
                   
                 b. Nonlinear 
                 b. Nonlinear MFA controller 
               
               
                   
                 c. Open-loop oscillating 
                 c. Flex-phase MFA controller 
               
               
                 3. Temp 
                 a. Regular or large time lag 
                 a. SISO MFA controller 
               
               
                   
                 b. Nonlinear 
                 b. Nonlinear MFA controller. 
               
               
                 4. Level 
                 a. Regular 
                 a. SISO MFA controller 
               
               
                   
                 b. Non-self-regulating 
                 b. SISO MFA controller 
               
               
                   
                 c. Minimal OP change 
                 c. Robust MFA controller 
               
               
                   
                 desirable 
               
               
                 5. PH 
                 a. No large time delay. 
                 a. MFA pH controller 
               
               
                   
                 b. There is a large time 
                 b. Anti-delay MFA pH 
               
               
                   
                 delay. 
                 controller 
               
               
                   
               
             
          
         
       
     
         [0071]      FIG. 12  is a flow chart describing the steps for the Control System Inspection mechanism according to this invention. It consists of the inspection for the controller configuration and the signals of the control system. At Block  198 , initialization is taking place. At Block  200 , a Controller Configuration Menu is shown that includes all information relating to the process selection and controller configuration. Table 4 shows an example of a temperature process to be controlled by a Nonlinear MFA controller. 
         [0000]    
       
         
               
               
             
           
               
                   
                 TABLE 4 
               
               
                   
                   
               
             
             
               
                   
                 Process Info: 
               
               
                   
                 Process Type = Temperature, Control Challenge = Nonlinear. 
               
               
                   
                 PV Low Limit = 100, PV High Limit = 1000, Engineering Unit = 
               
               
                   
                 Degree F. 
               
               
                   
                 Controller Info: 
               
               
                   
                 Selected Controller = Nonlinear MFA. 
               
               
                   
                 Configured Parameters: Kc = 2.0, Tc = 5.0 sec, NL Factor = 5. 
               
               
                   
                   
               
             
          
         
       
     
         [0072]    At Block  202 , the user is asked if the configuration is accurate. If not, it is advised to make all necessary changes at Block  204 . The Controller Configuration Menu will show again to let the user enter changes. At Block  202 , the user is asked if the configuration is accurate. If yes, configuration is done and the routine proceeds. 
         [0073]    At Block  206 , the user is asked to check the status of (1) Setpoint (SP), (2) Process Variable (PV), (3) Controller Output (OP), (4) Controller Output Tracking Variable (OTV), and (5) Controller Mode. All these signals have to be in their normal states before the controller can be launched to the automatic control mode. At Block  208 , the user verifies that the system is OK. If not, at Block  210 , it is advised to take all necessary actions to assure that all control loop signals are working properly. If yes, the routine ends with a successful control system configuration and inspection. 
         [0074]    Inside the Intelligent Engine routine as shown in  FIG. 3 , the program continues from Block  58  to Block  60 . If the user is ready to launch the controller, the program will proceed to Block  62  and a Controller Ready Flag is set.