Ungar $\unicode{x2013}$ A C++ Framework for Real-Time Optimal Control Using Template Metaprogramming (2309.06783v2)

Abstract: We present Ungar, an open-source library to aid the implementation of high-dimensional optimal control problems (OCPs). We adopt modern template metaprogramming techniques to enable the compile-time modeling of complex systems while retaining maximum runtime efficiency. Our framework provides syntactic sugar to allow for expressive formulations of a rich set of structured dynamical systems. While the core modules depend only on the header-only Eigen and Boost.Hana libraries, we bundle our codebase with optional packages and custom wrappers for automatic differentiation, code generation, and nonlinear programming. Finally, we demonstrate the versatility of Ungar in various model predictive control applications, namely, four-legged locomotion and collaborative loco-manipulation with multiple one-armed quadruped robots. Ungar is available under the Apache License 2.0 at https://github.com/fdevinc/ungar.

• The paper introduces Ungar, a novel framework that leverages template metaprogramming to enable compile-time modeling and runtime efficiency in solving optimal control problems.
• It details an architecture based on header-only libraries like Eigen and Boost.Hana, reducing runtime overhead and streamlining integration into C++ projects.
• Real-world cases in quadrupedal locomotion and collaborative robot manipulation demonstrate Ungar's adaptability and potential for future robust control applications.

Overview of "Ungar – A C++ Framework for Real-Time Optimal Control Using Template Metaprogramming"

The paper "Ungar – A C++ Framework for Real-Time Optimal Control Using Template Metaprogramming" introduces Ungar, a sophisticated software framework designed to address the complexities inherent in implementing high-dimensional optimal control problems (OCPs). Authored by Flavio De Vincenti and Stelian Coros, this paper details the framework’s architecture, functionality, and applications, emphasizing its novel use of template metaprogramming (TMP) to achieve both compile-time modeling and runtime efficiency for real-time control applications.

Framework Architecture

Ungar is developed to facilitate the solution of model predictive control (MPC) problems that require high-dimensional computations at real-time speeds. Such problems are typical in robotics, where fast and accurate control is mandatory. The framework is written in C++ and utilizes modern template metaprogramming techniques, allowing for complex systems to be modeled at compile time. This approach significantly reduces runtime overhead and enhances performance, which is crucial for applications requiring rapid decision-making.

Ungar’s core functionality relies solely on header-only libraries—specifically Eigen and Boost.Hana—which further simplifies its integration into existing C++ projects without the need for extensive external dependencies. The framework also supports additional tools for automatic differentiation and nonlinear programming through optional modules.

Core Features and Methodologies

1. Template Metaprogramming (TMP): Ungar leverages TMP to construct data structures that facilitate the modeling of optimal control problems. This design choice enables the static definition of variable hierarchies and ensures that operations such as variable access and manipulation incur minimal runtime costs.
2. Variable and Map Structures: The framework introduces a robust design for defining both "leaf" and "branch" variables, structuring how state and control variables interrelate in hierarchical systems. These constructs are synthesized into efficient data mappings using Eigen’s mapping capabilities, allowing for seamless interaction with raw data buffers.
3. Efficient Handling of OCPs: The paper illustrates Ungar's efficiency by showcasing implementations for quadrupedal locomotion and collaborative loco-manipulation. The framework's adaptability shines in its ability to handle different robotic configurations with minimal code adjustments.

Practical Implications and Experimental Validation

The paper demonstrates Ungar’s versatility in real-world scenarios through two MPC applications: a quadrupedal locomotion controller and a cooperative manipulation controller for multi-agent robotic systems. The former adapts the single rigid body dynamics model for dynamic gait optimization, while the latter extends it to manage multiple robots collaborating on shared tasks.

Performance benchmarking underscores the framework’s capability to manage compile-time and runtime efficiencies effectively. Ungar's lazy-map variant offers improved compile-time performance, making it suitable for early-stage development and prototyping. However, for optimized runtime performance, utilizing the fully-realized variable maps is recommended.

Theoretical and Future Prospects

Theoretically, Ungar’s approach sets a precedent for computational efficiency in real-time optimal control applications. The TMP paradigm, while demanding in terms of compiler resource consumption, provides a blueprint for future frameworks seeking to optimize high-dimensional control problem implementations.

The paper suggests several avenues for future work, including optimizing the compile-time aspects of the framework and expanding its utility beyond MPC into more generalized nonlinear programming scenarios. Moreover, there is potential for advancing the theoretical underpinnings of TMP in control applications, exploring how these methods could be extended or refined to support emerging computational needs in robotics and beyond.

In conclusion, Ungar represents a significant advancement in the intersection of control theory and software engineering, providing a highly adaptable and efficient framework for real-time optimal control. Its innovative use of TMP underscores the importance of compiler efficiency in addressing the computational challenges of modern robotic applications.