Patent Publication Number: US-7212915-B2

Title: Application of linear splines to internal combustion engine control

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
     This application claims the benefit of U.S. Provisional Application No. 60/672,593, filed on Apr. 19, 2005. The disclosure of the above application is incorporated herein by reference. 
    
    
     FIELD OF THE INVENTION 
     The present invention relates to internal combustion engine control, and more particularly to using linear splines to determine nonlinear behavior of an internal combustion engine. 
     BACKGROUND OF THE INVENTION 
     Automotive powertrains require accurate control systems to meet government regulations and customer expectations. Manufacturers of powertrain control systems recognize the benefit of applying analytical control system design methods to the development and calibration of their products. Accurate control systems provide improved performance, reduced variation, and reduced calibration effort. 
     Analytical control system design applies Control Theory to vehicle systems using differential equation engineering (or difference equation engineering, for discrete time systems). Generally, analytical control system design includes modeling a physical system as a differential equation and analytically determining a new differential equation. The new differential equation is often called the “control law” or “control algorithm.” The control law is connected to the system in question to obtain a desired behavior. The desired behavior is often expressed as either a differential equation or some attribute of a differential equation. 
     The analytic theory of linear differential and difference equations and the design theory for linear control systems are particularly well-suited for systems that can be described by linear, constant coefficient equations. The theory of non-linear differential equations, however, is less helpful for analytic design of control systems. Generally, the theory of non-linear differential equations is largely confined to describing equation properties that can ensure existence, uniqueness, and stability of solutions. As a result, the analytic design theory for non-linear control systems usually involves problems in terms of stability. 
     “Scheduling” involves using linear system descriptions for non-linear systems by modeling a nonlinear system as a linear system with parameters that are functions of other variables. In other words, linear systems are scheduled to represent non-linear behavior. Scheduling is extremely powerful because it permits the application of linear analysis and design techniques to non-linear systems. Conventional methods for scheduling linear systems include table look-up (i.e. interpolation) scheduling, polynomial scheduling, and “jump” linear scheduling. 
     In table look-up scheduling, system parameters are interpolated between values stored in a one-dimensional or multi-dimensional table. Scheduling via table lookup can be computationally expensive and does not permit standard least squares identification of table entries. Moreover, the computational expense increases geometrically with the dimension of the scheduling space (i.e. increases with additional scheduling variables). The inability to use least squares identification obscures the relationship between model parameters (as stored in the table entries) and system behavior. This limits the ability of designers to apply extensions of standard linear design theory, such as least squares identification. 
     In polynomial scheduling, system parameters are polynomial functions of the scheduling variables. In “jump” linear scheduling, system parameters are held constant over a range of the scheduling variables, but can change discretely when crossing into a different range of the scheduling parameters. “Jump” linear scheduling is computationally efficient, and it preserves transparency between system parameters and performance. For example, “jump” linear scheduling permits the use of least squares identification. However, with “jump” linear scheduling, the system behavior can become discontinuous across scheduling boundaries. Such discontinuity can produce undesirable system performance. 
     SUMMARY OF THE INVENTION 
     A modeling system for a control parameter of a vehicle comprises a first model that formulates the control parameter in terms of linear spline basis functions, coefficients, and knots. A second model is derived according to the first model, includes coefficients that are derived according to the linear spline basis functions, coefficients, and knots, and forms a linear equation for the control parameter. A memory module stores the linear equation. A control module calculates the control parameter according to the linear equation. 
     Further areas of applicability of the present invention will become apparent from the detailed description provided hereinafter. It should be understood that the detailed description and specific examples, while indicating the preferred embodiment of the invention, are intended for purposes of illustration only and are not intended to limit the scope of the invention. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The present invention will become more fully understood from the detailed description and the accompanying drawings, wherein: 
         FIG. 1  is a flow diagram that illustrates a control method that schedules a function using linear splines according to the present invention; 
         FIG. 2A  is a three-dimensional graphical representation of a collection of data points according to the present invention; 
         FIG. 2B  is a three-dimensional graphical representation of a linear spline fit of a collection of data points according to the present invention; 
         FIG. 2C  is a graphical representation of data ranges defined by linear spline knots according to the present invention; and 
         FIG. 3  is a functional block diagram of an engine control system that implements a linear spline method according to the present invention. 
     
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
     The following description of the preferred embodiment(s) is merely exemplary in nature and is in no way intended to limit the invention, its application, or uses. For purposes of clarity, the same reference numbers will be used in the drawings to identify similar elements. As used herein, the term module and/or device refers to an application specific integrated circuit (ASIC), an electronic circuit, a processor (shared, dedicated, or group) and memory that execute one or more software or firmware programs, a combinational logic circuit, and/or other suitable components that provide the described functionality. 
     The present invention permits the application of linear control design methods to non-linear systems. Linear spline scheduling provides a practical, generic method for modeling non-linear systems as scheduled, linear systems. More specifically, this invention relates to the application of linear splines to internal combustion engine control. Linear splines schedule the parameters of a linear system to represent the nonlinear behavior typically seen in internal combustion engine control systems. 
     Linear spline scheduling permits a “dual” formulation of system behavior that is computationally efficient while still preserving the transparency of the relationship between system parameters and system performance. A first formulation is linear in its parameters, thereby permitting the use of least squares identification. An algebraically equivalent second formulation allows a computationally efficient implementation of control laws. The dual formulations present a transparent relationship between system parameters and system behavior that makes the application of extensions to standard linear design theory relatively straightforward. As such, designers can apply standard linear design methods to systems scheduled via linear splines. 
     In a first implementation, the linear spline method is applied to a one-dimensional scheduled filter. A filter coefficient α is a function of a single variable, such as coolant temperature (TCO). The filter coefficient α is formulated according to linear splines as: 
     
       
         
           
             
               
                 
                   
                     α 
                     = 
                     
                       
                         c 
                         0 
                       
                       + 
                       
                         
                           ∑ 
                           
                             i 
                             = 
                             1 
                           
                           n 
                         
                         ⁢ 
                         
                           
                             c 
                             i 
                           
                           × 
                           
                             UTCO 
                             ⁡ 
                             
                               ( 
                               i 
                               ) 
                             
                           
                         
                       
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   where 
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       UTCO 
                       ⁡ 
                       
                         ( 
                         i 
                         ) 
                       
                     
                     = 
                     
                       { 
                       
                         
                           
                             
                               0 
                             
                             
                               
                                 
                                   if 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   TCO 
                                 
                                 ≤ 
                                 
                                   TCO 
                                   i 
                                 
                               
                             
                           
                           
                             
                               
                                 TCO 
                                 - 
                                 
                                   TCO 
                                   i 
                                 
                               
                             
                             
                               otherwise 
                             
                           
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   
                     Equation 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     1 
                   
                   ) 
                 
               
             
           
         
       
     
     UTCO(i) is a basis function that is a function of TCO. The basis function determines an output value according to a range defined by TCO i . TCO i  indicates a beginning of a data range. In terms of linear spline formulation, TCO i  is a linear spline “knot.” The terms c 0  and c i  are constants. The filter coefficient formulation is piecewise linear. As such, a first slope of the filter coefficient α is linear between linear spline knots TCO i  and TCO i+1 . Similarly, a second slope of the filter coefficient α is linear between linear spline knots TCO i+1  and TCO i+2 . However, the slope of the filter coefficient α changes at each linear spline knot. 
     Because the filter coefficient equation is linear in its parameters c 0  and c i , the parameters in Equation 1 can easily be fit with standard least squares fitting methods as are known in the art. In other words, after first defining data ranges, the least squares fitting method is used to determine the parameters that define the slope in each data range (i.e. between successive linear splines knots) by fitting the coefficients in Equation 1. Consider:
 
 R   i =[TCO i ,TCO i+1 )  i= 1,2, . . .  n− 1
 
 R   n =[TCO n ,∞)
 
where R i  is a data range. When TCO∈R i , the filter coefficient function can be rewritten as
 
α=δ 0 +δ 1 ×TCO  (Equation 2),
 
where
 
               δ   0     =       c   0     -       ∑     m   =   1     i     ⁢       c   m     ×     TCO   m                 
and
 
               δ   1     =       ∑     m   =   1     i     ⁢       c   m     .             
In other words, Equation 2 formulates the filter coefficient α as a standard linear equation for each TCO data range R i . Equation 2 is algebraically equivalent to Equation 1.
 
     A control method  10  implements a filter coefficient schedule according to Equation 2 as shown in  FIG. 1 . In step  12 , the method  10  determines the terms δ 0  and δ 1  for each temperature range R i  by using least squares fitting to find the parameters in Equation 1, and performing arithmetic detailed by Equation 2. In step  14 , the terms δ 0  and δ 1  are stored for each temperature range R i . For example, the terms δ 0  and δ 1  are stored in memory of a control module that implements the control method  10 . In step  16 , the method  10  determines which range the scheduling variable TCO is in. In step  18 , the method  10  calculates α according to Equation 2 using the appropriate δ 0  and δ 1  terms. Those skilled in the art can appreciate that this implementation requires only a single multiply (δ 1 ×TCO) and a single addition (δ 0 +δ 1 ×TCO) to calculate. A comparable interpolation from a one-dimensional table requires significantly more mathematical operations. For one-dimensional implementations, there is no loss in accuracy. Therefore, the linear spline method as described above is as accurate as a one-dimensional table lookup method if the number of knots in the linear spline formulation is equivalent to a number of entries in the interpolation table. 
     In a second implementation, the linear spline method is applied to a two-dimensional volumetric efficiency (VE) function. The VE function is scheduled as a function of manifold absolute pressure (MAP) and engine speed in rotations per minute (RPM). VE is formulated according to linear splines as: 
     
       
         
           
             VE 
             = 
             
               
                 c 
                 0 
               
               + 
               
                 
                   ∑ 
                   
                     i 
                     = 
                     1 
                   
                   n 
                 
                 ⁢ 
                 
                   
                     a 
                     i 
                   
                   × 
                   
                     UMAP 
                     ⁡ 
                     
                       ( 
                       i 
                       ) 
                     
                   
                 
               
               + 
               
                 
                   ∑ 
                   
                     j 
                     = 
                     1 
                   
                   m 
                 
                 ⁢ 
                 
                   
                     b 
                     j 
                   
                   × 
                   
                     URPM 
                     ⁡ 
                     
                       ( 
                       j 
                       ) 
                     
                   
                 
               
             
           
         
       
       
         
           where 
         
       
       
         
           
             
               UMAP 
               ⁡ 
               
                 ( 
                 i 
                 ) 
               
             
             = 
             
               { 
               
                 
                   
                     
                       
                         0 
                       
                       
                         
                           
                             if 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             MAP 
                           
                           ≤ 
                           
                             MAP 
                             i 
                           
                         
                       
                     
                     
                       
                         
                           MAP 
                           - 
                           
                             MAP 
                             i 
                           
                         
                       
                       
                         otherwise 
                       
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   and 
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     URPM 
                     ⁡ 
                     
                       ( 
                       j 
                       ) 
                     
                   
                 
                 = 
                 
                   { 
                   
                     
                       
                         
                           0 
                         
                         
                           
                             
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               RPM 
                             
                             ≤ 
                             
                               RPM 
                               j 
                             
                           
                         
                       
                       
                         
                           
                             RPM 
                             - 
                             
                               RPM 
                               j 
                             
                           
                         
                         
                           otherwise 
                         
                       
                     
                     . 
                   
                 
               
             
           
         
       
     
     UMAP(i) and URPM(j) are basis functions as described with respect to the one-dimensional filter coefficient application. The basis functions determine output values according to ranges defined by MAP i  and RPM j , or the linear spline knots for MAP and RPM, respectively. The terms c 0 , a i , and b j  are constants. Therefore, the least squares fitting method can be used to fit the parameters. 
     The linear spline knots are used to define ranges for least squares fitting as described below:
 
 R   i,j ={[MAP i ,MAP i+1 ),└RPM j ,RPM j+1 )}  i= 1,2, . . .  n− 1  j= 1,2, . . .  m− 1,
 
 R   n,j ={[MAP n ,∞),└RPM j ,RPM j+1 )}  j= 1,2, . . .  m− 1,
 
 R   i,m ={MAP i ,MAP i+1 ),[RPM m ,∞)}  i= 1,2, . . .  n− 1, and
 
 R   n,m ={[MAP n ,∞), [RPM m ,∞)}.
 
     When (MAP,RPM)ÅR i,j , the VE function can be rewritten as 
     
       
         
           
             
               
                 
                   
                     
                       VE 
                       = 
                       
                         
                           δ 
                           0 
                         
                         + 
                         
                           
                             δ 
                             1 
                           
                           × 
                           MAP 
                         
                         + 
                         
                           
                             δ 
                             2 
                           
                           × 
                           RPM 
                         
                       
                     
                     , 
                     
                       
 
                     
                     ⁢ 
                     where 
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       
                         δ 
                         0 
                       
                       = 
                       
                         
                           c 
                           0 
                         
                         - 
                         
                           
                             ∑ 
                             
                               k 
                               = 
                               1 
                             
                             i 
                           
                           ⁢ 
                           
                             
                               a 
                               k 
                             
                             × 
                             
                               MAP 
                               k 
                             
                           
                         
                         - 
                         
                           
                             ∑ 
                             
                               k 
                               = 
                               1 
                             
                             j 
                           
                           ⁢ 
                           
                             
                               b 
                               k 
                             
                             × 
                             
                               RPM 
                               k 
                             
                           
                         
                       
                     
                     , 
                     
                       
 
                     
                     ⁢ 
                     
                       
                         δ 
                         1 
                       
                       = 
                       
                         
                           ∑ 
                           
                             k 
                             = 
                             1 
                           
                           i 
                         
                         ⁢ 
                         
                           a 
                           k 
                         
                       
                     
                     , 
                     
                       
                         and 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           δ 
                           2 
                         
                       
                       = 
                       
                         
                           ∑ 
                           
                             k 
                             = 
                             1 
                           
                           j 
                         
                         ⁢ 
                         
                           
                             b 
                             k 
                           
                           . 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   
                     Equation 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     3 
                   
                   ) 
                 
               
             
           
         
       
     
     In other words, Equation 3 formulates VE as a standard linear equation for each data range. Those skilled in the art can appreciate that a control method as described in  FIG. 1  can be used to implement the VE function according to Equation 3. This implementation requires only two multiplications and two additions to calculate. A comparable interpolation from a two-dimensional table requires significantly more mathematical operations. Unlike the one-dimensional filter coefficient case, however, there is a small loss in accuracy. The numerical efficiency of linear spline method compared to table lookup increases with the dimensionality of the problem while the accuracy decreases. 
     In a third implementation, the linear spline method is applied to a two-dimensional VE function with a cross term. The VE function is still scheduled as a function of MAP and RPM. However, the VE is modeled with a cross term as described below. VE as a function of MAP and RPM with a cross term is formulated according to linear splines as: 
     
       
         
           
             
               
                 
                   VE 
                   = 
                     
                   ⁢ 
                   
                     
                       c 
                       0 
                     
                     + 
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         N 
                       
                       ⁢ 
                       
                         
                           a 
                           i 
                         
                         × 
                         
                           UMAP 
                           ⁡ 
                           
                             ( 
                             i 
                             ) 
                           
                         
                       
                     
                     + 
                     
                       
                         ∑ 
                         
                           j 
                           = 
                           1 
                         
                         m 
                       
                       ⁢ 
                       
                         
                           b 
                           j 
                         
                         × 
                         
                           URPM 
                           ⁡ 
                           
                             ( 
                             j 
                             ) 
                           
                         
                       
                     
                     + 
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     
                       
                         ∑ 
                         
                           j 
                           = 
                           1 
                         
                         m 
                       
                       ⁢ 
                       
                         
                           d 
                           j 
                         
                         × 
                         MAP 
                         × 
                         
                           URPM 
                           ⁡ 
                           
                             ( 
                             j 
                             ) 
                           
                         
                       
                     
                     + 
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         n 
                       
                       ⁢ 
                       
                         
                           e 
                           i 
                         
                         × 
                         RPM 
                         ⁢ 
                         
                             
                         
                         × 
                         
                           UMAP 
                           ⁡ 
                           
                             ( 
                             i 
                             ) 
                           
                         
                       
                     
                   
                 
               
             
           
         
       
       
         
           where 
         
       
       
         
           
             
               UMAP 
               ⁡ 
               
                 ( 
                 i 
                 ) 
               
             
             = 
             
               { 
               
                 
                   
                     
                       
                         0 
                       
                       
                         
                           
                             if 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             MAP 
                           
                           ≤ 
                           
                             MAP 
                             i 
                           
                         
                       
                     
                     
                       
                         
                           MAP 
                           - 
                           
                             MAP 
                             i 
                           
                         
                       
                       
                         otherwise 
                       
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   and 
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     URPM 
                     ⁡ 
                     
                       ( 
                       j 
                       ) 
                     
                   
                 
                 = 
                 
                   { 
                   
                     
                       
                         
                           0 
                         
                         
                           
                             
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               RPM 
                             
                             ≤ 
                             
                               RPM 
                               j 
                             
                           
                         
                       
                       
                         
                           
                             RPM 
                             - 
                             
                               RPM 
                               j 
                             
                           
                         
                         
                           otherwise 
                         
                       
                     
                     . 
                   
                   ⁢ 
                   
                       
                   
                 
               
             
           
         
       
     
     As with previously described implementations, the parameters are constant within each range of MAP and RPM. Therefore, the least squares fitting method can be used to fit the parameters. Linear spline knots are used to define ranges for least squares fitting as described below:
 
 R   i,j ={[MAP i ,MAP i+1 ),└RPM j   ,RPM   j+1 )}  i= 1,2, . . .  n− 1  j= 1,2, . . .  m− 1,
 
 R   n,j ={[MAP n ∞),└RPM j ,RPM j+1 )}  j= 1,2, . . .  m− 1,
 
 R   i,m ={[MAP i ,MAP i+1 ),[RPM m ,∞)}  i= 1,2, . . .  n− 1,
 
and  R   n,m ={[MAP n ,∞),[RPM m ,∞)}.
 
     When (MAP,RPM)∈R i,j , the VE function can be rewritten as 
     
       
         
           
             
               
                 
                   
                     
                       
                         
                           VE 
                           = 
                             
                           ⁢ 
                           
                             
                               δ 
                               0 
                             
                             + 
                             
                               
                                 δ 
                                 1 
                               
                               × 
                               MAP 
                             
                             + 
                             
                               
                                 δ 
                                 2 
                               
                               × 
                               RPM 
                             
                             + 
                           
                         
                       
                     
                     
                       
                         
                             
                           ⁢ 
                           
                             
                               
                                 δ 
                                 3 
                               
                               × 
                               MAP 
                               × 
                               RPM 
                             
                             , 
                           
                         
                       
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   where 
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       
                         δ 
                         0 
                       
                       = 
                       
                         
                           c 
                           0 
                         
                         - 
                         
                           
                             ∑ 
                             
                               k 
                               = 
                               1 
                             
                             i 
                           
                           ⁢ 
                           
                             
                               a 
                               k 
                             
                             × 
                             
                               MAP 
                               k 
                             
                           
                         
                         - 
                         
                           
                             ∑ 
                             
                               k 
                               = 
                               1 
                             
                             j 
                           
                           ⁢ 
                           
                             
                               b 
                               k 
                             
                             × 
                             
                               RPM 
                               k 
                             
                           
                         
                       
                     
                     , 
                     
                       
 
                     
                     ⁢ 
                     
                       
                         δ 
                         1 
                       
                       = 
                       
                         
                           
                             ∑ 
                             
                               k 
                               = 
                               1 
                             
                             i 
                           
                           ⁢ 
                           
                             a 
                             k 
                           
                         
                         - 
                         
                           
                             ∑ 
                             
                               k 
                               = 
                               1 
                             
                             j 
                           
                           ⁢ 
                           
                             
                               d 
                               j 
                             
                             × 
                             
                               RPM 
                               j 
                             
                           
                         
                       
                     
                     , 
                     
                       
 
                     
                     ⁢ 
                     
                       
                         δ 
                         2 
                       
                       = 
                       
                         
                           
                             ∑ 
                             
                               k 
                               = 
                               1 
                             
                             j 
                           
                           ⁢ 
                           
                             b 
                             k 
                           
                         
                         - 
                         
                           
                             ∑ 
                             
                               k 
                               = 
                               1 
                             
                             i 
                           
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           
                             
                               e 
                               k 
                             
                             × 
                             
                               MAP 
                               i 
                             
                           
                         
                       
                     
                     , 
                     
                       
 
                     
                     ⁢ 
                     
                       
                         and 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           δ 
                           3 
                         
                       
                       = 
                       
                         
                           
                             ∑ 
                             
                               k 
                               = 
                               1 
                             
                             i 
                           
                           ⁢ 
                           
                             d 
                             k 
                           
                         
                         + 
                         
                           
                             ∑ 
                             
                               k 
                               = 
                               1 
                             
                             j 
                           
                           ⁢ 
                           
                             
                               e 
                               k 
                             
                             . 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   
                     Equation 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     4 
                   
                   ) 
                 
               
             
           
         
       
     
     Those skilled in the art can appreciate that a control method as described with respect to the first and second implementations can be used to implement the VE function according to Equation 4. This implementation requires only three multiplications and three additions to calculate. A comparable interpolation from a two-dimensional table requires significantly more mathematical operations. Additionally, this implementation can be extended to more complicated polynomic formulations. In particular, the addition of quadratic terms to model VE with a scheduled, generalized quadratic equation follows directly since a square of MAP or RPM is the same as crossing MAP or RPM with itself. 
     An exemplary demonstration of the linear spline method with respect to the VE function of the third implementation is shown in  FIGS. 2A through 2C . Referring now to  FIG. 2A , a collection of exemplary data points represent VE as a function of MAP and RPM with cross terms. Referring now to  FIG. 2B , the data points from  FIG. 2A  are shown with a linear spline fit representation. Referring now to  FIG. 2C , a knot location plot demonstrates data ranges for values of RPM and MAP. For example, a first range  20  is defined by RPM between 500 and 1000 and by MAP between 0 and 25 KPa. In other words, for the first range  30 , 500 and 1000 are the linear spline knots for RPM. Similarly, 0 and 25 are the linear spline knots for MAP. A second range  22  is defined by RPM knots of 2000 and 2500 and by MAP knots of 45 and 55 KPa. In the second range  22 , VE is determined according to Equation 4:
 
 VE= 1673.49+5.415×MAP+0.01919×RPM−0.001577×MAP×RPM,
 
     where the values of the parameters are determined according to the above description of the third implementation. 
     In a fourth implementation, the linear spline method is applied to a three-dimensional lost fuel (% LF) function. The lost fuel function is scheduled as a function of MAP, RPM, and TCO. This implementation is described in more detail in U.S. patent application Ser. No. 60/672,592, filed on Apr. 19, 2005 which is hereby incorporated by reference in its entirety. % LF is formulated according to linear splines as: 
     
       
         
           
             
               
                 
                   
                     % 
                     ⁢ 
                     LF 
                   
                   = 
                     
                   ⁢ 
                   
                     
                       c 
                       0 
                     
                     + 
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         n 
                       
                       ⁢ 
                       
                         
                           a 
                           i 
                         
                         × 
                         
                           UMAP 
                           ⁡ 
                           
                             ( 
                             i 
                             ) 
                           
                         
                       
                     
                     + 
                     
                       
                         ∑ 
                         
                           j 
                           = 
                           1 
                         
                         m 
                       
                       ⁢ 
                       
                         
                           b 
                           j 
                         
                         × 
                         
                           URPM 
                           ⁡ 
                           
                             ( 
                             j 
                             ) 
                           
                         
                       
                     
                     + 
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     
                       ∑ 
                       
                         k 
                         = 
                         1 
                       
                       o 
                     
                     ⁢ 
                     
                       
                         d 
                         k 
                       
                       ⁢ 
                       
                         UTCO 
                         ⁡ 
                         
                           ( 
                           k 
                           ) 
                         
                       
                     
                   
                 
               
             
           
         
       
       
         
           where 
         
       
       
         
           
             
               UMAP 
               ⁡ 
               
                 ( 
                 i 
                 ) 
               
             
             = 
             
               { 
               
                 
                   
                     
                       0 
                     
                     
                       
                         
                           if 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           MAP 
                         
                         ≤ 
                         
                           MAP 
                           i 
                         
                       
                     
                   
                   
                     
                       
                         MAP 
                         - 
                         
                           MAP 
                           i 
                         
                       
                     
                     
                       otherwise 
                     
                   
                 
                 , 
                 
                   
 
                 
                 ⁢ 
                 
                   
                     URPM 
                     ⁡ 
                     
                       ( 
                       j 
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             0 
                           
                           
                             
                               
                                 if 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 RPM 
                               
                               ≤ 
                               
                                 RPM 
                                 j 
                               
                             
                           
                         
                         
                           
                             
                               RPM 
                               - 
                               
                                 RPM 
                                 j 
                               
                             
                           
                           
                             otherwise 
                           
                         
                       
                       , 
                       
                         
 
                       
                       ⁢ 
                       
                         
                           and 
                           ⁢ 
                           
                             
 
                           
                           ⁢ 
                           
                             UTCO 
                             ⁡ 
                             
                               ( 
                               k 
                               ) 
                             
                           
                         
                         = 
                         
                           { 
                           
                             
                               
                                 
                                   0 
                                 
                                 
                                   
                                     
                                       if 
                                       ⁢ 
                                       
                                           
                                       
                                       ⁢ 
                                       TCO 
                                     
                                     ≤ 
                                     
                                       TCO 
                                       k 
                                     
                                   
                                 
                               
                               
                                 
                                   
                                     TCO 
                                     - 
                                     
                                       TCO 
                                       k 
                                     
                                   
                                 
                                 
                                   otherwise 
                                 
                               
                             
                             . 
                           
                         
                       
                     
                   
                 
               
             
           
         
       
     
     As with previously described implementations, the parameters are constant. Therefore, the least squares fitting method can be used to fit the parameters. Linear spline knots are used to define ranges for least squares fitting as described below:
 
 R   i,j,k ={[MAP i ,MAP i+1 ),└RPM j ,RPM j+1 ),[TCO k ,TCO k+1 )},  i= 1,2, . . .  n− 1 ; j= 1,2, . . .  m− 1 ; k= 1,2, . . .  o− 1,
 
 R   n,j,k ={[MAP n ,∞),└RPM j ,RPM j+1 ),[TCO k ,TCO k+1 )}  j= 1,2, . . .  m− 1 ; k= 1,2, . . .  o− 1,
 
 R   i,m,k ={[MAP i ,MAP i+1 ),[RPM m ,∞),[TCO k ,TCO k+1 )}  i= 1,2, . . .  n− 1 ; k= 1,2, . . .  o− 1,
 
 R   i,j,o ={[MAP i ,MAP i+1 ),└RPM j ,RPM j+1 ),[TCO o ,∞)}  i= 1,2, . . .  n− 1 ; j= 1,2, . . .  m− 1,
 
 R   n,m,k ={[MAP n ,∞),[RPM m ,∞),[TCO k ,TCO k+1 )}  k= 1,2, . . .  o− 1,
 
R n,j,o ={[MAP n ,∞),└RPM j ,RPM j+1 ),[TCO o ,∞)}  j= 1,2, . . .  m− 1,
 
 R   i,m,o ={[MAP i ,MAP i+1 ),[RPM m ,∞),[TCO o ,∞)} i= 1,2, . . .  n− 1,
 
and
 
 R   n,m,o ={[MAP n ,∞),[RPM m ,∞),[TCO o ,∞)}.
 
     When (MAP,RPM,TCO)∈R i,j,k , the lost fuel function can be rewritten as 
     
       
         
           
             
               
                 
                   
                     
                       % 
                       ⁢ 
                       LF 
                     
                     = 
                     
                       
                         δ 
                         0 
                       
                       + 
                       
                         
                           δ 
                           1 
                         
                         × 
                         MAP 
                       
                       + 
                       
                         
                           δ 
                           2 
                         
                         × 
                         RPM 
                       
                       + 
                       
                         
                           δ 
                           3 
                         
                         × 
                         TCO 
                       
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   where 
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       
                         
                           
                             δ 
                             0 
                           
                           = 
                             
                           ⁢ 
                           
                             
                               c 
                               0 
                             
                             - 
                             
                               
                                 ∑ 
                                 
                                   p 
                                   = 
                                   1 
                                 
                                 i 
                               
                               ⁢ 
                               
                                 
                                   a 
                                   p 
                                 
                                 × 
                                 
                                   MAP 
                                   p 
                                 
                               
                             
                             - 
                             
                               
                                 ∑ 
                                 
                                   p 
                                   = 
                                   1 
                                 
                                 j 
                               
                               ⁢ 
                               
                                 
                                   b 
                                   p 
                                 
                                 × 
                               
                             
                           
                         
                       
                     
                     
                       
                         
                             
                           ⁢ 
                           
                             
                               
                                 RPM 
                                 p 
                               
                               - 
                               
                                 
                                   ∑ 
                                   
                                     p 
                                     = 
                                     1 
                                   
                                   k 
                                 
                                 ⁢ 
                                 
                                   
                                     d 
                                     p 
                                   
                                   × 
                                   
                                     TCO 
                                     p 
                                   
                                 
                               
                             
                             , 
                           
                         
                       
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       
                         δ 
                         1 
                       
                       = 
                       
                         
                           ∑ 
                           
                             p 
                             = 
                             1 
                           
                           i 
                         
                         ⁢ 
                         
                           a 
                           p 
                         
                       
                     
                     , 
                     
                       
                         δ 
                         2 
                       
                       = 
                       
                         
                           ∑ 
                           
                             p 
                             = 
                             1 
                           
                           j 
                         
                         ⁢ 
                         
                           b 
                           p 
                         
                       
                     
                     , 
                     
                       
                         and 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           δ 
                           3 
                         
                       
                       = 
                       
                         
                           ∑ 
                           
                             p 
                             = 
                             1 
                           
                           k 
                         
                         ⁢ 
                         
                           
                             d 
                             p 
                           
                           . 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   
                     Equation 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     5 
                   
                   ) 
                 
               
             
           
         
       
     
     Those skilled in the art can appreciate that a control method as described with respect to previous implementations can be used to implement the % LF function according to Equation 5. This implementation requires only three multiplications and three additions to calculate. A comparable interpolation from a three-dimensional table requires significantly more mathematical operations. 
     In a fifth implementation, the linear spline method is applied to a four-dimensional VE function scheduled as a function of MAP, RPM, intake cam position (INT), and exhaust cam position (EXH). VE as a function of MAP, RPM, INT, and EXH is formulated according to linear splines as: 
     
       
         
           
             
               
                 
                   VE 
                   = 
                     
                   ⁢ 
                   
                     
                       c 
                       0 
                     
                     + 
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         n 
                       
                       ⁢ 
                       
                         
                           a 
                           i 
                         
                         × 
                         
                           UMAP 
                           ⁡ 
                           
                             ( 
                             i 
                             ) 
                           
                         
                       
                     
                     + 
                     
                       
                         ∑ 
                         
                           j 
                           = 
                           1 
                         
                         m 
                       
                       ⁢ 
                       
                         
                           b 
                           j 
                         
                         × 
                         
                           URPM 
                           ⁡ 
                           
                             ( 
                             j 
                             ) 
                           
                         
                       
                     
                     + 
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     
                       
                         ∑ 
                         
                           k 
                           = 
                           1 
                         
                         o 
                       
                       ⁢ 
                       
                         
                           d 
                           k 
                         
                         × 
                         
                           UINT 
                           ⁡ 
                           
                             ( 
                             k 
                             ) 
                           
                         
                       
                     
                     + 
                     
                       
                         ∑ 
                         
                           l 
                           = 
                           1 
                         
                         p 
                       
                       ⁢ 
                       
                         
                           e 
                           l 
                         
                         × 
                         
                           UEXH 
                           ⁡ 
                           
                             ( 
                             l 
                             ) 
                           
                         
                       
                     
                   
                 
               
             
           
         
       
       
         
           where 
         
       
       
         
           
             
               UMAP 
               ⁡ 
               
                 ( 
                 i 
                 ) 
               
             
             = 
             
               { 
               
                 
                   
                     
                       0 
                     
                     
                       
                         
                           if 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           MAP 
                         
                         ≤ 
                         
                           MAP 
                           i 
                         
                       
                     
                   
                   
                     
                       
                         MAP 
                         - 
                         
                           MAP 
                           i 
                         
                       
                     
                     
                       otherwise 
                     
                   
                 
                 , 
                 
                   
 
                 
                 ⁢ 
                 
                   
                     URPM 
                     ⁡ 
                     
                       ( 
                       j 
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             0 
                           
                           
                             
                               
                                 if 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 RPM 
                               
                               ≤ 
                               
                                 RPM 
                                 j 
                               
                             
                           
                         
                         
                           
                             
                               RPM 
                               - 
                               
                                 RPM 
                                 j 
                               
                             
                           
                           
                             otherwise 
                           
                         
                       
                       , 
                       
                         
 
                       
                       ⁢ 
                       
                         
                           UINT 
                           ⁡ 
                           
                             ( 
                             k 
                             ) 
                           
                         
                         = 
                         
                           { 
                           
                             
                               
                                 
                                   0 
                                 
                                 
                                   
                                     
                                       if 
                                       ⁢ 
                                       
                                           
                                       
                                       ⁢ 
                                       INT 
                                     
                                     ≤ 
                                     
                                       INT 
                                       k 
                                     
                                   
                                 
                               
                               
                                 
                                   
                                     INT 
                                     - 
                                     
                                       INT 
                                       k 
                                     
                                   
                                 
                                 
                                   otherwise 
                                 
                               
                             
                             , 
                             
                               
 
                             
                             ⁢ 
                             
                               
                                 and 
                                 ⁢ 
                                 
                                   
 
                                 
                                 ⁢ 
                                 
                                   UEXH 
                                   ⁡ 
                                   
                                     ( 
                                     l 
                                     ) 
                                   
                                 
                               
                               = 
                               
                                 { 
                                 
                                   
                                     
                                       
                                         0 
                                       
                                       
                                         
                                           
                                             if 
                                             ⁢ 
                                             
                                                 
                                             
                                             ⁢ 
                                             EXH 
                                           
                                           ≤ 
                                           
                                             EXH 
                                             l 
                                           
                                         
                                       
                                     
                                     
                                       
                                         
                                           EXH 
                                           - 
                                           
                                             EXH 
                                             l 
                                           
                                         
                                       
                                       
                                         otherwise 
                                       
                                     
                                   
                                   . 
                                 
                               
                             
                           
                         
                       
                     
                   
                 
               
             
           
         
       
     
     As with previously described implementations, the parameters are constant. Therefore, the least squares fitting method can be used to fit the parameters. Linear spline knots are used to define ranges for least squares fitting as described below:
 
R i,j,k, ={[MAP i ,MAP i+1 ),└RPM j ,RPM j+1 ),[INT k   ,INT   k+1 ),[EXH l ,EXH l+1 )},  i= 1,2, . . .  n− 1 ; j= 1,2, . . .  m− 1 ; k= 1,2, . . .  o− 1 ; l= 1,2, . . .  p− 1,
 
 R   n,j,k,l ={[MAP n ,∞),└RPM j ,RPM j+1 ),[INT k ,INT k+1 ),[EXH l ,EXH l+1 )},  j= 1,2, . . .  m− 1 ,k= 1,2, . . .  o− 1 ,l= 1,2, . . .  p− 1,
 
.
 
.
 
.
 
 R   i,m,o,p ={[MAP i ,MAP i+1 ),[RPM m ,∞),[INT o ,∞),└EXH p ,∞)} i= 1,2, . . .  n− 1,
 
and
 
 R   n,m,o,p ={[MAP n ,∞),[RPM m ,∞),[INT o ,∞),└EXH p ,∞)}.
 
     When (MAP,RPM,INT,EXH)∈R i,j,k,l , the volumetric efficiency function can be rewritten as 
     
       
         
           
             
               
                 
                   
                     
                       
                         
                           VE 
                           = 
                             
                           ⁢ 
                           
                             
                               δ 
                               0 
                             
                             + 
                             
                               
                                 δ 
                                 1 
                               
                               × 
                               MAP 
                             
                             + 
                             
                               
                                 δ 
                                 2 
                               
                               × 
                               RPM 
                             
                             + 
                           
                         
                       
                     
                     
                       
                         
                             
                           ⁢ 
                           
                             
                               
                                 δ 
                                 3 
                               
                               × 
                               INT 
                             
                             + 
                             
                               
                                 δ 
                                 4 
                               
                               × 
                               EXH 
                             
                           
                         
                       
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   where 
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       
                         
                           
                             δ 
                             0 
                           
                           = 
                             
                           ⁢ 
                           
                             
                               c 
                               0 
                             
                             - 
                             
                               
                                 ∑ 
                                 
                                   q 
                                   = 
                                   1 
                                 
                                 i 
                               
                               ⁢ 
                               
                                 
                                   a 
                                   q 
                                 
                                 × 
                                 
                                   MAP 
                                   q 
                                 
                               
                             
                             - 
                             
                               
                                 ∑ 
                                 
                                   q 
                                   = 
                                   1 
                                 
                                 j 
                               
                               ⁢ 
                               
                                 
                                   b 
                                   q 
                                 
                                 × 
                                 
                                   RPM 
                                   q 
                                 
                               
                             
                             - 
                           
                         
                       
                     
                     
                       
                         
                             
                           ⁢ 
                           
                             
                               
                                 
                                   ∑ 
                                   
                                     p 
                                     = 
                                     1 
                                   
                                   k 
                                 
                                 ⁢ 
                                 
                                   
                                     d 
                                     q 
                                   
                                   × 
                                   
                                     INT 
                                     q 
                                   
                                 
                               
                               - 
                               
                                 
                                   ∑ 
                                   
                                     q 
                                     = 
                                     1 
                                   
                                   l 
                                 
                                 ⁢ 
                                 
                                   
                                     e 
                                     q 
                                   
                                   × 
                                   
                                     EXH 
                                     q 
                                   
                                 
                               
                             
                             , 
                           
                         
                       
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       
                         δ 
                         1 
                       
                       = 
                       
                         
                           ∑ 
                           
                             q 
                             = 
                             1 
                           
                           i 
                         
                         ⁢ 
                         
                           a 
                           q 
                         
                       
                     
                     , 
                     
                       
                         δ 
                         2 
                       
                       = 
                       
                         
                           ∑ 
                           
                             q 
                             = 
                             1 
                           
                           j 
                         
                         ⁢ 
                         
                           b 
                           q 
                         
                       
                     
                     , 
                     
                       
                         δ 
                         3 
                       
                       = 
                       
                         
                           ∑ 
                           
                             q 
                             = 
                             1 
                           
                           k 
                         
                         ⁢ 
                         
                           d 
                           q 
                         
                       
                     
                     , 
                     
                       
 
                     
                     ⁢ 
                     
                       
                         and 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           δ 
                           4 
                         
                       
                       = 
                       
                         
                           ∑ 
                           
                             q 
                             = 
                             1 
                           
                           l 
                         
                         ⁢ 
                         
                           
                             e 
                             q 
                           
                           . 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   
                     Equation 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     6 
                   
                   ) 
                 
               
             
           
         
       
     
     Those skilled in the art can appreciate that a control method as described with respect to previous implementations can be used to implement the VE function according to Equation 6. This implementation requires only four multiplications and four additions to calculate. 
     The present implementation for the VE function as described above demonstrates that the linear spline method allows parameterization that can be extended to other well-known linear design methods. For example, one problem associated with using high dimension schedules for certain functions is determining where to place break points (i.e. linear spline knots, table cell boundaries, etc.). However, because the linear spline method provides a formulation that is linear in its parameters, standard least squares fitting can be used for such problems. In one implementation, an excessive number of knots can be selected. Subsequently, standard least squares fitting or step-wise regression can be used to determine the best (i.e. reduced) set of knots. This method is particularly effective for problems such as the VE function where the curvature of the function is not known. 
     In a sixth implementation, the linear spline method is applied to a compound two-dimensional/one-dimensional fuel dynamics model coefficient α that is scheduled as a function of MAP and RPM. Further, the MAP and RPM coefficients are scheduled as a function of TCO. This implementation is motivated by U.S. patent application Ser. No. 60/672,592 as referenced above with respect to the fourth implementation. The fuel dynamics model coefficient α as a function of MAP, RPM, and TCO is formulated according to linear splines as: 
     
       
         
           
             α 
             = 
             
               
                 c 
                 0 
               
               + 
               
                 
                   ∑ 
                   
                     i 
                     = 
                     1 
                   
                   n 
                 
                 ⁢ 
                 
                   
                     a 
                     i 
                   
                   × 
                   
                     UMAP 
                     ⁡ 
                     
                       ( 
                       i 
                       ) 
                     
                   
                 
               
               + 
               
                 
                   ∑ 
                   
                     j 
                     = 
                     1 
                   
                   m 
                 
                 ⁢ 
                 
                   
                     b 
                     j 
                   
                   × 
                   
                     URPM 
                     ⁡ 
                     
                       ( 
                       j 
                       ) 
                     
                   
                 
               
             
           
         
       
       
         
           where 
         
       
       
         
           
             
               UMAP 
               ⁡ 
               
                 ( 
                 i 
                 ) 
               
             
             = 
             
               { 
               
                 
                   
                     
                       
                         
                             
                           ⁢ 
                           0 
                         
                       
                       
                         
                             
                           ⁢ 
                           
                             
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               MAP 
                             
                             ≤ 
                             
                               MAP 
                               i 
                             
                           
                         
                       
                     
                     
                       
                         
                             
                           ⁢ 
                           
                             MAP 
                             - 
                             
                               MAP 
                               i 
                             
                           
                         
                       
                       
                         
                             
                           ⁢ 
                           otherwise 
                         
                       
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   and 
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     URPM 
                     ⁡ 
                     
                       ( 
                       j 
                       ) 
                     
                   
                 
                 = 
                 
                   { 
                   
                     
                       
                         
                           
                               
                             ⁢ 
                             0 
                           
                         
                         
                           
                               
                             ⁢ 
                             
                               
                                 if 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 RPM 
                               
                               ≤ 
                               
                                 RPM 
                                 j 
                               
                             
                           
                         
                       
                       
                         
                           
                               
                             ⁢ 
                             
                               RPM 
                               - 
                               
                                 RPM 
                                 j 
                               
                             
                           
                         
                         
                           
                               
                             ⁢ 
                             otherwise 
                           
                         
                       
                     
                     . 
                   
                 
               
             
           
         
       
     
     Here, however, each term c 0 , a i  and b j  is a function of TCO: 
     
       
         
           
             
               
                 c 
                 0 
               
               = 
               
                 
                   d 
                   0 
                 
                 + 
                 
                   
                     ∑ 
                     
                       k 
                       = 
                       1 
                     
                     p 
                   
                   ⁢ 
                   
                     
                       d 
                       k 
                     
                     × 
                     
                       UTCO 
                       ⁡ 
                       
                         ( 
                         k 
                         ) 
                       
                     
                   
                 
               
             
             , 
             
               
 
             
             ⁢ 
             
               
                 a 
                 i 
               
               = 
               
                 
                   e 
                   
                     i 
                     , 
                     0 
                   
                 
                 + 
                 
                   
                     ∑ 
                     
                       k 
                       = 
                       1 
                     
                     p 
                   
                   ⁢ 
                   
                     
                       e 
                       
                         i 
                         , 
                         k 
                       
                     
                     × 
                     
                       UTCO 
                       ⁡ 
                       
                         ( 
                         k 
                         ) 
                       
                     
                   
                 
               
             
             , 
             
               
 
             
             ⁢ 
             and 
           
         
       
       
         
           
             
               
                 b 
                 j 
               
               = 
               
                 
                   f 
                   
                     j 
                     , 
                     0 
                   
                 
                 + 
                 
                   
                     ∑ 
                     
                       k 
                       = 
                       1 
                     
                     p 
                   
                   ⁢ 
                   
                     
                       f 
                       
                         j 
                         , 
                         k 
                       
                     
                     × 
                     
                       UTCO 
                       ⁡ 
                       
                         ( 
                         k 
                         ) 
                       
                     
                   
                 
               
             
             , 
             
               
 
             
             ⁢ 
             where 
           
         
       
       
         
           
             
               UTCO 
               ⁡ 
               
                 ( 
                 k 
                 ) 
               
             
             = 
             
               { 
               
                 
                   
                     
                       
                           
                         ⁢ 
                         0 
                       
                     
                     
                       
                           
                         ⁢ 
                         
                           
                             if 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             TCO 
                           
                           ≤ 
                           
                             TCO 
                             k 
                           
                         
                       
                     
                   
                   
                     
                       
                           
                         ⁢ 
                         
                           TCO 
                           - 
                           
                             TCO 
                             k 
                           
                         
                       
                     
                     
                       
                           
                         ⁢ 
                         otherwise 
                       
                     
                   
                 
                 . 
               
             
           
         
       
     
     As with previously described implementations, the least squares fitting method can be used to fit the parameters. Linear spline knots are used to define ranges for least squares fitting as described below:
 
 R   i,j,k ={[MAP i ,MAP i+1 ),└RPM j ,RPM j+1 ),[ TCO   k   ,TCO   k+1 )}  i= 1,2, . . .  n− 1 ; j= 1,2, . . .  m− 1 ; k= 1,2, . . .  p− 1,
 
 R   n,j,k ={[MAP n ,∞),└RPM j ,RPM j+1 ),[TCO k ,TCO k+1 )} j= 1,2, . . .  m− 1 ; k= 1,2, . . .  p− 1,
 
 R   i,m,k ={[MAP i ,MAP i+1 )[RPM m ,∞),[TCO k ,TCO k+1 )} i= 1,2, . . .  n− 1 ; k= 1,2, . . .  p− 1,
 
 R   i,j,p ={[MAP i ,MAP i+1 ),└RPM j ,RPM j+1 ),└TCO p ,∞)} i= 1,2, . . .  n− 1 ; j= 1,2, . . .  m− 1,
 
 R   n,m,k ={[MAP n ,∞),[RPM m ,∞),[TCO k ,TCO k+1 )} k= 1,2, . . .  p− 1,
 
 R   n,j,p ={[MAP n ,∞),└RPM j ,RPM j+1 ),└TCO p ,∞)} j= 1,2, . . .  m− 1,
 
and
 
 R   n,m,p ={[MAP n ,∞),[RPM m ,∞),└TCO p ,∞)}
 
     When (MAP,RPM,TCO)∈R i,j,k , the fuel dynamics model coefficient, α, can be rewritten as 
     
       
         
           
             
               
                 
                   
                     
                       
                         
                           α 
                           = 
                             
                           ⁢ 
                           
                             
                               ( 
                               
                                 
                                   δ 
                                   0 
                                 
                                 + 
                                 
                                   
                                     δ 
                                     1 
                                   
                                   × 
                                   TCO 
                                 
                               
                               ) 
                             
                             + 
                             
                               
                                 ( 
                                 
                                   
                                     δ 
                                     2 
                                   
                                   + 
                                   
                                     
                                       δ 
                                       3 
                                     
                                     × 
                                     TCO 
                                   
                                 
                                 ) 
                               
                               × 
                               MAP 
                             
                             + 
                           
                         
                       
                     
                     
                       
                         
                             
                           ⁢ 
                           
                             
                               ( 
                               
                                 
                                   δ 
                                   4 
                                 
                                 + 
                                 
                                   
                                     δ 
                                     5 
                                   
                                   × 
                                   TCO 
                                 
                               
                               ) 
                             
                             × 
                             RPM 
                           
                         
                       
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   where 
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       
                         
                           
                             δ 
                             0 
                           
                           = 
                             
                           ⁢ 
                           
                             
                               d 
                               0 
                             
                             - 
                             
                               
                                 ∑ 
                                 
                                   q 
                                   = 
                                   1 
                                 
                                 k 
                               
                               ⁢ 
                               
                                 
                                   d 
                                   q 
                                 
                                 × 
                                 
                                   TCO 
                                   q 
                                 
                               
                             
                             - 
                             
                               
                                 ∑ 
                                 
                                   r 
                                   = 
                                   1 
                                 
                                 i 
                               
                               ⁢ 
                               
                                 ( 
                                 
                                   
                                     ( 
                                     
                                       
                                         e 
                                         
                                           r 
                                           , 
                                           0 
                                         
                                       
                                       - 
                                       
                                         
                                           ∑ 
                                           
                                             q 
                                             = 
                                             1 
                                           
                                           k 
                                         
                                         ⁢ 
                                         
                                           
                                             e 
                                             
                                               r 
                                               , 
                                               q 
                                             
                                           
                                           × 
                                           
                                             TCO 
                                             q 
                                           
                                         
                                       
                                     
                                     ) 
                                   
                                   × 
                                 
                               
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             
                                 
                               ⁢ 
                               
                                 MAP 
                                 r 
                               
                               ) 
                             
                             - 
                             
                               
                                 ∑ 
                                 
                                   r 
                                   = 
                                   1 
                                 
                                 j 
                               
                               ⁢ 
                               
                                 ( 
                                 
                                   
                                     ( 
                                     
                                       
                                         f 
                                         
                                           r 
                                           , 
                                           0 
                                         
                                       
                                       - 
                                       
                                         
                                           ∑ 
                                           
                                             q 
                                             = 
                                             1 
                                           
                                           k 
                                         
                                         ⁢ 
                                         
                                           
                                             f 
                                             
                                               r 
                                               , 
                                               q 
                                             
                                           
                                           × 
                                           
                                             TCO 
                                             q 
                                           
                                         
                                       
                                     
                                     ) 
                                   
                                   × 
                                   
                                     RPM 
                                     r 
                                   
                                 
                                 ) 
                               
                             
                           
                           , 
                         
                       
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       
                         
                           
                             δ 
                             1 
                           
                           = 
                             
                           ⁢ 
                           
                             
                               
                                 ∑ 
                                 
                                   q 
                                   = 
                                   1 
                                 
                                 k 
                               
                               ⁢ 
                               
                                 d 
                                 q 
                               
                             
                             - 
                             
                               
                                 ∑ 
                                 
                                   r 
                                   = 
                                   1 
                                 
                                 i 
                               
                               ⁢ 
                               
                                 ( 
                                 
                                   
                                     ( 
                                     
                                       
                                         ∑ 
                                         
                                           q 
                                           = 
                                           1 
                                         
                                         k 
                                       
                                       ⁢ 
                                       
                                         e 
                                         
                                           r 
                                           , 
                                           q 
                                         
                                       
                                     
                                     ) 
                                   
                                   × 
                                   
                                     MAP 
                                     r 
                                   
                                 
                                 ) 
                               
                             
                             - 
                           
                         
                       
                     
                     
                       
                         
                             
                           ⁢ 
                           
                             
                               
                                 ∑ 
                                 
                                   r 
                                   = 
                                   1 
                                 
                                 j 
                               
                               ⁢ 
                               
                                 ( 
                                 
                                   
                                     ( 
                                     
                                       
                                         ∑ 
                                         
                                           q 
                                           = 
                                           1 
                                         
                                         k 
                                       
                                       ⁢ 
                                       
                                         f 
                                         
                                           r 
                                           , 
                                           q 
                                         
                                       
                                     
                                     ) 
                                   
                                   × 
                                   
                                     RPM 
                                     r 
                                   
                                 
                                 ) 
                               
                             
                             , 
                           
                         
                       
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       
                         δ 
                         2 
                       
                       = 
                       
                         
                           ∑ 
                           
                             r 
                             = 
                             1 
                           
                           i 
                         
                         ⁢ 
                         
                           ( 
                           
                             
                               e 
                               
                                 r 
                                 , 
                                 0 
                               
                             
                             - 
                             
                               
                                 ∑ 
                                 
                                   q 
                                   = 
                                   1 
                                 
                                 k 
                               
                               ⁢ 
                               
                                 
                                   e 
                                   
                                     r 
                                     , 
                                     q 
                                   
                                 
                                 × 
                                 
                                   TCO 
                                   q 
                                 
                               
                             
                           
                           ) 
                         
                       
                     
                     , 
                     
                       
 
                     
                     ⁢ 
                     
                       
                         δ 
                         3 
                       
                       = 
                       
                         
                           ∑ 
                           
                             r 
                             = 
                             1 
                           
                           i 
                         
                         ⁢ 
                         
                           
                             ∑ 
                             
                               q 
                               = 
                               1 
                             
                             k 
                           
                           ⁢ 
                           
                             e 
                             
                               r 
                               , 
                               q 
                             
                           
                         
                       
                     
                     , 
                     
                       
 
                     
                     ⁢ 
                     
                       
                         δ 
                         4 
                       
                       = 
                       
                         
                           ∑ 
                           
                             r 
                             = 
                             1 
                           
                           j 
                         
                         ⁢ 
                         
                           ( 
                           
                             
                               f 
                               
                                 r 
                                 , 
                                 0 
                               
                             
                             - 
                             
                               
                                 ∑ 
                                 
                                   q 
                                   = 
                                   1 
                                 
                                 k 
                               
                               ⁢ 
                               
                                 
                                   f 
                                   
                                     r 
                                     , 
                                     q 
                                   
                                 
                                 × 
                                 
                                   TCO 
                                   q 
                                 
                               
                             
                           
                           ) 
                         
                       
                     
                     , 
                     
                       
 
                     
                     ⁢ 
                     and 
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       δ 
                       5 
                     
                     = 
                     
                       
                         ∑ 
                         
                           r 
                           = 
                           1 
                         
                         j 
                       
                       ⁢ 
                       
                         
                           ∑ 
                           
                             q 
                             = 
                             1 
                           
                           k 
                         
                         ⁢ 
                         
                           
                             f 
                             
                               r 
                               , 
                               q 
                             
                           
                           . 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   
                     Equation 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     7 
                   
                   ) 
                 
               
             
           
         
       
     
     Those skilled in the art can appreciate that a control method as described with respect to previous implementations can be used to implement the fuel dynamics model coefficient α function according to Equation 7. This implementation requires only five multiplications and five additions per coefficient, ax, to calculate. 
     Referring now to  FIG. 3 , an engine control system  30  that implements the linear spline method of the present invention is shown. A throttle  32  and fuel system  34  determine air and fuel delivered to an engine  36  through an intake manifold  38 . An ignition system  40  ignites an air/fuel mixture in the engine  36 . Exhaust gas created by the ignition of the air/fuel mixture is expelled through the exhaust manifold  42 . The catalytic converter  44  receives the exhaust gas and reduces emissions levels of the exhaust gas. 
     A control module  46  communicates with various components of the engine control system  30 , including, but not limited to, a throttle position sensor  48  (TPS), the fuel system  34 , the ignition system  40 , and an engine speed sensor  50  (RPM). The control module  46  receives a throttle position signal from the TPS  48  and determines air flow into the engine  36 . The air flow data is then used to calculate fuel delivery from the fuel system  34  to the engine  36 . The control module  46  further communicates with the ignition system  40  to determine ignition spark timing. 
     The control module  46  may receive additional signals from other components in the engine control system  30 . The control module  46  receives an engine coolant temperature from an engine coolant temperature sensor  52 . The control module  46  receives an engine speed from the engine speed sensor  50 . The control module  46  receives MAP from a MAP sensor  54 . The control module  46  receives a measured burned fuel mass from an exhaust sensor  56 . These and other variables may affect the overall performance and behavior of the engine control system  30 . 
     The control module  46  includes a memory  58  that stores data for implementing the linear spline method. For example, the memory  58  stores Equations 2 through 7 as described above, as well as values for the parameters of each equation and each data range. The control module  46  receives values of the variables of the Equations from the engine control system  30  such as RPM, MAP, and TCO. The control module  46  calculates the Equations according to the stored parameters and the received values. 
     Those skilled in the art can now appreciate from the foregoing description that the broad teachings of the present invention can be implemented in a variety of forms. Therefore, while this invention has been described in connection with particular examples thereof, the true scope of the invention should not be so limited since other modifications will become apparent to the skilled practitioner upon a study of the drawings, the specification and the following claims.