A modular approach for topology optimization

## Project description

# pyMOTO

Modular topology optimization framework with semi-automatic derivatives. The two main types `Module`

and `Signal`

are used to implement a problem formulation to be optimized. The `Module`

implements functionality (and design
sensitivity calculations) and `Signal`

carries data of both the variables and their derivatives.

Sensitivity calculations are done based on backpropagation. The final value of interest is seeded with sensitivity
value $\frac{\textup{d}f}{\textup{d}f}=1$. Then the modules are executed in reverse order, each applying the chain rule.
As example for a `Module`

which maps $x\rightarrow y$, only the following operation needs to be implemented:

$$ \frac{\textup{d}f}{\textup{d}x} = \frac{\textup{d}f}{\textup{d}y}\frac{\textup{d}y}{\textup{d}x}\text{.} $$

In this way, the order of modules can easily be adapted without having to worry about sensitivities, as these are automatically calculated.

# Quick start installation

- Make sure you have Python running in some kind of virtual environment (e.g. conda, miniconda, venv)
- Install the pymoto Python package (and its dependencies)
- Option A (conda): If you are working with Conda, install by
`conda install -c aatmdelissen pymoto`

- Option B (pip): Type
`pip install pymoto`

into your console to install

- Option A (conda): If you are working with Conda, install by
- Download one of the examples found in the repository's example folder (here)
- Run the example by typing
`python ex_....py`

in the console

A local installation for development in `pyMOTO`

can be done by first downloading the entire git repo, and then calling
`pip install -e .`

in the `pyMOTO`

folder (of course from within your virtual environment).

## Dependencies

**NumPy**- Dense linear algebra and solvers**SciPy**- Sparse linear algebra and solvers**SymPy**- Symbolic differentiation for`MathGeneral`

module**Matplotlib**- Plotting and visualisation- (optional)
**SAO**- Sequential approximated optimizers - (optional)
**opt_einsum**- Optimized function for`EinSum`

module

For fast linear solvers for sparse matrices:

- (optional)
**pypardiso**- Uses the Intel OneAPI PARDISO solver (recommended) - (optional)
**scikit-umfpack**- Fast LU linear solver based on UMFPACK - (optional)
**scikit-sparse**- Fast Cholesky solver based on CHOLMOD - (optional)
**cvxopt**- Another fast Cholesky solver based on CHOLMOD

**Note on linear solvers for sparse matrices:** Scipy implements a version of LU which is quite slow. To increase the
speed of the optimization, `pypardiso`

is recommended as it contains a very robust and flexible solver for symmetric
and asymmetric matrices. An alternative is `scikit-umfpack`

which provides a fast LU factorization. For symmetric
matrices a Cholesky factorization is recommended (not provided with Scipy), which can be used by either installing
`scikit-sparse`

or `cvxopt`

.

# License

pyMOTO is available under te MIT License.

## Project details

## Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.