# MPCC

## Installation
### Local installation - linux only
Clone this repo

git clone https://github.com/UMBSDriverless/MPpyC

Install the boost dependencies

apt-get install libboost-dev libboost-python-dev libboost-numpy-dev

Install the python requirements

apt-get install python3 python3-numpy python3-matplotlib python3-tk

(the names of the dependencies may vary in other distros)

cd into the _src_ directory, then run

sh install.sh

This will download the external dependencies and install them, then build libMPCC and the python binding.
### Container installation
#### Linux
To build the container with MPpyCC in it run

docker build -t mppycc .

Then enter it by using

sh run.sh

#### Windows
MPpyCC works on Windows too, but only the docker version. The process is based on [this guide](https://www.vitaarca.net/post/tech/a-simple-docker-example/).

Do not use this unless you hate yourself. Use Linux instead.

- Install __WSL2__ and Ubuntu (from the windows store)
- Install [vcxsrv](https://sourceforge.net/projects/vcxsrv/)
- Install __Docker__
- Enable virtualization from the BIOS
- Enable WSL integration from the Docker frontend. Settings > Resources > WSL integration
- Allow VcXsrv (both vcxsrv and xlaunch) through Windows Firewall for both public and private network. Press Windows key and type “Allow an app through Windows Firewall” and check for the VcXsrv entry.
- Launch XLaunch (in folder VcXsrv), go through the setup and set “Disable access control”.
- Open Ubuntu console by pressing the windows key and typing ubuntu (the Ubuntu app previously installed from Windows Store).
- From within the ubuntu console type `sudo apt install x11-xserver-utils` then `xhost local:root`
- From within the ubuntu console type `export DISPLAY=$(grep -oP "(?<=nameserver ).+" /etc/resolv.conf):0.0`
- Build the image with

  docker build -t mppycc .

- Run the image with

  docker run -it \
    --volume="$(pwd)/params:/MPpyCC/params:ro" \
    --volume="/tmp/.X11-unix:/tmp/.X11-unix:rw" \
    --env="DISPLAY" mppycc /bin/bash

## Troubleshooting and known issues
- ```multiple definition of `BLASFEO_PROCESSOR_FEATURES'``` error during build.

this error is caused by the External/Blasfeo examples. To solve it simply set _BLASFEO_EXAMPLES_ to OFF in _CmakeLists.txt_ on line 121/122.

  set(BLASFEO_EXAMPLES OFF CACHE BOOL "Examples disabled")

OR simply delete the _External/blasfeo/examples_ directory and remove the import from _CmakeLists.txt_

  if(BLASFEO_EXAMPLES MATCHES ON)
  	add_subdirectory(examples)
  endif()

## References
Alex Liniger's [MPCC](https://github.com/alexliniger/MPCC/tree/master/C%2B%2B)

## MPpyC docs

**Get started**
- [Introduction](#introduction)
- [Resources](#resources)

**Organization**
- [Structure](#structure)
+ [main.py](#main.py)
+ [bindings](#bindings)
+ [libMPCC](#libMPCC)
+ [params](#params)
+ [python_code](#python_code)
- [Domain Model](#domain_model)

**Going further**
- [Customization](#customization)
+ [Adding custom sensors](#adding-custom-sensors)

## Introduction
This MPC is written in python and uses Alex Liniger's [MPCC](https://github.com/alexliniger/MPCC/tree/master/C%2B%2B) in C++.
## Resources

### Boost.Python

[Boost.Python](https://www.boost.org/doc/libs/1_66_0/libs/python/doc/html/index.html) is a C++ library which enables seamless interoperability between C++ and the Python programming language. The library includes support for:

- References and Pointers
- Globally Registered Type Coercions
- Automatic Cross-Module Type Conversions
- Efficient Function Overloading
- C++ to Python Exception Translation
- Default Arguments
- Keyword Arguments
- Manipulating Python objects in C++
- Exporting C++ Iterators as Python Iterators
- Documentation Strings

### Nlohmann JSON

[Nlohmann JSON](https://github.com/nlohmann/json) is a library for an easy use of JSON in C++.

## Structure
Explained directory and file structure.

### main.py
The behaviour of the _main_ can be summarized as follows:
- Loads configuration parameters from a JSON file.
- Initialises the variables (plotter for the graphs, an interface used to call the MPCC methods and the initial state).
- In a loop gets the action from the MPCC, makes the step forward and logs the moves.

### bindings
The bindings directory contains the C++ code that works as intermediate to call the MPCC methods. The class _python_interface_ has an header where the structs _TrackPosNumpy_, _ConsoleFrame_ and StabilityMatrices are defined.

class PythonInterface {
public:
  PythonInterface();
  PythonInterface(std::string path_name);
  State reset();
  MPCReturn run_mpc(State x);
  State step(State x_old, Input u);
  TrackPosNumpy get_track();
  ConsoleFrame get_console_frame();
  StabilityMatrices get_stability_matrices();

private:
  Integrator* integrator;
  MPC* mpc;
  Track* track;
  double v0;
  double Ts;
  int n_sim;
  std::array<Stage, N + 1> current_stages;
};

In three private variables are kept the pointers to the track, the MPC and the integrator.
In _python_interface.cpp_ are defined the classes needed in the python code through the Boost.Python library:
- _State_
- _Input_
- _OptVariables_
- _MPCReturn_
- _TrackPosNumpy_
- _ConsoleFrame_
- _StabilityMatrices_

### libMPCC
In this directory is contained the code from the Alex Liniger's [MPCC](https://github.com/alexliniger/MPCC/tree/master/C%2B%2B).

### params
In the _params_ directory are present the JSON files containing system parameters.

### python_code
Here are presents the _plotting.py_ and _stability_checker.py_ files. The first is used to plot graphs with physical informations of the system during the simulation. The second checks the rank of the control matrices and the observation matrix.

## Domain Model