Google summer of code 2024

[armantekinalp]

Google Summer of Code

About Elastica

Elastica is a free and open-source software project for the simulation of assemblies of slender, one-dimensional bodies using Cosserat rod theory. Slender structures are ubiquitous in both nature and engineered systems at all different sizes, from DNA strands to space tethers. Elastica has been designed to model such slender structures, with a particular focus on muscular structures and soft robotics. We are focused on providing useful simulation tools to the robotics and biomechanics communities to model, control, and visualize how these slender structures evolve and interact. Some examples of what Elastica has been for can be found here.

PyElastica

PyElastica is the Python implementation of Elastica. PyElastica is designed to be modular, extensible, and easy to use. It allows the user to model a collection of slender rods that are each subject to different 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. We are actively developing it and continually adding new features and performance improvements.

Application advice

Before applying for a Google Summer of Code project, make sure you review our contribution guidelines. Applicants should have prior experience with Python 3. A basic understanding of scientific computing, in particular computational mechanics/numerical simulations, is preferred, however, lack of such knowledge should not hamper your ability to come up with a competitive proposal.

We have provided some projects ideas below. Before applying, make please reach out to us to discuss your idea. Make an issue on the PyElastica GitHub repo . Projects that have reached out and discussed with us will be prioritized. If you have general questions about PyElastica, you can also comment below.

Deliverables: Projects with limited and well-defined scopes will 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.

Ideas List

Theme: Improving visualization abilities

Currently, we do not have great tools for visualizing simulations. We have identified three different aspects of visualization that we think would make a good GSoC project. We think each is large enough to be its own but it might be possible to combine projects together if one solution satisfies the requirements of both.

Project 1: Integration with 3D rendering software

Skills required: Python, Blender
Difficulty: Intermediate
Project size: 350 hours
Description: 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.
Mentors: Arman Tekinalp, Seung Hyun Kim, Yashraj Bhosale, Ali Albazroun

Theme: Improving backend functionality and optimizing kernels

Project 2: Optimizing backend kernels in PyElastica

Skills required: Python
Difficulty: Advanced
Project size: 350 hours (depending on the extent of proposed features)
Description: This project is focused on optimizing the backend kernels of PyElastica. Currently, we are using Numba njit compilation for accelerating our code, but we would like to improve the speed of the backend code without sacrificing the modularity and extensibility of the code. As a part of this project, you will work on optimizing some of the kernels in the backend. We would like you to use other accelerators like Jax/PyTorch. All optimized kernels have to be profiled and tested at the unit test level and simulation level.
Mentors: Arman Tekinalp, Seung Hyun Kim, Yashraj Bhosale

Project 3: Binding PyElastica with Elastica++

Skills required: Python, C++17, PyBind, CMake, Docker??
Difficulty: Advanced
Project size: 350 hours (depending on the extent of proposed features)
Description: This project is focused on binding C++ backend code to PyElastica. Currently, we have implemented C++ native elastica (elastica++) backend with SMP (TBB). As a part of this project, you will work on writing binding code using PyBind and packaging necessary C++ dependencies.
Mentors: Arman Tekinalp, Seung Hyun Kim, Songyuan Cui, Yashraj Bhosale

Theme: Logging, saving, and restarting simulations

Project 4: Saving and restart framework for simulations

Skills required: Python, hdf5
Difficulty: Easy to Intermdiate
Project size: 175 hours
Description: Develop a framework for saving simulations both as checkpoints which can be relaunched if the simulation crashes and at the end of the simulation. Enough information about the simulation should be included that the simulation can be loaded and restarted from the saved data and utilities to do so should also be written. A filetype/database standard for the data should be identified (we are flexible about what type and will work with you to identify it) in order to allow interoperability with postprocessing data pipelines.
Mentors: Arman Tekinalp, Seung Hyun Kim

[AsadNizami]

[armantekinalp]

@AsadNizami I don't understand your question. Could you please elaborate more?

[AsadNizami]

Not an important question but as mentioned in the theme of the first project.

We have identified three different aspects of visualization that we think would make a good GSoC

I assume the first project is one of the applications of visualization. I wanted to ask what the other applications were.

[armantekinalp]

That is wrong, actually. We will have only one visualization project this year.

[AsadNizami]

okay.

[CharcoalF]

Dear PyElastica team,

I hope this message finds you well. As a newcomer to GSoC, I'm keenly interested in the first task.

My understanding is:

1. Using Python to preprocess and transform data from Elastica into a format compatible with Blender.
2. Employing Blender's API to control the software for image rendering.

The goal is to integrate Elastica's data with Blender's graphics capabilities, enabling highly customized data visualization for better understanding and analysis of simulation results.

Brief Workflow:

1. Data Preparation: Understand Elastica's data structure, then write Python scripts to extract, clean, and organize the data for Blender usage.
2. Blender Scripting: Develop Python scripts to create scenes, objects, materials, etc., in Blender using its API, and apply the extracted data for rendering.
3. Data Conversion: Convert Elastica data into Blender-recognized formats like vertex coordinates, normals, texture coordinates, etc.
4. Image Generation: Utilize Blender's rendering engine to produce high-quality images or videos via Python scripts controlling rendering parameters.
5. Custom Visualization: Implement user-customizable features in Python scripts, such as custom viewpoints, animation effects, interactive controls, etc., to meet specific visualization needs.

While I understand that actions speak louder than words, I plan to delve into the repository soon. I'd appreciate any additional suggestions to guide my exploration.

I've reviewed the documentation and recognize that submitting a pull request after addressing bugs/issues is a prerequisite for participation. Should I focus on resolving existing open issues or create a small demo for the first task? Any further analysis or resources you can provide regarding the project would be immensely helpful.

[armantekinalp]

You can take a look our slithering snake example. A demo uploading snake to blender and visualizing it there would be interesting. Future goals would be including other solid rigid object, scientific visualization of boundary conditions and loadings.

[CharcoalF]

Hi,

I wanted to provide a quick update regarding my progress and an issue I encountered while trying to visualize the slithering snake example in Blender.

Step 1: I've modified continuum_snake.py by adding a new function called “export_to_obj”. This function exports the snake simulation results to OBJ, a format supported by Blender. Afterwards, we can import these models into Blender.

def export_to_obj(pp_list, filename):
    with open(filename, 'w') as f:
        # Write vertex positions
        for position in pp_list['position']:
            for pos in position:
                f.write(f'v {pos[0]} {pos[1]} {pos[2]}\n')
        
        # Write face indices
        num_vertices = len(pp_list['position'][0])
        for i in range(num_vertices - 1):
            f.write(f'f {i+1} {i+2}\n')
        f.write(f'f {num_vertices} 1\n')
                
print(f'Successfully exported snake model to {filename}')

To export, use:

export_to_obj(pp_list, "snake_model.obj")

While running continuum_snake.py, I encountered an issue with the line damper_base = ea.Damping.DamperBase, resulting in an AttributeError: module 'elastica' has no attribute 'Damping'. I checked the location docs/api/damping.rst, but I suspect that damping may not be a function available in elastica.

Any thoughts or suggestions? Thank you.

[YaraShahin]

Hello @CharcoalF

I believe the class Damping exists in the current repo at elastica/modules/damping.py. I believe you might have an import error (didn't import Daming) or another issue with the module installation. Could you post the full code?

[armantekinalp]

Hi @CharcoalF I haven't seen this post. Could you please create a new conda environment and install pyelastica ? Sounds like import or installation issue.

[ankith26]

Redirected from #336

Hello!

I have some prior experience with contributing to some open source projects, but I hope to expand my knowledge and experience by engaging with more projects new to me. I'm quite interested in this task, as I feel like I have the required skills to work on this.

Just a couple of things, before I make my formal proposal document

1. If my understanding is correct, the project Elastica++ mentioned in the linked discussion is https://github.com/mattialab/elastica (please correct me if I'm mistaken)
2. I'd also like to know whether the entire library is to be binded to python, or only a subset of it
3. pybind11 does not seem to support Py_LIMITED_API. So, using this approach will mean that a separate wheel for every python version supported will have to be released, per supported platform. Alternative approaches that could be considered are writing C extensions manually with Py_LIMITED_API or using something like HPy. Both these approaches will be more time-consuming to implement, and also could have a small runtime performance cost. However they will save build time and reduce overall release size.

These are also some related things that I'd like to work on, if accepted

1. Adding type stubs and stub testing for it. Relevent projects that could be useful: pybind11-stubgen, mypy stubgen and mypy stubtest
2. Updating CI to build and test against various python versions (if going the pybind11 way). Relevant project that could be useful: cibuildwheel
3. Updating docs/tests/examples as per need.

Also, I'd like to get started with contributing to this project right away, taking on existing issues initially.

Thanks!

[ankith26]

Thanks for the elaboration, I have a better understanding now.

I'd also like a ballpark estimate of the number of functions/types to be exported, which would help me plan my timeline in my proposal document (though no hurries of course). And also I'd like to know how much of these have pure python implementations already, as this would give me a better idea on test-writing (for the ones that don't have python implementations, I'm thinking it would be nice to add python implementations first and then test that both implementations behave the same for test cases)

Is this project only going to be limited to mac/manylinux? If accepted, I'm interested in also adding windows builds as a stretch-goal (task to do incase I finish rest of the planned tasks early)

[skim0119]

Here are two main functions in python/numba implementation. Each equation is modularized and implemented in separate functions for testing purposes, but they are two vectorized equations.

• sigma
• kappa
  Elastica++ implementations are structured in a very similar way as above.

We wouldn't mind your attempt to build PyElastica for Windows, but we must say the primary purpose of Elastica++ is to scale a large simulation supporting hybrid (MPI+SMP) HPC. For this reason, we are prioritizing linux (and mac) development.

[ankith26]

Hello!

First of all, thanks for accepting my GSoC proposal.

I'm sure you mentors would have already read my proposal, so for the next 2-3 weeks I'd like to take your inputs on it, discuss the specifics and finalize the plan of what I'll be working on after the coding period starts. Is this thread the preferred place for further discussions, or would y'all like a dedicated discussion thread or issue on this repo? Or is there any other medium of communication y'all would prefer?

[armantekinalp]

Hey @ankith26 can you send me an email? Do you have my contact info

[ankith26]

I don't know your email address. Could you point me to it, or if you prefer you can email me at one of the emails I listed in my proposal submission.

[vikas-chaudhary-2802]

Hi , @skim0119 @armantekinalp Can you please tell me which projects holds the most priority level ?

[skim0119]

All of them hold equal priority. Topics are chosen to cover a wide range of technical skills, and we expect participants to propose a solution that suits their skill level.

[vikas-chaudhary-2802]

Hiee @skim0119 @armantekinalp I want to discuss about my proposal that i submit. I want feedback so that i am ready for the next year