A wrapped package for Data-enabled predictive control (DeePC) implementation. Including DeePC and Robust DeePC design with multiple objective functions.

If you have questions, remarks, technical issues etc. feel free to use the issues page of this repository. I am looking forward to your feedback and the discussion.

Introduction: link

PyPI site: link

This package operates within the Python framework.

• Numpy
• Matplotlib
• CasADi     <-- 3 <= version <= 4

• Download the deepctools file and save it to your project directory.

• Or install using pip

    pip install deepctools

Then you can use the deepctools in your python project.

. 
└── deeptools 
    ├── hankel 
    ├── deepctools 
    │   ├── initialize_DeePCsolver
    │   ├── initialize_RDeePCsolver
    │   └── solver_step
    ├── getCasadiFunc 
    └── DiscreteSimulator

Under this file and function, there is detailed explanation of the usage, inputs, outputs of the functions.

Construct Hankel matrix of order L based on data x

• The data x: $x \in \mathbb{R}^{T, n_x}$
• The Hankel matrix: $H_L(x) \in \mathbb{R}^{n_x L \times T - L + 1}$

Formulate and solve the DeePC problem, including DeePC and Robust DeePC design.

Construct the nlp solver for DeePC using CasADi IPOPT sovler, only formulate the solver once at the first beginning.

In the online loop, no need to reformulate the NLP problem which saves lots of computational time.

Each iteration, only need provide updated parameters: $u_{ini}$, $y_{ini}$ (, $u_{ref}$, $y_{ref}$ if set-point changes during control).

Objective function: $J = \Vert y - y^r \Vert_Q^2 + \Vert u_{loss} \Vert_R^2 + \mathcal{o}(\sigma_y, g)$

$u_{loss}$ can be:

        'u': u

        'uus': u - u_ref

        'du': delta u

There is a tutorial file in tutorial.py.

Formulate the DeePC design with different loss on control inputs.

The optmization problem can be formulated as:

        Standard DeePC design:                        |            Equivalent expression
     min J  =  || y - yref ||_Q^2 + || uloss ||_R^2   |   min J  =  || Uf*g - yref ||_Q^2 + || uloss ||_R^2
         s.t.   [Up]       [uini]                     |      s.t.   Up * g = uini
                [Yp] * g = [yini]                     |             Yp * g = yini
                [Uf]       [ u  ]                     |             ulb <= u <= uub
                [Yf]       [ y  ]                     |             ylb <= y <= yub
                ulb <= u <= uub                       |
                ylb <= y <= yub                       |  uloss = (u)   or    (u - uref)    or    (du)

Formulate the Robust DeePC design with slack variables and different loss on control inputs.

The optmization problem can be formulated as:

              Robust DeePC design:                    |            Equivalent expression
     min J  =  || y - yref ||_Q^2 + || uloss ||_R^2   |   min J  =  || Uf*g - ys ||_Q^2 + || uloss ||_R^2
                 + lambda_y||sigma_y||_2^2            |             + lambda_y||Yp*g-yini||_2^2
                 + lambda_g||g||_2^2                  |             + lambda_g||g||_2^2
         s.t.   [Up]       [uini]     [   0   ]       |      s.t.   Up * g = uini
                [Yp] * g = [yini]  +  [sigma_y]       |             ulb <= u <= uub
                [Uf]       [ u  ]     [   0   ]       |             ylb <= y <= yub
                [Yf]       [ y  ]     [   0   ]       |
                ulb <= u <= uub                       |
                ylb <= y <= yub                       |  uloss = (u)   or    (u - uref)    or    (du)

Solve the optimization problem for one step, and output the optimized control inputs, operator g, and solving time.

Construct the Function using CasADi

Construct the discrete system simulator for predicting next step

This is a tutorial example to illustrate how to use the deepctools to develop and implement DeePC design to different processes.

A simple discrete-time nonlinear model of polynomial single-input-single-output system is used:

        y(t) = 4 * y(t-1) * u(t-1) - 0.5 * y(t-1) + 2 * u(t-1) * u(t) + u(t)

The model has been crafted as a Plant class to facilitate its utilization.

Notice:

• This system is adopted from the paper.
• Note this plant is a nonlinear model which do not satisfy the assumption of Fundamental Lemma, the control performance can be bad.
• For your own project, you can replace this plant to your own system.

Within the sample code, you have the option to specify either DeePC or Robust DeePC design, along with various objective functions. This segment is implemented within the main function.

Feasible DeePC config:

     DeePC        |  {Tini:1, Np:5, T:5, uloss:uus}    | T merely influence the performance as long as T>=5 
     Robust DeePC |  {Tini:1, Np:1, T:600, uloss:du}   | T will influence the steady-state loss 
     Robust DeePC |  {Tini:1, Np:1, T:600, uloss:uus}  | T will influence the steady-state loss
     Robust DeePC |  {Tini:1, Np:1, T:600, uloss:u}    | T will influence the steady-state loss

Figure of control peformance under first config:

The project is released under the APACHE license. See LICENSE for details.