Template Class DifferentialActionModelAbstractTpl

Defined in File diff-action-base.hpp

Inheritance Relationships

Base Type

public crocoddyl::DifferentialActionModelBase (Class DifferentialActionModelBase)

Derived Types

public crocoddyl::DifferentialActionModelContactFwdDynamicsTpl< _Scalar > (Template Class DifferentialActionModelContactFwdDynamicsTpl)
public crocoddyl::DifferentialActionModelContactInvDynamicsTpl< _Scalar > (Template Class DifferentialActionModelContactInvDynamicsTpl)
public crocoddyl::DifferentialActionModelFreeFwdDynamicsTpl< _Scalar > (Template Class DifferentialActionModelFreeFwdDynamicsTpl)
public crocoddyl::DifferentialActionModelFreeInvDynamicsTpl< _Scalar > (Template Class DifferentialActionModelFreeInvDynamicsTpl)
public crocoddyl::DifferentialActionModelLQRTpl< _Scalar > (Template Class DifferentialActionModelLQRTpl)
public crocoddyl::DifferentialActionModelNumDiffTpl< _Scalar > (Template Class DifferentialActionModelNumDiffTpl)

Class Documentation

template<typename _Scalar> class DifferentialActionModelAbstractTpl : public crocoddyl::DifferentialActionModelBase 

Abstract class for differential action model.

A differential action model combines dynamics, cost and constraints models. We can use it in each node of our optimal control problem thanks to dedicated integration rules (e.g., IntegratedActionModelEulerTpl or IntegratedActionModelRKTpl). These integrated action models produce action models (ActionModelAbstractTpl). Thus, every time that we want to describe a problem, we need to provide ways of computing the dynamics, cost, constraints functions and their derivatives. All these are described inside the differential action model.

Concretely speaking, the differential action model is the time-continuous version of an action model, i.e.,

\[\begin{split} \begin{aligned} &\dot{\mathbf{v}} = \mathbf{f}(\mathbf{q}, \mathbf{v}, \mathbf{u}), &\textrm{(dynamics)}\\ &\ell(\mathbf{q}, \mathbf{v},\mathbf{u}) = \int_0^{\delta t} a(\mathbf{r}(\mathbf{q}, \mathbf{v},\mathbf{u}))\,dt, &\textrm{(cost)}\\ &\mathbf{g}(\mathbf{q}, \mathbf{v},\mathbf{u})<\mathbf{0}, &\textrm{(inequality constraint)}\\ &\mathbf{h}(\mathbf{q}, \mathbf{v},\mathbf{u})=\mathbf{0}, &\textrm{(equality constraint)} \end{aligned} \end{split}\]

where

the configuration \(\mathbf{q}\in\mathcal{Q}\) lies in the configuration manifold described with a nq-tuple,
the velocity \(\mathbf{v}\in T_{\mathbf{q}}\mathcal{Q}\) is the tangent vector to the configuration manifold with nv dimension,
the control input \(\mathbf{u}\in\mathbb{R}^{nu}\) is an Euclidean vector,
\(\mathbf{r}(\cdot)\) and \(a(\cdot)\) are the residual and activation functions (see ResidualModelAbstractTpl and ActivationModelAbstractTpl, respectively),
\(\mathbf{g}(\cdot)\in\mathbb{R}^{ng}\) and \(\mathbf{h}(\cdot)\in\mathbb{R}^{nh}\) are the inequality and equality vector functions, respectively.

Both configuration and velocity describe the system space \(\mathbf{x}=(\mathbf{q}, \mathbf{v})\in\mathcal{X}\) which lies in the state manifold. Note that the acceleration \(\dot{\mathbf{v}}\in T_{\mathbf{q}}\mathcal{Q}\) lies also in the tangent space of the configuration manifold. The computation of these equations are carried out inside calc() function. In short, this function computes the system acceleration, cost and constraints values (also called constraints violations). This procedure is equivalent to running a forward pass of the action model.

However, during numerical optimization, we also need to run backward passes of the differential action model. These calculations are performed by calcDiff(). In short, this function builds a linear-quadratic approximation of the differential action model, i.e.,

\[\begin{split} \begin{aligned} &\delta\dot{\mathbf{v}} = \mathbf{f_{q}}\delta\mathbf{q}+\mathbf{f_{v}}\delta\mathbf{v}+\mathbf{f_{u}}\delta\mathbf{u}, &\textrm{(dynamics)}\\ &\ell(\delta\mathbf{q},\delta\mathbf{v},\delta\mathbf{u}) = \begin{bmatrix}1 \\ \delta\mathbf{q} \\ \delta\mathbf{v} \\ \delta\mathbf{u}\end{bmatrix}^T \begin{bmatrix}0 & \mathbf{\ell_q}^T & \mathbf{\ell_v}^T & \mathbf{\ell_u}^T \\ \mathbf{\ell_q} & \mathbf{\ell_{qq}} & \mathbf{\ell_{qv}} & \mathbf{\ell_{uq}}^T \\ \mathbf{\ell_v} & \mathbf{\ell_{vq}} & \mathbf{\ell_{vv}} & \mathbf{\ell_{uv}}^T \\ \mathbf{\ell_u} & \mathbf{\ell_{uq}} & \mathbf{\ell_{uv}} & \mathbf{\ell_{uu}}\end{bmatrix} \begin{bmatrix}1 \\ \delta\mathbf{q} \\ \delta\mathbf{v} \\ \delta\mathbf{u}\end{bmatrix}, &\textrm{(cost)}\\ &\mathbf{g_q}\delta\mathbf{q}+\mathbf{g_v}\delta\mathbf{v}+\mathbf{g_u}\delta\mathbf{u}\leq\mathbf{0}, &\textrm{(inequality constraints)}\\ &\mathbf{h_q}\delta\mathbf{q}+\mathbf{h_v}\delta\mathbf{v}+\mathbf{h_u}\delta\mathbf{u}=\mathbf{0}, &\textrm{(equality constraints)} \end{aligned} \end{split}\]

where

\(\mathbf{f_x}=(\mathbf{f_q};\,\, \mathbf{f_v})\in\mathbb{R}^{nv\times ndx}\) and \(\mathbf{f_u}\in\mathbb{R}^{nv\times nu}\) are the Jacobians of the dynamics,
\(\mathbf{\ell_x}=(\mathbf{\ell_q};\,\, \mathbf{\ell_v})\in\mathbb{R}^{ndx}\) and \(\mathbf{\ell_u}\in\mathbb{R}^{nu}\) are the Jacobians of the cost function,
\(\mathbf{\ell_{xx}}=(\mathbf{\ell_{qq}}\,\, \mathbf{\ell_{qv}};\,\, \mathbf{\ell_{vq}}\, \mathbf{\ell_{vv}})\in\mathbb{R}^{ndx\times ndx}\), \(\mathbf{\ell_{xu}}=(\mathbf{\ell_q};\,\, \mathbf{\ell_v})\in\mathbb{R}^{ndx\times nu}\) and \(\mathbf{\ell_{uu}}\in\mathbb{R}^{nu\times nu}\) are the Hessians of the cost function,
\(\mathbf{g_x}=(\mathbf{g_q};\,\, \mathbf{g_v})\in\mathbb{R}^{ng\times ndx}\) and \(\mathbf{g_u}\in\mathbb{R}^{ng\times nu}\) are the Jacobians of the inequality constraints, and
\(\mathbf{h_x}=(\mathbf{h_q};\,\, \mathbf{h_v})\in\mathbb{R}^{nh\times ndx}\) and \(\mathbf{h_u}\in\mathbb{R}^{nh\times nu}\) are the Jacobians of the equality constraints.

Additionally, it is important to note that calcDiff() computes the derivatives using the latest stored values by calc(). Thus, we need to first run calc().