GSoC 2015 Ideas

Jim Crist edited this page Mar 12, 2015 · 10 revisions

Implement O(N) Method

Difficulty: Hard
Projects: SymPy
Languages: Python
Potential Mentors: Jason Moore

Roy Featherstone, Abhi Jain, and others developed recursive methods of forming the right hand side of the ODEs for complex multibody systems that have an evaluation time of O(N) instead of O(N^3). This project would be dedicated to implementing a symbolic O(N) method to compliment the LagrangesMethod and KanesMethod classes. This would give a significant speed boost in numerical ode evaluation for systems with bodies greater than 20 or so.

Efficient EoM Generation

Difficulty: Medium to Hard
Projects: SymPy, CSymPy
Languages: Python, C++
Potential Mentors: Jason Moore, Jim Crist, Gilbert Gede

Currently we have basic equation of motion generation with automated Kane's and Lagrange's methods. The algorithm's that derive these equations of motion can be improved in both speed of computation and the resulting simplification of the equations of motion. This project would involve cleaning up the code base, profiling to find the slow functions, and digging into the SymPy codebase for trigsimpification and other relevant function calls to speed up the EoM generation. One could also look into csympy (see below) for speed increases. These modification will help speed up both the entire SymPy codebase and the Mechanics package.

CSymPy

Difficulty: Medium to Hard
Projects: SymPy, CSymPy
Languages: C++, Python
Potential Mentors: Ondrej Certik

Recently, a C++ implementation of the SymPy core has matured. This library could significantly increase the speed of derivation of the equations of motion of complex systems. This project would be dedicated to ensuring CSymPy worked with all operations typically used in multibody systems analysis. Most work would be done on CSymPy to improve core algorithms such as differentiation and simplification speeds. Large benchmark multibody problems would be developed in Python to test the speed.

Efficient Code Generation

Difficulty: Medium to Hard
Projects: PyDy, SymPy
Languages: Python, C, C++, Fortran, Octave/Matlab
Potential Mentors: Jason Moore, Jim Crist

Currently, SymPy Mechanics can derive the symbolic equations of motion of complex mutlibody systems. These continuous differential equations can be solved to find the state trajectories through time. But in only the simplest systems can these differential equations be integrated symbolically. In general, one must integrate the differential equations numerically using various integration routines. For example, SciPy provides functionality for integrating ordinary differential equations as do many other software packages. A classic approach to problems such as these is to automatically generate code that can be integrated using robust numerical routines. We'd like to develop code output classes to interface with KanesMethod and LagrangesMethod classes that utilize SymPy code generation package. Generated code should be able to be directly run and/or compiled and run to perform a numerical integration of the equations of motion and produce time history of states. Besides developing the code generation classes for the KanesMethod and LagrangesMethod results, we'd like to spend some time improving the general code generation portions of SymPy and the common subexpression elimination routines. We'd also like to look into utilizing or learning from other code bases that generate effcient code, such as Theano, numba, parakeet, etc. Some experimental work has been done in the pydy-code-gen package. Thie paper http://jnaiam.org/new/uploads/files/16985fffb53018456cf3506db1c5e42b.pdf could help improve ODE code generation.

Difficulty: Medium
Projects: PyDy, SciPy or other projects with numerical integration routines Potential Mentors: Gilbert Gede

Another approach to solving ordinary differential equations would be to implement a Mathematica-like NDSovle and InterpolatingFunction classes for numerically solving differential equations. This is different than the code output classes, in that all of the numerics are done at runtime instead of generating separate external code. NDSolve would likely be external to SymPy due to its numerical rather than symbolic nature, but would need to be discussed with the SymPy devs to determine the best location.

Flexible Body Support

Difficulty: Hard
Projects: SymPy

SymPy Mechanics currently only deals with rigid bodies. It is possible to extend the code base to include the functionality for deriving the equations of motion of systems that include flexible bodies. Flexible bodies can be described by both spatial and time varying partial differential equations. One approach that would integrate well with the KanesMethod class is described in "Dynamics of an Arbitrary Flexible Body in Large Rotation and Translation" by Arun K. Banerjee and John M. Dickenst, but there are many other algorithms that could be introduced. This project would lie primarily in SymPy by extending the classes in mechanics to handle the spatial variables and including the automatic derivation of the flexible equations of motion.

Benchmark Suite, Robust Testing, and Example Gallery

Difficulty: Easy
Projects: SymPy, PyDy Potential Mentors: Gilbert Gede

Our testing suite currently implements several benchmark problems that have well known solutions in the literature. We like to restructure the tests so that both Kane's method and Lagrange's method (and any future methods) will test the same set of benchmark dynamics problems. We'd also like to make it very easy to add benchmark problems to the test suite (in particular non-trivial cases) so that the current EoM methods and any future methods will automatically be tested against these problems. All of the examples should have a common format and displayed on the website/documentation. These examples should be able to be run with a single script before each release.

See this project for example benchmark problems: http://lim.ii.udc.es/mbsbenchmark/

Generalize EoM Methods and System Classes

Difficulty: Medium
Projects: SymPy, PyDy
Languages: Python
Potenial Mentors: Jason Moore, Jim Crist, Gilbert Gede

We need to create an abstract base class for equations of motion methods (LagrangesMethod, KanesMethod) and develop a better generalized System class that consumes or uses the *Methods classes. Ideally we'd have a standard way for a user to build up a symbolic system and the system has all of the methods needed to do further analyses, simulation, and visualization.

Realtime Simulation

Difficulty: Medium
Projects: PyDy
Languages: Python, Javascript
Potential Mentors: Jason Moore

We can currently visualize a system after it has been simulated. Ideally we'd have a real time simulation such that the parameters and forces can be changed at each time step. We'd like an interactive simulation environment. This would likely make use of the IPython server/client messaging protocol to actively update the Javascript WebGL visualizations.

Interactive Generation of a System

Difficulty: Hard
Projects: SymPy and other 2D/3D visualization interactive toolkits
Potential Mentors: Tarun

Develop GUI based tool for creating multi-body models. This would include a 2D and/or 3D drag-n-drop workspace where you can add in basic bodies, add kinematic constraints, and apply forces. This interactive work would generate SymPy Mechanics code on the fly and thus the equations of motion. If the code output or NDSolve functionality is available, the visualization could even be animated in the same interactive workspace. The commerical product Working Model has features similar to this.

High Level System Specification for Kinematic Chains

Difficulty: Medium
Projects: PyDy Potential Mentors: Jim Crist

Develop a higher level specification language that abstracts out the underlying system generation. This is similar to the "Interactive Generation of a System" project above, but takes a text based approach to it. Many systems can be modelled as a series interconnected links with varying types of joints (robots, humans, etc...). Instead of manually creating these system using the current api, a higher level markup would be desired. This could take a few different forms:

  1. Abstract out various types of joints (pin, ball, universal, prismatic, etc...), implementing classes for each. A nice api for building up a system from these would need to be designed and created. This design would also mesh nicely with our visualization system, as each joint/link could be matched easily with a corresponding element of the visualization. As such, the user could potentially freed from having to manually create the visualization setup later.
  2. Use a table of Denavit-Hartenberg parameters. These are commonly used in robotics or the design of spatial mechanisms. As there are many conventions for DH parameters, an option to choose which convention would need to be provided.
  3. Use exponential coordinates, and express the system as a series of twists. This is the approach taken in Murray, Li, Sastry, and can result in a more compact representation for forward kinematics. These have the added benefit of not having multiple conventions (unlike DH parameters).

Physics Abstraction Layer

Difficulty: Hard
Projects: PyDy, OSRF

There are a variety of open source physics and multibody engines available. We'd like PyDy to provide a "physics abstraction layer" to some of the best ones (Simbody, PyDy, DART, MBDyn, Open Dynamics Engine, Bullet, etc) for the Python programming language. This would involve developing a specification for multibody system definition and shim between this specification and at least one or two engines (see http://gazebosim.org/sdf/dev.html for an example). This system would allow plugins to different systems to be created (possible even for commericial packages), then one could manipulate the engines with a common pythonic interface.

Wrap Simbody

Difficulty: Medium to Hard
Projects: PyDy, Simbody
Languages: Cython, C++, Python
Potential Mentors: Tarun

Simbody is a mullibody dynamics engine written in C++. We'd like to provide wrappers and integration into the PyDy code base to take advantage of Simbody's Featherstone based numerical approach to multibody dynamics.

Random

Difficulty: Variable Projects: Variable

  • Integrate our system with other popular physics engines such as MBDyn, Bullet, ODE, DART, Simbody, etc.
  • Also see ideas from last year gsoc_2014_ideas and the roadmap for more inspiration.
Clone this wiki locally
You can’t perform that action at this time.
You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.
Press h to open a hovercard with more details.