DOCSEARCHbyAlgolia
Submit Docs

Project Chrono Documentation

repository·main·Indexed 25 days ago

https://github.com/projectchrono/chrono

A multi-physics simulation engine for modeling rigid and deformable bodies, granular dynamics, fluid-solid interactions, and robotics sensors. It features a C++ core with Python and C# APIs, supporting multibody system modeling and specialized modules such as Chrono::Vehicle for ground vehicle simulation. The engine integrates with ROS2 for sensor simulation and supports co-simulation with OpenFOAM via preCICE.

Tokens
114.8K
Snippets
135
Records
653
Agent score
84%

What's inside Project Chrono

  1. Overview of DEM-Engine (DEME)

    main

    DEM-Engine (DEME) is a C++ package designed for high-efficiency Discrete Element Method (DEM) simulations. It is optimized for GPU acceleration and supports complex particle shapes and customizable contact force models. It is designed to be easily integrated with other C/C++ packages like Chrono for co-simulation.

    Key features include:

    • Support for up to two GPUs simultaneously (consumer and data center GPUs).
    • Complex particle shapes represented by clumped spheres.
    • Customizable contact force models (e.g., cohesive or electrostatic forces).
    • Co-simulation capabilities with Chrono.

  2. Overview of SynChrono module capabilities

    main

    The Chrono SYNCHRONO module enables the synchronization of distributed simulations of multiple vehicles or robots within a single, time- and space-coherent Chrono world.

    Key features include:

    • Synchronization of distributed simulations.
    • Out-of-the-box wrapping of Chrono::Vehicle models.
    • Integration with Chrono::Irrlicht and Chrono::Sensor visualizations.
    • Modeling of intelligent intersection systems.
    • Synchronization of deformable (SCM) terrain.

  3. Overview of SynChrono multi-agent simulation

    main

    SynChrono is a framework for simulating multiple autonomous agents (such as robots or vehicles) in a unified environment by distributing their dynamics across different computing nodes.

    It is designed for scenarios where agents are not strongly coupled (e.g., autonomous vehicles where one vehicle's dynamics do not immediately impact another's unless a collision occurs). Instead of a single monolithic ChSystem, each simulation node manages its own ChSystem. SynChrono synchronizes the motion of all agents periodically via a 'heartbeat' mechanism.

  5. Overview of Chrono::Sensor module capabilities

    main

    The Chrono::Sensor module provides parameterized models for simulating sensors used in robotics and autonomous vehicles. It supports the following sensor types:

    • RGB mono Camera
    • Lidar
    • Radar
    • GPS
    • IMU (accelerometer, gyroscope, magnetometer)
    • Tachometer

    The module includes a library of pre-defined sensor models for quick implementation, including generic versions of Cameras, Lidars (including Velodyne VLP-16 and HDL-32E), GPS, and IMUs.

  6. Overview of Chrono::Postprocess features

    main

    The Chrono::Postprocess module supports several export targets:

    • Blender: Exports files compatible with the chrono_import.py add-in. It converts ChVisualization assets into Blender objects, allows camera attachment to moving objects, and supports exporting scalar/vector fields (via falsecolor maps) and rendering object reference frames, contacts, or joint references.
    • POVray: Converts ChVisualization assets attached to rigid bodies into POVray rendering primitives. It supports custom POV-specific statements, camera attachment to moving objects, and rendering contacts as colored vectors and points.
    • GNUplot: Automatically creates .gpl scripts from C++ and can launch GNUplot directly to create and save plots as .EPS, .PNG, or other formats.

  7. Overview of the Vehicle Driver Subsystem

    main

    The Chrono::Vehicle driver subsystem provides inputs for steering, throttle, and braking. It supports three main modes:

    1. Interactive Drivers: For real-time simulations using keyboard, mouse, or game controllers.
    2. Data-driven (Open-loop) Drivers: For design-of-experiment simulations using time-dependent signals from a text file.
    3. Closed-loop Drivers: For automated control using PID controllers (e.g., path-following or constant-speed control).

    The base class ChDriver defines the interface for returning normalized inputs:

    • Throttle: $[0, 1]$ range.
    • Steering: $[-1, +1]$ range (negative is left).
    • Braking: $[0, 1]$ range.

    Drivers can use Synchronize to receive vehicle state information and Advance to implement internal dynamics.

  8. Overview of Chrono::Sensor

    main

    The Chrono::Sensor module provides simulation support for various sensors attached to ChBody objects. It is compatible with core rigid body simulations (including Chrono::Vehicle) and SCMTerrain, but is not currently compatible with FSI (Fluid-Structure Interaction) problems.

    Supported Sensors:

    • RGB monocular camera (including physics-based versions)
    • Depth camera
    • Segmentation camera
    • Normal-map camera
    • Lidar
    • GPS
    • IMU (Accelerometer, Gyroscope, and Magnetometer)

  9. Overview of Chrono DEM module tutorials

    main

    The Chrono::Dem module provides support for GPU-accelerated granular dynamics using the penalty-based discrete element method (also known as SMC). The following demos are available to demonstrate various granular dynamics scenarios:

    • demo_DEM_ballCosim: A co-simulation example where a large sphere (represented as a triangular mesh) interacts with granular material. The sphere's dynamics are managed by ChSystem, while contact forces are generated by the Chrono::DEM system.
    • demo_DEM_fixedTerrain: A utility for terrain initialization that generates fixed particles on a surface mesh and loads additional particles above it.
    • demo_DEM_movingBoundary: Demonstrates a settled container of granular material being displaced by a moving boundary plane.
    • demo_DEM_mixer: Demonstrates a cylindrical container with a rotating blade used for mixing granular material.
    • demo_DEM_repose: Demonstrates granular material flowing through a hopper funnel to form a stable pile, illustrating the angle of repose.

  10. Introduction to PyChrono

    main

    PyChrono is a Python module that provides an alternative to C++ programming for building applications with Chrono. It allows you to call a large portion of the Chrono API using Python scripting.

    Advantages:

    • Simplicity and interpreted nature.
    • Easy integration with third-party modules like Matplotlib (plotting) and NumPy (algebra).
    • Minimal installation requirements.

    Disadvantages:

    • Slower execution speed compared to C++.
    • Does not cover the entire C++ API surface.

  11. Overview of Project CHRONO capabilities

    main

    Project CHRONO is an open-source multi-physics package designed for modeling and simulating complex physical systems. It supports:

    • Rigid Body Dynamics: Large systems of connected rigid bodies governed by differential-algebraic equations (DAE).
    • Deformable Body Dynamics: Bodies governed by partial differential equations (PDE).
    • Granular Dynamics: Uses non-smooth contact formulations (DVI) or smooth contact formulations (DAE).
    • Fluid-Solid Interaction (FSI): Coupled DAE and PDE dynamics.
    • First-order Dynamic Systems: Systems governed by ordinary differential equations (ODE).
    • Robotics Sensors: Simulation of camera, LiDAR, GPS, IMU, and SPAD sensors via a ROS2 interface.

    The core engine provides multibody system modeling, visualization, and simulation, with optional modules for specialized tasks like ground vehicle simulation, robotics, co-simulation, and parallel computing (multi-core, GPU, and distributed).