-
-
Notifications
You must be signed in to change notification settings - Fork 346
GSoC 2019 Ideas
The page contains a list of ideas for students applying to Google Summer of Code 2019. Cantera is participating under the NumFOCUS umbrella, so students should apply to the NumFOCUS organization. The NumFOCUS organization has several tips for your application, see here. Please note that you MUST apply through the NumFOCUS page on the Summer of Code website.
- Sign up for the mailing list and introduce yourself - your background, where you're attending university, your interests, hobbies, etc.
- Read the documentation available at https://cantera.org to understand what Cantera is for and about and review our Guide for Contributors
- Make sure you can build the most recent Git commit of Cantera, following the instructions on our Compiling page. If you're having trouble, post on the mailing list!
- Once you find a project that interests you, reach out to the mentor listed below on the mailing list and/or by email
- When you start working on your application, keep in mind the guidelines for applications provided by NumFOCUS at https://github.com/numfocus/gsoc/blob/master/CONTRIBUTING-students.md
- YOU MUST submit your application to the Summer of Code website to be considered. We are NOT allowed to accept applicants unless they apply through Google.
The following ideas are not organized in any particular fashion at the moment and we think any of these ideas would make a good GSoC project. The particular project that you choose for your application will not affect our evaluation of your application; your application will be evaluated on its own strength, taking into account how well you address whichever project you choose.
Each idea below gives short description of the project, our best estimate at the difficulty, any required basic knowledge, and the project mentors you should contact regarding the project. We strongly encourage any interested students to reach out to the mentors by posting on our mailing list and/or emailing them directly by the email linked in their GitHub profiles.
Please feel free to propose your own project if you like. If you want to propose your own project, please follow the template from the ideas below and definitely post on the mailing list with your idea so that we can discuss and help refine it.
- Re-implement the Matlab interface
- Implement GPU solver for reactor simulations using SUNDIALS 3.1 interface
- Implement GPU solver for 1D flame simulations
- Implement a steady-state solver for 0-D systems
- Fix up Mixmaster
- Improve Jupyter notebook integration
- Implement an interface to the CoolProp library
- Implement wrapped versions of Cantera classes that support units
- Develop tools to help users visualize and solve common input file errors
- Develop plugins to automate Cantera website building
- Improve website documentation of available ThermoPhase objects
- Improve CI Infrastructure support for Cantera
We currently have a Matlab interface to the C++ core library, based on the "mex" extension interface, but it is difficult to maintain. We would like to look at ways of replacing this interface. Options under consideration include using the "loadlibrary" interface to more directly call Cantera's C wrapper functions, or by using Matlab to import/call the Python interface.
Medium
C/C++/Matlab or Matlab/Python, depending on which option is pursued
The matrices representing the systems of equations in Cantera are generally solved using SUNDIALS. Newer versions of SUNDIALS have a better interface to integrate with heterogeneous computing environments. This project will add GPU support to Cantera for reactor network integration.
Medium
C++, CUDA/OpenCL
Solving 1D flame problems in Cantera requires the solution of linear systems with large, banded matrices. This problem is well-suited to GPUs, but current GPU libraries do not implement algorithms for this particular matrix structure. This project involves the implementation of standard algorithms for solving such systems on the GPU, and then using this algorithm within Cantera's 1D flame solver.
Hard
C++, CUDA/OpenCL, Linear algebra/matrix computations
Cantera can solve systems of equations representing physically zero-dimensional (i.e., time dependent-only) or one-dimensional (i.e., time + space) systems. The solution of the 1-D problems is done under the assumption of steady state, resulting in a differential-algebraic system of equations to solve. There is a solver implemented in Cantera as part of the 1-D code that solves these problems. 0-D systems can either be transient or steady state, represented by an ODE or algebraic equation respectively; at the moment, the only way to achieve solutions of the steady state problem is to integrate the transient problem until properties stop changing. We would like to modify or implement the existing steady-state 1-D solver for 0-D systems
Medium-Hard
C++
Mixmaster is our (very simple) GUI to access a limited subset of Cantera's functionality. It would be useful if this GUI were... well, useful. At the moment, it may be broken (not sure, haven't tried it recently), it cannot be installed on user systems very easily (it is a Python package, but missing the installation infrastructure), it is more-or-less entirely undocumented, and it would be nice if it were extended with a bit more functionality
Easy
Python
There is room to provide more integration between Cantera and Jupyter notebooks to enhance the interactive user experience in this environment. This project could start with things like HTML representations of phase "reports", and extend to things like progress indicator widgets for reactor networks or 1D flame integration. Another possibility would be generating notebook examples with slider based UIs for running common calculations.
Easy
Python
Cantera currently provides equations of state for a limited number of pure substances covering the liquid/vapor/supercritical regions. The goal of this project would be to introduce a new class to wrap the CoolProp library and provide access to its large range of equations of state within Cantera.
Medium
C++
Nearly all calculations in Cantera are done in SI units (K, Pa, kg, kmol), and the units of quantities available to the user are also in SI units. Although this is the most useful general case, it would be helpful if users could input other units to Cantera functions and the conversion to SI is done internally before conducting calculations. This project would implement a wrapper around Cantera classes and/or functions to enable the use of alternative units transparently. See also: https://github.com/Cantera/cantera/issues/202
Medium-Easy
Python
The bedrock of any thermo-kinetic calculation is the chemical mechanism upon which these calculations are performed. Mechanism information is provided in the form of input files, which can be written from scratch by a user, adopted from various sources and repositories on the web, or via a hybrid of these two approaches. Unfortunately, this ad-hoc approach all to frequently can result in errors in the resulting mechanism files, leading to inaccurate or unexpected results, or sometimes syntax errors that prevent loading the mechanism at all. To complicate matters, such mechanism errors can be difficult to diagnose, particularly for larger mechanisms.
This project will develop tools to help users visualize and diagnose common mechanism file errors. There is currently some example code in the form of a Jupyter notebook, and the first step would be to flesh out, generalize, and add documentation to the ideas outlined there. After completing this first task, other aspects of the project could include:
- Updating mechanism converter files to catch common errors
- Writing scripts in other Cantera languages (Matlab, Python)
- Design a GUI-based application to give users advanced options in visualizing errors in very large mechanisms (there may be some overlap with Fix up Mixmaster, here).
Medium-Easy
Python or Matlab
For each release of Cantera, we produce a detailed change log of all of the commits, issues resolved, and pull requests merged, along with some comments about each of these. We would like to post this information on our website, but we need to be able to automatically link the commit hashes, GitHub usernames, and GitHub issue/PR numbers back to GitHub (similar to the way that GitHub itself works). This portion of this project will be to write a plugin for the Nikola static site generator that processes a properly formatted Markdown file and generates the appropriate HTML output. See also: https://github.com/Cantera/cantera-website/issues/38
Currently, users can only search within the documentation, either the Sphinx-generated Python and Matlab documentation or the doxygen-generated C++ documentation. We would like users to be able to search the entire website, particularly as we move more content out of the documentation and into the rest of the site. Since the Cantera website is statically generated HTML, we need to rely on an external service to provide the search across all of our pages. This portion of this project will investigate the options available for full-text search on static HTML sites and implement the best choice by integrating with the Nikola static site generator that we use. See also: https://github.com/Cantera/cantera-website/issues/34
On the Cantera website, we provide detailed documentation of all of the configuration options that can be specified when building Cantera from source. Currently, that page is manually generated by copy-pasting from the relevant lines in the main SConstruct file. This portion of this project would develop a plugin for the Nikola static site generator to automatically create this file when the website is built. See also: https://github.com/Cantera/cantera-website/issues/26
The Sphinx documentation generator implements the ability to automatically link to Python objects with the :py:class: and similar roles in reST documents. There is a similar Sphinx extension called doxylink that allows you to link from Sphinx-processed reST files to C++ object documentation generated by Doxygen. In 2018, we switched to using the Nikola static site generator for our website, so we implemented a partial replacement as a plugin for Nikola. However, this replacement only handles our Python, Matlab, and CTI documentation; we're missing the ability to link to C++ documentation. This portion of this project will add back that missing functionality by writing a plugin for Nikola that runs on every site build.
There may be other plugins that would be useful, feel free to propose others. For this proposal to be successful, we would like to have 2-3 new automations integrated to the website.
Medium
Python
Cantera makes available a range of thermodynamic phase models, which implement a given equation of state and method for calculating phase and species thermodynamic properties. These are instantiated as ThermoPhase objects, within the Cantera C++ library.
At present, very few of the available ThermoPhase classes are thoroughly documented. This causes problems for users, who need to find the appropriate model to solve the problem of interest, as well as developers, who need to better understand the range of current thermodynamic capabilities, plus the level of development of each class, in order to guide future development efforts.
The goal of this project would be to thoroughly document the ThermoPhase objects available in Cantera, in the the Science page of our website. The GSoC student should add the following for each thermodynamic phase model:
- A physical description of the class: Theoretical basis for the class, underlying assumptions, etc.
- Document the equations of state and property calculations for both phase and species properties.
- Identify the implementation status of the Phase (complete, partial, or marginal) and how the class may be accessed, both in terms of input files (cti, xml, and/or YAML) and programming environment (C++, Python, and/or Matlab)
- Document whether the class functionality is covered by any tests.
- Provide links to any examples demonstrating the use of the class.
This project will provide significant benefit to Cantera users, and also help determine priorities for Cantera developers.
Easy
Basic fundamentals of thermodynamics, LaTeX equation editing.
Cantera uses Travis CI and Appveyor as our primary CI providers connected to our repositories on GitHub. However, we have identified several sore spots with these services, namely:
- Appveyor is limited to one build running at a time
- Travis CI experiences random failures due to build timeouts/errors for dependencies installed using Homebrew
- In some ways, these services duplicate our existing CI infrastructure provided via our BuildBot instance
Aside from these issues, we have identified several additional capabilities that would improve our productivity:
- Integrate build and running of our samples in the source repository as a regression test
- Integrate running our Jupyter Notebook samples, maintained in a separate repository, as a regression test
- More frequently run builds of our packaging infrastructure for conda, macOS, and Windows installer packages
- Test the install scripts on platforms that our core contributors don't use as frequently (Linux distributions other than Ubuntu, primarily)
This project will investigate, suggest, and implement improvements such as those listed above in our CI infrastructure.
Easy
Experience with CI services preferred, although not required