SBEL Logo

Google Summer of Code 2016 Project Chrono Ideas List

  1. ###Mesh To Point Cloud Tool
    • Prerequisites: Linux, git, basic geometry and computer graphics.
    • Description of Programming Skills: C/C++.
    • Difficulty Level: Easy-Medium
    • List of Potential Mentors: Arman Pazouki, Felipe Gutierrez, Milad Raksha, Dan Negrut.
    • Detailed Description: An essential pre-processing step in Lagrangian-Lagrangian Fluid-Solid Interaction (FSI) simulations is the representation of the solid phase as a dense point cloud. The fluid-solid coupling forces are captures by the interaction of solid particles and fluid particles as described in [1, 2]. For complex geometries generating a point cloud representation is not a trivial task. Modern CAD tools, however, make it easy to generate mesh representations (.obj files, .stl files, etc) of complex geometries. The first goal of this project is to develop an efficient, flexible, and robust tool that will take any input mesh file and a point separation value and return a point cloud representation of the mesh. This tool will be added to Chrono::FSI, the fluid-solid interaction module of the open-source multiphysics engine, Chrono. The second goal will be to improve Chrono::FSI model definition API with the use of this too. References
      1. Reference 1
      2. Reference 2
  2. ###CAD plug-in
    • Prerequisites: API of a mainstream 3D parametric CAD (ex.: SolidWorks or Inventor), GIT, basic geometry and computer graphics.
    • Description of Programming Skills: C/C++ and C#. * Difficulty Level: Medium-high * List of Potential Mentors: Alessandro Tasora, Dan Negrut, Radu Serban.
    • Detailed Description: At the current stage of development, Chrono::Engine is a middleware, and as such it consists of C++ software libraries but there is not yet a graphical user interface (GUI). A possible solution would be to port Chrono::Engine in a third party CAD tool. This means leveraging a mainstream 3D parametric CAD (such as SolidWorks or Solid Edge or Inventor, or others) as a powerful modeling tool, and to customize the CAD user interface by developing a plug-in that provides additional buttons and windows for controlling Chrono-specific features. For example, one could find an additional toolbar that allow creating jets of Chrono particles in the 3D CAD model. Some properties such as weight, inertias, materials, constraints and mating should be automatically converted from the CAD model to the Chrono model. Special interactive tools could be developed to optimize the conversion from CAD models in Chrono-friendly primitives (spheres, convex hulls, triangulated meshes, etc.). Vice versa, the result of the Chrono simulation should be transferred automatically to the 3D views of the CAD tool for the output of animations, plots, postprocessing. To accomplish this project, one should use both the C++ API of Chrono::Engine and the API of the hosting CAD software – in most cases the latter are based on NET/COM interfaces, and as such they usually fit well in C# or VisualBasic development. A proof-of-concept of this tool is presented in the experimental Chrono::SolidWorks add-in [1], which now just exports the CAD model as a Python file to be imported in an external Chrono::Engine application. References
      1. Reference 1
  3. ###Blender plug-in
    • Prerequisites: API of the Blender modeling tool, GIT, basic geometry and computer graphics.
    • Description of Programming Skills: C++ and Python.
    • Difficulty Level: Medium-high
    • List of Potential Mentors: Alessandro Tasora, Dan Negrut, Radu Serban.
    • Detailed Description: At the current stage of development, Chrono::Engine is a middleware, and as such it consists of C++ software libraries but there is not yet a graphical user interface (GUI). A possible solution would be to create a plug-in for Blender, the popular 3D tool. Blender is a free software [1] and offers advanced rendering and interactive modeling capabilities; its interface and tools can be expanded by using a Python application programming interface (API). Such API would be used to introduce additional buttons and settings for Chrono-specific features. For example, one could find an additional toolbar that allow creating Chrono gears, pulleys or joints. Properties such as the collision surfaces, the mass and volume would be automatically converted from the CAD model to the Chrono model. Other buttons would allow the interactive creation of constraints (spherical joints, revolute joints, engines) that will be simulated in Chrono. A button should launch the Chrono simulation, whose results should be displayed and rendered in the 3D views of Blender. For higher performance, one could integrate Chrono::Engine in Blender directly using C++, instead of using the Python interface. A similar concept is the Blender plug-in for the Bullet3D physics engine [2], which can be used as inspiration. References
      1. Reference 1
      2. Reference 2
  4. ###Ogre 3D real-time visualization module
    • Prerequisites: Ogre rendering technology, GIT, basic computer graphics.
    • Description of Programming Skills: C++.
    • Difficulty Level: Medium
    • List of Potential Mentors: Alessandro Tasora, Dan Negrut, Hammad Mazhar.
    • Detailed Description: Chrono::Engine is a modular library. One of the optional modules is the Irrlicht module: it is used for displaying the Chrono simulations in a 3D realtime view. The problem with the current Irrlicht module is that it leverages on a 3rd party library (namely, Irrlicht engine [1]) that has some limitations. We plan to develop a new module that uses the more popular Ogre 3D library [2]. This would allow a more efficient visualization of complex scenes, especially with cast shadows, ambient lighting and other advanced rendering techniques. Moreover, Ogre 3D is the most popular free library for realtime visualization. The student should take inspiration from the existing Irrlicht module in order to develop the new Ogre module; current features should be replicated in the new module (such as populating the visualization shapes, colors and meshes of the rendering engine from a tree of Chrono ‘assets’) and if possible new features should be added (such as a better user interface, more extensive setting panels, better shading, real-time profiler with oscilloscope plots of the CPU overhead, etc.) References
      1. Reference 1
      2. Reference 2
  5. ###VTK postprocessing
    • Prerequisites: VTK, GIT, basic computer graphics.
    • Description of Programming Skills: C++, basic Python scripting
    • Difficulty Level: Easy-Medium
    • List of Potential Mentors: Alessandro Tasora, Dan Negrut, Hammad Mazhar.
    • Detailed Description: Chrono::Engine is a modular library. One of the optional modules is the post-processing module: it is used for generating output files that can be load in post-processing tools such as Matlab and GNUplot (for plotting) and POVray (for batch ray-tracing rendering). A new output type in form of VTK files would be welcome. VTK is the leading technology for scientific visualization of large dataset: in particular, a free tool called VTK ParaView can load, process and display the VTK files in 3D views [1]. ParaView can also generate animations and additional postprocessing of the input data (ex. isosurfaces and flow lines in case of CFD animations). For these reasons, Chrono::Engine would benefit from a VTK exporter. This would be developed as a set of C++ classes in the already existing post-processing module of Chrono::Engine. It should convert all Chrono::Engine assets (spheres, cylinders, meshes, finite element nodes, etc.) in VTK objects. Special care could be used to convert FEA objects (finite element shells, beams, tetrahedrons etc.) that could be displayed using false color shading. The same when converting SPH results of Chrono::Engine, which could be displayed with special CFD rendering methods in ParaView. In all cases the results would be exported as a VTK file (one file per each simulation frame, in case of animations). There are at least two formats: the legacy VTK file format or the XML VTK file format; if possible, both should be implemented. Some Python scripts for an easy automation of the loading of files into the ParaView VTK tool could be optionally developed. References
      1. Reference 1
  6. ###Computational plasticity
    • Prerequisites: Continuum mechanics, linear algebra, plasticity, FEA.
    • Description of Programming Skills: C++
    • Difficulty Level: Medium-high
    • List of Potential Mentors: Alessandro Tasora, Dan Negrut.
    • Detailed Description: Chrono::Engine is a modular library. One of the optional modules targets finite element analysis (FEA). It is already capable of simulating non-linear problems with large deformations using corotational finite elments (tetrahedrons, beams, bricks) absolute nodal coordinate formulations (ANCF) and such. However, only the elastic case is currently supported. A welcome feature would be the addition of computational plasticity [1]. The new feature would be used to simulate structures subject to permanent deformations (car crashes, collisions between ships hulls, metal sheet working, soil compaction, etc.). In such a case, a modification to the current C++ classes for finite elements should be done: the so called plastic flow information must be attached to finite element quadrature points, and a modification to the time integration algorithm(s) must be done so that the plastic return mapping (i.e. the limiting to the strain when it exceeds the yield surface) is taken into account. Different types of plasticity should be implemented: at least the Von Mises and the Drucker Prager ones. References
      1. Computational Methods for Plasticity: Theory and Applications, 2008 John Wiley & Sons, Ltd, E. A. de Souza Neto, D. Perić, D. R. J. Owen
  7. ###Chrono::FEA Pre-Processing
    • Prerequisites: git, basic geometry and computer graphics
    • Description of Programming Skills: C++
    • Difficulty Level: Easy-Medium
    • List of Potential Mentors: Milad Rakhsha, Antonio Recuero, Alessandro Tasora, Dan Negrut.
    • Detailed Description: Chrono::Engine is a modular library. One of the optional modules targets finite element analysis (FEA). For complex geometries, it is necessary that the computational mesh be imported from external mesh files saved in different formats. This module is already capable of importing tetrahedron mesh saved by Abaqus and TetGen. It is also capable of importing quadrilateral shells saved in GMF format. However, support for importing other types of meshes have not been implemented in chrono::FEA yet. The first goal of this project is to implement such utilities that provide the Chrono’s user with tools for importing, and manipulating different types of mesh. The second goal of the project is to writes utilities that can evaluate the quality of a mesh from different points of view, and inform the users some information that allows them to decide on whether or not a better mesh should be used in order to obtain more accurate/stable solution. References
      1. Reference 1

© Simulation Based Engineering Laboratory, Dan Negrut 2017. SBEL is led by Mead Witter Foundation Professor Dan Negrut in the Department of Mechanical Engineering at Univeristy of Wisconsin-Madison

[SBEL Home] [ProCSI] [Workshops] [AC-Summer School] [Consortia] [Chrono Tutorials]
UW Logo