Elastica Sponsor Logos Cosserat Rods | Elastica

Google Summer of Code

Ideas Page

Elastica is an open-source software package designed to numerically simulate physical systems that can be represented as with single or multiple slender structures using Cosserat rod theory. Slender structures are ubiquitous in natural and artificial systems and across scales, from DNA strands to flagella and space tethers. They also make up a variety of complex systems, from birds’ nests made of twigs to living creatures made of bones, tendons, fibers and muscles. Examples of what Elastica has been for can be found here

What are Cosserat rods?

Cosserat rods provide a powerful and versatile framework to model dynamic slender elements, interacting among themselves and the environment. These can be assembled into heterogeneous architectures, active or passive, biological or synthetic, to study their functioning and dynamics at the system level.

The theory of Cosserat rods is a method of modeling 1D, slender rods accounting for bend, twist, stretch, and shear; allowing all possible modes of deformation to be considered under a wide range of boundary conditions. It models the rod as a deformable curve with attached deformable vectors to characterize its orientation, and evolves the system using a set of coupled second-order, nonlinear partial differential equations.

About Elastica

Elastica is designed to be modular, extensible and easy to use. It allows the user to define a collection of Cosserat rods subject to both external (i.e. gravity, friction, etc…) and internal (i.e. muscle torque) forces. Rods can account for self contact and can be combined to create assemblies of rods capable of modeling increasingly complex systems.

Elastica is currently written in Python (PyElastica) to allow user-friendliness, modularity, interoperability with other open-source software packages and fast development times. We are actively developing it and continually adding new features and performance improvements.

Application Instructions

Students applying for a Google Summer of Code project must have experience with Python (in particular numpy) as well as C/C++ if relevant to the project. A basic understanding of scientific computing, and in particular mechanics/numerical simulations, is strongly preferred.

We have provided a few possible projects we are interested in, however, if you have a new idea or variation on what we propose we are interested in injecting new ideas into the project. Regardless of if the project you are thinking of is from the list or new, you should reach out to us to discuss what you are thinking so we can provide some initial feedback. Make an issue on the PyElastica GitHub repo and attach the GSoC label. Projects that have reached out and discussed with us will be prioritized. Projects with a limited and well defined scope will also be favored. We would prefer a project that is finished, documented, tested, and deployed by the end of the summer even if it means all the possible features are not implemented.

Project Ideas

Improving visualization abilities

Skills required: Python, JSON, VTK, Blender, Visualization, CAD
Difficulty: Intermediate
Mentors: Noel Naughton, Arman Tekinalp and Mattia Gazzola
Description: Currently we do not have a great tools for visualizing simulations. Usually we use matplotlib for fast visualization of POVray for final rendering. Both have issues with usability and scalability. There are three different aspects of this project that can be proposed (each is large enough to be its own project, although it might be possible to combine projects together if one solution satisfies the requirements of both).

Required for all projects: Over the summer we will be developing a data framework to enable importing/exporting simulation data as well as saving and restarting simulations. All visualization projects will need to identify the requirements necessary for their project that can be interfaced with this framework.

Project #1: Fast, real-time visualization of simulations

This project is focused on implementation of a lightweight, fast visualization method that can be used either during an Elastica simulation to track progress or after simulation for fast visualization and post-processing of data. Use of VTK is encouraged (the Fury python package may also be useful). It should be capable of visualizing simulations, rotate/zoom, set camera angles, and generate images/videos.

Project #2: Integration with 3D rendering software

This project should focus on developing a pipeline to export simulation data from a finished Elastica simulation to an open-source 3D rendering software (such as Blender) to create high resolution images and videos of simulations. It should provide both an automatic method based on reasonable default parameters as well as the ability to customize the visualization in Blender. Documentation and tutorials for users will also be required.

Project #3: CAD integration

This project is focused on implementing automatic import and setup of simulation geometry from CAD file using an neutral file format (such as *.stl). It will develop an interface to read in a CAD file, convert the geometry to an Elastica simulation, allow necessary simulation parameters that can not be defined in the CAD file to be specified and have substantial error checking to make sure the user does not forget necessary properties. The ability to export an Elastica simulation into the same neutral CAD format should should also be implemented.

Reducing simulation times

Skills required: Python, Cython, C/C++, MPI, Numba
Difficulty: Advanced
Mentors: Arman Tekinalp, Noel Naughton and Teja Parthasarathy
Description: We currently use Numba’s just in time compilation ability to speed up simulation time, however, for large assemblies of rods, simulation time can become extremely long. Reducing simulation times is a major priority to enable improved time to solution. Previous demonstrated ability to write scalable, high performance code will be required for these projects.

Project #4: Implementing time consuming functions in Cython

This project will explore reimplementing major bottlenecks in the Python codebase in C using Cython. It will:

Project #5: Add parallel processing and/or GPU integration

Numba provides multi-threaded and GPU capabilities that may allow substantial speedup. Additionally, when running on a cluster, use of MPI to scale across nodes can provide substantial speedups. We will provide access to computing clusters with both GPUs and multiple nodes to allow testing and development. Some key aspects of this project include: