Skip to content

shahind/MFAC

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

20 Commits
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

MFAC

Model Free Adaptive Control Toolbox for Python

This project aims to provide a simple and fast python package for model-free adaptive control. The package includes compact form dynamic linearization (CFDL), partial form dynamic linearization (PFDL) and full form dynamic linearization (FFDL) model free adaptive control methods both for SISO and MIMO systems.

Installation

You can easily install MFAC Toolbox from PyPI:

pip install MFAC

Simple Example

The following code shows the functionality of MFAC Toolbox in controlling a simple SISO system using CFDL method from (\examples\siso_cfdl_simple.py):

import numpy as np
import matplotlib.pyplot as plt
from mfac.plants.siso import Model1
from mfac.controllers import CompactFormDynamicLinearization

# define the model and set the initial values
model = Model1(initial_state=np.array([0]))

# Simulation conditions
total_time = 8
step_time = 0.01

# Desired output (y_desire)
y_d = np.zeros(int(total_time / step_time) + 1)
for k in range(int(total_time / step_time) + 1):
    y_d[k] = 0.5 + 0.5*np.power(-1, np.round(k/200))

# log function which will be ran after each iteration
def log_function(cfdl):
    print('iteration: ', cfdl.iteration)

# define the controller
controller = CompactFormDynamicLinearization(model=model,
                                             iteration_function=log_function,
                                             time_step=step_time,
                                             reference_output=y_d,
                                             simulation_time=total_time,
                                             labda=1,
                                             eta=1,
                                             mu=1,
                                             rho=0.45,
                                             )

# run the simulation
controller.run()

# plot the output
fig, ax = plt.subplots()
ax.plot(model.Y)
ax.plot(y_d)
ax.set(xlabel='time (t)', ylabel='output (y)',
       title='system output')
ax.grid()
# fig.savefig("test.png")
plt.show()

the output will be like:
img.png

Components

To control a system using the current MFAC library, two major components are required; model and controller.

Model

A model is simply a class with the following structure:

Part Variables/Methods Description
Input Initial_state (array) Initial position of the plant in state space
Parameters number_of_inputs (int)
number_of_states (int)
number_of_outputs (int)
x (array)
y (array)
u (array)
X (array)
Y (array)
U (array)
time (int)
Number of control inputs
Number of state parameters
Number of outputs
The current state of the system
The current output of the system
Current input control of the system
States of the system during the simulation
Outputs of the system during the simulation
Controls of the system during the simulation
The current time of the simulation (discrete)
Functions reset()
step()
observe()
render()
predict()
Resets the plant for the next simulation
Gets the input controller and moves one step forward, returns the output
Observes the system's state or output variable defined by full_state input parameter
Renders the system based on input parameter mode which can be print, plot, or visual
Gets a series of inputs (k future steps) and predicts the systems state or output

Controller

A controller is simply a class with the following structure:

Part Variables/Methods Description
Input model (Model)
iteration_function (Function)
reference_output (array)
simulation_time (int)
time_step (Float)
mimo (Boolean)
Control parameters
The plant to be controlled
The function which will be called in each step
The desired output
Simulation duration in seconds
Timestep for each step
The control for using the MIMO form
Control parameters for each specific method
Parameters u (array)
fai (array)
U (array)
Fai (array)
The current control input
The current fai value
Control inputs during the simulation
Fai values during the simulation
Functions run() Runs the simulation based on the time and time step, in each step calles the model.step() with the calculated control and calls the iteration_function at the end of step

Development Status

Currently developed methods:

  • CFDL
  • FFDL
  • PFDL

Currently developed models:

  • Simple SISO model 1 (Model1)
  • Simple MIMO model 1 (Model1)

Currently tested scenarios:

  • CFDL on SISO Model1
  • CFDL on MIMO Model1