Ideas Page

This page presents a wish-list with ideas for further improvement and development of MechSys. The list includes some desired new features and some general fixes on code and/or documentation.

Table of Contents

MSYS-0001: Blender Interface: msys_blender (medium)

A Python plug-in for Blender has been developed in MechSys (msys_blender); however some work is still necessary. Another problem is that the plug-in interface has not been updated to the latest Blender 2.50+ versions. The idea is to use Blender as a 3D CAD to define geometries of simulation problems. Then, 2D and 3D meshes can be generated using MechSys' mesh generation tools (structured quads/cubes and unstructured triangles/tets). Much advantage is taken from Blender platform. Ideas:

• Update msys_blender to the latest Blender;
• Update/develop a GUI to control and generate 2D/3D meshes in Blender;
• Re-develop the mechsys Python module (shared library) for mesh generation only;
• Develop routines to generate JSON input files to be used in simulations.

Expected outcomes

• A robust and convenient graphical interface to define the geometry and input data for numerical simulations;
• A mesh generation tool for Blender (not only for surfaces).

Knowledge prerequisites

MSYS-0002: Input files go_input (easy)

To run simulations in MechSys, usually a C++ program has to be written. This eventually becomes inefficient when simulations with different data are desired, since the code has to be modified too much. On the other hand, a tool could be written in order to read the input data of a simulation. Also, by means of a standard file such as json, other tools could be connected more easily. For instance, a web interface or even blender could be used to set and run simulations by communicating the interface with the engine via files. The Go programming language could be used to do so. Also, this would allow converting other computation routines to Go as well.

This project includes some ideas that can be easily implemented by students with basic skills on C++ and Go programming languages. Ideas:

• Write routines to read/write input files written in json and then connect Go with the C++ code;
• Develop an interface for Blender to access and generate those files.

Expected outcomes

• Code to read an generate input files for the C++ engine;
• Perhaps a web interface for the json files.

Knowledge prerequisites

MSYS-0003: Material models mat_models (medium)

Material models in MechSys are defined in such a way to be general enough and then be used in a number of different continuum methods. For solid mechanics, models represent the relation between stress and strains, for example. For complex materials, the theory of plasticity can be successfully employed to better represent the non-linear material behaviour. Rate-type models are then created and these must be integrated (in time or for each strain increment) in order to solve a boundary value problem (using the FEM/MPM). Another important step before using material models in simulations is to find their parameters. A tool to do this calibration is of great help then. Also, models should be tested in simpler uniform representative elementary volumes (RVEs) before running a larger problem. Therefore, a tool to realize this testing, usually named "driver", could be implemented.

This project includes some ideas that can be implemented by students with skills on C++ and Go programming languages. Basic knowledge on numerical methods is required. Complete knowledge of mathematical models based on continuum mechanics is required. Ideas:

• Replace code for the integration of rate-type elastoplastic models;
• Develop/finalize a GUI tool for calibrating material parameters and visualising model prediction curves: "driver" tool;
• Develop an interface in Go programming language in such a way that models prepared in Go can be used by the C++ code.

Expected outcomes

• More robust algorithms for the solution of rate-type models;
• Convenient tools for parameter calibration;
• Easier introduction of new material models (by means of codes written in Go).

Knowledge prerequisites

Finite Element Method: FEM (all levels)

The FEM module in MechSys is implemented in a fairly general way and can be used for the solution of many PDEs. However, it is mainly tailored for solid mechanics and fluid dynamics -- "stiffness" matrices are directly implemented. The MechSys/FEM can solve, for instance, elasticity problems such as those representing soft bodies. A very modular approach is taken in MechSys and a goal is to make the core routines as general as possible in order to allow new elements and models to be easily added. In addition, parallel computing using OpenMPI is employed to solve large scale problems.

The following three sections list some ideas regarding future improvements of MechSys/FEM.

MSYS-0004: FEM: {doc,sims} (easy)

The documentation of MechSys/FEM needs some checking and corrections, in addition to more examples on its use. Also, more simulation scripts could be developed illustrating MechSys/FEM capabilities.

This project includes some ideas that can be easily implemented by students with basic skills on Python, and C++. Comprehensive knowledge on numerical methods is not required. Ideas:

• Check and improve the documentation, especially with examples of use, including for larger-scale simulations;
• Prepare simulation scripts for validation, verification, and benchmarking simulations;

Expected outcomes

• Better documentation;
• More examples on how to run large scale simulations with MechSys/FEM;
• Many verification tests and examples.

Knowledge prerequisites

MSYS-0005: FEM: foundation (medium)

The FEM::Domain class in MechSys is getting too large and needs some code organization and clean up. One fundamental step is the definition of boundary conditions (BCs), where the setting up of natural BCs should come after the setting up of essential BCs. The same code is being used also for activating and deactivating elements, for instance, during excavation and addition of elements. A better method to set the BCs up could be developed. This should also handle the callback functions needed when specifying dynamic BCs. Another desired improvement is related the organization of the FEM::Element and FEM::Solver interfaces. Also, the parallel code should be verified and improved. This is largely implemented in the FEM::Domain class but could be moved to a separate file.

This project includes some ideas that can be implemented by students with basic skills on Python, and C++. Basic knowledge on numerical methods is required. Ideas:

• Re-write code for boundary conditions setting up;
• Fix/clean the interfaces of elements and solvers;
• Check/improve the parallel solver.

Expected outcomes

• A robust method to handle the specification of boundary conditions, including callback functions;
• Cleaner code which should make it easier the addition of new features;
• Better parallel solver.

Knowledge prerequisites

MSYS-0006: FEM: gpu (hard)

For large meshes, the FEM matrices become too big and the related computations too slow. A strategy to overcome these problems is to decompose the geometric domain in parts and then process smaller matrices/vectors in parallel. From time to time communication is required. In MechSys/FEM, this is done with OpenMPI quite well. Nonetheless, newer techniques using graphic processing units seems to be very powerful. They require cheaper "clusters", since many adapters can be added to a single machine -- this saves energy in addition to end in a smaller communication overhead. Also, modern GPUs have many (less powerful) cores which could be exploited for massive parallel calculations. For FEM simulations, two places could be improved: during the assembly of elements and the solution of large sparse linear systems. For the first one, a new assembly routine could be developed. For the second one, linear solvers designed for GPU could be linked to (e.g CUSP). For instance, routines written in CUDA could be developed.

This project includes some ideas that can be implemented by students with skills C++, CUDA and Python. Comprehensive knowledge on numerical methods is required. Ideas:

• Code the assembly of elements employing the Graphics Processor Unit (GPU);
• Code a parallel solver employing the GPU.

Expected outcomes

• Powerful simulation FEM tool for large scale problems.

Knowledge prerequisites

MSYS-0007: FEM: {iface,emb} (hard)

When simulating discrete inclusions such as faults, cracks or highly permeable planes inside a continuum body, the FEM requires the discretization of all these 1D or 2D inclusions. The mesh generation becomes too complex, especially when simulations with successively refined meshes are sought. A way to overcome this problem is the use of the "embedded technique" where the properties of inclusions are smeared to the underlying solid elements. Raul Durand, a developer of MechSys, has developed an efficient and reliable method based on this technique; however it became incompatible with the latest updates of the source code. In addition, new finite elements for the simulation of joints and contacts are desired. Therefore, this project aims to recover our previous embedded elements code and introduce new elements.

This project includes some ideas that can be implemented by students with skills on C++, Python and Go programming languages. Comprehensive knowledge on numerical methods is required. Ideas:

• Add elements for interfaces in order to simulate, for instance, joints and contacts;
• Reintroduce the code for embedded elements for the simulation of reinforcements and drains.

Expected outcomes

• Broader range of simulation problems, e.g. domains including joints, reinforcements, contacts, drains, etc.

Knowledge prerequisites

MSYS-0008: FEM: fluids (hard)

The solution of the Navier-Stokes equations can be successfully obtained with the finite element method. To do so, care must be taken with the convection components of these equations, in addition to its stiffness provoked by the incompressibility of the fluid. MechSys/FEM has all necessary tools to solve this but work needs to be done in order to put all together. It is also desired to code a number of validation and illustrative examples, in addition to improve the documentation dealing with fluids.

This project includes some ideas that can be implemented by students with skills on C++, Python and Go programming languages. Comprehensive knowledge on numerical methods is required. Knowledge on fluid dynamics is required. Ideas:

• Extend/finalize the module for simulation of fluids in MechSys/FEM;
• Improve documentation dealing with computational fluid dynamics, including the addition of case examples.

Expected outcomes

• An efficient and robust solver for the Navier-Stokes equations based on the finite element method.

Knowledge prerequisites

MSYS-0009: FEM: coupling (hard)

MechSys consists of a number of libraries based on different numerical methods. Each one has a range of applications in which they have better potential. For instance, the FEM is better suited for solid bodies, for instance structure elements where bending moments are required for design purposes. On the other hand, some applications may benefit from particle methods such as the MPM or discrete methods such as the DEM. Coupling these different methods may provide the "ultimate" tool for the simulation, at the same time, of a broader range of problems.

This project includes some ideas that can be implemented by students with skills on C++, Go and Python. Comprehensive knowledge on numerical methods is required. Ideas:

• Develop interface elements and contact detection/modelling routines;
• Code couple routines for the FEM and DEM;
• Code couple routines for the FEM and MPM.

Expected outcomes

• Uniform interface to couple the continuum and discrete solvers in MechSys;
• General simulation tool for mechanics.

Knowledge prerequisites