openpilot v0.9.6 release

date: 2024-02-21T23:02:42
master commit: 0b4d08fab8e35a264bc7383e878538f8083c33e5

third_party/acados/acados_template/c_templates_tera/CMakeLists.in.txt

@@ -0,0 +1,397 @@
+#
+# Copyright (c) The acados authors.
+#
+# This file is part of acados.
+#
+# The 2-Clause BSD License
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.;
+#
+
+{%- if solver_options.qp_solver %}
+	{%- set qp_solver = solver_options.qp_solver %}
+{%- else %}
+	{%- set qp_solver = "FULL_CONDENSING_HPIPM" %}
+{%- endif %}
+
+{%- if solver_options.hessian_approx %}
+	{%- set hessian_approx = solver_options.hessian_approx %}
+{%- elif solver_options.sens_hess %}
+	{%- set hessian_approx = "EXACT" %}
+{%- else %}
+	{%- set hessian_approx = "GAUSS_NEWTON" %}
+{%- endif %}
+
+{%- if constraints.constr_type %}
+	{%- set constr_type = constraints.constr_type %}
+{%- else %}
+	{%- set constr_type = "NONE" %}
+{%- endif %}
+
+{%- if constraints.constr_type_e %}
+	{%- set constr_type_e = constraints.constr_type_e %}
+{%- else %}
+	{%- set constr_type_e = "NONE" %}
+{%- endif %}
+
+{%- if cost.cost_type %}
+	{%- set cost_type = cost.cost_type %}
+{%- else %}
+	{%- set cost_type = "NONE" %}
+{%- endif %}
+
+{%- if cost.cost_type_e %}
+	{%- set cost_type_e = cost.cost_type_e %}
+{%- else %}
+	{%- set cost_type_e = "NONE" %}
+{%- endif %}
+
+{%- if cost.cost_type_0 %}
+	{%- set cost_type_0 = cost.cost_type_0 %}
+{%- else %}
+	{%- set cost_type_0 = "NONE" %}
+{%- endif %}
+
+{%- if dims.nh %}
+	{%- set dims_nh = dims.nh %}
+{%- else %}
+	{%- set dims_nh = 0 %}
+{%- endif %}
+
+{%- if dims.nphi %}
+	{%- set dims_nphi = dims.nphi %}
+{%- else %}
+	{%- set dims_nphi = 0 %}
+{%- endif %}
+
+{%- if dims.nh_e %}
+	{%- set dims_nh_e = dims.nh_e %}
+{%- else %}
+	{%- set dims_nh_e = 0 %}
+{%- endif %}
+
+{%- if dims.nphi_e %}
+	{%- set dims_nphi_e = dims.nphi_e %}
+{%- else %}
+	{%- set dims_nphi_e = 0 %}
+{%- endif %}
+
+{%- if solver_options.model_external_shared_lib_dir %}
+	{%- set model_external_shared_lib_dir = solver_options.model_external_shared_lib_dir %}
+{%- endif %}
+
+{%- if solver_options.model_external_shared_lib_name %}
+	{%- set model_external_shared_lib_name = solver_options.model_external_shared_lib_name %}
+{%- endif %}
+
+{#- control operator #}
+{%- if os and os == "pc" %}
+	{%- set control = "&" %}
+{%- else %}
+	{%- set control = ";" %}
+{%- endif %}
+
+{%- if acados_link_libs and os and os == "pc" %}{# acados linking libraries and flags #}
+	{%- set link_libs = acados_link_libs.qpoases ~ " " ~ acados_link_libs.hpmpc ~ " " ~ acados_link_libs.osqp -%}
+	{%- set openmp_flag = acados_link_libs.openmp %}
+{%- else %}
+	{%- set openmp_flag = " " %}
+	{%- if qp_solver == "FULL_CONDENSING_QPOASES" %}
+		{%- set link_libs = "-lqpOASES_e" %}
+	{%- elif qp_solver == "FULL_CONDENSING_DAQP" %}
+		{%- set link_libs = "-ldaqp" %}
+	{%- else %}
+		{%- set link_libs = "" %}
+	{%- endif %}
+{%- endif %}
+
+cmake_minimum_required(VERSION 3.13)
+
+project({{ model.name }})
+
+# build options.
+option(BUILD_ACADOS_SOLVER_LIB "Should the solver library acados_solver_{{ model.name }} be build?" OFF)
+option(BUILD_ACADOS_OCP_SOLVER_LIB "Should the OCP solver library acados_ocp_solver_{{ model.name }} be build?" OFF)
+option(BUILD_EXAMPLE "Should the example main_{{ model.name }} be build?" OFF)
+{%- if solver_options.integrator_type != "DISCRETE" %}
+option(BUILD_SIM_EXAMPLE "Should the simulation example main_sim_{{ model.name }} be build?" OFF)
+option(BUILD_ACADOS_SIM_SOLVER_LIB "Should the simulation solver library acados_sim_solver_{{ model.name }} be build?" OFF)
+{%- endif %}
+
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND CMAKE_SYSTEM_NAME MATCHES "Windows")
+    # MinGW, change to .lib such that mex recognizes it
+    set(CMAKE_SHARED_LIBRARY_SUFFIX ".lib")
+    set(CMAKE_SHARED_LIBRARY_PREFIX "")
+endif()
+
+
+# object target names
+set(MODEL_OBJ model_{{ model.name }})
+set(OCP_OBJ ocp_{{ model.name }})
+set(SIM_OBJ sim_{{ model.name }})
+
+# model
+set(MODEL_SRC
+	{%- if model.dyn_ext_fun_type == "casadi" %}
+{%- if  solver_options.integrator_type == "ERK" %}
+    {{ model.name }}_model/{{ model.name }}_expl_ode_fun.c
+    {{ model.name }}_model/{{ model.name }}_expl_vde_forw.c
+    {{ model.name }}_model/{{ model.name }}_expl_vde_adj.c
+	{%- if hessian_approx == "EXACT" %}
+    {{ model.name }}_model/{{ model.name }}_expl_ode_hess.c
+	{%- endif %}
+{%- elif solver_options.integrator_type == "IRK" %}
+    {{ model.name }}_model/{{ model.name }}_impl_dae_fun.c
+    {{ model.name }}_model/{{ model.name }}_impl_dae_fun_jac_x_xdot_z.c
+    {{ model.name }}_model/{{ model.name }}_impl_dae_jac_x_xdot_u_z.c
+	{%- if hessian_approx == "EXACT" %}
+    {{ model.name }}_model/{{ model.name }}_impl_dae_hess.c
+	{%- endif %}
+{%- elif solver_options.integrator_type == "LIFTED_IRK" %}
+    {{ model.name }}_model/{{ model.name }}_impl_dae_fun.c
+    {{ model.name }}_model/{{ model.name }}_impl_dae_fun_jac_x_xdot_u.c
+	{%- if hessian_approx == "EXACT" %}
+    {{ model.name }}_model/{{ model.name }}_impl_dae_hess.c
+	{%- endif %}
+{%- elif solver_options.integrator_type == "GNSF" %}
+	{% if model.gnsf.purely_linear != 1 %}
+    {{ model.name }}_model/{{ model.name }}_gnsf_phi_fun.c
+    {{ model.name }}_model/{{ model.name }}_gnsf_phi_fun_jac_y.c
+    {{ model.name }}_model/{{ model.name }}_gnsf_phi_jac_y_uhat.c
+		{% if model.gnsf.nontrivial_f_LO == 1 %}
+    {{ model.name }}_model/{{ model.name }}_gnsf_f_lo_fun_jac_x1k1uz.c
+		{%- endif %}
+	{%- endif %}
+    {{ model.name }}_model/{{ model.name }}_gnsf_get_matrices_fun.c
+{%- elif solver_options.integrator_type == "DISCRETE" %}
+    {{ model.name }}_model/{{ model.name }}_dyn_disc_phi_fun.c
+    {{ model.name }}_model/{{ model.name }}_dyn_disc_phi_fun_jac.c
+		{%- if hessian_approx == "EXACT" %}
+    {{ model.name }}_model/{{ model.name }}_dyn_disc_phi_fun_jac_hess.c
+		{%- endif %}
+{%- endif -%}
+	{%- else %}
+    {{ model.name }}_model/{{ model.dyn_generic_source }}
+	{%- endif %}
+)
+add_library(${MODEL_OBJ} OBJECT ${MODEL_SRC} )
+
+# optimal control problem - mostly CasADi exports
+if(${BUILD_ACADOS_SOLVER_LIB} OR ${BUILD_ACADOS_OCP_SOLVER_LIB} OR ${BUILD_EXAMPLE})
+    set(OCP_SRC
+{%- if constr_type == "BGP" and dims_nphi > 0 %}
+        {{ model.name }}_constraints/{{ model.name }}_phi_constraint.c
+{%- endif %}
+{%- if constr_type_e == "BGP" and dims_nphi_e > 0 %}
+        {{ model.name }}_constraints/{{ model.name }}_phi_e_constraint.c
+{%- endif %}
+
+{%- if constr_type == "BGH" and dims_nh > 0 %}
+        {{ model.name }}_constraints/{{ model.name }}_constr_h_fun_jac_uxt_zt.c
+        {{ model.name }}_constraints/{{ model.name }}_constr_h_fun.c
+    {%- if hessian_approx == "EXACT" %}
+        {{ model.name }}_constraints/{{ model.name }}_constr_h_fun_jac_uxt_zt_hess.c
+    {%- endif %}
+{%- endif %}
+
+{%- if constr_type_e == "BGH" and dims_nh_e > 0 %}
+        {{ model.name }}_constraints/{{ model.name }}_constr_h_e_fun_jac_uxt_zt.c
+        {{ model.name }}_constraints/{{ model.name }}_constr_h_e_fun.c
+    {%- if hessian_approx == "EXACT" %}
+        {{ model.name }}_constraints/{{ model.name }}_constr_h_e_fun_jac_uxt_zt_hess.c
+    {%- endif %}
+{%- endif %}
+
+{%- if cost_type_0 == "NONLINEAR_LS" %}
+        {{ model.name }}_cost/{{ model.name }}_cost_y_0_fun.c
+        {{ model.name }}_cost/{{ model.name }}_cost_y_0_fun_jac_ut_xt.c
+        {{ model.name }}_cost/{{ model.name }}_cost_y_0_hess.c
+{%- elif cost_type_0 == "CONVEX_OVER_NONLINEAR" %}
+        {{ model.name }}_cost/{{ model.name }}_conl_cost_0_fun.c
+        {{ model.name }}_cost/{{ model.name }}_conl_cost_0_fun_jac_hess.c
+{%- elif cost_type_0 == "EXTERNAL" %}
+    {%- if cost.cost_ext_fun_type_0 == "casadi" %}
+        {{ model.name }}_cost/{{ model.name }}_cost_ext_cost_0_fun.c
+        {{ model.name }}_cost/{{ model.name }}_cost_ext_cost_0_fun_jac.c
+        {{ model.name }}_cost/{{ model.name }}_cost_ext_cost_0_fun_jac_hess.c
+    {%- else %}
+        {{ model.name }}_cost/{{ cost.cost_source_ext_cost_0 }}
+    {%- endif %}
+{%- endif %}
+{%- if cost_type == "NONLINEAR_LS" %}
+        {{ model.name }}_cost/{{ model.name }}_cost_y_fun.c
+        {{ model.name }}_cost/{{ model.name }}_cost_y_fun_jac_ut_xt.c
+        {{ model.name }}_cost/{{ model.name }}_cost_y_hess.c
+{%- elif cost_type == "CONVEX_OVER_NONLINEAR" %}
+        {{ model.name }}_cost/{{ model.name }}_conl_cost_fun.c
+        {{ model.name }}_cost/{{ model.name }}_conl_cost_fun_jac_hess.c
+{%- elif cost_type == "EXTERNAL" %}
+    {%- if cost.cost_ext_fun_type == "casadi" %}
+        {{ model.name }}_cost/{{ model.name }}_cost_ext_cost_fun.c
+        {{ model.name }}_cost/{{ model.name }}_cost_ext_cost_fun_jac.c
+        {{ model.name }}_cost/{{ model.name }}_cost_ext_cost_fun_jac_hess.c
+    {%- elif cost.cost_source_ext_cost != cost.cost_source_ext_cost_0 %}
+        {{ model.name }}_cost/{{ cost.cost_source_ext_cost }}
+    {%- endif %}
+{%- endif %}
+{%- if cost_type_e == "NONLINEAR_LS" %}
+        {{ model.name }}_cost/{{ model.name }}_cost_y_e_fun.c
+        {{ model.name }}_cost/{{ model.name }}_cost_y_e_fun_jac_ut_xt.c
+        {{ model.name }}_cost/{{ model.name }}_cost_y_e_hess.c
+{%- elif cost_type_e == "CONVEX_OVER_NONLINEAR" %}
+        {{ model.name }}_cost/{{ model.name }}_conl_cost_e_fun.c
+        {{ model.name }}_cost/{{ model.name }}_conl_cost_e_fun_jac_hess.c
+{%- elif cost_type_e == "EXTERNAL" %}
+    {%- if cost.cost_ext_fun_type_e == "casadi" %}
+        {{ model.name }}_cost/{{ model.name }}_cost_ext_cost_e_fun.c
+        {{ model.name }}_cost/{{ model.name }}_cost_ext_cost_e_fun_jac.c
+        {{ model.name }}_cost/{{ model.name }}_cost_ext_cost_e_fun_jac_hess.c
+    {%- elif cost.cost_source_ext_cost_e != cost.cost_source_ext_cost_0 %}
+        {{ model.name }}_cost/{{ cost.cost_source_ext_cost_e }}
+    {%- endif %}
+{%- endif %}
+        acados_solver_{{ model.name }}.c)
+    add_library(${OCP_OBJ} OBJECT ${OCP_SRC})
+endif()
+
+{%- if solver_options.integrator_type != "DISCRETE" %}
+# for sim solver
+if(${BUILD_ACADOS_SOLVER_LIB} OR ${BUILD_EXAMPLE}
+    {%- if solver_options.integrator_type != "DISCRETE" %}
+    OR ${BUILD_SIM_EXAMPLE} OR ${BUILD_ACADOS_SIM_SOLVER_LIB}
+    {%- endif -%}
+    )
+    set(SIM_SRC acados_sim_solver_{{ model.name }}.c)
+    add_library(${SIM_OBJ} OBJECT ${SIM_SRC})
+endif()
+{%- endif %}
+
+# for target example
+set(EX_SRC main_{{ model.name }}.c)
+set(EX_EXE main_{{ model.name }})
+
+{%- if model_external_shared_lib_dir and model_external_shared_lib_name %}
+set(EXTERNAL_DIR {{ model_external_shared_lib_dir | replace(from="\", to="/")  }})
+set(EXTERNAL_LIB {{ model_external_shared_lib_name }})
+{%- else %}
+set(EXTERNAL_DIR)
+set(EXTERNAL_LIB)
+{%- endif %}
+
+# set some search paths for preprocessor and linker
+set(ACADOS_INCLUDE_PATH {{ acados_include_path | replace(from="\", to="/")  }} CACHE PATH "Define the path which contains the include directory for acados.")
+set(ACADOS_LIB_PATH {{ acados_lib_path | replace(from="\", to="/") }} CACHE PATH "Define the path which contains the lib directory for acados.")
+
+# c-compiler flags for debugging
+set(CMAKE_C_FLAGS_DEBUG "-O0 -ggdb")
+
+set(CMAKE_C_FLAGS "-fPIC -std=c99 {{ openmp_flag }}
+{%- if qp_solver == "FULL_CONDENSING_QPOASES" -%}
+    -DACADOS_WITH_QPOASES
+{%- endif -%}
+{%- if qp_solver == "FULL_CONDENSING_DAQP" -%}
+    -DACADOS_WITH_DAQP
+{%- endif -%}
+{%- if qp_solver == "PARTIAL_CONDENSING_OSQP" -%}
+    -DACADOS_WITH_OSQP
+{%- endif -%}
+{%- if qp_solver == "PARTIAL_CONDENSING_QPDUNES" -%}
+    -DACADOS_WITH_QPDUNES
+{%- endif -%}
+")
+#-fno-diagnostics-show-line-numbers -g
+
+include_directories(
+   ${ACADOS_INCLUDE_PATH}
+   ${ACADOS_INCLUDE_PATH}/acados
+   ${ACADOS_INCLUDE_PATH}/blasfeo/include
+   ${ACADOS_INCLUDE_PATH}/hpipm/include
+{%- if qp_solver == "FULL_CONDENSING_QPOASES" %}
+   ${ACADOS_INCLUDE_PATH}/qpOASES_e/
+{%- endif %}
+{%- if qp_solver == "FULL_CONDENSING_DAQP" %}
+   ${ACADOS_INCLUDE_PATH}/daqp/include
+{%- endif %}
+)
+
+# linker flags
+link_directories(${ACADOS_LIB_PATH})
+
+# link to libraries
+if(UNIX)
+    link_libraries(acados hpipm blasfeo m {{ link_libs }})
+else()
+    link_libraries(acados hpipm blasfeo {{ link_libs }})
+endif()
+
+# the targets
+
+# bundled_shared_lib
+if(${BUILD_ACADOS_SOLVER_LIB})
+    set(LIB_ACADOS_SOLVER acados_solver_{{ model.name }})
+    add_library(${LIB_ACADOS_SOLVER} SHARED $<TARGET_OBJECTS:${MODEL_OBJ}> $<TARGET_OBJECTS:${OCP_OBJ}>
+    {%- if solver_options.integrator_type != "DISCRETE" %}
+        $<TARGET_OBJECTS:${SIM_OBJ}>
+    {%- endif -%}
+    )
+    install(TARGETS ${LIB_ACADOS_SOLVER} DESTINATION ${CMAKE_INSTALL_PREFIX})
+endif(${BUILD_ACADOS_SOLVER_LIB})
+
+# ocp_shared_lib
+if(${BUILD_ACADOS_OCP_SOLVER_LIB})
+    set(LIB_ACADOS_OCP_SOLVER acados_ocp_solver_{{ model.name }})
+    add_library(${LIB_ACADOS_OCP_SOLVER} SHARED $<TARGET_OBJECTS:${MODEL_OBJ}> $<TARGET_OBJECTS:${OCP_OBJ}>)
+    # Specify libraries or flags to use when linking a given target and/or its dependents.
+    target_link_libraries(${LIB_ACADOS_OCP_SOLVER} PRIVATE ${EXTERNAL_LIB})
+    target_link_directories(${LIB_ACADOS_OCP_SOLVER} PRIVATE ${EXTERNAL_DIR})
+    install(TARGETS ${LIB_ACADOS_OCP_SOLVER} DESTINATION ${CMAKE_INSTALL_PREFIX})
+endif(${BUILD_ACADOS_OCP_SOLVER_LIB})
+
+# example
+if(${BUILD_EXAMPLE})
+    add_executable(${EX_EXE} ${EX_SRC} $<TARGET_OBJECTS:${MODEL_OBJ}> $<TARGET_OBJECTS:${OCP_OBJ}>
+    {%- if solver_options.integrator_type != "DISCRETE" %}
+        $<TARGET_OBJECTS:${SIM_OBJ}>
+    {%- endif -%}
+    )
+    install(TARGETS ${EX_EXE} DESTINATION ${CMAKE_INSTALL_PREFIX})
+endif(${BUILD_EXAMPLE})
+
+{% if solver_options.integrator_type != "DISCRETE" -%}
+# example_sim
+if(${BUILD_SIM_EXAMPLE})
+    set(EX_SIM_SRC main_sim_{{ model.name }}.c)
+    set(EX_SIM_EXE main_sim_{{ model.name }})
+    add_executable(${EX_SIM_EXE} ${EX_SIM_SRC} $<TARGET_OBJECTS:${MODEL_OBJ}> $<TARGET_OBJECTS:${SIM_OBJ}>)
+    install(TARGETS ${EX_SIM_EXE} DESTINATION ${CMAKE_INSTALL_PREFIX})
+endif(${BUILD_SIM_EXAMPLE})
+
+# sim_shared_lib
+if(${BUILD_ACADOS_SIM_SOLVER_LIB})
+    set(LIB_ACADOS_SIM_SOLVER acados_sim_solver_{{ model.name }})
+    add_library(${LIB_ACADOS_SIM_SOLVER} SHARED $<TARGET_OBJECTS:${MODEL_OBJ}> $<TARGET_OBJECTS:${SIM_OBJ}>)
+    install(TARGETS ${LIB_ACADOS_SIM_SOLVER} DESTINATION ${CMAKE_INSTALL_PREFIX})
+endif(${BUILD_ACADOS_SIM_SOLVER_LIB})
+{%- endif %}
+

third_party/acados/acados_template/c_templates_tera/Makefile.in

@@ -0,0 +1,468 @@
+#
+# Copyright (c) The acados authors.
+#
+# This file is part of acados.
+#
+# The 2-Clause BSD License
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.;
+#
+
+{%- if solver_options.qp_solver %}
+	{%- set qp_solver = solver_options.qp_solver %}
+{%- else %}
+	{%- set qp_solver = "FULL_CONDENSING_HPIPM" %}
+{%- endif %}
+
+{%- if solver_options.hessian_approx %}
+	{%- set hessian_approx = solver_options.hessian_approx %}
+{%- elif solver_options.sens_hess %}
+	{%- set hessian_approx = "EXACT" %}
+{%- else %}
+	{%- set hessian_approx = "GAUSS_NEWTON" %}
+{%- endif %}
+
+{%- if constraints.constr_type %}
+	{%- set constr_type = constraints.constr_type %}
+{%- else %}
+	{%- set constr_type = "NONE" %}
+{%- endif %}
+
+{%- if constraints.constr_type_e %}
+	{%- set constr_type_e = constraints.constr_type_e %}
+{%- else %}
+	{%- set constr_type_e = "NONE" %}
+{%- endif %}
+
+{%- if cost.cost_type %}
+	{%- set cost_type = cost.cost_type %}
+{%- else %}
+	{%- set cost_type = "NONE" %}
+{%- endif %}
+
+{%- if cost.cost_type_e %}
+	{%- set cost_type_e = cost.cost_type_e %}
+{%- else %}
+	{%- set cost_type_e = "NONE" %}
+{%- endif %}
+
+{%- if cost.cost_type_0 %}
+	{%- set cost_type_0 = cost.cost_type_0 %}
+{%- else %}
+	{%- set cost_type_0 = "NONE" %}
+{%- endif %}
+
+{%- if dims.nh %}
+	{%- set dims_nh = dims.nh %}
+{%- else %}
+	{%- set dims_nh = 0 %}
+{%- endif %}
+
+{%- if dims.nphi %}
+	{%- set dims_nphi = dims.nphi %}
+{%- else %}
+	{%- set dims_nphi = 0 %}
+{%- endif %}
+
+{%- if dims.nh_e %}
+	{%- set dims_nh_e = dims.nh_e %}
+{%- else %}
+	{%- set dims_nh_e = 0 %}
+{%- endif %}
+
+{%- if dims.nphi_e %}
+	{%- set dims_nphi_e = dims.nphi_e %}
+{%- else %}
+	{%- set dims_nphi_e = 0 %}
+{%- endif %}
+{%- if solver_options.model_external_shared_lib_dir %}
+	{%- set model_external_shared_lib_dir = solver_options.model_external_shared_lib_dir %}
+{%- endif %}
+{%- if solver_options.model_external_shared_lib_name %}
+	{%- set model_external_shared_lib_name = solver_options.model_external_shared_lib_name %}
+{%- endif %}
+
+{# control operator #}
+{%- if os and os == "pc" %}
+	{%- set control = "&" %}
+{%- else %}
+	{%- set control = ";" %}
+{%- endif %}
+
+{# acados linking libraries and flags #}
+{%- if acados_link_libs and os and os == "pc" %}
+	{%- set link_libs = acados_link_libs.qpoases ~ " " ~ acados_link_libs.hpmpc ~ " " ~ acados_link_libs.osqp -%}
+	{%- set openmp_flag = acados_link_libs.openmp %}
+{%- else %}
+	{%- set openmp_flag = " " %}
+	{%- if qp_solver == "FULL_CONDENSING_QPOASES" %}
+		{%- set link_libs = "-lqpOASES_e" %}
+	{%- elif qp_solver == "FULL_CONDENSING_DAQP" %}
+		{%- set link_libs = "-ldaqp" %}
+	{%- else %}
+		{%- set link_libs = "" %}
+	{%- endif %}
+{%- endif %}
+
+# define sources and use make's implicit rules to generate object files (*.o)
+
+# model
+MODEL_SRC=
+	{%- if model.dyn_ext_fun_type == "casadi" %}
+{%- if solver_options.integrator_type == "ERK" %}
+MODEL_SRC+= {{ model.name }}_model/{{ model.name }}_expl_ode_fun.c
+MODEL_SRC+= {{ model.name }}_model/{{ model.name }}_expl_vde_forw.c
+MODEL_SRC+= {{ model.name }}_model/{{ model.name }}_expl_vde_adj.c
+	{%- if hessian_approx == "EXACT" %}
+MODEL_SRC+= {{ model.name }}_model/{{ model.name }}_expl_ode_hess.c
+	{%- endif %}
+{%- elif solver_options.integrator_type == "IRK" %}
+MODEL_SRC+= {{ model.name }}_model/{{ model.name }}_impl_dae_fun.c
+MODEL_SRC+= {{ model.name }}_model/{{ model.name }}_impl_dae_fun_jac_x_xdot_z.c
+MODEL_SRC+= {{ model.name }}_model/{{ model.name }}_impl_dae_jac_x_xdot_u_z.c
+		{%- if hessian_approx == "EXACT" %}
+MODEL_SRC+= {{ model.name }}_model/{{ model.name }}_impl_dae_hess.c
+		{%- endif %}
+{%- elif solver_options.integrator_type == "LIFTED_IRK" %}
+MODEL_SRC+= {{ model.name }}_model/{{ model.name }}_impl_dae_fun.c
+MODEL_SRC+= {{ model.name }}_model/{{ model.name }}_impl_dae_fun_jac_x_xdot_u.c
+	{%- if hessian_approx == "EXACT" %}
+MODEL_SRC+= {{ model.name }}_model/{{ model.name }}_impl_dae_hess.c
+	{%- endif %}
+{%- elif solver_options.integrator_type == "GNSF" %}
+	{% if model.gnsf.purely_linear != 1 %}
+MODEL_SRC+= {{ model.name }}_model/{{ model.name }}_gnsf_phi_fun.c
+MODEL_SRC+= {{ model.name }}_model/{{ model.name }}_gnsf_phi_fun_jac_y.c
+MODEL_SRC+= {{ model.name }}_model/{{ model.name }}_gnsf_phi_jac_y_uhat.c
+		{% if model.gnsf.nontrivial_f_LO == 1 %}
+MODEL_SRC+= {{ model.name }}_model/{{ model.name }}_gnsf_f_lo_fun_jac_x1k1uz.c
+		{%- endif %}
+	{%- endif %}
+MODEL_SRC+= {{ model.name }}_model/{{ model.name }}_gnsf_get_matrices_fun.c
+{%- elif solver_options.integrator_type == "DISCRETE" %}
+MODEL_SRC+= {{ model.name }}_model/{{ model.name }}_dyn_disc_phi_fun.c
+MODEL_SRC+= {{ model.name }}_model/{{ model.name }}_dyn_disc_phi_fun_jac.c
+		{%- if hessian_approx == "EXACT" %}
+MODEL_SRC+= {{ model.name }}_model/{{ model.name }}_dyn_disc_phi_fun_jac_hess.c
+		{%- endif %}
+{%- endif %}
+	{%- else %}
+MODEL_SRC+= {{ model.name }}_model/{{ model.dyn_generic_source }}
+	{%- endif %}
+MODEL_OBJ := $(MODEL_SRC:.c=.o)
+
+# optimal control problem - mostly CasADi exports
+OCP_SRC=
+{%- if constr_type == "BGP" and dims_nphi > 0 %}
+OCP_SRC+= {{ model.name }}_constraints/{{ model.name }}_phi_constraint.c
+{%- endif %}
+{%- if constr_type_e == "BGP" and dims_nphi_e > 0 %}
+OCP_SRC+= {{ model.name }}_constraints/{{ model.name }}_phi_e_constraint.c
+{%- endif %}
+
+{%- if constr_type == "BGH" and dims_nh > 0 %}
+OCP_SRC+= {{ model.name }}_constraints/{{ model.name }}_constr_h_fun_jac_uxt_zt.c
+OCP_SRC+= {{ model.name }}_constraints/{{ model.name }}_constr_h_fun.c
+	{%- if hessian_approx == "EXACT" %}
+OCP_SRC+= {{ model.name }}_constraints/{{ model.name }}_constr_h_fun_jac_uxt_zt_hess.c
+	{%- endif %}
+{%- endif %}
+
+{%- if constr_type_e == "BGH" and dims_nh_e > 0 %}
+OCP_SRC+= {{ model.name }}_constraints/{{ model.name }}_constr_h_e_fun_jac_uxt_zt.c
+OCP_SRC+= {{ model.name }}_constraints/{{ model.name }}_constr_h_e_fun.c
+	{%- if hessian_approx == "EXACT" %}
+OCP_SRC+= {{ model.name }}_constraints/{{ model.name }}_constr_h_e_fun_jac_uxt_zt_hess.c
+	{%- endif %}
+{%- endif %}
+
+{%- if cost_type_0 == "NONLINEAR_LS" %}
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_cost_y_0_fun.c
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_cost_y_0_fun_jac_ut_xt.c
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_cost_y_0_hess.c
+{%- elif cost_type_0 == "CONVEX_OVER_NONLINEAR" %}
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_conl_cost_0_fun.c
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_conl_cost_0_fun_jac_hess.c
+{%- elif cost_type_0 == "EXTERNAL" %}
+	{%- if cost.cost_ext_fun_type_0 == "casadi" %}
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_cost_ext_cost_0_fun.c
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_cost_ext_cost_0_fun_jac.c
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_cost_ext_cost_0_fun_jac_hess.c
+	{%- else %}
+OCP_SRC+= {{ model.name }}_cost/{{ cost.cost_source_ext_cost_0 }}
+	{%- endif %}
+{%- endif %}
+{%- if cost_type == "NONLINEAR_LS" %}
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_cost_y_fun.c
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_cost_y_fun_jac_ut_xt.c
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_cost_y_hess.c
+{%- elif cost_type == "CONVEX_OVER_NONLINEAR" %}
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_conl_cost_fun.c
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_conl_cost_fun_jac_hess.c
+{%- elif cost_type == "EXTERNAL" %}
+	{%- if cost.cost_ext_fun_type == "casadi" %}
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_cost_ext_cost_fun.c
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_cost_ext_cost_fun_jac.c
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_cost_ext_cost_fun_jac_hess.c
+	{%- elif cost.cost_source_ext_cost != cost.cost_source_ext_cost_0 %}
+OCP_SRC+= {{ model.name }}_cost/{{ cost.cost_source_ext_cost }}
+	{%- endif %}
+{%- endif %}
+{%- if cost_type_e == "NONLINEAR_LS" %}
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_cost_y_e_fun.c
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_cost_y_e_fun_jac_ut_xt.c
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_cost_y_e_hess.c
+{%- elif cost_type_e == "CONVEX_OVER_NONLINEAR" %}
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_conl_cost_e_fun.c
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_conl_cost_e_fun_jac_hess.c
+{%- elif cost_type_e == "EXTERNAL" %}
+	{%- if cost.cost_ext_fun_type_e == "casadi" %}
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_cost_ext_cost_e_fun.c
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_cost_ext_cost_e_fun_jac.c
+OCP_SRC+= {{ model.name }}_cost/{{ model.name }}_cost_ext_cost_e_fun_jac_hess.c
+	{%- elif cost.cost_source_ext_cost_e != cost.cost_source_ext_cost_0 %}
+OCP_SRC+= {{ model.name }}_cost/{{ cost.cost_source_ext_cost_e }}
+	{%- endif %}
+{%- endif %}
+{%- if solver_options.custom_update_filename %}
+	{%- if solver_options.custom_update_filename != "" %}
+OCP_SRC+= {{ solver_options.custom_update_filename }}
+	{%- endif %}
+{%- endif %}
+
+OCP_SRC+= acados_solver_{{ model.name }}.c
+OCP_OBJ := $(OCP_SRC:.c=.o)
+
+# for sim solver
+SIM_SRC= acados_sim_solver_{{ model.name }}.c
+SIM_OBJ := $(SIM_SRC:.c=.o)
+
+# for target example
+EX_SRC= main_{{ model.name }}.c
+EX_OBJ := $(EX_SRC:.c=.o)
+EX_EXE := $(EX_SRC:.c=)
+
+# for target example_sim
+EX_SIM_SRC= main_sim_{{ model.name }}.c
+EX_SIM_OBJ := $(EX_SIM_SRC:.c=.o)
+EX_SIM_EXE := $(EX_SIM_SRC:.c=)
+
+# combine model, sim and ocp object files
+OBJ=
+OBJ+= $(MODEL_OBJ)
+{%- if solver_options.integrator_type != "DISCRETE" %}
+OBJ+= $(SIM_OBJ)
+{%- endif %}
+OBJ+= $(OCP_OBJ)
+
+EXTERNAL_DIR=
+EXTERNAL_LIB=
+
+{%- if model_external_shared_lib_dir and model_external_shared_lib_name %}
+EXTERNAL_DIR+= {{ model_external_shared_lib_dir  }}
+EXTERNAL_LIB+= {{ model_external_shared_lib_name }}
+{%- endif %}
+
+INCLUDE_PATH = {{ acados_include_path }}
+LIB_PATH = {{ acados_lib_path }}
+
+# preprocessor flags for make's implicit rules
+{%- if qp_solver == "FULL_CONDENSING_QPOASES" %}
+CPPFLAGS += -DACADOS_WITH_QPOASES
+{%- endif %}
+{%- if qp_solver == "FULL_CONDENSING_DAQP" %}
+CPPFLAGS += -DACADOS_WITH_DAQP
+{%- endif %}
+{%- if qp_solver == "PARTIAL_CONDENSING_OSQP" %}
+CPPFLAGS += -DACADOS_WITH_OSQP
+{%- endif %}
+{%- if qp_solver == "PARTIAL_CONDENSING_QPDUNES" %}
+CPPFLAGS += -DACADOS_WITH_QPDUNES
+{%- endif %}
+CPPFLAGS+= -I$(INCLUDE_PATH)
+CPPFLAGS+= -I$(INCLUDE_PATH)/acados
+CPPFLAGS+= -I$(INCLUDE_PATH)/blasfeo/include
+CPPFLAGS+= -I$(INCLUDE_PATH)/hpipm/include
+ {%- if qp_solver == "FULL_CONDENSING_QPOASES" %}
+CPPFLAGS+= -I $(INCLUDE_PATH)/qpOASES_e/
+ {%- endif %}
+ {%- if qp_solver == "FULL_CONDENSING_DAQP" %}
+CPPFLAGS+= -I $(INCLUDE_PATH)/daqp/include
+ {%- endif %}
+
+{# c-compiler flags #}
+# define the c-compiler flags for make's implicit rules
+CFLAGS = -fPIC -std=c99 {{ openmp_flag }} {{ solver_options.ext_fun_compile_flags }}#-fno-diagnostics-show-line-numbers -g
+# # Debugging
+# CFLAGS += -g3
+
+# linker flags
+LDFLAGS+= -L$(LIB_PATH)
+
+# link to libraries
+LDLIBS+= -lacados
+LDLIBS+= -lhpipm
+LDLIBS+= -lblasfeo
+LDLIBS+= -lm
+LDLIBS+= {{ link_libs }}
+
+# libraries
+LIBACADOS_SOLVER=libacados_solver_{{ model.name }}{{ shared_lib_ext }}
+LIBACADOS_OCP_SOLVER=libacados_ocp_solver_{{ model.name }}{{ shared_lib_ext }}
+LIBACADOS_SIM_SOLVER=lib$(SIM_SRC:.c={{ shared_lib_ext }})
+
+# virtual targets
+.PHONY : all clean
+
+#all: clean example_sim example shared_lib
+{% if solver_options.integrator_type == "DISCRETE" -%}
+all: clean example
+shared_lib: ocp_shared_lib
+{%- else %}
+all: clean example_sim example
+shared_lib: bundled_shared_lib ocp_shared_lib sim_shared_lib
+{%- endif %}
+
+# some linker targets
+example: $(EX_OBJ) $(OBJ)
+	$(CC) $^ -o $(EX_EXE) $(LDFLAGS) $(LDLIBS)
+
+example_sim: $(EX_SIM_OBJ) $(MODEL_OBJ) $(SIM_OBJ)
+	$(CC) $^ -o $(EX_SIM_EXE) $(LDFLAGS) $(LDLIBS)
+
+{% if solver_options.integrator_type != "DISCRETE" -%}
+bundled_shared_lib: $(OBJ)
+	$(CC) -shared $^ -o $(LIBACADOS_SOLVER) $(LDFLAGS) $(LDLIBS)
+{%- endif %}
+
+ocp_shared_lib: $(OCP_OBJ) $(MODEL_OBJ)
+	$(CC) -shared $^ -o $(LIBACADOS_OCP_SOLVER) $(LDFLAGS) $(LDLIBS) \
+	-L$(EXTERNAL_DIR) -l$(EXTERNAL_LIB)
+
+sim_shared_lib: $(SIM_OBJ) $(MODEL_OBJ)
+	$(CC) -shared $^ -o $(LIBACADOS_SIM_SOLVER) $(LDFLAGS) $(LDLIBS)
+
+
+# Cython targets
+ocp_cython_c: ocp_shared_lib
+	cython \
+	-o acados_ocp_solver_pyx.c \
+	-I $(INCLUDE_PATH)/../interfaces/acados_template/acados_template \
+	$(INCLUDE_PATH)/../interfaces/acados_template/acados_template/acados_ocp_solver_pyx.pyx \
+	-I {{ code_export_directory }} \
+
+ocp_cython_o: ocp_cython_c
+	$(CC) $(ACADOS_FLAGS) -c -O2 \
+	-fPIC \
+	-o acados_ocp_solver_pyx.o \
+	-I $(INCLUDE_PATH)/blasfeo/include/ \
+	-I $(INCLUDE_PATH)/hpipm/include/ \
+	-I $(INCLUDE_PATH) \
+	{%- for path in cython_include_dirs %}
+	-I {{ path }} \
+	{%- endfor %}
+	acados_ocp_solver_pyx.c \
+
+ocp_cython: ocp_cython_o
+	$(CC) $(ACADOS_FLAGS) -shared \
+	-o acados_ocp_solver_pyx{{ shared_lib_ext }} \
+	-Wl,-rpath=$(LIB_PATH) \
+	acados_ocp_solver_pyx.o \
+	$(abspath .)/libacados_ocp_solver_{{ model.name }}{{ shared_lib_ext }} \
+	$(LDFLAGS) $(LDLIBS)
+
+# Sim Cython targets
+sim_cython_c: sim_shared_lib
+	cython \
+	-o acados_sim_solver_pyx.c \
+	-I $(INCLUDE_PATH)/../interfaces/acados_template/acados_template \
+	$(INCLUDE_PATH)/../interfaces/acados_template/acados_template/acados_sim_solver_pyx.pyx \
+	-I {{ code_export_directory }} \
+
+sim_cython_o: sim_cython_c
+	$(CC) $(ACADOS_FLAGS) -c -O2 \
+	-fPIC \
+	-o acados_sim_solver_pyx.o \
+	-I $(INCLUDE_PATH)/blasfeo/include/ \
+	-I $(INCLUDE_PATH)/hpipm/include/ \
+	-I $(INCLUDE_PATH) \
+	{%- for path in cython_include_dirs %}
+	-I {{ path }} \
+	{%- endfor %}
+	acados_sim_solver_pyx.c \
+
+sim_cython: sim_cython_o
+	$(CC) $(ACADOS_FLAGS) -shared \
+	-o acados_sim_solver_pyx{{ shared_lib_ext }} \
+	-Wl,-rpath=$(LIB_PATH) \
+	acados_sim_solver_pyx.o \
+	$(abspath .)/libacados_sim_solver_{{ model.name }}{{ shared_lib_ext }} \
+	$(LDFLAGS) $(LDLIBS)
+
+{%- if os and os == "pc" %}
+
+clean:
+	del \Q *.o 2>nul
+	del \Q *{{ shared_lib_ext }} 2>nul
+	del \Q main_{{ model.name }} 2>nul
+
+clean_ocp_shared_lib:
+	del \Q libacados_ocp_solver_{{ model.name }}{{ shared_lib_ext }} 2>nul
+	del \Q acados_solver_{{ model.name }}.o 2>nul
+
+clean_ocp_cython:
+	del \Q libacados_ocp_solver_{{ model.name }}{{ shared_lib_ext }} 2>nul
+	del \Q acados_solver_{{ model.name }}.o 2>nul
+	del \Q acados_ocp_solver_pyx{{ shared_lib_ext }} 2>nul
+	del \Q acados_ocp_solver_pyx.o 2>nul
+
+clean_sim_cython:
+	del \Q libacados_sim_solver_{{ model.name }}{{ shared_lib_ext }} 2>nul
+	del \Q acados_sim_solver_{{ model.name }}.o 2>nul
+	del \Q acados_sim_solver_pyx{{ shared_lib_ext }} 2>nul
+	del \Q acados_sim_solver_pyx.o 2>nul
+
+{%- else %}
+
+clean:
+	$(RM) $(OBJ) $(EX_OBJ) $(EX_SIM_OBJ)
+	$(RM) $(LIBACADOS_SOLVER) $(LIBACADOS_OCP_SOLVER) $(LIBACADOS_SIM_SOLVER)
+	$(RM) $(EX_EXE) $(EX_SIM_EXE)
+
+clean_ocp_shared_lib:
+	$(RM) $(LIBACADOS_OCP_SOLVER)
+	$(RM) $(OCP_OBJ)
+
+clean_ocp_cython:
+	$(RM) libacados_ocp_solver_{{ model.name }}{{ shared_lib_ext }}
+	$(RM) acados_solver_{{ model.name }}.o
+	$(RM) acados_ocp_solver_pyx{{ shared_lib_ext }}
+	$(RM) acados_ocp_solver_pyx.o
+
+clean_sim_cython:
+	$(RM) libacados_sim_solver_{{ model.name }}{{ shared_lib_ext }}
+	$(RM) acados_sim_solver_{{ model.name }}.o
+	$(RM) acados_sim_solver_pyx{{ shared_lib_ext }}
+	$(RM) acados_sim_solver_pyx.o
+
+{%- endif %}

third_party/acados/acados_template/c_templates_tera/acados_sim_solver.in.c

@@ -0,0 +1,526 @@
+/*
+ * Copyright (c) The acados authors.
+ *
+ * This file is part of acados.
+ *
+ * The 2-Clause BSD License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.;
+ */
+
+{%- if solver_options.hessian_approx %}
+	{%- set hessian_approx = solver_options.hessian_approx %}
+{%- elif solver_options.sens_hess %}
+	{%- set hessian_approx = "EXACT" %}
+{%- else %}
+	{%- set hessian_approx = "GAUSS_NEWTON" %}
+{%- endif %}
+// standard
+#include <stdio.h>
+#include <stdlib.h>
+
+// acados
+#include "acados_c/external_function_interface.h"
+#include "acados_c/sim_interface.h"
+#include "acados_c/external_function_interface.h"
+
+#include "acados/sim/sim_common.h"
+#include "acados/utils/external_function_generic.h"
+#include "acados/utils/print.h"
+
+
+// example specific
+#include "{{ model.name }}_model/{{ model.name }}_model.h"
+#include "acados_sim_solver_{{ model.name }}.h"
+
+
+// ** solver data **
+
+sim_solver_capsule * {{ model.name }}_acados_sim_solver_create_capsule()
+{
+    void* capsule_mem = malloc(sizeof(sim_solver_capsule));
+    sim_solver_capsule *capsule = (sim_solver_capsule *) capsule_mem;
+
+    return capsule;
+}
+
+
+int {{ model.name }}_acados_sim_solver_free_capsule(sim_solver_capsule * capsule)
+{
+    free(capsule);
+    return 0;
+}
+
+
+int {{ model.name }}_acados_sim_create(sim_solver_capsule * capsule)
+{
+    // initialize
+    const int nx = {{ model.name | upper }}_NX;
+    const int nu = {{ model.name | upper }}_NU;
+    const int nz = {{ model.name | upper }}_NZ;
+    const int np = {{ model.name | upper }}_NP;
+    bool tmp_bool;
+
+    {#// double Tsim = {{ solver_options.tf / dims.N }};#}
+    double Tsim = {{ solver_options.Tsim }};
+
+    {% if solver_options.integrator_type == "IRK" %}
+    capsule->sim_impl_dae_fun = (external_function_param_{{ model.dyn_ext_fun_type }} *) malloc(sizeof(external_function_param_{{ model.dyn_ext_fun_type }}));
+    capsule->sim_impl_dae_fun_jac_x_xdot_z = (external_function_param_{{ model.dyn_ext_fun_type }} *) malloc(sizeof(external_function_param_{{ model.dyn_ext_fun_type }}));
+    capsule->sim_impl_dae_jac_x_xdot_u_z = (external_function_param_{{ model.dyn_ext_fun_type }} *) malloc(sizeof(external_function_param_{{ model.dyn_ext_fun_type }}));
+
+  {%- if model.dyn_ext_fun_type == "casadi" %}
+    // external functions (implicit model)
+    capsule->sim_impl_dae_fun->casadi_fun = &{{ model.name }}_impl_dae_fun;
+    capsule->sim_impl_dae_fun->casadi_work = &{{ model.name }}_impl_dae_fun_work;
+    capsule->sim_impl_dae_fun->casadi_sparsity_in = &{{ model.name }}_impl_dae_fun_sparsity_in;
+    capsule->sim_impl_dae_fun->casadi_sparsity_out = &{{ model.name }}_impl_dae_fun_sparsity_out;
+    capsule->sim_impl_dae_fun->casadi_n_in = &{{ model.name }}_impl_dae_fun_n_in;
+    capsule->sim_impl_dae_fun->casadi_n_out = &{{ model.name }}_impl_dae_fun_n_out;
+    external_function_param_{{ model.dyn_ext_fun_type }}_create(capsule->sim_impl_dae_fun, np);
+
+    capsule->sim_impl_dae_fun_jac_x_xdot_z->casadi_fun = &{{ model.name }}_impl_dae_fun_jac_x_xdot_z;
+    capsule->sim_impl_dae_fun_jac_x_xdot_z->casadi_work = &{{ model.name }}_impl_dae_fun_jac_x_xdot_z_work;
+    capsule->sim_impl_dae_fun_jac_x_xdot_z->casadi_sparsity_in = &{{ model.name }}_impl_dae_fun_jac_x_xdot_z_sparsity_in;
+    capsule->sim_impl_dae_fun_jac_x_xdot_z->casadi_sparsity_out = &{{ model.name }}_impl_dae_fun_jac_x_xdot_z_sparsity_out;
+    capsule->sim_impl_dae_fun_jac_x_xdot_z->casadi_n_in = &{{ model.name }}_impl_dae_fun_jac_x_xdot_z_n_in;
+    capsule->sim_impl_dae_fun_jac_x_xdot_z->casadi_n_out = &{{ model.name }}_impl_dae_fun_jac_x_xdot_z_n_out;
+    external_function_param_{{ model.dyn_ext_fun_type }}_create(capsule->sim_impl_dae_fun_jac_x_xdot_z, np);
+
+    // external_function_param_{{ model.dyn_ext_fun_type }} impl_dae_jac_x_xdot_u_z;
+    capsule->sim_impl_dae_jac_x_xdot_u_z->casadi_fun = &{{ model.name }}_impl_dae_jac_x_xdot_u_z;
+    capsule->sim_impl_dae_jac_x_xdot_u_z->casadi_work = &{{ model.name }}_impl_dae_jac_x_xdot_u_z_work;
+    capsule->sim_impl_dae_jac_x_xdot_u_z->casadi_sparsity_in = &{{ model.name }}_impl_dae_jac_x_xdot_u_z_sparsity_in;
+    capsule->sim_impl_dae_jac_x_xdot_u_z->casadi_sparsity_out = &{{ model.name }}_impl_dae_jac_x_xdot_u_z_sparsity_out;
+    capsule->sim_impl_dae_jac_x_xdot_u_z->casadi_n_in = &{{ model.name }}_impl_dae_jac_x_xdot_u_z_n_in;
+    capsule->sim_impl_dae_jac_x_xdot_u_z->casadi_n_out = &{{ model.name }}_impl_dae_jac_x_xdot_u_z_n_out;
+    external_function_param_{{ model.dyn_ext_fun_type }}_create(capsule->sim_impl_dae_jac_x_xdot_u_z, np);
+  {%- else %}
+    capsule->sim_impl_dae_fun->fun = &{{ model.dyn_impl_dae_fun }};
+    capsule->sim_impl_dae_fun_jac_x_xdot_z->fun = &{{ model.dyn_impl_dae_fun_jac }};
+    capsule->sim_impl_dae_jac_x_xdot_u_z->fun = &{{ model.dyn_impl_dae_jac }};
+  {%- endif %}
+
+{%- if hessian_approx == "EXACT" %}
+    capsule->sim_impl_dae_hess = (external_function_param_{{ model.dyn_ext_fun_type }} *) malloc(sizeof(external_function_param_{{ model.dyn_ext_fun_type }}));
+    // external_function_param_{{ model.dyn_ext_fun_type }} impl_dae_jac_x_xdot_u_z;
+    capsule->sim_impl_dae_hess->casadi_fun = &{{ model.name }}_impl_dae_hess;
+    capsule->sim_impl_dae_hess->casadi_work = &{{ model.name }}_impl_dae_hess_work;
+    capsule->sim_impl_dae_hess->casadi_sparsity_in = &{{ model.name }}_impl_dae_hess_sparsity_in;
+    capsule->sim_impl_dae_hess->casadi_sparsity_out = &{{ model.name }}_impl_dae_hess_sparsity_out;
+    capsule->sim_impl_dae_hess->casadi_n_in = &{{ model.name }}_impl_dae_hess_n_in;
+    capsule->sim_impl_dae_hess->casadi_n_out = &{{ model.name }}_impl_dae_hess_n_out;
+    external_function_param_{{ model.dyn_ext_fun_type }}_create(capsule->sim_impl_dae_hess, np);
+{%- endif %}
+
+    {% elif solver_options.integrator_type == "ERK" %}
+    // explicit ode
+    capsule->sim_forw_vde_casadi = (external_function_param_{{ model.dyn_ext_fun_type }} *) malloc(sizeof(external_function_param_{{ model.dyn_ext_fun_type }}));
+    capsule->sim_vde_adj_casadi = (external_function_param_{{ model.dyn_ext_fun_type }} *) malloc(sizeof(external_function_param_{{ model.dyn_ext_fun_type }}));
+    capsule->sim_expl_ode_fun_casadi = (external_function_param_{{ model.dyn_ext_fun_type }} *) malloc(sizeof(external_function_param_{{ model.dyn_ext_fun_type }}));
+
+    capsule->sim_forw_vde_casadi->casadi_fun = &{{ model.name }}_expl_vde_forw;
+    capsule->sim_forw_vde_casadi->casadi_n_in = &{{ model.name }}_expl_vde_forw_n_in;
+    capsule->sim_forw_vde_casadi->casadi_n_out = &{{ model.name }}_expl_vde_forw_n_out;
+    capsule->sim_forw_vde_casadi->casadi_sparsity_in = &{{ model.name }}_expl_vde_forw_sparsity_in;
+    capsule->sim_forw_vde_casadi->casadi_sparsity_out = &{{ model.name }}_expl_vde_forw_sparsity_out;
+    capsule->sim_forw_vde_casadi->casadi_work = &{{ model.name }}_expl_vde_forw_work;
+    external_function_param_{{ model.dyn_ext_fun_type }}_create(capsule->sim_forw_vde_casadi, np);
+
+    capsule->sim_vde_adj_casadi->casadi_fun = &{{ model.name }}_expl_vde_adj;
+    capsule->sim_vde_adj_casadi->casadi_n_in = &{{ model.name }}_expl_vde_adj_n_in;
+    capsule->sim_vde_adj_casadi->casadi_n_out = &{{ model.name }}_expl_vde_adj_n_out;
+    capsule->sim_vde_adj_casadi->casadi_sparsity_in = &{{ model.name }}_expl_vde_adj_sparsity_in;
+    capsule->sim_vde_adj_casadi->casadi_sparsity_out = &{{ model.name }}_expl_vde_adj_sparsity_out;
+    capsule->sim_vde_adj_casadi->casadi_work = &{{ model.name }}_expl_vde_adj_work;
+    external_function_param_{{ model.dyn_ext_fun_type }}_create(capsule->sim_vde_adj_casadi, np);
+
+    capsule->sim_expl_ode_fun_casadi->casadi_fun = &{{ model.name }}_expl_ode_fun;
+    capsule->sim_expl_ode_fun_casadi->casadi_n_in = &{{ model.name }}_expl_ode_fun_n_in;
+    capsule->sim_expl_ode_fun_casadi->casadi_n_out = &{{ model.name }}_expl_ode_fun_n_out;
+    capsule->sim_expl_ode_fun_casadi->casadi_sparsity_in = &{{ model.name }}_expl_ode_fun_sparsity_in;
+    capsule->sim_expl_ode_fun_casadi->casadi_sparsity_out = &{{ model.name }}_expl_ode_fun_sparsity_out;
+    capsule->sim_expl_ode_fun_casadi->casadi_work = &{{ model.name }}_expl_ode_fun_work;
+    external_function_param_{{ model.dyn_ext_fun_type }}_create(capsule->sim_expl_ode_fun_casadi, np);
+
+{%- if hessian_approx == "EXACT" %}
+    capsule->sim_expl_ode_hess = (external_function_param_{{ model.dyn_ext_fun_type }} *) malloc(sizeof(external_function_param_{{ model.dyn_ext_fun_type }}));
+    // external_function_param_{{ model.dyn_ext_fun_type }} impl_dae_jac_x_xdot_u_z;
+    capsule->sim_expl_ode_hess->casadi_fun = &{{ model.name }}_expl_ode_hess;
+    capsule->sim_expl_ode_hess->casadi_work = &{{ model.name }}_expl_ode_hess_work;
+    capsule->sim_expl_ode_hess->casadi_sparsity_in = &{{ model.name }}_expl_ode_hess_sparsity_in;
+    capsule->sim_expl_ode_hess->casadi_sparsity_out = &{{ model.name }}_expl_ode_hess_sparsity_out;
+    capsule->sim_expl_ode_hess->casadi_n_in = &{{ model.name }}_expl_ode_hess_n_in;
+    capsule->sim_expl_ode_hess->casadi_n_out = &{{ model.name }}_expl_ode_hess_n_out;
+    external_function_param_{{ model.dyn_ext_fun_type }}_create(capsule->sim_expl_ode_hess, np);
+{%- endif %}
+
+    {% elif solver_options.integrator_type == "GNSF" -%}
+  {% if model.gnsf.purely_linear != 1 %}
+    capsule->sim_gnsf_phi_fun = (external_function_param_{{ model.dyn_ext_fun_type }} *) malloc(sizeof(external_function_param_{{ model.dyn_ext_fun_type }}));
+    capsule->sim_gnsf_phi_fun_jac_y = (external_function_param_{{ model.dyn_ext_fun_type }} *) malloc(sizeof(external_function_param_{{ model.dyn_ext_fun_type }}));
+    capsule->sim_gnsf_phi_jac_y_uhat = (external_function_param_{{ model.dyn_ext_fun_type }} *) malloc(sizeof(external_function_param_{{ model.dyn_ext_fun_type }}));
+  {% if model.gnsf.nontrivial_f_LO == 1 %}
+    capsule->sim_gnsf_f_lo_jac_x1_x1dot_u_z = (external_function_param_{{ model.dyn_ext_fun_type }} *) malloc(sizeof(external_function_param_{{ model.dyn_ext_fun_type }}));
+  {%- endif %}
+  {%- endif %}
+    capsule->sim_gnsf_get_matrices_fun = (external_function_param_{{ model.dyn_ext_fun_type }} *) malloc(sizeof(external_function_param_{{ model.dyn_ext_fun_type }}));
+
+  {% if model.gnsf.purely_linear != 1 %}
+    capsule->sim_gnsf_phi_fun->casadi_fun = &{{ model.name }}_gnsf_phi_fun;
+    capsule->sim_gnsf_phi_fun->casadi_n_in = &{{ model.name }}_gnsf_phi_fun_n_in;
+    capsule->sim_gnsf_phi_fun->casadi_n_out = &{{ model.name }}_gnsf_phi_fun_n_out;
+    capsule->sim_gnsf_phi_fun->casadi_sparsity_in = &{{ model.name }}_gnsf_phi_fun_sparsity_in;
+    capsule->sim_gnsf_phi_fun->casadi_sparsity_out = &{{ model.name }}_gnsf_phi_fun_sparsity_out;
+    capsule->sim_gnsf_phi_fun->casadi_work = &{{ model.name }}_gnsf_phi_fun_work;
+    external_function_param_{{ model.dyn_ext_fun_type }}_create(capsule->sim_gnsf_phi_fun, np);
+
+    capsule->sim_gnsf_phi_fun_jac_y->casadi_fun = &{{ model.name }}_gnsf_phi_fun_jac_y;
+    capsule->sim_gnsf_phi_fun_jac_y->casadi_n_in = &{{ model.name }}_gnsf_phi_fun_jac_y_n_in;
+    capsule->sim_gnsf_phi_fun_jac_y->casadi_n_out = &{{ model.name }}_gnsf_phi_fun_jac_y_n_out;
+    capsule->sim_gnsf_phi_fun_jac_y->casadi_sparsity_in = &{{ model.name }}_gnsf_phi_fun_jac_y_sparsity_in;
+    capsule->sim_gnsf_phi_fun_jac_y->casadi_sparsity_out = &{{ model.name }}_gnsf_phi_fun_jac_y_sparsity_out;
+    capsule->sim_gnsf_phi_fun_jac_y->casadi_work = &{{ model.name }}_gnsf_phi_fun_jac_y_work;
+    external_function_param_{{ model.dyn_ext_fun_type }}_create(capsule->sim_gnsf_phi_fun_jac_y, np);
+
+    capsule->sim_gnsf_phi_jac_y_uhat->casadi_fun = &{{ model.name }}_gnsf_phi_jac_y_uhat;
+    capsule->sim_gnsf_phi_jac_y_uhat->casadi_n_in = &{{ model.name }}_gnsf_phi_jac_y_uhat_n_in;
+    capsule->sim_gnsf_phi_jac_y_uhat->casadi_n_out = &{{ model.name }}_gnsf_phi_jac_y_uhat_n_out;
+    capsule->sim_gnsf_phi_jac_y_uhat->casadi_sparsity_in = &{{ model.name }}_gnsf_phi_jac_y_uhat_sparsity_in;
+    capsule->sim_gnsf_phi_jac_y_uhat->casadi_sparsity_out = &{{ model.name }}_gnsf_phi_jac_y_uhat_sparsity_out;
+    capsule->sim_gnsf_phi_jac_y_uhat->casadi_work = &{{ model.name }}_gnsf_phi_jac_y_uhat_work;
+    external_function_param_{{ model.dyn_ext_fun_type }}_create(capsule->sim_gnsf_phi_jac_y_uhat, np);
+
+  {% if model.gnsf.nontrivial_f_LO == 1 %}
+    capsule->sim_gnsf_f_lo_jac_x1_x1dot_u_z->casadi_fun = &{{ model.name }}_gnsf_f_lo_fun_jac_x1k1uz;
+    capsule->sim_gnsf_f_lo_jac_x1_x1dot_u_z->casadi_n_in = &{{ model.name }}_gnsf_f_lo_fun_jac_x1k1uz_n_in;
+    capsule->sim_gnsf_f_lo_jac_x1_x1dot_u_z->casadi_n_out = &{{ model.name }}_gnsf_f_lo_fun_jac_x1k1uz_n_out;
+    capsule->sim_gnsf_f_lo_jac_x1_x1dot_u_z->casadi_sparsity_in = &{{ model.name }}_gnsf_f_lo_fun_jac_x1k1uz_sparsity_in;
+    capsule->sim_gnsf_f_lo_jac_x1_x1dot_u_z->casadi_sparsity_out = &{{ model.name }}_gnsf_f_lo_fun_jac_x1k1uz_sparsity_out;
+    capsule->sim_gnsf_f_lo_jac_x1_x1dot_u_z->casadi_work = &{{ model.name }}_gnsf_f_lo_fun_jac_x1k1uz_work;
+    external_function_param_{{ model.dyn_ext_fun_type }}_create(capsule->sim_gnsf_f_lo_jac_x1_x1dot_u_z, np);
+  {%- endif %}
+  {%- endif %}
+
+    capsule->sim_gnsf_get_matrices_fun->casadi_fun = &{{ model.name }}_gnsf_get_matrices_fun;
+    capsule->sim_gnsf_get_matrices_fun->casadi_n_in = &{{ model.name }}_gnsf_get_matrices_fun_n_in;
+    capsule->sim_gnsf_get_matrices_fun->casadi_n_out = &{{ model.name }}_gnsf_get_matrices_fun_n_out;
+    capsule->sim_gnsf_get_matrices_fun->casadi_sparsity_in = &{{ model.name }}_gnsf_get_matrices_fun_sparsity_in;
+    capsule->sim_gnsf_get_matrices_fun->casadi_sparsity_out = &{{ model.name }}_gnsf_get_matrices_fun_sparsity_out;
+    capsule->sim_gnsf_get_matrices_fun->casadi_work = &{{ model.name }}_gnsf_get_matrices_fun_work;
+    external_function_param_{{ model.dyn_ext_fun_type }}_create(capsule->sim_gnsf_get_matrices_fun, np);
+    {% endif %}
+
+    // sim plan & config
+    sim_solver_plan_t plan;
+    plan.sim_solver = {{ solver_options.integrator_type }};
+
+    // create correct config based on plan
+    sim_config * {{ model.name }}_sim_config = sim_config_create(plan);
+    capsule->acados_sim_config = {{ model.name }}_sim_config;
+
+    // sim dims
+    void *{{ model.name }}_sim_dims = sim_dims_create({{ model.name }}_sim_config);
+    capsule->acados_sim_dims = {{ model.name }}_sim_dims;
+    sim_dims_set({{ model.name }}_sim_config, {{ model.name }}_sim_dims, "nx", &nx);
+    sim_dims_set({{ model.name }}_sim_config, {{ model.name }}_sim_dims, "nu", &nu);
+    sim_dims_set({{ model.name }}_sim_config, {{ model.name }}_sim_dims, "nz", &nz);
+{% if solver_options.integrator_type == "GNSF" %}
+    int gnsf_nx1 = {{ dims.gnsf_nx1 }};
+    int gnsf_nz1 = {{ dims.gnsf_nz1 }};
+    int gnsf_nout = {{ dims.gnsf_nout }};
+    int gnsf_ny = {{ dims.gnsf_ny }};
+    int gnsf_nuhat = {{ dims.gnsf_nuhat }};
+
+    sim_dims_set({{ model.name }}_sim_config, {{ model.name }}_sim_dims, "nx1", &gnsf_nx1);
+    sim_dims_set({{ model.name }}_sim_config, {{ model.name }}_sim_dims, "nz1", &gnsf_nz1);
+    sim_dims_set({{ model.name }}_sim_config, {{ model.name }}_sim_dims, "nout", &gnsf_nout);
+    sim_dims_set({{ model.name }}_sim_config, {{ model.name }}_sim_dims, "ny", &gnsf_ny);
+    sim_dims_set({{ model.name }}_sim_config, {{ model.name }}_sim_dims, "nuhat", &gnsf_nuhat);
+{% endif %}
+
+    // sim opts
+    sim_opts *{{ model.name }}_sim_opts = sim_opts_create({{ model.name }}_sim_config, {{ model.name }}_sim_dims);
+    capsule->acados_sim_opts = {{ model.name }}_sim_opts;
+    int tmp_int = {{ solver_options.sim_method_newton_iter }};
+    sim_opts_set({{ model.name }}_sim_config, {{ model.name }}_sim_opts, "newton_iter", &tmp_int);
+    double tmp_double = {{ solver_options.sim_method_newton_tol }};
+    sim_opts_set({{ model.name }}_sim_config, {{ model.name }}_sim_opts, "newton_tol", &tmp_double);
+    sim_collocation_type collocation_type = {{ solver_options.collocation_type }};
+    sim_opts_set({{ model.name }}_sim_config, {{ model.name }}_sim_opts, "collocation_type", &collocation_type);
+
+{% if problem_class == "SIM" %}
+    tmp_int = {{ solver_options.sim_method_num_stages }};
+    sim_opts_set({{ model.name }}_sim_config, {{ model.name }}_sim_opts, "num_stages", &tmp_int);
+    tmp_int = {{ solver_options.sim_method_num_steps }};
+    sim_opts_set({{ model.name }}_sim_config, {{ model.name }}_sim_opts, "num_steps", &tmp_int);
+
+    // options that are not available to AcadosOcpSolver
+    //  (in OCP they will be determined by other options, like exact_hessian)
+    tmp_bool = {{ solver_options.sens_forw }};
+    sim_opts_set({{ model.name }}_sim_config, {{ model.name }}_sim_opts, "sens_forw", &tmp_bool);
+    tmp_bool = {{ solver_options.sens_adj }};
+    sim_opts_set({{ model.name }}_sim_config, {{ model.name }}_sim_opts, "sens_adj", &tmp_bool);
+    tmp_bool = {{ solver_options.sens_algebraic }};
+    sim_opts_set({{ model.name }}_sim_config, {{ model.name }}_sim_opts, "sens_algebraic", &tmp_bool);
+    tmp_bool = {{ solver_options.sens_hess }};
+    sim_opts_set({{ model.name }}_sim_config, {{ model.name }}_sim_opts, "sens_hess", &tmp_bool);
+    tmp_bool = {{ solver_options.output_z }};
+    sim_opts_set({{ model.name }}_sim_config, {{ model.name }}_sim_opts, "output_z", &tmp_bool);
+
+{% else %} {# num_stages and num_steps of first shooting interval are used #}
+    tmp_int = {{ solver_options.sim_method_num_stages[0] }};
+    sim_opts_set({{ model.name }}_sim_config, {{ model.name }}_sim_opts, "num_stages", &tmp_int);
+    tmp_int = {{ solver_options.sim_method_num_steps[0] }};
+    sim_opts_set({{ model.name }}_sim_config, {{ model.name }}_sim_opts, "num_steps", &tmp_int);
+    tmp_bool = {{ solver_options.sim_method_jac_reuse[0] }};
+    sim_opts_set({{ model.name }}_sim_config, {{ model.name }}_sim_opts, "jac_reuse", &tmp_bool);
+{% endif %}
+
+    // sim in / out
+    sim_in *{{ model.name }}_sim_in = sim_in_create({{ model.name }}_sim_config, {{ model.name }}_sim_dims);
+    capsule->acados_sim_in = {{ model.name }}_sim_in;
+    sim_out *{{ model.name }}_sim_out = sim_out_create({{ model.name }}_sim_config, {{ model.name }}_sim_dims);
+    capsule->acados_sim_out = {{ model.name }}_sim_out;
+
+    sim_in_set({{ model.name }}_sim_config, {{ model.name }}_sim_dims,
+               {{ model.name }}_sim_in, "T", &Tsim);
+
+    // model functions
+{%- if solver_options.integrator_type == "IRK" %}
+    {{ model.name }}_sim_config->model_set({{ model.name }}_sim_in->model,
+                 "impl_ode_fun", capsule->sim_impl_dae_fun);
+    {{ model.name }}_sim_config->model_set({{ model.name }}_sim_in->model,
+                 "impl_ode_fun_jac_x_xdot", capsule->sim_impl_dae_fun_jac_x_xdot_z);
+    {{ model.name }}_sim_config->model_set({{ model.name }}_sim_in->model,
+                 "impl_ode_jac_x_xdot_u", capsule->sim_impl_dae_jac_x_xdot_u_z);
+{%- if hessian_approx == "EXACT" %}
+    {{ model.name }}_sim_config->model_set({{ model.name }}_sim_in->model,
+                "impl_dae_hess", capsule->sim_impl_dae_hess);
+{%- endif %}
+
+{%- elif solver_options.integrator_type == "ERK" %}
+    {{ model.name }}_sim_config->model_set({{ model.name }}_sim_in->model,
+                 "expl_vde_forw", capsule->sim_forw_vde_casadi);
+    {{ model.name }}_sim_config->model_set({{ model.name }}_sim_in->model,
+                 "expl_vde_adj", capsule->sim_vde_adj_casadi);
+    {{ model.name }}_sim_config->model_set({{ model.name }}_sim_in->model,
+                 "expl_ode_fun", capsule->sim_expl_ode_fun_casadi);
+{%- if hessian_approx == "EXACT" %}
+    {{ model.name }}_sim_config->model_set({{ model.name }}_sim_in->model,
+                "expl_ode_hess", capsule->sim_expl_ode_hess);
+{%- endif %}
+{%- elif solver_options.integrator_type == "GNSF" %}
+  {% if model.gnsf.purely_linear != 1 %}
+    {{ model.name }}_sim_config->model_set({{ model.name }}_sim_in->model,
+                 "phi_fun", capsule->sim_gnsf_phi_fun);
+    {{ model.name }}_sim_config->model_set({{ model.name }}_sim_in->model,
+                 "phi_fun_jac_y", capsule->sim_gnsf_phi_fun_jac_y);
+    {{ model.name }}_sim_config->model_set({{ model.name }}_sim_in->model,
+                 "phi_jac_y_uhat", capsule->sim_gnsf_phi_jac_y_uhat);
+  {% if model.gnsf.nontrivial_f_LO == 1 %}
+    {{ model.name }}_sim_config->model_set({{ model.name }}_sim_in->model,
+                 "f_lo_jac_x1_x1dot_u_z", capsule->sim_gnsf_f_lo_jac_x1_x1dot_u_z);
+  {%- endif %}
+  {%- endif %}
+    {{ model.name }}_sim_config->model_set({{ model.name }}_sim_in->model,
+                 "gnsf_get_matrices_fun", capsule->sim_gnsf_get_matrices_fun);
+{%- endif %}
+
+    // sim solver
+    sim_solver *{{ model.name }}_sim_solver = sim_solver_create({{ model.name }}_sim_config,
+                                               {{ model.name }}_sim_dims, {{ model.name }}_sim_opts);
+    capsule->acados_sim_solver = {{ model.name }}_sim_solver;
+
+{% if dims.np > 0 %}
+    /* initialize parameter values */
+    double* p = calloc(np, sizeof(double));
+    {% for item in parameter_values %}
+        {%- if item != 0 %}
+    p[{{ loop.index0 }}] = {{ item }};
+        {%- endif %}
+    {%- endfor %}
+
+    {{ model.name }}_acados_sim_update_params(capsule, p, np);
+    free(p);
+{% endif %}{# if dims.np #}
+
+    /* initialize input */
+    // x
+    double x0[{{ dims.nx }}];
+    for (int ii = 0; ii < {{ dims.nx }}; ii++)
+        x0[ii] = 0.0;
+
+    sim_in_set({{ model.name }}_sim_config, {{ model.name }}_sim_dims,
+               {{ model.name }}_sim_in, "x", x0);
+
+
+    // u
+    double u0[{{ dims.nu }}];
+    for (int ii = 0; ii < {{ dims.nu }}; ii++)
+        u0[ii] = 0.0;
+
+    sim_in_set({{ model.name }}_sim_config, {{ model.name }}_sim_dims,
+               {{ model.name }}_sim_in, "u", u0);
+
+    // S_forw
+    double S_forw[{{ dims.nx * (dims.nx + dims.nu) }}];
+    for (int ii = 0; ii < {{ dims.nx * (dims.nx + dims.nu) }}; ii++)
+        S_forw[ii] = 0.0;
+    for (int ii = 0; ii < {{ dims.nx }}; ii++)
+        S_forw[ii + ii * {{ dims.nx }} ] = 1.0;
+
+
+    sim_in_set({{ model.name }}_sim_config, {{ model.name }}_sim_dims,
+               {{ model.name }}_sim_in, "S_forw", S_forw);
+
+    int status = sim_precompute({{ model.name }}_sim_solver, {{ model.name }}_sim_in, {{ model.name }}_sim_out);
+
+    return status;
+}
+
+
+int {{ model.name }}_acados_sim_solve(sim_solver_capsule *capsule)
+{
+    // integrate dynamics using acados sim_solver
+    int status = sim_solve(capsule->acados_sim_solver,
+                           capsule->acados_sim_in, capsule->acados_sim_out);
+    if (status != 0)
+        printf("error in {{ model.name }}_acados_sim_solve()! Exiting.\n");
+
+    return status;
+}
+
+
+int {{ model.name }}_acados_sim_free(sim_solver_capsule *capsule)
+{
+    // free memory
+    sim_solver_destroy(capsule->acados_sim_solver);
+    sim_in_destroy(capsule->acados_sim_in);
+    sim_out_destroy(capsule->acados_sim_out);
+    sim_opts_destroy(capsule->acados_sim_opts);
+    sim_dims_destroy(capsule->acados_sim_dims);
+    sim_config_destroy(capsule->acados_sim_config);
+
+    // free external function
+{%- if solver_options.integrator_type == "IRK" %}
+    external_function_param_{{ model.dyn_ext_fun_type }}_free(capsule->sim_impl_dae_fun);
+    external_function_param_{{ model.dyn_ext_fun_type }}_free(capsule->sim_impl_dae_fun_jac_x_xdot_z);
+    external_function_param_{{ model.dyn_ext_fun_type }}_free(capsule->sim_impl_dae_jac_x_xdot_u_z);
+{%- if hessian_approx == "EXACT" %}
+    external_function_param_{{ model.dyn_ext_fun_type }}_free(capsule->sim_impl_dae_hess);
+{%- endif %}
+{%- elif solver_options.integrator_type == "ERK" %}
+    external_function_param_{{ model.dyn_ext_fun_type }}_free(capsule->sim_forw_vde_casadi);
+    external_function_param_{{ model.dyn_ext_fun_type }}_free(capsule->sim_vde_adj_casadi);
+    external_function_param_{{ model.dyn_ext_fun_type }}_free(capsule->sim_expl_ode_fun_casadi);
+{%- if hessian_approx == "EXACT" %}
+    external_function_param_{{ model.dyn_ext_fun_type }}_free(capsule->sim_expl_ode_hess);
+{%- endif %}
+{%- elif solver_options.integrator_type == "GNSF" %}
+  {% if model.gnsf.purely_linear != 1 %}
+    external_function_param_{{ model.dyn_ext_fun_type }}_free(capsule->sim_gnsf_phi_fun);
+    external_function_param_{{ model.dyn_ext_fun_type }}_free(capsule->sim_gnsf_phi_fun_jac_y);
+    external_function_param_{{ model.dyn_ext_fun_type }}_free(capsule->sim_gnsf_phi_jac_y_uhat);
+  {% if model.gnsf.nontrivial_f_LO == 1 %}
+    external_function_param_{{ model.dyn_ext_fun_type }}_free(capsule->sim_gnsf_f_lo_jac_x1_x1dot_u_z);
+  {%- endif %}
+  {%- endif %}
+    external_function_param_{{ model.dyn_ext_fun_type }}_free(capsule->sim_gnsf_get_matrices_fun);
+{% endif %}
+
+    return 0;
+}
+
+
+int {{ model.name }}_acados_sim_update_params(sim_solver_capsule *capsule, double *p, int np)
+{
+    int status = 0;
+    int casadi_np = {{ model.name | upper }}_NP;
+
+    if (casadi_np != np) {
+        printf("{{ model.name }}_acados_sim_update_params: trying to set %i parameters for external functions."
+            " External function has %i parameters. Exiting.\n", np, casadi_np);
+        exit(1);
+    }
+
+{%- if solver_options.integrator_type == "ERK" %}
+    capsule->sim_forw_vde_casadi[0].set_param(capsule->sim_forw_vde_casadi, p);
+    capsule->sim_vde_adj_casadi[0].set_param(capsule->sim_vde_adj_casadi, p);
+    capsule->sim_expl_ode_fun_casadi[0].set_param(capsule->sim_expl_ode_fun_casadi, p);
+{%- if hessian_approx == "EXACT" %}
+    capsule->sim_expl_ode_hess[0].set_param(capsule->sim_expl_ode_hess, p);
+{%- endif %}
+{%- elif solver_options.integrator_type == "IRK" %}
+    capsule->sim_impl_dae_fun[0].set_param(capsule->sim_impl_dae_fun, p);
+    capsule->sim_impl_dae_fun_jac_x_xdot_z[0].set_param(capsule->sim_impl_dae_fun_jac_x_xdot_z, p);
+    capsule->sim_impl_dae_jac_x_xdot_u_z[0].set_param(capsule->sim_impl_dae_jac_x_xdot_u_z, p);
+{%- if hessian_approx == "EXACT" %}
+    capsule->sim_impl_dae_hess[0].set_param(capsule->sim_impl_dae_hess, p);
+{%- endif %}
+{%- elif solver_options.integrator_type == "GNSF" %}
+  {% if model.gnsf.purely_linear != 1 %}
+    capsule->sim_gnsf_phi_fun[0].set_param(capsule->sim_gnsf_phi_fun, p);
+    capsule->sim_gnsf_phi_fun_jac_y[0].set_param(capsule->sim_gnsf_phi_fun_jac_y, p);
+    capsule->sim_gnsf_phi_jac_y_uhat[0].set_param(capsule->sim_gnsf_phi_jac_y_uhat, p);
+  {% if model.gnsf.nontrivial_f_LO == 1 %}
+    capsule->sim_gnsf_f_lo_jac_x1_x1dot_u_z[0].set_param(capsule->sim_gnsf_f_lo_jac_x1_x1dot_u_z, p);
+  {%- endif %}
+  {%- endif %}
+    capsule->sim_gnsf_get_matrices_fun[0].set_param(capsule->sim_gnsf_get_matrices_fun, p);
+{% endif %}
+
+    return status;
+}
+
+/* getters pointers to C objects*/
+sim_config * {{ model.name }}_acados_get_sim_config(sim_solver_capsule *capsule)
+{
+    return capsule->acados_sim_config;
+};
+
+sim_in * {{ model.name }}_acados_get_sim_in(sim_solver_capsule *capsule)
+{
+    return capsule->acados_sim_in;
+};
+
+sim_out * {{ model.name }}_acados_get_sim_out(sim_solver_capsule *capsule)
+{
+    return capsule->acados_sim_out;
+};
+
+void * {{ model.name }}_acados_get_sim_dims(sim_solver_capsule *capsule)
+{
+    return capsule->acados_sim_dims;
+};
+
+sim_opts * {{ model.name }}_acados_get_sim_opts(sim_solver_capsule *capsule)
+{
+    return capsule->acados_sim_opts;
+};
+
+sim_solver  * {{ model.name }}_acados_get_sim_solver(sim_solver_capsule *capsule)
+{
+    return capsule->acados_sim_solver;
+};
+

third_party/acados/acados_template/c_templates_tera/acados_sim_solver.in.h

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) The acados authors.
+ *
+ * This file is part of acados.
+ *
+ * The 2-Clause BSD License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.;
+ */
+
+#ifndef ACADOS_SIM_{{ model.name }}_H_
+#define ACADOS_SIM_{{ model.name }}_H_
+
+#include "acados_c/sim_interface.h"
+#include "acados_c/external_function_interface.h"
+
+#define {{ model.name | upper }}_NX     {{ dims.nx }}
+#define {{ model.name | upper }}_NZ     {{ dims.nz }}
+#define {{ model.name | upper }}_NU     {{ dims.nu }}
+#define {{ model.name | upper }}_NP     {{ dims.np }}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+// ** capsule for solver data **
+typedef struct sim_solver_capsule
+{
+    // acados objects
+    sim_in *acados_sim_in;
+    sim_out *acados_sim_out;
+    sim_solver *acados_sim_solver;
+    sim_opts *acados_sim_opts;
+    sim_config *acados_sim_config;
+    void *acados_sim_dims;
+
+    /* external functions */
+    // ERK
+    external_function_param_{{ model.dyn_ext_fun_type }} * sim_forw_vde_casadi;
+    external_function_param_{{ model.dyn_ext_fun_type }} * sim_vde_adj_casadi;
+    external_function_param_{{ model.dyn_ext_fun_type }} * sim_expl_ode_fun_casadi;
+    external_function_param_{{ model.dyn_ext_fun_type }} * sim_expl_ode_hess;
+
+    // IRK
+    external_function_param_{{ model.dyn_ext_fun_type }} * sim_impl_dae_fun;
+    external_function_param_{{ model.dyn_ext_fun_type }} * sim_impl_dae_fun_jac_x_xdot_z;
+    external_function_param_{{ model.dyn_ext_fun_type }} * sim_impl_dae_jac_x_xdot_u_z;
+    external_function_param_{{ model.dyn_ext_fun_type }} * sim_impl_dae_hess;
+
+    // GNSF
+    external_function_param_{{ model.dyn_ext_fun_type }} * sim_gnsf_phi_fun;
+    external_function_param_{{ model.dyn_ext_fun_type }} * sim_gnsf_phi_fun_jac_y;
+    external_function_param_{{ model.dyn_ext_fun_type }} * sim_gnsf_phi_jac_y_uhat;
+    external_function_param_{{ model.dyn_ext_fun_type }} * sim_gnsf_f_lo_jac_x1_x1dot_u_z;
+    external_function_param_{{ model.dyn_ext_fun_type }} * sim_gnsf_get_matrices_fun;
+
+} sim_solver_capsule;
+
+
+ACADOS_SYMBOL_EXPORT int {{ model.name }}_acados_sim_create(sim_solver_capsule *capsule);
+ACADOS_SYMBOL_EXPORT int {{ model.name }}_acados_sim_solve(sim_solver_capsule *capsule);
+ACADOS_SYMBOL_EXPORT int {{ model.name }}_acados_sim_free(sim_solver_capsule *capsule);
+ACADOS_SYMBOL_EXPORT int {{ model.name }}_acados_sim_update_params(sim_solver_capsule *capsule, double *value, int np);
+
+ACADOS_SYMBOL_EXPORT sim_config * {{ model.name }}_acados_get_sim_config(sim_solver_capsule *capsule);
+ACADOS_SYMBOL_EXPORT sim_in * {{ model.name }}_acados_get_sim_in(sim_solver_capsule *capsule);
+ACADOS_SYMBOL_EXPORT sim_out * {{ model.name }}_acados_get_sim_out(sim_solver_capsule *capsule);
+ACADOS_SYMBOL_EXPORT void * {{ model.name }}_acados_get_sim_dims(sim_solver_capsule *capsule);
+ACADOS_SYMBOL_EXPORT sim_opts * {{ model.name }}_acados_get_sim_opts(sim_solver_capsule *capsule);
+ACADOS_SYMBOL_EXPORT sim_solver * {{ model.name }}_acados_get_sim_solver(sim_solver_capsule *capsule);
+
+
+ACADOS_SYMBOL_EXPORT sim_solver_capsule * {{ model.name }}_acados_sim_solver_create_capsule(void);
+ACADOS_SYMBOL_EXPORT int {{ model.name }}_acados_sim_solver_free_capsule(sim_solver_capsule *capsule);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // ACADOS_SIM_{{ model.name }}_H_

third_party/acados/acados_template/c_templates_tera/acados_sim_solver.in.pxd

@@ -0,0 +1,51 @@
+#
+# Copyright (c) The acados authors.
+#
+# This file is part of acados.
+#
+# The 2-Clause BSD License
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.;
+#
+
+cimport acados_sim_solver_common
+
+cdef extern from "acados_sim_solver_{{ model.name }}.h":
+    ctypedef struct sim_solver_capsule "sim_solver_capsule":
+        pass
+
+    sim_solver_capsule * acados_sim_solver_create_capsule "{{ model.name }}_acados_sim_solver_create_capsule"()
+    int acados_sim_solver_free_capsule "{{ model.name }}_acados_sim_solver_free_capsule"(sim_solver_capsule *capsule)
+
+    int acados_sim_create "{{ model.name }}_acados_sim_create"(sim_solver_capsule * capsule)
+    int acados_sim_solve "{{ model.name }}_acados_sim_solve"(sim_solver_capsule * capsule)
+    int acados_sim_free "{{ model.name }}_acados_sim_free"(sim_solver_capsule * capsule)
+    int acados_sim_update_params "{{ model.name }}_acados_sim_update_params"(sim_solver_capsule * capsule, double *value, int np_)
+    # int acados_sim_update_params_sparse "{{ model.name }}_acados_sim_update_params_sparse"(sim_solver_capsule * capsule, int stage, int *idx, double *p, int n_update)
+
+    acados_sim_solver_common.sim_in *acados_get_sim_in "{{ model.name }}_acados_get_sim_in"(sim_solver_capsule * capsule)
+    acados_sim_solver_common.sim_out *acados_get_sim_out "{{ model.name }}_acados_get_sim_out"(sim_solver_capsule * capsule)
+    acados_sim_solver_common.sim_solver *acados_get_sim_solver "{{ model.name }}_acados_get_sim_solver"(sim_solver_capsule * capsule)
+    acados_sim_solver_common.sim_config *acados_get_sim_config "{{ model.name }}_acados_get_sim_config"(sim_solver_capsule * capsule)
+    acados_sim_solver_common.sim_opts *acados_get_sim_opts "{{ model.name }}_acados_get_sim_opts"(sim_solver_capsule * capsule)
+    void *acados_get_sim_dims "{{ model.name }}_acados_get_sim_dims"(sim_solver_capsule * capsule)

third_party/acados/acados_template/c_templates_tera/acados_solver.in.h

@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) The acados authors.
+ *
+ * This file is part of acados.
+ *
+ * The 2-Clause BSD License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.;
+ */
+
+#ifndef ACADOS_SOLVER_{{ model.name }}_H_
+#define ACADOS_SOLVER_{{ model.name }}_H_
+
+#include "acados/utils/types.h"
+
+#include "acados_c/ocp_nlp_interface.h"
+#include "acados_c/external_function_interface.h"
+
+#define {{ model.name | upper }}_NX     {{ dims.nx }}
+#define {{ model.name | upper }}_NZ     {{ dims.nz }}
+#define {{ model.name | upper }}_NU     {{ dims.nu }}
+#define {{ model.name | upper }}_NP     {{ dims.np }}
+#define {{ model.name | upper }}_NBX    {{ dims.nbx }}
+#define {{ model.name | upper }}_NBX0   {{ dims.nbx_0 }}
+#define {{ model.name | upper }}_NBU    {{ dims.nbu }}
+#define {{ model.name | upper }}_NSBX   {{ dims.nsbx }}
+#define {{ model.name | upper }}_NSBU   {{ dims.nsbu }}
+#define {{ model.name | upper }}_NSH    {{ dims.nsh }}
+#define {{ model.name | upper }}_NSG    {{ dims.nsg }}
+#define {{ model.name | upper }}_NSPHI  {{ dims.nsphi }}
+#define {{ model.name | upper }}_NSHN   {{ dims.nsh_e }}
+#define {{ model.name | upper }}_NSGN   {{ dims.nsg_e }}
+#define {{ model.name | upper }}_NSPHIN {{ dims.nsphi_e }}
+#define {{ model.name | upper }}_NSBXN  {{ dims.nsbx_e }}
+#define {{ model.name | upper }}_NS     {{ dims.ns }}
+#define {{ model.name | upper }}_NSN    {{ dims.ns_e }}
+#define {{ model.name | upper }}_NG     {{ dims.ng }}
+#define {{ model.name | upper }}_NBXN   {{ dims.nbx_e }}
+#define {{ model.name | upper }}_NGN    {{ dims.ng_e }}
+#define {{ model.name | upper }}_NY0    {{ dims.ny_0 }}
+#define {{ model.name | upper }}_NY     {{ dims.ny }}
+#define {{ model.name | upper }}_NYN    {{ dims.ny_e }}
+#define {{ model.name | upper }}_N      {{ dims.N }}
+#define {{ model.name | upper }}_NH     {{ dims.nh }}
+#define {{ model.name | upper }}_NPHI   {{ dims.nphi }}
+#define {{ model.name | upper }}_NHN    {{ dims.nh_e }}
+#define {{ model.name | upper }}_NPHIN  {{ dims.nphi_e }}
+#define {{ model.name | upper }}_NR     {{ dims.nr }}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+{%- if not solver_options.custom_update_filename %}
+    {%- set custom_update_filename = "" %}
+{% else %}
+    {%- set custom_update_filename = solver_options.custom_update_filename %}
+{%- endif %}
+
+// ** capsule for solver data **
+typedef struct {{ model.name }}_solver_capsule
+{
+    // acados objects
+    ocp_nlp_in *nlp_in;
+    ocp_nlp_out *nlp_out;
+    ocp_nlp_out *sens_out;
+    ocp_nlp_solver *nlp_solver;
+    void *nlp_opts;
+    ocp_nlp_plan_t *nlp_solver_plan;
+    ocp_nlp_config *nlp_config;
+    ocp_nlp_dims *nlp_dims;
+
+    // number of expected runtime parameters
+    unsigned int nlp_np;
+
+    /* external functions */
+    // dynamics
+{% if solver_options.integrator_type == "ERK" %}
+    external_function_param_casadi *forw_vde_casadi;
+    external_function_param_casadi *expl_ode_fun;
+{% if solver_options.hessian_approx == "EXACT" %}
+    external_function_param_casadi *hess_vde_casadi;
+{%- endif %}
+{% elif solver_options.integrator_type == "IRK" %}
+    external_function_param_{{ model.dyn_ext_fun_type }} *impl_dae_fun;
+    external_function_param_{{ model.dyn_ext_fun_type }} *impl_dae_fun_jac_x_xdot_z;
+    external_function_param_{{ model.dyn_ext_fun_type }} *impl_dae_jac_x_xdot_u_z;
+{% if solver_options.hessian_approx == "EXACT" %}
+    external_function_param_{{ model.dyn_ext_fun_type }} *impl_dae_hess;
+{%- endif %}
+{% elif solver_options.integrator_type == "LIFTED_IRK" %}
+    external_function_param_{{ model.dyn_ext_fun_type }} *impl_dae_fun;
+    external_function_param_{{ model.dyn_ext_fun_type }} *impl_dae_fun_jac_x_xdot_u;
+{% elif solver_options.integrator_type == "GNSF" %}
+    external_function_param_casadi *gnsf_phi_fun;
+    external_function_param_casadi *gnsf_phi_fun_jac_y;
+    external_function_param_casadi *gnsf_phi_jac_y_uhat;
+    external_function_param_casadi *gnsf_f_lo_jac_x1_x1dot_u_z;
+    external_function_param_casadi *gnsf_get_matrices_fun;
+{% elif solver_options.integrator_type == "DISCRETE" %}
+    external_function_param_{{ model.dyn_ext_fun_type }} *discr_dyn_phi_fun;
+    external_function_param_{{ model.dyn_ext_fun_type }} *discr_dyn_phi_fun_jac_ut_xt;
+{%- if solver_options.hessian_approx == "EXACT" %}
+    external_function_param_{{ model.dyn_ext_fun_type }} *discr_dyn_phi_fun_jac_ut_xt_hess;
+{%- endif %}
+{%- endif %}
+
+
+    // cost
+{% if cost.cost_type == "NONLINEAR_LS" %}
+    external_function_param_casadi *cost_y_fun;
+    external_function_param_casadi *cost_y_fun_jac_ut_xt;
+    external_function_param_casadi *cost_y_hess;
+{% elif cost.cost_type == "CONVEX_OVER_NONLINEAR" %}
+    external_function_param_casadi *conl_cost_fun;
+    external_function_param_casadi *conl_cost_fun_jac_hess;
+{%- elif cost.cost_type == "EXTERNAL" %}
+    external_function_param_{{ cost.cost_ext_fun_type }} *ext_cost_fun;
+    external_function_param_{{ cost.cost_ext_fun_type }} *ext_cost_fun_jac;
+    external_function_param_{{ cost.cost_ext_fun_type }} *ext_cost_fun_jac_hess;
+{% endif %}
+
+{% if cost.cost_type_0 == "NONLINEAR_LS" %}
+    external_function_param_casadi cost_y_0_fun;
+    external_function_param_casadi cost_y_0_fun_jac_ut_xt;
+    external_function_param_casadi cost_y_0_hess;
+{% elif cost.cost_type_0 == "CONVEX_OVER_NONLINEAR" %}
+    external_function_param_casadi conl_cost_0_fun;
+    external_function_param_casadi conl_cost_0_fun_jac_hess;
+{% elif cost.cost_type_0 == "EXTERNAL" %}
+    external_function_param_{{ cost.cost_ext_fun_type_0 }} ext_cost_0_fun;
+    external_function_param_{{ cost.cost_ext_fun_type_0 }} ext_cost_0_fun_jac;
+    external_function_param_{{ cost.cost_ext_fun_type_0 }} ext_cost_0_fun_jac_hess;
+{%- endif %}
+
+{% if cost.cost_type_e == "NONLINEAR_LS" %}
+    external_function_param_casadi cost_y_e_fun;
+    external_function_param_casadi cost_y_e_fun_jac_ut_xt;
+    external_function_param_casadi cost_y_e_hess;
+{% elif cost.cost_type_e == "CONVEX_OVER_NONLINEAR" %}
+    external_function_param_casadi conl_cost_e_fun;
+    external_function_param_casadi conl_cost_e_fun_jac_hess;
+{% elif cost.cost_type_e == "EXTERNAL" %}
+    external_function_param_{{ cost.cost_ext_fun_type_e }} ext_cost_e_fun;
+    external_function_param_{{ cost.cost_ext_fun_type_e }} ext_cost_e_fun_jac;
+    external_function_param_{{ cost.cost_ext_fun_type_e }} ext_cost_e_fun_jac_hess;
+{%- endif %}
+
+    // constraints
+{%- if constraints.constr_type == "BGP" %}
+    external_function_param_casadi *phi_constraint;
+{% elif constraints.constr_type == "BGH" and dims.nh > 0 %}
+    external_function_param_casadi *nl_constr_h_fun_jac;
+    external_function_param_casadi *nl_constr_h_fun;
+{%- if solver_options.hessian_approx == "EXACT" %}
+    external_function_param_casadi *nl_constr_h_fun_jac_hess;
+{%- endif %}
+{%- endif %}
+
+
+{% if constraints.constr_type_e == "BGP" %}
+    external_function_param_casadi phi_e_constraint;
+{% elif constraints.constr_type_e == "BGH" and dims.nh_e > 0 %}
+    external_function_param_casadi nl_constr_h_e_fun_jac;
+    external_function_param_casadi nl_constr_h_e_fun;
+{%- if solver_options.hessian_approx == "EXACT" %}
+    external_function_param_casadi nl_constr_h_e_fun_jac_hess;
+{%- endif %}
+{%- endif %}
+
+{%- if custom_update_filename != "" %}
+    void * custom_update_memory;
+{%- endif %}
+
+} {{ model.name }}_solver_capsule;
+
+ACADOS_SYMBOL_EXPORT {{ model.name }}_solver_capsule * {{ model.name }}_acados_create_capsule(void);
+ACADOS_SYMBOL_EXPORT int {{ model.name }}_acados_free_capsule({{ model.name }}_solver_capsule *capsule);
+
+ACADOS_SYMBOL_EXPORT int {{ model.name }}_acados_create({{ model.name }}_solver_capsule * capsule);
+
+ACADOS_SYMBOL_EXPORT int {{ model.name }}_acados_reset({{ model.name }}_solver_capsule* capsule, int reset_qp_solver_mem);
+
+/**
+ * Generic version of {{ model.name }}_acados_create which allows to use a different number of shooting intervals than
+ * the number used for code generation. If new_time_steps=NULL and n_time_steps matches the number used for code
+ * generation, the time-steps from code generation is used.
+ */
+ACADOS_SYMBOL_EXPORT int {{ model.name }}_acados_create_with_discretization({{ model.name }}_solver_capsule * capsule, int n_time_steps, double* new_time_steps);
+/**
+ * Update the time step vector. Number N must be identical to the currently set number of shooting nodes in the
+ * nlp_solver_plan. Returns 0 if no error occurred and a otherwise a value other than 0.
+ */
+ACADOS_SYMBOL_EXPORT int {{ model.name }}_acados_update_time_steps({{ model.name }}_solver_capsule * capsule, int N, double* new_time_steps);
+/**
+ * This function is used for updating an already initialized solver with a different number of qp_cond_N.
+ */
+ACADOS_SYMBOL_EXPORT int {{ model.name }}_acados_update_qp_solver_cond_N({{ model.name }}_solver_capsule * capsule, int qp_solver_cond_N);
+ACADOS_SYMBOL_EXPORT int {{ model.name }}_acados_update_params({{ model.name }}_solver_capsule * capsule, int stage, double *value, int np);
+ACADOS_SYMBOL_EXPORT int {{ model.name }}_acados_update_params_sparse({{ model.name }}_solver_capsule * capsule, int stage, int *idx, double *p, int n_update);
+
+ACADOS_SYMBOL_EXPORT int {{ model.name }}_acados_solve({{ model.name }}_solver_capsule * capsule);
+ACADOS_SYMBOL_EXPORT int {{ model.name }}_acados_free({{ model.name }}_solver_capsule * capsule);
+ACADOS_SYMBOL_EXPORT void {{ model.name }}_acados_print_stats({{ model.name }}_solver_capsule * capsule);
+ACADOS_SYMBOL_EXPORT int {{ model.name }}_acados_custom_update({{ model.name }}_solver_capsule* capsule, double* data, int data_len);
+
+
+ACADOS_SYMBOL_EXPORT ocp_nlp_in *{{ model.name }}_acados_get_nlp_in({{ model.name }}_solver_capsule * capsule);
+ACADOS_SYMBOL_EXPORT ocp_nlp_out *{{ model.name }}_acados_get_nlp_out({{ model.name }}_solver_capsule * capsule);
+ACADOS_SYMBOL_EXPORT ocp_nlp_out *{{ model.name }}_acados_get_sens_out({{ model.name }}_solver_capsule * capsule);
+ACADOS_SYMBOL_EXPORT ocp_nlp_solver *{{ model.name }}_acados_get_nlp_solver({{ model.name }}_solver_capsule * capsule);
+ACADOS_SYMBOL_EXPORT ocp_nlp_config *{{ model.name }}_acados_get_nlp_config({{ model.name }}_solver_capsule * capsule);
+ACADOS_SYMBOL_EXPORT void *{{ model.name }}_acados_get_nlp_opts({{ model.name }}_solver_capsule * capsule);
+ACADOS_SYMBOL_EXPORT ocp_nlp_dims *{{ model.name }}_acados_get_nlp_dims({{ model.name }}_solver_capsule * capsule);
+ACADOS_SYMBOL_EXPORT ocp_nlp_plan_t *{{ model.name }}_acados_get_nlp_plan({{ model.name }}_solver_capsule * capsule);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif  // ACADOS_SOLVER_{{ model.name }}_H_

third_party/acados/acados_template/c_templates_tera/acados_solver.in.pxd

@@ -0,0 +1,62 @@
+#
+# Copyright (c) The acados authors.
+#
+# This file is part of acados.
+#
+# The 2-Clause BSD License
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.;
+#
+
+cimport acados_solver_common
+
+cdef extern from "acados_solver_{{ model.name }}.h":
+    ctypedef struct nlp_solver_capsule "{{ model.name }}_solver_capsule":
+        pass
+
+    nlp_solver_capsule * acados_create_capsule "{{ model.name }}_acados_create_capsule"()
+    int acados_free_capsule "{{ model.name }}_acados_free_capsule"(nlp_solver_capsule *capsule)
+
+    int acados_create "{{ model.name }}_acados_create"(nlp_solver_capsule * capsule)
+
+    int acados_create_with_discretization "{{ model.name }}_acados_create_with_discretization"(nlp_solver_capsule * capsule, int n_time_steps, double* new_time_steps)
+    int acados_update_time_steps "{{ model.name }}_acados_update_time_steps"(nlp_solver_capsule * capsule, int N, double* new_time_steps)
+    int acados_update_qp_solver_cond_N "{{ model.name }}_acados_update_qp_solver_cond_N"(nlp_solver_capsule * capsule, int qp_solver_cond_N)
+
+    int acados_update_params "{{ model.name }}_acados_update_params"(nlp_solver_capsule * capsule, int stage, double *value, int np_)
+    int acados_update_params_sparse "{{ model.name }}_acados_update_params_sparse"(nlp_solver_capsule * capsule, int stage, int *idx, double *p, int n_update)
+    int acados_solve "{{ model.name }}_acados_solve"(nlp_solver_capsule * capsule)
+    int acados_reset "{{ model.name }}_acados_reset"(nlp_solver_capsule * capsule, int reset_qp_solver_mem)
+    int acados_free "{{ model.name }}_acados_free"(nlp_solver_capsule * capsule)
+    void acados_print_stats "{{ model.name }}_acados_print_stats"(nlp_solver_capsule * capsule)
+
+    int acados_custom_update "{{ model.name }}_acados_custom_update"(nlp_solver_capsule* capsule, double * data, int data_len)
+
+    acados_solver_common.ocp_nlp_in *acados_get_nlp_in "{{ model.name }}_acados_get_nlp_in"(nlp_solver_capsule * capsule)
+    acados_solver_common.ocp_nlp_out *acados_get_nlp_out "{{ model.name }}_acados_get_nlp_out"(nlp_solver_capsule * capsule)
+    acados_solver_common.ocp_nlp_out *acados_get_sens_out "{{ model.name }}_acados_get_sens_out"(nlp_solver_capsule * capsule)
+    acados_solver_common.ocp_nlp_solver *acados_get_nlp_solver "{{ model.name }}_acados_get_nlp_solver"(nlp_solver_capsule * capsule)
+    acados_solver_common.ocp_nlp_config *acados_get_nlp_config "{{ model.name }}_acados_get_nlp_config"(nlp_solver_capsule * capsule)
+    void *acados_get_nlp_opts "{{ model.name }}_acados_get_nlp_opts"(nlp_solver_capsule * capsule)
+    acados_solver_common.ocp_nlp_dims *acados_get_nlp_dims "{{ model.name }}_acados_get_nlp_dims"(nlp_solver_capsule * capsule)
+    acados_solver_common.ocp_nlp_plan *acados_get_nlp_plan "{{ model.name }}_acados_get_nlp_plan"(nlp_solver_capsule * capsule)

third_party/acados/acados_template/c_templates_tera/constraints.in.h

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) The acados authors.
+ *
+ * This file is part of acados.
+ *
+ * The 2-Clause BSD License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.;
+ */
+
+#ifndef {{ model.name }}_CONSTRAINTS
+#define {{ model.name }}_CONSTRAINTS
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+{% if dims.nphi > 0 %}
+int {{ model.name }}_phi_constraint(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_phi_constraint_work(int *, int *, int *, int *);
+const int *{{ model.name }}_phi_constraint_sparsity_in(int);
+const int *{{ model.name }}_phi_constraint_sparsity_out(int);
+int {{ model.name }}_phi_constraint_n_in(void);
+int {{ model.name }}_phi_constraint_n_out(void);
+{% endif %}
+
+{% if dims.nphi_e > 0 %}
+int {{ model.name }}_phi_e_constraint(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_phi_e_constraint_work(int *, int *, int *, int *);
+const int *{{ model.name }}_phi_e_constraint_sparsity_in(int);
+const int *{{ model.name }}_phi_e_constraint_sparsity_out(int);
+int {{ model.name }}_phi_e_constraint_n_in(void);
+int {{ model.name }}_phi_e_constraint_n_out(void);
+{% endif %}
+
+{% if dims.nh > 0 %}
+int {{ model.name }}_constr_h_fun_jac_uxt_zt(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_constr_h_fun_jac_uxt_zt_work(int *, int *, int *, int *);
+const int *{{ model.name }}_constr_h_fun_jac_uxt_zt_sparsity_in(int);
+const int *{{ model.name }}_constr_h_fun_jac_uxt_zt_sparsity_out(int);
+int {{ model.name }}_constr_h_fun_jac_uxt_zt_n_in(void);
+int {{ model.name }}_constr_h_fun_jac_uxt_zt_n_out(void);
+
+int {{ model.name }}_constr_h_fun(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_constr_h_fun_work(int *, int *, int *, int *);
+const int *{{ model.name }}_constr_h_fun_sparsity_in(int);
+const int *{{ model.name }}_constr_h_fun_sparsity_out(int);
+int {{ model.name }}_constr_h_fun_n_in(void);
+int {{ model.name }}_constr_h_fun_n_out(void);
+
+{% if solver_options.hessian_approx == "EXACT" -%}
+int {{ model.name }}_constr_h_fun_jac_uxt_zt_hess(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_constr_h_fun_jac_uxt_zt_hess_work(int *, int *, int *, int *);
+const int *{{ model.name }}_constr_h_fun_jac_uxt_zt_hess_sparsity_in(int);
+const int *{{ model.name }}_constr_h_fun_jac_uxt_zt_hess_sparsity_out(int);
+int {{ model.name }}_constr_h_fun_jac_uxt_zt_hess_n_in(void);
+int {{ model.name }}_constr_h_fun_jac_uxt_zt_hess_n_out(void);
+{% endif %}
+{% endif %}
+
+{% if dims.nh_e > 0 %}
+int {{ model.name }}_constr_h_e_fun_jac_uxt_zt(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_constr_h_e_fun_jac_uxt_zt_work(int *, int *, int *, int *);
+const int *{{ model.name }}_constr_h_e_fun_jac_uxt_zt_sparsity_in(int);
+const int *{{ model.name }}_constr_h_e_fun_jac_uxt_zt_sparsity_out(int);
+int {{ model.name }}_constr_h_e_fun_jac_uxt_zt_n_in(void);
+int {{ model.name }}_constr_h_e_fun_jac_uxt_zt_n_out(void);
+
+int {{ model.name }}_constr_h_e_fun(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_constr_h_e_fun_work(int *, int *, int *, int *);
+const int *{{ model.name }}_constr_h_e_fun_sparsity_in(int);
+const int *{{ model.name }}_constr_h_e_fun_sparsity_out(int);
+int {{ model.name }}_constr_h_e_fun_n_in(void);
+int {{ model.name }}_constr_h_e_fun_n_out(void);
+
+{% if solver_options.hessian_approx == "EXACT" -%}
+int {{ model.name }}_constr_h_e_fun_jac_uxt_zt_hess(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_constr_h_e_fun_jac_uxt_zt_hess_work(int *, int *, int *, int *);
+const int *{{ model.name }}_constr_h_e_fun_jac_uxt_zt_hess_sparsity_in(int);
+const int *{{ model.name }}_constr_h_e_fun_jac_uxt_zt_hess_sparsity_out(int);
+int {{ model.name }}_constr_h_e_fun_jac_uxt_zt_hess_n_in(void);
+int {{ model.name }}_constr_h_e_fun_jac_uxt_zt_hess_n_out(void);
+{% endif %}
+{% endif %}
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif  // {{ model.name }}_CONSTRAINTS

third_party/acados/acados_template/c_templates_tera/cost.in.h

@@ -0,0 +1,238 @@
+/*
+ * Copyright (c) The acados authors.
+ *
+ * This file is part of acados.
+ *
+ * The 2-Clause BSD License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.;
+ */
+
+
+#ifndef {{ model.name }}_COST
+#define {{ model.name }}_COST
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+// Cost at initial shooting node
+{% if cost.cost_type_0 == "NONLINEAR_LS" %}
+int {{ model.name }}_cost_y_0_fun(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_cost_y_0_fun_work(int *, int *, int *, int *);
+const int *{{ model.name }}_cost_y_0_fun_sparsity_in(int);
+const int *{{ model.name }}_cost_y_0_fun_sparsity_out(int);
+int {{ model.name }}_cost_y_0_fun_n_in(void);
+int {{ model.name }}_cost_y_0_fun_n_out(void);
+
+int {{ model.name }}_cost_y_0_fun_jac_ut_xt(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_cost_y_0_fun_jac_ut_xt_work(int *, int *, int *, int *);
+const int *{{ model.name }}_cost_y_0_fun_jac_ut_xt_sparsity_in(int);
+const int *{{ model.name }}_cost_y_0_fun_jac_ut_xt_sparsity_out(int);
+int {{ model.name }}_cost_y_0_fun_jac_ut_xt_n_in(void);
+int {{ model.name }}_cost_y_0_fun_jac_ut_xt_n_out(void);
+
+int {{ model.name }}_cost_y_0_hess(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_cost_y_0_hess_work(int *, int *, int *, int *);
+const int *{{ model.name }}_cost_y_0_hess_sparsity_in(int);
+const int *{{ model.name }}_cost_y_0_hess_sparsity_out(int);
+int {{ model.name }}_cost_y_0_hess_n_in(void);
+int {{ model.name }}_cost_y_0_hess_n_out(void);
+{% elif cost.cost_type_0 == "CONVEX_OVER_NONLINEAR" %}
+
+int {{ model.name }}_conl_cost_0_fun(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_conl_cost_0_fun_work(int *, int *, int *, int *);
+const int *{{ model.name }}_conl_cost_0_fun_sparsity_in(int);
+const int *{{ model.name }}_conl_cost_0_fun_sparsity_out(int);
+int {{ model.name }}_conl_cost_0_fun_n_in(void);
+int {{ model.name }}_conl_cost_0_fun_n_out(void);
+
+int {{ model.name }}_conl_cost_0_fun_jac_hess(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_conl_cost_0_fun_jac_hess_work(int *, int *, int *, int *);
+const int *{{ model.name }}_conl_cost_0_fun_jac_hess_sparsity_in(int);
+const int *{{ model.name }}_conl_cost_0_fun_jac_hess_sparsity_out(int);
+int {{ model.name }}_conl_cost_0_fun_jac_hess_n_in(void);
+int {{ model.name }}_conl_cost_0_fun_jac_hess_n_out(void);
+
+{% elif cost.cost_type_0 == "EXTERNAL" %}
+    {%- if cost.cost_ext_fun_type_0 == "casadi" %}
+int {{ model.name }}_cost_ext_cost_0_fun(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_cost_ext_cost_0_fun_work(int *, int *, int *, int *);
+const int *{{ model.name }}_cost_ext_cost_0_fun_sparsity_in(int);
+const int *{{ model.name }}_cost_ext_cost_0_fun_sparsity_out(int);
+int {{ model.name }}_cost_ext_cost_0_fun_n_in(void);
+int {{ model.name }}_cost_ext_cost_0_fun_n_out(void);
+
+int {{ model.name }}_cost_ext_cost_0_fun_jac_hess(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_cost_ext_cost_0_fun_jac_hess_work(int *, int *, int *, int *);
+const int *{{ model.name }}_cost_ext_cost_0_fun_jac_hess_sparsity_in(int);
+const int *{{ model.name }}_cost_ext_cost_0_fun_jac_hess_sparsity_out(int);
+int {{ model.name }}_cost_ext_cost_0_fun_jac_hess_n_in(void);
+int {{ model.name }}_cost_ext_cost_0_fun_jac_hess_n_out(void);
+
+int {{ model.name }}_cost_ext_cost_0_fun_jac(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_cost_ext_cost_0_fun_jac_work(int *, int *, int *, int *);
+const int *{{ model.name }}_cost_ext_cost_0_fun_jac_sparsity_in(int);
+const int *{{ model.name }}_cost_ext_cost_0_fun_jac_sparsity_out(int);
+int {{ model.name }}_cost_ext_cost_0_fun_jac_n_in(void);
+int {{ model.name }}_cost_ext_cost_0_fun_jac_n_out(void);
+    {%- else %}
+int {{ cost.cost_function_ext_cost_0 }}(void **, void **, void *);
+    {%- endif %}
+{% endif %}
+
+
+// Cost at path shooting node
+{% if cost.cost_type == "NONLINEAR_LS" %}
+int {{ model.name }}_cost_y_fun(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_cost_y_fun_work(int *, int *, int *, int *);
+const int *{{ model.name }}_cost_y_fun_sparsity_in(int);
+const int *{{ model.name }}_cost_y_fun_sparsity_out(int);
+int {{ model.name }}_cost_y_fun_n_in(void);
+int {{ model.name }}_cost_y_fun_n_out(void);
+
+int {{ model.name }}_cost_y_fun_jac_ut_xt(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_cost_y_fun_jac_ut_xt_work(int *, int *, int *, int *);
+const int *{{ model.name }}_cost_y_fun_jac_ut_xt_sparsity_in(int);
+const int *{{ model.name }}_cost_y_fun_jac_ut_xt_sparsity_out(int);
+int {{ model.name }}_cost_y_fun_jac_ut_xt_n_in(void);
+int {{ model.name }}_cost_y_fun_jac_ut_xt_n_out(void);
+
+int {{ model.name }}_cost_y_hess(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_cost_y_hess_work(int *, int *, int *, int *);
+const int *{{ model.name }}_cost_y_hess_sparsity_in(int);
+const int *{{ model.name }}_cost_y_hess_sparsity_out(int);
+int {{ model.name }}_cost_y_hess_n_in(void);
+int {{ model.name }}_cost_y_hess_n_out(void);
+
+{% elif cost.cost_type == "CONVEX_OVER_NONLINEAR" %}
+int {{ model.name }}_conl_cost_fun(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_conl_cost_fun_work(int *, int *, int *, int *);
+const int *{{ model.name }}_conl_cost_fun_sparsity_in(int);
+const int *{{ model.name }}_conl_cost_fun_sparsity_out(int);
+int {{ model.name }}_conl_cost_fun_n_in(void);
+int {{ model.name }}_conl_cost_fun_n_out(void);
+
+int {{ model.name }}_conl_cost_fun_jac_hess(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_conl_cost_fun_jac_hess_work(int *, int *, int *, int *);
+const int *{{ model.name }}_conl_cost_fun_jac_hess_sparsity_in(int);
+const int *{{ model.name }}_conl_cost_fun_jac_hess_sparsity_out(int);
+int {{ model.name }}_conl_cost_fun_jac_hess_n_in(void);
+int {{ model.name }}_conl_cost_fun_jac_hess_n_out(void);
+{% elif cost.cost_type == "EXTERNAL" %}
+    {%- if cost.cost_ext_fun_type == "casadi" %}
+int {{ model.name }}_cost_ext_cost_fun(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_cost_ext_cost_fun_work(int *, int *, int *, int *);
+const int *{{ model.name }}_cost_ext_cost_fun_sparsity_in(int);
+const int *{{ model.name }}_cost_ext_cost_fun_sparsity_out(int);
+int {{ model.name }}_cost_ext_cost_fun_n_in(void);
+int {{ model.name }}_cost_ext_cost_fun_n_out(void);
+
+int {{ model.name }}_cost_ext_cost_fun_jac_hess(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_cost_ext_cost_fun_jac_hess_work(int *, int *, int *, int *);
+const int *{{ model.name }}_cost_ext_cost_fun_jac_hess_sparsity_in(int);
+const int *{{ model.name }}_cost_ext_cost_fun_jac_hess_sparsity_out(int);
+int {{ model.name }}_cost_ext_cost_fun_jac_hess_n_in(void);
+int {{ model.name }}_cost_ext_cost_fun_jac_hess_n_out(void);
+
+int {{ model.name }}_cost_ext_cost_fun_jac(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_cost_ext_cost_fun_jac_work(int *, int *, int *, int *);
+const int *{{ model.name }}_cost_ext_cost_fun_jac_sparsity_in(int);
+const int *{{ model.name }}_cost_ext_cost_fun_jac_sparsity_out(int);
+int {{ model.name }}_cost_ext_cost_fun_jac_n_in(void);
+int {{ model.name }}_cost_ext_cost_fun_jac_n_out(void);
+    {%- else %}
+int {{ cost.cost_function_ext_cost }}(void **, void **, void *);
+    {%- endif %}
+{% endif %}
+
+// Cost at terminal shooting node
+{% if cost.cost_type_e == "NONLINEAR_LS" %}
+int {{ model.name }}_cost_y_e_fun(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_cost_y_e_fun_work(int *, int *, int *, int *);
+const int *{{ model.name }}_cost_y_e_fun_sparsity_in(int);
+const int *{{ model.name }}_cost_y_e_fun_sparsity_out(int);
+int {{ model.name }}_cost_y_e_fun_n_in(void);
+int {{ model.name }}_cost_y_e_fun_n_out(void);
+
+int {{ model.name }}_cost_y_e_fun_jac_ut_xt(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_cost_y_e_fun_jac_ut_xt_work(int *, int *, int *, int *);
+const int *{{ model.name }}_cost_y_e_fun_jac_ut_xt_sparsity_in(int);
+const int *{{ model.name }}_cost_y_e_fun_jac_ut_xt_sparsity_out(int);
+int {{ model.name }}_cost_y_e_fun_jac_ut_xt_n_in(void);
+int {{ model.name }}_cost_y_e_fun_jac_ut_xt_n_out(void);
+
+int {{ model.name }}_cost_y_e_hess(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_cost_y_e_hess_work(int *, int *, int *, int *);
+const int *{{ model.name }}_cost_y_e_hess_sparsity_in(int);
+const int *{{ model.name }}_cost_y_e_hess_sparsity_out(int);
+int {{ model.name }}_cost_y_e_hess_n_in(void);
+int {{ model.name }}_cost_y_e_hess_n_out(void);
+{% elif cost.cost_type_e == "CONVEX_OVER_NONLINEAR" %}
+int {{ model.name }}_conl_cost_e_fun(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_conl_cost_e_fun_work(int *, int *, int *, int *);
+const int *{{ model.name }}_conl_cost_e_fun_sparsity_in(int);
+const int *{{ model.name }}_conl_cost_e_fun_sparsity_out(int);
+int {{ model.name }}_conl_cost_e_fun_n_in(void);
+int {{ model.name }}_conl_cost_e_fun_n_out(void);
+
+int {{ model.name }}_conl_cost_e_fun_jac_hess(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_conl_cost_e_fun_jac_hess_work(int *, int *, int *, int *);
+const int *{{ model.name }}_conl_cost_e_fun_jac_hess_sparsity_in(int);
+const int *{{ model.name }}_conl_cost_e_fun_jac_hess_sparsity_out(int);
+int {{ model.name }}_conl_cost_e_fun_jac_hess_n_in(void);
+int {{ model.name }}_conl_cost_e_fun_jac_hess_n_out(void);
+{% elif cost.cost_type_e == "EXTERNAL" %}
+    {%- if cost.cost_ext_fun_type_e == "casadi" %}
+int {{ model.name }}_cost_ext_cost_e_fun(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_cost_ext_cost_e_fun_work(int *, int *, int *, int *);
+const int *{{ model.name }}_cost_ext_cost_e_fun_sparsity_in(int);
+const int *{{ model.name }}_cost_ext_cost_e_fun_sparsity_out(int);
+int {{ model.name }}_cost_ext_cost_e_fun_n_in(void);
+int {{ model.name }}_cost_ext_cost_e_fun_n_out(void);
+
+int {{ model.name }}_cost_ext_cost_e_fun_jac_hess(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_cost_ext_cost_e_fun_jac_hess_work(int *, int *, int *, int *);
+const int *{{ model.name }}_cost_ext_cost_e_fun_jac_hess_sparsity_in(int);
+const int *{{ model.name }}_cost_ext_cost_e_fun_jac_hess_sparsity_out(int);
+int {{ model.name }}_cost_ext_cost_e_fun_jac_hess_n_in(void);
+int {{ model.name }}_cost_ext_cost_e_fun_jac_hess_n_out(void);
+
+int {{ model.name }}_cost_ext_cost_e_fun_jac(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_cost_ext_cost_e_fun_jac_work(int *, int *, int *, int *);
+const int *{{ model.name }}_cost_ext_cost_e_fun_jac_sparsity_in(int);
+const int *{{ model.name }}_cost_ext_cost_e_fun_jac_sparsity_out(int);
+int {{ model.name }}_cost_ext_cost_e_fun_jac_n_in(void);
+int {{ model.name }}_cost_ext_cost_e_fun_jac_n_out(void);
+    {%- else %}
+int {{ cost.cost_function_ext_cost_e }}(void **, void **, void *);
+    {%- endif %}
+{% endif %}
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif  // {{ model.name }}_COST

third_party/acados/acados_template/c_templates_tera/main.in.c

@@ -0,0 +1,226 @@
+/*
+ * Copyright (c) The acados authors.
+ *
+ * This file is part of acados.
+ *
+ * The 2-Clause BSD License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.;
+ */
+
+{%- if not solver_options.custom_update_filename %}
+    {%- set custom_update_filename = "" %}
+{% else %}
+    {%- set custom_update_filename = solver_options.custom_update_filename %}
+{%- endif %}
+
+// standard
+#include <stdio.h>
+#include <stdlib.h>
+// acados
+#include "acados/utils/print.h"
+#include "acados/utils/math.h"
+#include "acados_c/ocp_nlp_interface.h"
+#include "acados_c/external_function_interface.h"
+#include "acados_solver_{{ model.name }}.h"
+
+// blasfeo
+#include "blasfeo/include/blasfeo_d_aux_ext_dep.h"
+
+#define NX     {{ model.name | upper }}_NX
+#define NZ     {{ model.name | upper }}_NZ
+#define NU     {{ model.name | upper }}_NU
+#define NP     {{ model.name | upper }}_NP
+#define NBX    {{ model.name | upper }}_NBX
+#define NBX0   {{ model.name | upper }}_NBX0
+#define NBU    {{ model.name | upper }}_NBU
+#define NSBX   {{ model.name | upper }}_NSBX
+#define NSBU   {{ model.name | upper }}_NSBU
+#define NSH    {{ model.name | upper }}_NSH
+#define NSG    {{ model.name | upper }}_NSG
+#define NSPHI  {{ model.name | upper }}_NSPHI
+#define NSHN   {{ model.name | upper }}_NSHN
+#define NSGN   {{ model.name | upper }}_NSGN
+#define NSPHIN {{ model.name | upper }}_NSPHIN
+#define NSBXN  {{ model.name | upper }}_NSBXN
+#define NS     {{ model.name | upper }}_NS
+#define NSN    {{ model.name | upper }}_NSN
+#define NG     {{ model.name | upper }}_NG
+#define NBXN   {{ model.name | upper }}_NBXN
+#define NGN    {{ model.name | upper }}_NGN
+#define NY0    {{ model.name | upper }}_NY0
+#define NY     {{ model.name | upper }}_NY
+#define NYN    {{ model.name | upper }}_NYN
+#define NH     {{ model.name | upper }}_NH
+#define NPHI   {{ model.name | upper }}_NPHI
+#define NHN    {{ model.name | upper }}_NHN
+#define NPHIN  {{ model.name | upper }}_NPHIN
+#define NR     {{ model.name | upper }}_NR
+
+
+int main()
+{
+
+    {{ model.name }}_solver_capsule *acados_ocp_capsule = {{ model.name }}_acados_create_capsule();
+    // there is an opportunity to change the number of shooting intervals in C without new code generation
+    int N = {{ model.name | upper }}_N;
+    // allocate the array and fill it accordingly
+    double* new_time_steps = NULL;
+    int status = {{ model.name }}_acados_create_with_discretization(acados_ocp_capsule, N, new_time_steps);
+
+    if (status)
+    {
+        printf("{{ model.name }}_acados_create() returned status %d. Exiting.\n", status);
+        exit(1);
+    }
+
+    ocp_nlp_config *nlp_config = {{ model.name }}_acados_get_nlp_config(acados_ocp_capsule);
+    ocp_nlp_dims *nlp_dims = {{ model.name }}_acados_get_nlp_dims(acados_ocp_capsule);
+    ocp_nlp_in *nlp_in = {{ model.name }}_acados_get_nlp_in(acados_ocp_capsule);
+    ocp_nlp_out *nlp_out = {{ model.name }}_acados_get_nlp_out(acados_ocp_capsule);
+    ocp_nlp_solver *nlp_solver = {{ model.name }}_acados_get_nlp_solver(acados_ocp_capsule);
+    void *nlp_opts = {{ model.name }}_acados_get_nlp_opts(acados_ocp_capsule);
+
+    // initial condition
+    int idxbx0[NBX0];
+    {%- for i in range(end=dims.nbx_0) %}
+    idxbx0[{{ i }}] = {{ constraints.idxbx_0[i] }};
+    {%- endfor %}
+
+    double lbx0[NBX0];
+    double ubx0[NBX0];
+    {%- for i in range(end=dims.nbx_0) %}
+    lbx0[{{ i }}] = {{ constraints.lbx_0[i] }};
+    ubx0[{{ i }}] = {{ constraints.ubx_0[i] }};
+    {%- endfor %}
+
+    ocp_nlp_constraints_model_set(nlp_config, nlp_dims, nlp_in, 0, "idxbx", idxbx0);
+    ocp_nlp_constraints_model_set(nlp_config, nlp_dims, nlp_in, 0, "lbx", lbx0);
+    ocp_nlp_constraints_model_set(nlp_config, nlp_dims, nlp_in, 0, "ubx", ubx0);
+
+    // initialization for state values
+    double x_init[NX];
+    {%- for i in range(end=dims.nx) %}
+    x_init[{{ i }}] = 0.0;
+    {%- endfor %}
+
+    // initial value for control input
+    double u0[NU];
+    {%- for i in range(end=dims.nu) %}
+    u0[{{ i }}] = 0.0;
+    {%- endfor %}
+
+
+  {%- if dims.np > 0 %}
+    // set parameters
+    double p[NP];
+    {%- for item in parameter_values %}
+    p[{{ loop.index0 }}] = {{ item }};
+    {%- endfor %}
+
+    for (int ii = 0; ii <= N; ii++)
+    {
+        {{ model.name }}_acados_update_params(acados_ocp_capsule, ii, p, NP);
+    }
+  {% endif %}{# if np > 0 #}
+
+    // prepare evaluation
+    int NTIMINGS = 1;
+    double min_time = 1e12;
+    double kkt_norm_inf;
+    double elapsed_time;
+    int sqp_iter;
+
+    double xtraj[NX * (N+1)];
+    double utraj[NU * N];
+
+
+    // solve ocp in loop
+    int rti_phase = 0;
+
+    for (int ii = 0; ii < NTIMINGS; ii++)
+    {
+        // initialize solution
+        for (int i = 0; i < N; i++)
+        {
+            ocp_nlp_out_set(nlp_config, nlp_dims, nlp_out, i, "x", x_init);
+            ocp_nlp_out_set(nlp_config, nlp_dims, nlp_out, i, "u", u0);
+        }
+        ocp_nlp_out_set(nlp_config, nlp_dims, nlp_out, N, "x", x_init);
+        ocp_nlp_solver_opts_set(nlp_config, nlp_opts, "rti_phase", &rti_phase);
+        status = {{ model.name }}_acados_solve(acados_ocp_capsule);
+        ocp_nlp_get(nlp_config, nlp_solver, "time_tot", &elapsed_time);
+        min_time = MIN(elapsed_time, min_time);
+    }
+
+    /* print solution and statistics */
+    for (int ii = 0; ii <= nlp_dims->N; ii++)
+        ocp_nlp_out_get(nlp_config, nlp_dims, nlp_out, ii, "x", &xtraj[ii*NX]);
+    for (int ii = 0; ii < nlp_dims->N; ii++)
+        ocp_nlp_out_get(nlp_config, nlp_dims, nlp_out, ii, "u", &utraj[ii*NU]);
+
+    printf("\n--- xtraj ---\n");
+    d_print_exp_tran_mat( NX, N+1, xtraj, NX);
+    printf("\n--- utraj ---\n");
+    d_print_exp_tran_mat( NU, N, utraj, NU );
+    // ocp_nlp_out_print(nlp_solver->dims, nlp_out);
+
+    printf("\nsolved ocp %d times, solution printed above\n\n", NTIMINGS);
+
+    if (status == ACADOS_SUCCESS)
+    {
+        printf("{{ model.name }}_acados_solve(): SUCCESS!\n");
+    }
+    else
+    {
+        printf("{{ model.name }}_acados_solve() failed with status %d.\n", status);
+    }
+
+
+{%- if custom_update_filename != "" %}
+    {{ model.name }}_acados_custom_update(acados_ocp_capsule, xtraj, NX*(N+1));
+{%- endif %}
+
+    // get solution
+    ocp_nlp_out_get(nlp_config, nlp_dims, nlp_out, 0, "kkt_norm_inf", &kkt_norm_inf);
+    ocp_nlp_get(nlp_config, nlp_solver, "sqp_iter", &sqp_iter);
+
+    {{ model.name }}_acados_print_stats(acados_ocp_capsule);
+
+    printf("\nSolver info:\n");
+    printf(" SQP iterations %2d\n minimum time for %d solve %f [ms]\n KKT %e\n",
+           sqp_iter, NTIMINGS, min_time*1000, kkt_norm_inf);
+
+    // free solver
+    status = {{ model.name }}_acados_free(acados_ocp_capsule);
+    if (status) {
+        printf("{{ model.name }}_acados_free() returned status %d. \n", status);
+    }
+    // free solver capsule
+    status = {{ model.name }}_acados_free_capsule(acados_ocp_capsule);
+    if (status) {
+        printf("{{ model.name }}_acados_free_capsule() returned status %d. \n", status);
+    }
+
+    return status;
+}

third_party/acados/acados_template/c_templates_tera/main_sim.in.c

@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) The acados authors.
+ *
+ * This file is part of acados.
+ *
+ * The 2-Clause BSD License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.;
+ */
+
+
+// standard
+#include <stdio.h>
+#include <stdlib.h>
+// acados
+#include "acados/utils/print.h"
+#include "acados/utils/math.h"
+#include "acados_c/sim_interface.h"
+#include "acados_sim_solver_{{ model.name }}.h"
+
+#define NX     {{ model.name | upper }}_NX
+#define NZ     {{ model.name | upper }}_NZ
+#define NU     {{ model.name | upper }}_NU
+#define NP     {{ model.name | upper }}_NP
+
+
+int main()
+{
+    int status = 0;
+    sim_solver_capsule *capsule = {{ model.name }}_acados_sim_solver_create_capsule();
+    status = {{ model.name }}_acados_sim_create(capsule);
+
+    if (status)
+    {
+        printf("acados_create() returned status %d. Exiting.\n", status);
+        exit(1);
+    }
+
+    sim_config *acados_sim_config = {{ model.name }}_acados_get_sim_config(capsule);
+    sim_in *acados_sim_in = {{ model.name }}_acados_get_sim_in(capsule);
+    sim_out *acados_sim_out = {{ model.name }}_acados_get_sim_out(capsule);
+    void *acados_sim_dims = {{ model.name }}_acados_get_sim_dims(capsule);
+
+    // initial condition
+    double x_current[NX];
+    {%- for i in range(end=dims.nx) %}
+    x_current[{{ i }}] = 0.0;
+    {%- endfor %}
+
+  {% if constraints.lbx_0 %}
+    {%- for i in range(end=dims.nbx_0) %}
+    x_current[{{ constraints.idxbx_0[i] }}] = {{ constraints.lbx_0[i] }};
+    {%- endfor %}
+    {% if dims.nbx_0 != dims.nx %}
+    printf("main_sim: NOTE: initial state not fully defined via lbx_0, using 0.0 for indices that are not in idxbx_0.");
+    {%- endif %}
+  {% else %}
+    printf("main_sim: initial state not defined, should be in lbx_0, using zero vector.");
+  {%- endif %}
+
+
+    // initial value for control input
+    double u0[NU];
+    {%- for i in range(end=dims.nu) %}
+    u0[{{ i }}] = 0.0;
+    {%- endfor %}
+
+  {%- if dims.np > 0 %}
+    // set parameters
+    double p[NP];
+    {%- for item in parameter_values %}
+    p[{{ loop.index0 }}] = {{ item }};
+    {%- endfor %}
+
+    {{ model.name }}_acados_sim_update_params(capsule, p, NP);
+  {% endif %}{# if np > 0 #}
+
+    int n_sim_steps = 3;
+    // solve ocp in loop
+    for (int ii = 0; ii < n_sim_steps; ii++)
+    {
+        sim_in_set(acados_sim_config, acados_sim_dims,
+            acados_sim_in, "x", x_current);
+        status = {{ model.name }}_acados_sim_solve(capsule);
+
+        if (status != ACADOS_SUCCESS)
+        {
+            printf("acados_solve() failed with status %d.\n", status);
+        }
+
+        sim_out_get(acados_sim_config, acados_sim_dims,
+               acados_sim_out, "x", x_current);
+        
+        printf("\nx_current, %d\n", ii);
+        for (int jj = 0; jj < NX; jj++)
+        {
+            printf("%e\n", x_current[jj]);
+        }
+    }
+
+    printf("\nPerformed %d simulation steps with acados integrator successfully.\n\n", n_sim_steps);
+
+    // free solver
+    status = {{ model.name }}_acados_sim_free(capsule);
+    if (status) {
+        printf("{{ model.name }}_acados_sim_free() returned status %d. \n", status);
+    }
+
+    {{ model.name }}_acados_sim_solver_free_capsule(capsule);
+
+    return status;
+}

third_party/acados/acados_template/c_templates_tera/matlab_templates/acados_mex_create.in.c

@@ -0,0 +1,384 @@
+/*
+ * Copyright (c) The acados authors.
+ *
+ * This file is part of acados.
+ *
+ * The 2-Clause BSD License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.;
+ */
+
+
+// standard
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// acados
+#include "acados/utils/print.h"
+#include "acados_c/ocp_nlp_interface.h"
+#include "acados_solver_{{ model.name }}.h"
+
+// mex
+#include "mex.h"
+
+
+void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
+{
+    long long *l_ptr;
+    int status = 0;
+
+    // create solver
+    {{ model.name }}_solver_capsule *acados_ocp_capsule = {{ model.name }}_acados_create_capsule();
+
+    status = {{ model.name }}_acados_create(acados_ocp_capsule);
+
+    if (status)
+    {
+        mexPrintf("{{ model.name }}_acados_create() returned status %d.\n", status);
+    }
+    mexPrintf("{{ model.name }}_acados_create() -> success!\n");
+
+    // get pointers to nlp solver related objects
+    ocp_nlp_plan_t *nlp_plan = {{ model.name }}_acados_get_nlp_plan(acados_ocp_capsule);
+    ocp_nlp_config *nlp_config = {{ model.name }}_acados_get_nlp_config(acados_ocp_capsule);
+    ocp_nlp_dims *nlp_dims = {{ model.name }}_acados_get_nlp_dims(acados_ocp_capsule);
+    ocp_nlp_in *nlp_in = {{ model.name }}_acados_get_nlp_in(acados_ocp_capsule);
+    ocp_nlp_out *nlp_out = {{ model.name }}_acados_get_nlp_out(acados_ocp_capsule);
+    ocp_nlp_solver *nlp_solver = {{ model.name }}_acados_get_nlp_solver(acados_ocp_capsule);
+    void *nlp_opts = {{ model.name }}_acados_get_nlp_opts(acados_ocp_capsule);
+
+    // mexPrintf("acados: got pointer to objectes!\n");
+
+    // field names of output struct
+    #define FIELDS_OCP 9
+    #define FIELDS_EXT_FUN 25
+    #define MAX_FIELDS 25
+    char *fieldnames[MAX_FIELDS];
+
+    for (int i = 0; i < MAX_FIELDS; i++)
+    {
+        fieldnames[i] = (char*) mxMalloc(50);
+    }
+
+    memcpy(fieldnames[0],"config",sizeof("config"));
+    memcpy(fieldnames[1],"dims",sizeof("dims"));
+    memcpy(fieldnames[2],"opts",sizeof("opts"));
+    memcpy(fieldnames[3],"in",sizeof("in"));
+    memcpy(fieldnames[4],"out",sizeof("out"));
+    memcpy(fieldnames[5],"solver",sizeof("solver"));
+    memcpy(fieldnames[6],"sens_out",sizeof("sens_out"));
+    memcpy(fieldnames[7],"plan",sizeof("plan"));
+    memcpy(fieldnames[8],"capsule",sizeof("capsule"));
+
+    // create output struct - C_ocp
+    plhs[0] = mxCreateStructMatrix(1, 1, 9, (const char **) fieldnames);
+
+    // MEX: config, dims, opts, in, out, solver, sens_out, plan
+    // plan
+    mxArray *plan_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    l_ptr = mxGetData(plan_mat);
+    l_ptr[0] = (long long) nlp_plan;
+    mxSetField(plhs[0], 0, "plan", plan_mat);
+
+    // config
+    mxArray *config_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    l_ptr = mxGetData(config_mat);
+    l_ptr[0] = (long long) nlp_config;
+    mxSetField(plhs[0], 0, "config", config_mat);
+
+    // dims
+    mxArray *dims_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    l_ptr = mxGetData(dims_mat);
+    l_ptr[0] = (long long) nlp_dims;
+    mxSetField(plhs[0], 0, "dims", dims_mat);
+
+    // opts
+    mxArray *opts_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    l_ptr = mxGetData(opts_mat);
+    l_ptr[0] = (long long) nlp_opts;
+    mxSetField(plhs[0], 0, "opts", opts_mat);
+
+    // in
+    mxArray *in_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    l_ptr = mxGetData(in_mat);
+    l_ptr[0] = (long long) nlp_in;
+    mxSetField(plhs[0], 0, "in", in_mat);
+
+    // out
+    mxArray *out_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    l_ptr = mxGetData(out_mat);
+    l_ptr[0] = (long long) nlp_out;
+    mxSetField(plhs[0], 0, "out", out_mat);
+
+    // solver
+    mxArray *solver_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    l_ptr = mxGetData(solver_mat);
+    l_ptr[0] = (long long) nlp_solver;
+    mxSetField(plhs[0], 0, "solver", solver_mat);
+
+    // TODO: sens_out not actually implemented in templates..
+    // sens_out
+    mxArray *sens_out_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    l_ptr = mxGetData(sens_out_mat);
+    l_ptr[0] = (long long) 1;
+    mxSetField(plhs[0], 0, "sens_out", sens_out_mat);
+
+    // capsule
+    mxArray *capsule_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    l_ptr = mxGetData(capsule_mat);
+    l_ptr[0] = (long long) acados_ocp_capsule;
+    mxSetField(plhs[0], 0, "capsule", capsule_mat);
+
+    /* store external function pointers */
+    // dyn
+    memcpy(fieldnames[0],"expl_ode_fun",sizeof("expl_ode_fun"));
+    memcpy(fieldnames[1],"forw_vde",sizeof("forw_vde"));
+    memcpy(fieldnames[2],"hess_vde",sizeof("hess_vde"));
+    memcpy(fieldnames[3],"impl_dae_fun",sizeof("impl_dae_fun"));
+    memcpy(fieldnames[4],"impl_dae_fun_jac_x_xdot_z",sizeof("impl_dae_fun_jac_x_xdot_z"));
+    memcpy(fieldnames[5],"impl_dae_jac_x_xdot_u_z",sizeof("impl_dae_jac_x_xdot_u_z"));
+    memcpy(fieldnames[6],"impl_dae_hess",sizeof("impl_dae_hess"));
+
+    memcpy(fieldnames[7],"gnsf_phi_fun",sizeof("gnsf_phi_fun"));
+    memcpy(fieldnames[8],"gnsf_phi_fun_jac_y",sizeof("gnsf_phi_fun_jac_y"));
+    memcpy(fieldnames[9],"gnsf_phi_jac_y_uhat",sizeof("gnsf_phi_jac_y_uhat"));
+    memcpy(fieldnames[10],"gnsf_f_lo_jac_x1_x1dot_u_z",sizeof("gnsf_f_lo_jac_x1_x1dot_u_z"));
+    memcpy(fieldnames[11],"gnsf_get_matrices_fun",sizeof("gnsf_get_matrices_fun"));
+
+    memcpy(fieldnames[12],"disc_phi_fun",sizeof("disc_phi_fun"));
+    memcpy(fieldnames[13],"disc_phi_fun_jac",sizeof("disc_phi_fun_jac"));
+    memcpy(fieldnames[14],"disc_phi_fun_jac_hess",sizeof("disc_phi_fun_jac_hess"));
+    
+    // cost
+    memcpy(fieldnames[15],"cost_y_fun",sizeof("cost_y_fun"));
+    memcpy(fieldnames[16],"cost_y_fun_jac_ut_xt",sizeof("cost_y_fun_jac_ut_xt"));
+    memcpy(fieldnames[17],"cost_y_hess",sizeof("cost_y_hess"));
+    memcpy(fieldnames[18],"ext_cost_fun",sizeof("ext_cost_fun"));
+    memcpy(fieldnames[19],"ext_cost_fun_jac",sizeof("ext_cost_fun_jac"));
+    memcpy(fieldnames[20],"ext_cost_fun_jac_hess",sizeof("ext_cost_fun_jac_hess"));
+
+    // constraints
+    memcpy(fieldnames[21],"phi_constraint",sizeof("phi_constraint"));
+    memcpy(fieldnames[22],"nl_constr_h_fun_jac",sizeof("nl_constr_h_fun_jac"));
+    memcpy(fieldnames[23],"nl_constr_h_fun",sizeof("nl_constr_h_fun"));
+    memcpy(fieldnames[24],"nl_constr_h_fun_jac_hess",sizeof("nl_constr_h_fun_jac_hess"));
+
+
+    // create output struct - C_ocp_ext_fun
+    plhs[1] = mxCreateStructMatrix(1, 1, FIELDS_EXT_FUN, (const char **) fieldnames);
+
+
+    for (int i = 0; i < FIELDS_EXT_FUN; i++)
+    {
+        mxFree( fieldnames[i] );
+    }
+
+/* dynamics */
+    mxArray *expl_ode_fun_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    mxArray *forw_vde_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    mxArray *hess_vde_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    mxArray *impl_dae_fun_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    mxArray *impl_dae_fun_jac_x_xdot_z_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    mxArray *impl_dae_jac_x_xdot_u_z_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    mxArray *impl_dae_hess_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+
+    mxArray *gnsf_phi_fun_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    mxArray *gnsf_phi_fun_jac_y_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    mxArray *gnsf_phi_jac_y_uhat_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    mxArray *gnsf_f_lo_jac_x1_x1dot_u_z_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    mxArray *gnsf_get_matrices_fun_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+
+    mxArray *disc_phi_fun_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    mxArray *disc_phi_fun_jac_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+    mxArray *disc_phi_fun_jac_hess_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
+
+{% if solver_options.integrator_type == "ERK" %}
+    {# TODO: remove _casadi from these names.. #}
+    l_ptr = mxGetData(forw_vde_mat);
+    l_ptr[0] = (long long) acados_ocp_capsule->forw_vde_casadi;
+    l_ptr = mxGetData(expl_ode_fun_mat);
+    l_ptr[0] = (long long) acados_ocp_capsule->expl_ode_fun;
+{% if solver_options.hessian_approx == "EXACT" %}
+    l_ptr = mxGetData(hess_vde_mat);
+    l_ptr[0] = (long long) acados_ocp_capsule->hess_vde_casadi;
+{%- endif %}
+{% elif solver_options.integrator_type == "IRK" %}
+    l_ptr = mxGetData(impl_dae_fun_mat);
+    l_ptr[0] = (long long) acados_ocp_capsule->impl_dae_fun;
+    l_ptr = mxGetData(impl_dae_fun_jac_x_xdot_z_mat);
+    l_ptr[0] = (long long) acados_ocp_capsule->impl_dae_fun_jac_x_xdot_z;
+    l_ptr = mxGetData(impl_dae_jac_x_xdot_u_z_mat);
+    l_ptr[0] = (long long) acados_ocp_capsule->impl_dae_jac_x_xdot_u_z;
+{% if solver_options.hessian_approx == "EXACT" %}
+    l_ptr = mxGetData(impl_dae_hess_mat);
+    l_ptr[0] = (long long) acados_ocp_capsule->impl_dae_hess;
+{%- endif %}
+{% elif solver_options.integrator_type == "GNSF" %}
+    {% if model.gnsf.purely_linear != 1 %}
+    l_ptr = mxGetData(gnsf_phi_fun_mat);
+    l_ptr[0] = (long long) acados_ocp_capsule->gnsf_phi_fun;
+    l_ptr = mxGetData(gnsf_phi_fun_jac_y_mat);
+    l_ptr[0] = (long long) acados_ocp_capsule->gnsf_phi_fun_jac_y;
+    l_ptr = mxGetData(gnsf_phi_jac_y_uhat_mat);
+    l_ptr[0] = (long long) acados_ocp_capsule->gnsf_phi_jac_y_uhat;
+    {% if model.gnsf.nontrivial_f_LO == 1 %}
+    l_ptr = mxGetData(gnsf_f_lo_jac_x1_x1dot_u_z_mat);
+    l_ptr[0] = (long long) acados_ocp_capsule->gnsf_f_lo_jac_x1_x1dot_u_z;
+    {%- endif %}
+    {%- endif %}
+    l_ptr = mxGetData(gnsf_get_matrices_fun_mat);
+    l_ptr[0] = (long long) acados_ocp_capsule->gnsf_get_matrices_fun;
+{% elif solver_options.integrator_type == "DISCRETE" %}
+    l_ptr = mxGetData(disc_phi_fun_mat);
+    l_ptr[0] = (long long) acados_ocp_capsule->discr_dyn_phi_fun;
+    l_ptr = mxGetData(disc_phi_fun_jac_mat);
+    l_ptr[0] = (long long) acados_ocp_capsule->discr_dyn_phi_fun_jac_ut_xt;
+{% if solver_options.hessian_approx == "EXACT" %}
+    l_ptr = mxGetData(disc_phi_fun_jac_hess_mat);
+    l_ptr[0] = (long long) acados_ocp_capsule->discr_dyn_phi_fun_jac_ut_xt_hess;
+{%- endif %}
+{%- endif %}
+    mxSetField(plhs[1], 0, "expl_ode_fun", expl_ode_fun_mat);
+    mxSetField(plhs[1], 0, "forw_vde", forw_vde_mat);
+    mxSetField(plhs[1], 0, "hess_vde", hess_vde_mat);
+
+    mxSetField(plhs[1], 0, "gnsf_phi_fun", gnsf_phi_fun_mat);
+    mxSetField(plhs[1], 0, "gnsf_phi_fun_jac_y", gnsf_phi_fun_jac_y_mat);
+    mxSetField(plhs[1], 0, "gnsf_phi_jac_y_uhat", gnsf_phi_jac_y_uhat_mat);
+    mxSetField(plhs[1], 0, "gnsf_f_lo_jac_x1_x1dot_u_z", gnsf_f_lo_jac_x1_x1dot_u_z_mat);
+    mxSetField(plhs[1], 0, "gnsf_get_matrices_fun", gnsf_get_matrices_fun_mat);
+
+    mxSetField(plhs[1], 0, "impl_dae_fun", impl_dae_fun_mat);
+    mxSetField(plhs[1], 0, "impl_dae_fun_jac_x_xdot_z", impl_dae_fun_jac_x_xdot_z_mat);
+    mxSetField(plhs[1], 0, "impl_dae_jac_x_xdot_u_z", impl_dae_jac_x_xdot_u_z_mat);
+    mxSetField(plhs[1], 0, "impl_dae_hess", impl_dae_hess_mat);
+
+    mxSetField(plhs[1], 0, "disc_phi_fun", disc_phi_fun_mat);
+    mxSetField(plhs[1], 0, "disc_phi_fun_jac", disc_phi_fun_jac_mat);
+    mxSetField(plhs[1], 0, "disc_phi_fun_jac_hess", disc_phi_fun_jac_hess_mat);
+/* constaints */
+    mxArray *phi_constraint_mat = mxCreateNumericMatrix(1, 2, mxINT64_CLASS, mxREAL);
+    l_ptr = mxGetData(phi_constraint_mat);
+{%- if constraints.constr_type == "BGP" %}
+    l_ptr[0] = (long long) acados_ocp_capsule->phi_constraint;
+{% endif %}
+{% if constraints.constr_type_e == "BGP" %}
+    l_ptr[1] = (long long) &acados_ocp_capsule->phi_e_constraint;
+{% endif %}
+    mxSetField(plhs[1], 0, "phi_constraint", phi_constraint_mat);
+
+    mxArray *nl_constr_h_fun_jac_mat = mxCreateNumericMatrix(1, 2, mxINT64_CLASS, mxREAL);
+    l_ptr = mxGetData(nl_constr_h_fun_jac_mat);
+{% if constraints.constr_type == "BGH" and dims.nh > 0 %}
+    l_ptr[0] = (long long) acados_ocp_capsule->nl_constr_h_fun_jac;
+{% endif %}
+{% if constraints.constr_type_e == "BGH" and dims.nh_e > 0 %}
+    l_ptr[1] = (long long) &acados_ocp_capsule->nl_constr_h_e_fun_jac;
+{%- endif %}
+    mxSetField(plhs[1], 0, "nl_constr_h_fun_jac", nl_constr_h_fun_jac_mat);
+
+    mxArray *nl_constr_h_fun_mat = mxCreateNumericMatrix(1, 2, mxINT64_CLASS, mxREAL);
+    l_ptr = mxGetData(nl_constr_h_fun_mat);
+{% if constraints.constr_type == "BGH" and dims.nh > 0 %}
+    l_ptr[0] = (long long) acados_ocp_capsule->nl_constr_h_fun;
+{% endif %}
+{% if constraints.constr_type_e == "BGH" and dims.nh_e > 0 %}
+    l_ptr[1] = (long long) &acados_ocp_capsule->nl_constr_h_e_fun;
+{%- endif %}
+    mxSetField(plhs[1], 0, "nl_constr_h_fun", nl_constr_h_fun_mat);
+
+    mxArray *nl_constr_h_fun_jac_hess_mat = mxCreateNumericMatrix(1, 2, mxINT64_CLASS, mxREAL);
+    l_ptr = mxGetData(nl_constr_h_fun_jac_hess_mat);
+{% if constraints.constr_type == "BGH" and dims.nh > 0 and solver_options.hessian_approx == "EXACT" %}
+    l_ptr[0] = (long long) acados_ocp_capsule->nl_constr_h_fun_jac_hess;
+{% endif %}
+{% if constraints.constr_type_e == "BGH" and dims.nh_e > 0 and solver_options.hessian_approx == "EXACT" %}
+    l_ptr[1] = (long long) &acados_ocp_capsule->nl_constr_h_e_fun_jac_hess;
+{%- endif %}
+    mxSetField(plhs[1], 0, "nl_constr_h_fun_jac_hess", nl_constr_h_fun_jac_hess_mat);
+
+/* cost */
+    mxArray *cost_y_fun_mat = mxCreateNumericMatrix(1, 2, mxINT64_CLASS, mxREAL);
+    l_ptr = mxGetData(cost_y_fun_mat);
+{% if cost.cost_type == "NONLINEAR_LS" %}
+    l_ptr[0] = (long long) acados_ocp_capsule->cost_y_fun;
+{% endif %}
+{% if cost.cost_type_e == "NONLINEAR_LS" %}
+    l_ptr[1] = (long long) &acados_ocp_capsule->cost_y_e_fun;
+{%- endif %}
+    mxSetField(plhs[1], 0, "cost_y_fun", cost_y_fun_mat);
+
+    mxArray *cost_y_fun_jac_ut_xt_mat = mxCreateNumericMatrix(1, 2, mxINT64_CLASS, mxREAL);
+    l_ptr = mxGetData(cost_y_fun_jac_ut_xt_mat);
+{% if cost.cost_type == "NONLINEAR_LS" %}
+    l_ptr[0] = (long long) acados_ocp_capsule->cost_y_fun_jac_ut_xt;
+{% endif %}
+{% if cost.cost_type_e == "NONLINEAR_LS" %}
+    l_ptr[1] = (long long) &acados_ocp_capsule->cost_y_e_fun_jac_ut_xt;
+{%- endif %}
+    mxSetField(plhs[1], 0, "cost_y_fun_jac_ut_xt", cost_y_fun_jac_ut_xt_mat);
+
+    mxArray *cost_y_hess_mat = mxCreateNumericMatrix(1, 2, mxINT64_CLASS, mxREAL);
+    l_ptr = mxGetData(cost_y_hess_mat);
+{% if cost.cost_type == "NONLINEAR_LS" %}
+    l_ptr[0] = (long long) acados_ocp_capsule->cost_y_hess;
+{% endif %}
+{% if cost.cost_type_e == "NONLINEAR_LS" %}
+    l_ptr[1] = (long long) &acados_ocp_capsule->cost_y_e_hess;
+{%- endif %}
+    mxSetField(plhs[1], 0, "cost_y_hess", cost_y_hess_mat);
+
+    mxArray *ext_cost_fun_mat = mxCreateNumericMatrix(1, 2, mxINT64_CLASS, mxREAL);
+    l_ptr = mxGetData(ext_cost_fun_mat);
+{% if cost.cost_type == "EXTERNAL" %}
+    l_ptr[0] = (long long) acados_ocp_capsule->ext_cost_fun;
+{% endif -%}
+{% if cost.cost_type_e == "EXTERNAL" %}
+    l_ptr[1] = (long long) &acados_ocp_capsule->ext_cost_e_fun;
+{%- endif %}
+    mxSetField(plhs[1], 0, "ext_cost_fun", ext_cost_fun_mat);
+
+    mxArray *ext_cost_fun_jac_mat = mxCreateNumericMatrix(1, 2, mxINT64_CLASS, mxREAL);
+    l_ptr = mxGetData(ext_cost_fun_jac_mat);
+{% if cost.cost_type == "EXTERNAL" %}
+    l_ptr[0] = (long long) acados_ocp_capsule->ext_cost_fun_jac;
+{% endif -%}
+{% if cost.cost_type_e == "EXTERNAL" %}
+    l_ptr[1] = (long long) &acados_ocp_capsule->ext_cost_e_fun_jac;
+{%- endif %}
+    mxSetField(plhs[1], 0, "ext_cost_fun_jac", ext_cost_fun_jac_mat);
+
+    mxArray *ext_cost_fun_jac_hess_mat = mxCreateNumericMatrix(1, 2, mxINT64_CLASS, mxREAL);
+    l_ptr = mxGetData(ext_cost_fun_jac_hess_mat);
+{% if cost.cost_type == "EXTERNAL" %}
+    l_ptr[0] = (long long) acados_ocp_capsule->ext_cost_fun_jac_hess;
+{% endif -%}
+{% if cost.cost_type_e == "EXTERNAL" %}
+    l_ptr[1] = (long long) &acados_ocp_capsule->ext_cost_e_fun_jac_hess;
+{%- endif %}
+    mxSetField(plhs[1], 0, "ext_cost_fun_jac_hess", ext_cost_fun_jac_hess_mat);
+
+
+    return;
+}

third_party/acados/acados_template/c_templates_tera/matlab_templates/acados_mex_free.in.c

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) The acados authors.
+ *
+ * This file is part of acados.
+ *
+ * The 2-Clause BSD License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.;
+ */
+
+// system
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+// acados
+#include "acados_solver_{{ model.name }}.h"
+
+// mex
+#include "mex.h"
+
+
+void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
+{
+    int status = 0;
+    long long *ptr;
+
+    // mexPrintf("\nin mex_acados_free\n");
+    const mxArray *C_ocp = prhs[0];
+    // capsule
+    ptr = (long long *) mxGetData( mxGetField( C_ocp, 0, "capsule" ) );
+    {{ model.name }}_solver_capsule *capsule = ({{ model.name }}_solver_capsule *) ptr[0];
+
+    status = {{ model.name }}_acados_free(capsule);
+    if (status)
+    {
+        mexPrintf("{{ model.name }}_acados_free() returned status %d.\n", status);
+    }
+
+    status = {{ model.name }}_acados_free_capsule(capsule);
+    if (status)
+    {
+        mexPrintf("{{ model.name }}_acados_free_capsule() returned status %d.\n", status);
+    }
+
+    return;
+}
+

third_party/acados/acados_template/c_templates_tera/matlab_templates/acados_mex_set.in.c

@@ -0,0 +1,632 @@
+/*
+ * Copyright (c) The acados authors.
+ *
+ * This file is part of acados.
+ *
+ * The 2-Clause BSD License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.;
+ */
+
+
+// standard
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// acados
+#include "acados/utils/print.h"
+#include "acados_c/ocp_nlp_interface.h"
+#include "acados_solver_{{ model.name }}.h"
+
+// mex
+#include "mex.h"
+#include "mex_macros.h"
+
+
+void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
+{
+
+    long long *ptr;
+    int acados_size;
+    mxArray *mex_field;
+    char fun_name[20] = "ocp_set";
+    char buffer [500]; // for error messages
+
+    /* RHS */
+    int min_nrhs = 6;
+
+    // C ocp
+    const mxArray *C_ocp = prhs[2];
+    // capsule
+    ptr = (long long *) mxGetData( mxGetField( C_ocp, 0, "capsule" ) );
+    {{ model.name }}_solver_capsule *capsule = ({{ model.name }}_solver_capsule *) ptr[0];
+    // plan
+    ptr = (long long *) mxGetData( mxGetField( C_ocp, 0, "plan" ) );
+    ocp_nlp_plan_t *plan = (ocp_nlp_plan_t *) ptr[0];
+    // config
+    ptr = (long long *) mxGetData( mxGetField( C_ocp, 0, "config" ) );
+    ocp_nlp_config *config = (ocp_nlp_config *) ptr[0];
+    // dims
+    ptr = (long long *) mxGetData( mxGetField( C_ocp, 0, "dims" ) );
+    ocp_nlp_dims *dims = (ocp_nlp_dims *) ptr[0];
+    // opts
+    ptr = (long long *) mxGetData( mxGetField( C_ocp, 0, "opts" ) );
+    void *opts = (void *) ptr[0];
+    // in
+    ptr = (long long *) mxGetData( mxGetField( C_ocp, 0, "in" ) );
+    ocp_nlp_in *in = (ocp_nlp_in *) ptr[0];
+    // out
+    ptr = (long long *) mxGetData( mxGetField( C_ocp, 0, "out" ) );
+    ocp_nlp_out *out = (ocp_nlp_out *) ptr[0];
+    // solver
+    ptr = (long long *) mxGetData( mxGetField( C_ocp, 0, "solver" ) );
+    ocp_nlp_solver *solver = (ocp_nlp_solver *) ptr[0];
+
+    const mxArray *C_ext_fun_pointers = prhs[3];
+    // field
+    char *field = mxArrayToString( prhs[4] );
+    // value
+    double *value = mxGetPr( prhs[5] );
+
+    // for checks
+    int matlab_size = (int) mxGetNumberOfElements( prhs[5] );
+    int nrow = (int) mxGetM( prhs[5] );
+    int ncol = (int) mxGetN( prhs[5] );
+
+    int N = dims->N;
+    int nu = dims->nu[0];
+    int nx = dims->nx[0];
+
+    // stage
+    int s0, se;
+    if (nrhs==min_nrhs)
+    {
+        s0 = 0;
+        se = N;
+    }
+    else if (nrhs==min_nrhs+1)
+    {
+        s0 = mxGetScalar( prhs[6] );
+        if (s0 > N)
+        {
+            sprintf(buffer, "ocp_set: N < specified stage = %d\n", s0);
+            mexErrMsgTxt(buffer);            
+        }
+        se = s0 + 1;
+    }
+    else
+    {
+        sprintf(buffer, "ocp_set: wrong nrhs: %d\n", nrhs);
+        mexErrMsgTxt(buffer);
+    }
+
+    /* Set value */
+    // constraints
+    if (!strcmp(field, "constr_x0"))
+    {
+        acados_size = nx;
+        MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+        ocp_nlp_constraints_model_set(config, dims, in, 0, "lbx", value);
+        ocp_nlp_constraints_model_set(config, dims, in, 0, "ubx", value);
+    }
+    else if (!strcmp(field, "constr_C"))
+    {
+        for (int ii=s0; ii<se; ii++)
+        {
+            int ng = ocp_nlp_dims_get_from_attr(config, dims, out, ii, "ug");
+            MEX_DIM_CHECK_MAT(fun_name, "constr_C", nrow, ncol, ng, nx);
+
+            ocp_nlp_constraints_model_set(config, dims, in, ii, "C", value);
+        }
+    }
+    else if (!strcmp(field, "constr_lbx"))
+    {
+        for (int ii=s0; ii<se; ii++)
+        {
+            acados_size = ocp_nlp_dims_get_from_attr(config, dims, out, ii, "lbx");
+            MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+
+            ocp_nlp_constraints_model_set(config, dims, in, ii, "lbx", value);
+        }
+    }
+    else if (!strcmp(field, "constr_ubx"))
+    {
+        for (int ii=s0; ii<se; ii++)
+        {
+            acados_size = ocp_nlp_dims_get_from_attr(config, dims, out, ii, "ubx");
+            MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+
+            ocp_nlp_constraints_model_set(config, dims, in, ii, "ubx", value);
+        }
+    }
+    else if (!strcmp(field, "constr_lbu"))
+    {
+        for (int ii=s0; ii<se; ii++)
+        {
+            acados_size = ocp_nlp_dims_get_from_attr(config, dims, out, ii, "lbu");
+            MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+
+            ocp_nlp_constraints_model_set(config, dims, in, ii, "lbu", value);
+        }
+    }
+    else if (!strcmp(field, "constr_ubu"))
+    {
+        for (int ii=s0; ii<se; ii++)
+        {
+            acados_size = ocp_nlp_dims_get_from_attr(config, dims, out, ii, "ubu");
+            MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+
+            ocp_nlp_constraints_model_set(config, dims, in, ii, "ubu", value);
+        }
+    }
+    else if (!strcmp(field, "constr_D"))
+    {
+        for (int ii=s0; ii<se; ii++)
+        {
+            int ng = ocp_nlp_dims_get_from_attr(config, dims, out, ii, "ug");
+            MEX_DIM_CHECK_MAT(fun_name, "constr_D", nrow, ncol, ng, nu);
+
+            ocp_nlp_constraints_model_set(config, dims, in, ii, "D", value);
+        }
+    }
+    else if (!strcmp(field, "constr_lg"))
+    {
+        for (int ii=s0; ii<se; ii++)
+        {
+            acados_size = ocp_nlp_dims_get_from_attr(config, dims, out, ii, "lg");
+            MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+
+            ocp_nlp_constraints_model_set(config, dims, in, ii, "lg", value);
+        }
+    }
+    else if (!strcmp(field, "constr_ug"))
+    {
+        for (int ii=s0; ii<se; ii++)
+        {
+            acados_size = ocp_nlp_dims_get_from_attr(config, dims, out, ii, "ug");
+            MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+
+            ocp_nlp_constraints_model_set(config, dims, in, ii, "ug", value);
+        }
+    }
+    else if (!strcmp(field, "constr_lh"))
+    {
+        for (int ii=s0; ii<se; ii++)
+        {
+            acados_size = ocp_nlp_dims_get_from_attr(config, dims, out, ii, "lh");
+            MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+
+            ocp_nlp_constraints_model_set(config, dims, in, ii, "lh", value);
+        }
+    }
+    else if (!strcmp(field, "constr_uh"))
+    {
+        for (int ii=s0; ii<se; ii++)
+        {
+            acados_size = ocp_nlp_dims_get_from_attr(config, dims, out, ii, "uh");
+            MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+
+            ocp_nlp_constraints_model_set(config, dims, in, ii, "uh", value);
+        }
+    }
+    // cost:
+    else if (!strcmp(field, "cost_y_ref"))
+    {
+        for (int ii=s0; ii<se; ii++)
+        {
+            if ((plan->nlp_cost[ii] == LINEAR_LS) || (plan->nlp_cost[ii] == NONLINEAR_LS))
+            {
+                acados_size = ocp_nlp_dims_get_from_attr(config, dims, out, ii, "y_ref");
+                MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+                ocp_nlp_cost_model_set(config, dims, in, ii, "y_ref", value);
+            }
+            else
+            {
+                MEX_FIELD_NOT_SUPPORTED_FOR_COST_STAGE(fun_name, field, plan->nlp_cost[ii], ii);
+            }
+        }
+    }
+    else if (!strcmp(field, "cost_y_ref_e"))
+    {
+        acados_size = ocp_nlp_dims_get_from_attr(config, dims, out, N, "y_ref");
+        MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+        ocp_nlp_cost_model_set(config, dims, in, N, "y_ref", value);
+    }
+    else if (!strcmp(field, "cost_Vu"))
+    {
+        for (int ii=s0; ii<se; ii++)
+        {
+            if ((plan->nlp_cost[ii] == LINEAR_LS) || (plan->nlp_cost[ii] == NONLINEAR_LS))
+            {
+                int ny = ocp_nlp_dims_get_from_attr(config, dims, out, ii, "y_ref");
+                int nu = ocp_nlp_dims_get_from_attr(config, dims, out, ii, "u");
+                acados_size = ny * nu;
+                MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+                ocp_nlp_cost_model_set(config, dims, in, ii, "Vu", value);
+            }
+            else
+            {
+                MEX_FIELD_NOT_SUPPORTED_FOR_COST_STAGE(fun_name, field, plan->nlp_cost[ii], ii);
+            }
+        }
+    }
+    else if (!strcmp(field, "cost_Vx"))
+    {
+        for (int ii=s0; ii<se; ii++)
+        {
+            if ((plan->nlp_cost[ii] == LINEAR_LS) || (plan->nlp_cost[ii] == NONLINEAR_LS))
+            {
+                int ny = ocp_nlp_dims_get_from_attr(config, dims, out, ii, "y_ref");
+                int nx = ocp_nlp_dims_get_from_attr(config, dims, out, ii, "x");
+                acados_size = ny * nx;
+                MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+                ocp_nlp_cost_model_set(config, dims, in, ii, "Vx", value);
+            }
+            else
+            {
+                MEX_FIELD_NOT_SUPPORTED_FOR_COST_STAGE(fun_name, field, plan->nlp_cost[ii], ii);
+            }
+        }
+    }
+    else if (!strcmp(field, "cost_W"))
+    {
+        for (int ii=s0; ii<se; ii++)
+        {
+            if ((plan->nlp_cost[ii] == LINEAR_LS) || (plan->nlp_cost[ii] == NONLINEAR_LS))
+            {
+                int ny = ocp_nlp_dims_get_from_attr(config, dims, out, s0, "y_ref");
+                acados_size = ny * ny;
+                MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+                ocp_nlp_cost_model_set(config, dims, in, ii, "W", value);
+            }
+            else
+            {
+                MEX_FIELD_NOT_SUPPORTED_FOR_COST_STAGE(fun_name, field, plan->nlp_cost[ii], ii);
+            }
+        }
+    }
+    else if (!strcmp(field, "cost_Z"))
+    {
+        acados_size = ocp_nlp_dims_get_from_attr(config, dims, out, s0, "cost_Z");
+        MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+        for (int ii=s0; ii<se; ii++)
+        {
+            ocp_nlp_cost_model_set(config, dims, in, ii, "Z", value);
+        }
+    }
+    else if (!strcmp(field, "cost_Zl"))
+    {
+        acados_size = ocp_nlp_dims_get_from_attr(config, dims, out, s0, "Zl");
+        MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+        for (int ii=s0; ii<se; ii++)
+        {
+            ocp_nlp_cost_model_set(config, dims, in, ii, "Zl", value);
+        }
+    }
+    else if (!strcmp(field, "cost_Zu"))
+    {
+        acados_size = ocp_nlp_dims_get_from_attr(config, dims, out, s0, "Zu");
+        MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+        for (int ii=s0; ii<se; ii++)
+        {
+            ocp_nlp_cost_model_set(config, dims, in, ii, "Zu", value);
+        }
+    }
+    else if (!strcmp(field, "cost_z"))
+    {
+        acados_size = ocp_nlp_dims_get_from_attr(config, dims, out, s0, "cost_z");
+        MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+        for (int ii=s0; ii<se; ii++)
+        {
+            ocp_nlp_cost_model_set(config, dims, in, ii, "z", value);
+        }
+    }
+    else if (!strcmp(field, "cost_zl"))
+    {
+        acados_size = ocp_nlp_dims_get_from_attr(config, dims, out, s0, "zl");
+        MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+        for (int ii=s0; ii<se; ii++)
+        {
+            ocp_nlp_cost_model_set(config, dims, in, ii, "zl", value);
+        }
+    }
+    else if (!strcmp(field, "cost_zu"))
+    {
+        acados_size = ocp_nlp_dims_get_from_attr(config, dims, out, s0, "zu");
+        MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+        for (int ii=s0; ii<se; ii++)
+        {
+            ocp_nlp_cost_model_set(config, dims, in, ii, "zu", value);
+        }
+    }
+    // constraints TODO
+    // // NOTE(oj): how is it with Jbx, Jbu, idxb can they be changed?!
+    // else if (!strcmp(field, "constr_lbx"))
+    // {
+    //     // bounds at 0 are a special case.
+    //     if (s0==0)
+    //     {
+    //         sprintf(buffer, "%s cannot set %s for stage 0", fun_name, field);
+    //         mexErrMsgTxt(buffer);
+    //     }
+    // }
+    // initializations
+    else if (!strcmp(field, "init_x") || !strcmp(field, "x"))
+    {
+        if (nrhs == min_nrhs)
+        {
+            acados_size = (N+1) * nx;
+            MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+            for (int ii=0; ii<=N; ii++)
+            {
+                ocp_nlp_out_set(config, dims, out, ii, "x", value+ii*nx);
+            }
+        }
+        else // (nrhs == min_nrhs + 1)
+        {
+            acados_size = nx;
+            MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+            ocp_nlp_out_set(config, dims, out, s0, "x", value);
+        }
+    }
+    else if (!strcmp(field, "init_u") || !strcmp(field, "u"))
+    {
+        if (nrhs==min_nrhs)
+        {
+            acados_size = N*nu;
+            MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+            for (int ii=0; ii<N; ii++)
+            {
+                ocp_nlp_out_set(config, dims, out, ii, "u", value+ii*nu);
+            }
+        }
+        else // (nrhs == min_nrhs + 1)
+        {
+            acados_size = nu;
+            MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+            ocp_nlp_out_set(config, dims, out, s0, "u", value);
+        }
+    }
+    else if (!strcmp(field, "init_z")||!strcmp(field, "z"))
+    {
+        sim_solver_plan_t sim_plan = plan->sim_solver_plan[0];
+        sim_solver_t type = sim_plan.sim_solver;
+        if (type == IRK)
+        {
+            int nz = ocp_nlp_dims_get_from_attr(config, dims, out, 0, "z");
+            if (nrhs==min_nrhs)
+            {
+                acados_size = N*nz;
+                MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+                for (int ii=0; ii<N; ii++)
+                {
+                    ocp_nlp_set(config, solver, ii, "z_guess", value+ii*nz);
+                }
+            }
+            else // (nrhs==min_nrhs+1)
+            {
+                acados_size = nz;
+                MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+                ocp_nlp_set(config, solver, s0, "z_guess", value);
+            }
+        }
+        else
+        {
+            MEX_FIELD_ONLY_SUPPORTED_FOR_SOLVER(fun_name, "init_z", "irk")
+        }
+    }
+    else if (!strcmp(field, "init_xdot")||!strcmp(field, "xdot"))
+    {
+        sim_solver_plan_t sim_plan = plan->sim_solver_plan[0];
+        sim_solver_t type = sim_plan.sim_solver;
+        if (type == IRK)
+        {
+            int nx = ocp_nlp_dims_get_from_attr(config, dims, out, 0, "x");
+            if (nrhs==min_nrhs)
+            {
+                acados_size = N*nx;
+                MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+                for (int ii=0; ii<N; ii++)
+                {
+                    ocp_nlp_set(config, solver, ii, "xdot_guess", value+ii*nx);
+                }
+            }
+            else // nrhs==min_nrhs+1)
+            {
+                acados_size = nx;
+                MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+                ocp_nlp_set(config, solver, s0, "xdot_guess", value);
+            }
+        }
+        else
+        {
+            MEX_FIELD_ONLY_SUPPORTED_FOR_SOLVER(fun_name, "init_z", "irk")
+        }
+    }
+    else if (!strcmp(field, "init_gnsf_phi")||!strcmp(field, "gnsf_phi"))
+    {
+        sim_solver_plan_t sim_plan = plan->sim_solver_plan[0];
+        sim_solver_t type = sim_plan.sim_solver;
+        if (type == GNSF)
+        {
+            int nout = ocp_nlp_dims_get_from_attr(config, dims, out, 0, "init_gnsf_phi");
+
+            if (nrhs==min_nrhs)
+            {
+                acados_size = N*nout;
+                MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+                for (int ii=0; ii<N; ii++)
+                {
+                    ocp_nlp_set(config, solver, ii, "gnsf_phi_guess", value+ii*nx);
+                }
+            }
+            else // (nrhs==min_nrhs+1)
+            {
+                acados_size = nout;
+                MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+                ocp_nlp_set(config, solver, s0, "gnsf_phi_guess", value);
+            }
+        }
+        else
+        {
+            MEX_FIELD_ONLY_SUPPORTED_FOR_SOLVER(fun_name, "init_gnsf_phi", "irk_gnsf")
+        }
+    }
+    else if (!strcmp(field, "init_pi")||!strcmp(field, "pi"))
+    {
+        if (nrhs==min_nrhs)
+        {
+            acados_size = N*nx;
+            MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+            for (int ii=0; ii<N; ii++)
+            {
+                ocp_nlp_out_set(config, dims, out, ii, "pi", value+ii*nx);
+            }
+        }
+        else // (nrhs==min_nrhs+1)
+        {
+            acados_size = nx;
+            MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+            ocp_nlp_out_set(config, dims, out, s0, "pi", value);
+        }
+    }
+    else if (!strcmp(field, "init_lam")||!strcmp(field, "lam"))
+    {
+        if (nrhs==min_nrhs)
+        {
+            MEX_SETTER_NO_ALL_STAGES_SUPPORT(fun_name, field)
+        }
+        else //(nrhs==min_nrhs+1)
+        {
+            acados_size = ocp_nlp_dims_get_from_attr(config, dims, out, s0, "lam");
+            MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+            ocp_nlp_out_set(config, dims, out, s0, "lam", value);
+        }
+    }
+    else if (!strcmp(field, "init_t")||!strcmp(field, "t"))
+    {
+        if (nrhs==min_nrhs)
+        {
+            MEX_SETTER_NO_ALL_STAGES_SUPPORT(fun_name, field)
+        }
+        else //(nrhs==min_nrhs+1)
+        {
+            acados_size = ocp_nlp_dims_get_from_attr(config, dims, out, s0, "t");
+            MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+            ocp_nlp_out_set(config, dims, out, s0, "t", value);
+        }
+    }
+    else if (!strcmp(field, "init_sl")||!strcmp(field, "sl"))
+    {
+        if (nrhs==min_nrhs)
+        {
+            MEX_SETTER_NO_ALL_STAGES_SUPPORT(fun_name, field)
+        }
+        else //(nrhs==min_nrhs+1)
+        {
+            acados_size = ocp_nlp_dims_get_from_attr(config, dims, out, s0, "sl");
+            MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+            ocp_nlp_out_set(config, dims, out, s0, field, value);
+        }
+    }
+    else if (!strcmp(field, "init_su")||!strcmp(field, "su"))
+    {
+        if (nrhs==min_nrhs)
+        {
+            MEX_SETTER_NO_ALL_STAGES_SUPPORT(fun_name, field)
+        }
+        else //(nrhs==min_nrhs+1)
+        {
+            acados_size = ocp_nlp_dims_get_from_attr(config, dims, out, s0, "su");
+            MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+            ocp_nlp_out_set(config, dims, out, s0, field, value);
+        }
+    }
+    else if (!strcmp(field, "p"))
+    {
+        if (nrhs==min_nrhs) // all stages
+        {
+            for (int ii=0; ii<=N; ii++)
+            {
+                {{ model.name }}_acados_update_params(capsule, ii, value, matlab_size);
+            }
+        }
+        else if (nrhs==min_nrhs+1) // one stage
+        {
+            int stage = mxGetScalar( prhs[6] );
+            {{ model.name }}_acados_update_params(capsule, stage, value, matlab_size);
+        }
+    }
+    else if (!strcmp(field, "nlp_solver_max_iter"))
+    {
+        acados_size = 1;
+        MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+        int nlp_solver_max_iter = (int) value[0];
+        ocp_nlp_solver_opts_set(config, opts, "max_iter", &nlp_solver_max_iter);
+    }
+    else if (!strcmp(field, "rti_phase"))
+    {
+        acados_size = 1;
+        MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+        int rti_phase = (int) value[0];
+        if (plan->nlp_solver == SQP && rti_phase != 0)
+        {
+            MEX_FIELD_ONLY_SUPPORTED_FOR_SOLVER(fun_name, field, "sqp_rti")
+        }
+        ocp_nlp_solver_opts_set(config, opts, "rti_phase", &rti_phase);
+    }
+    else if (!strcmp(field, "qp_warm_start"))
+    {
+        acados_size = 1;
+        MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+        int qp_warm_start = (int) value[0];
+        ocp_nlp_solver_opts_set(config, opts, "qp_warm_start", &qp_warm_start);
+    }
+    else if (!strcmp(field, "warm_start_first_qp"))
+    {
+        acados_size = 1;
+        MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+        int warm_start_first_qp = (int) value[0];
+        ocp_nlp_solver_opts_set(config, opts, "warm_start_first_qp", &warm_start_first_qp);
+    }
+    else if (!strcmp(field, "print_level"))
+    {
+        acados_size = 1;
+        MEX_DIM_CHECK_VEC(fun_name, field, matlab_size, acados_size);
+        int print_level = (int) value[0];
+        ocp_nlp_solver_opts_set(config, opts, "print_level", &print_level);
+    }
+    else
+    {
+        MEX_FIELD_NOT_SUPPORTED_SUGGEST(fun_name, field, "p, constr_x0,\
+ constr_lbx, constr_ubx, constr_C, constr_D, constr_lg, constr_ug, constr_lh, constr_uh,\
+ constr_lbu, constr_ubu, cost_y_ref[_e], sl, su, x, xdot, u, pi, lam, z, \
+ cost_Vu, cost_Vx, cost_Vz, cost_W, cost_Z, cost_Zl, cost_Zu, cost_z,\
+ cost_zl, cost_zu, init_x, init_u, init_z, init_xdot, init_gnsf_phi,\
+ init_pi, nlp_solver_max_iter, qp_warm_start, warm_start_first_qp, print_level");
+    }
+
+    return;
+}
+

third_party/acados/acados_template/c_templates_tera/matlab_templates/acados_mex_solve.in.c

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) The acados authors.
+ *
+ * This file is part of acados.
+ *
+ * The 2-Clause BSD License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.;
+ */
+
+// system
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+// acados
+#include "acados_solver_{{ model.name }}.h"
+
+// mex
+#include "mex.h"
+
+
+
+void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
+{
+    // C_ocp
+    long long *ptr;
+    const mxArray *C_ocp = prhs[0];
+
+    // capsule
+    ptr = (long long *) mxGetData( mxGetField( C_ocp, 0, "capsule" ) );
+    {{ model.name }}_solver_capsule *capsule = ({{ model.name }}_solver_capsule *) ptr[0];
+
+    // solve
+    {{ model.name }}_acados_solve(capsule);
+
+}

third_party/acados/acados_template/c_templates_tera/matlab_templates/acados_sim_solver_sfun.in.c

@@ -0,0 +1,230 @@
+/*
+ * Copyright (c) The acados authors.
+ *
+ * This file is part of acados.
+ *
+ * The 2-Clause BSD License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.;
+ */
+
+#define S_FUNCTION_NAME   acados_sim_solver_sfunction_{{ model.name }}
+#define S_FUNCTION_LEVEL  2
+
+#define MDL_START
+
+// acados
+// #include "acados/utils/print.h"
+#include "acados_c/ocp_nlp_interface.h"
+#include "acados_c/external_function_interface.h"
+
+// example specific
+#include "{{ model.name }}_model/{{ model.name }}_model.h"
+#include "acados_sim_solver_{{ model.name }}.h"
+
+#include "simstruc.h"
+
+#define SAMPLINGTIME {{ solver_options.Tsim }}
+
+
+static void mdlInitializeSizes (SimStruct *S)
+{
+    // specify the number of continuous and discrete states
+    ssSetNumContStates(S, 0);
+    ssSetNumDiscStates(S, 0);
+
+    {# compute number of input ports #}
+    {%- set n_inputs = 1 %}  {# x0 #}
+    {%- if dims.nu > 0 %}  {# u0 -#}
+        {%- set n_inputs = n_inputs + 1 -%}
+    {%- endif %}
+    {%- if dims.np > 0 %}  {# parameters #}
+        {%- set n_inputs = n_inputs + 1 -%}
+    {%- endif %}
+
+    // specify the number of input ports
+    if ( !ssSetNumInputPorts(S, {{ n_inputs }}) )
+        return;
+
+    // specify the number of output ports
+    if ( !ssSetNumOutputPorts(S, 1) )
+        return;
+
+    // specify dimension information for the input ports
+    {%- set i_input = 0 %}
+    // x0
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.nx }});
+
+    {%- if dims.nu > 0 %}
+    {%- set i_input = i_input + 1 %}
+    // u0
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.nu }});
+    {%- endif %}
+
+    {%- if dims.np > 0 %}
+    {%- set i_input = i_input + 1 %}
+    // parameters
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.np }});
+    {%- endif %}
+
+    // specify dimension information for the output ports
+    ssSetOutputPortVectorDimension(S, 0, {{ dims.nx }} ); // xnext
+
+    // specify the direct feedthrough status
+    // should be set to 1 for all inputs used in mdlOutputs
+    {%- for i in range(end=n_inputs) %}
+    ssSetInputPortDirectFeedThrough(S, {{ i }}, 1);
+    {%- endfor %}
+
+    // one sample time
+    ssSetNumSampleTimes(S, 1);
+}
+
+
+#if defined(MATLAB_MEX_FILE)
+
+#define MDL_SET_INPUT_PORT_DIMENSION_INFO
+#define MDL_SET_OUTPUT_PORT_DIMENSION_INFO
+
+static void mdlSetInputPortDimensionInfo(SimStruct *S, int_T port, const DimsInfo_T *dimsInfo)
+{
+    if ( !ssSetInputPortDimensionInfo(S, port, dimsInfo) )
+         return;
+}
+
+static void mdlSetOutputPortDimensionInfo(SimStruct *S, int_T port, const DimsInfo_T *dimsInfo)
+{
+    if ( !ssSetOutputPortDimensionInfo(S, port, dimsInfo) )
+         return;
+}
+
+#endif /* MATLAB_MEX_FILE */
+
+
+static void mdlInitializeSampleTimes(SimStruct *S)
+{
+    ssSetSampleTime(S, 0, SAMPLINGTIME);
+    ssSetOffsetTime(S, 0, 0.0);
+}
+
+
+static void mdlStart(SimStruct *S)
+{
+    sim_solver_capsule *capsule = {{ model.name }}_acados_sim_solver_create_capsule();
+    {{ model.name }}_acados_sim_create(capsule);
+
+    ssSetUserData(S, (void*)capsule);
+}
+
+static void mdlOutputs(SimStruct *S, int_T tid)
+{
+    sim_solver_capsule *capsule = ssGetUserData(S);
+
+    sim_config *acados_sim_config = {{ model.name }}_acados_get_sim_config(capsule);
+    sim_in *acados_sim_in = {{ model.name }}_acados_get_sim_in(capsule);
+    sim_out *acados_sim_out = {{ model.name }}_acados_get_sim_out(capsule);
+    void *acados_sim_dims = {{ model.name }}_acados_get_sim_dims(capsule);
+    // sim_opts * {{ model.name }}_acados_get_sim_opts(capsule);
+    // sim_solver * {{ model.name }}_acados_get_sim_solver(capsule);
+
+    InputRealPtrsType in_sign;
+    {% set input_sizes = [dims.nx, dims.nu, dims.np] %}
+
+    // local buffer
+    {%- set buffer_size =  input_sizes | sort | last %}
+    real_t buffer[{{ buffer_size }}];
+
+
+    /* go through inputs */
+    {%- set i_input = 0 %}
+    // initial condition
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+    for (int i = 0; i < {{ dims.nx }}; i++)
+        buffer[i] = (double)(*in_sign[i]);
+
+    sim_in_set(acados_sim_config, acados_sim_dims,
+               acados_sim_in, "x", buffer);
+
+
+    // ssPrintf("\nin acados sim:\n");
+    // for (int i = 0; i < {{ dims.nx }}; i++) ssPrintf("x0[%d] = %f\n", i, buffer[i]);
+    //     ssPrintf("\n");
+
+{% if dims.nu > 0 %}
+    // control input - u
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+
+    for (int i = 0; i < {{ dims.nu }}; i++)
+        buffer[i] = (double)(*in_sign[i]);
+
+    sim_in_set(acados_sim_config, acados_sim_dims,
+               acados_sim_in, "u", buffer);
+{%- endif %}
+
+
+{% if dims.np > 0 %}
+    // parameters
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+
+    for (int i = 0; i < {{ dims.np }}; i++)
+        buffer[i] = (double)(*in_sign[i]);
+
+    // update value of parameters
+    {{ model.name }}_acados_sim_update_params(capsule, buffer, {{ dims.np }});
+{%- endif %}
+
+
+    /* call solver */
+    int acados_status = {{ model.name }}_acados_sim_solve(capsule);
+
+
+    /* set outputs */
+    real_t *out_x = ssGetOutputPortRealSignal(S, 0);
+
+    // get simulated state
+    sim_out_get(acados_sim_config, acados_sim_dims, acados_sim_out,
+                "xn", (void *) out_x);
+
+    // ssPrintf("\nacados sim solve: returned %d\n", acados_status);
+    // for (int i = 0; i < {{ dims.nx }}; i++) ssPrintf("x_sim[%d] = %f\n", i, out_x[i]);
+    //     ssPrintf("\n");
+
+}
+
+
+static void mdlTerminate(SimStruct *S)
+{
+    sim_solver_capsule *capsule = ssGetUserData(S);
+
+    {{ model.name }}_acados_sim_free(capsule);
+    {{ model.name }}_acados_sim_solver_free_capsule(capsule);
+}
+
+
+#ifdef  MATLAB_MEX_FILE
+#include "simulink.c"
+#else
+#include "cg_sfun.h"
+#endif

third_party/acados/acados_template/c_templates_tera/matlab_templates/acados_solver_sfun.in.c

@@ -0,0 +1,853 @@
+/*
+ * Copyright (c) The acados authors.
+ *
+ * This file is part of acados.
+ *
+ * The 2-Clause BSD License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.;
+ */
+
+#define S_FUNCTION_NAME acados_solver_sfunction_{{ model.name }}
+#define S_FUNCTION_LEVEL 2
+
+#define MDL_START
+
+// acados
+// #include "acados/utils/print.h"
+#include "acados_c/sim_interface.h"
+#include "acados_c/external_function_interface.h"
+
+// example specific
+#include "{{ model.name }}_model/{{ model.name }}_model.h"
+#include "acados_solver_{{ model.name }}.h"
+
+#include "simstruc.h"
+
+{% if simulink_opts.samplingtime == "t0" -%}
+#define SAMPLINGTIME {{ solver_options.time_steps[0] }}
+{%- elif simulink_opts.samplingtime == "-1" -%}
+#define SAMPLINGTIME -1
+{%- else -%}
+  {{ throw(message = "simulink_opts.samplingtime must be '-1' or 't0', got val") }}
+{%- endif %}
+
+static void mdlInitializeSizes (SimStruct *S)
+{
+    // specify the number of continuous and discrete states
+    ssSetNumContStates(S, 0);
+    ssSetNumDiscStates(S, 0);
+
+    int N = {{ model.name | upper }}_N;
+
+  {%- for key, val in simulink_opts.inputs -%}
+    {%- if val != 0 and val != 1 -%}
+      {{ throw(message = "simulink_opts.inputs must be 0 or 1, got val") }}
+    {%- endif -%}
+  {%- endfor -%}
+
+  {#- compute number of input ports #}
+  {%- set n_inputs = 0 -%}
+  {%- if dims.nbx_0 > 0 and simulink_opts.inputs.lbx_0 -%}  {#- lbx_0 #}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+  {%- if dims.nbx_0 > 0 and simulink_opts.inputs.ubx_0 -%}  {#- ubx_0 #}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+  {%- if dims.np > 0 and simulink_opts.inputs.parameter_traj -%}  {#- parameter_traj #}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+  {%- if dims.ny_0 > 0 and simulink_opts.inputs.y_ref_0 -%}  {#- y_ref_0 -#}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+  {%- if dims.ny > 0 and dims.N > 1 and simulink_opts.inputs.y_ref -%}  {#- y_ref -#}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+  {%- if dims.ny_e > 0 and dims.N > 0 and simulink_opts.inputs.y_ref_e -%}  {#- y_ref_e #}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+  {%- if dims.nbx > 0 and dims.N > 1 and simulink_opts.inputs.lbx -%}  {#- lbx #}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+  {%- if dims.nbx > 0 and dims.N > 1 and simulink_opts.inputs.ubx -%}  {#- ubx #}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+  {%- if dims.nbx_e > 0 and dims.N > 0 and simulink_opts.inputs.lbx_e -%}  {#- lbx_e #}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+  {%- if dims.nbx_e > 0 and dims.N > 0 and simulink_opts.inputs.ubx_e -%}  {#- ubx_e #}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+  {%- if dims.nbu > 0 and dims.N > 0 and simulink_opts.inputs.lbu -%}  {#- lbu #}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+  {%- if dims.nbu > 0 and dims.N > 0 and simulink_opts.inputs.ubu -%}  {#- ubu #}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+  {%- if dims.ng > 0 and simulink_opts.inputs.lg -%}  {#- lg #}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+  {%- if dims.ng > 0 and simulink_opts.inputs.ug -%}  {#- ug #}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+  {%- if dims.nh > 0 and simulink_opts.inputs.lh -%}  {#- lh #}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+  {%- if dims.nh > 0 and simulink_opts.inputs.uh -%}  {#- uh #}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+  {%- if dims.nh_e > 0 and simulink_opts.inputs.lh_e -%}  {#- lh_e #}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+  {%- if dims.nh_e > 0 and simulink_opts.inputs.uh_e -%}  {#- uh_e #}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+
+  {%- for key, val in simulink_opts.inputs -%}
+    {%- if val != 0 and val != 1 -%}
+      {{ throw(message = "simulink_opts.inputs must be 0 or 1, got val") }}
+    {%- endif -%}
+  {%- endfor -%}
+  {%- if dims.ny_0 > 0 and simulink_opts.inputs.cost_W_0 %}  {#- cost_W_0 #}
+    {%- set n_inputs = n_inputs + 1 %}
+  {%- endif -%}
+  {%- if dims.ny > 0 and simulink_opts.inputs.cost_W %}  {#- cost_W #}
+    {%- set n_inputs = n_inputs + 1 %}
+  {%- endif -%}
+  {%- if dims.ny_e > 0 and simulink_opts.inputs.cost_W_e %}  {#- cost_W_e #}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+
+  {%- if simulink_opts.inputs.reset_solver -%}  {#- reset_solver #}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+
+  {%- if simulink_opts.inputs.x_init -%}  {#- x_init #}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+
+  {%- if simulink_opts.inputs.u_init -%}  {#- u_init #}
+    {%- set n_inputs = n_inputs + 1 -%}
+  {%- endif -%}
+
+    // specify the number of input ports
+    if ( !ssSetNumInputPorts(S, {{ n_inputs }}) )
+        return;
+
+    // specify the number of output ports
+    {%- set_global n_outputs = 0 %}
+    {%- for key, val in simulink_opts.outputs %}
+      {%- if val == 1 %}
+        {%- set_global n_outputs = n_outputs + val %}
+      {%- elif val != 0 %}
+        {{ throw(message = "simulink_opts.outputs must be 0 or 1, got val") }}
+      {%- endif %}
+    {%- endfor %}
+    if ( !ssSetNumOutputPorts(S, {{ n_outputs }}) )
+        return;
+
+    // specify dimension information for the input ports
+    {%- set i_input = -1 %}{# note here i_input is 0-based #}
+  {%- if dims.nbx_0 > 0 and simulink_opts.inputs.lbx_0 -%}  {#- lbx_0 #}
+    {%- set i_input = i_input + 1 %}
+    // lbx_0
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.nbx_0 }});
+  {%- endif %}
+  {%- if dims.nbx_0 > 0 and simulink_opts.inputs.ubx_0 -%}  {#- ubx_0 #}
+    {%- set i_input = i_input + 1 %}
+    // ubx_0
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.nbx_0 }});
+  {%- endif %}
+
+  {%- if dims.np > 0 and simulink_opts.inputs.parameter_traj -%}  {#- parameter_traj #}
+    {%- set i_input = i_input + 1 %}
+    // parameters
+    ssSetInputPortVectorDimension(S, {{ i_input }}, (N+1) * {{ dims.np }});
+  {%- endif %}
+
+  {%- if dims.ny > 0 and simulink_opts.inputs.y_ref_0 %}
+    {%- set i_input = i_input + 1 %}
+    // y_ref_0
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.ny_0 }});
+  {%- endif %}
+
+  {%- if dims.ny > 0 and dims.N > 1 and simulink_opts.inputs.y_ref %}
+    {%- set i_input = i_input + 1 %}
+    // y_ref
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ (dims.N-1) * dims.ny }});
+  {%- endif %}
+
+  {%- if dims.ny_e > 0 and dims.N > 0 and simulink_opts.inputs.y_ref_e %}
+    {%- set i_input = i_input + 1 %}
+    // y_ref_e
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.ny_e }});
+  {%- endif %}
+
+  {%- if dims.nbx > 0 and dims.N > 1 and simulink_opts.inputs.lbx -%}  {#- lbx #}
+    {%- set i_input = i_input + 1 %}
+    // lbx
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ (dims.N-1) * dims.nbx }});
+  {%- endif %}
+  {%- if dims.nbx > 0 and dims.N > 1 and simulink_opts.inputs.ubx -%}  {#- ubx #}
+    {%- set i_input = i_input + 1 %}
+    // ubx
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ (dims.N-1) * dims.nbx }});
+  {%- endif %}
+
+  {%- if dims.nbx_e > 0 and dims.N > 0 and simulink_opts.inputs.lbx_e -%}  {#- lbx_e #}
+    {%- set i_input = i_input + 1 %}
+    // lbx_e
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.nbx_e }});
+  {%- endif %}
+  {%- if dims.nbx_e > 0 and dims.N > 0 and simulink_opts.inputs.ubx_e -%}  {#- ubx_e #}
+    {%- set i_input = i_input + 1 %}
+    // ubx_e
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.nbx_e }});
+  {%- endif %}
+
+  {%- if dims.nbu > 0 and dims.N > 0 and simulink_opts.inputs.lbu -%}  {#- lbu #}
+    {%- set i_input = i_input + 1 %}
+    // lbu
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.N*dims.nbu }});
+  {%- endif -%}
+  {%- if dims.nbu > 0 and dims.N > 0 and simulink_opts.inputs.ubu -%}  {#- ubu #}
+    {%- set i_input = i_input + 1 %}
+    // ubu
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.N*dims.nbu }});
+  {%- endif -%}
+
+
+  {%- if dims.ng > 0 and simulink_opts.inputs.lg -%}  {#- lg #}
+    {%- set i_input = i_input + 1 %}
+    // lg
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.N*dims.ng }});
+  {%- endif -%}
+  {%- if dims.ng > 0 and simulink_opts.inputs.ug -%}  {#- ug #}
+    {%- set i_input = i_input + 1 %}
+    // ug
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.N*dims.ng }});
+  {%- endif -%}
+
+  {%- if dims.nh > 0 and simulink_opts.inputs.lh -%}  {#- lh #}
+    {%- set i_input = i_input + 1 %}
+    // lh
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.N*dims.nh }});
+  {%- endif -%}
+  {%- if dims.nh > 0 and simulink_opts.inputs.uh -%}  {#- uh #}
+    {%- set i_input = i_input + 1 %}
+    // uh
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.N*dims.nh }});
+  {%- endif -%}
+
+  {%- if dims.nh_e > 0 and simulink_opts.inputs.lh_e -%}  {#- lh_e #}
+    {%- set i_input = i_input + 1 %}
+    // lh_e
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.nh_e }});
+  {%- endif -%}
+  {%- if dims.nh_e > 0 and simulink_opts.inputs.uh_e -%}  {#- uh_e #}
+    {%- set i_input = i_input + 1 %}
+    // uh_e
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.nh_e }});
+  {%- endif -%}
+
+  {%- if dims.ny_0 > 0 and simulink_opts.inputs.cost_W_0 %}  {#- cost_W_0 #}
+    {%- set i_input = i_input + 1 %}
+    // cost_W_0
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.ny_0 * dims.ny_0 }});
+  {%- endif %}
+
+  {%- if dims.ny > 0 and simulink_opts.inputs.cost_W %}  {#- cost_W #}
+    {%- set i_input = i_input + 1 %}
+    // cost_W
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.ny * dims.ny }});
+  {%- endif %}
+
+  {%- if dims.ny_e > 0 and simulink_opts.inputs.cost_W_e %}  {#- cost_W_e #}
+    {%- set i_input = i_input + 1 %}
+    // cost_W_e
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.ny_e * dims.ny_e }});
+  {%- endif %}
+
+  {%- if simulink_opts.inputs.reset_solver -%}  {#- reset_solver #}
+    {%- set i_input = i_input + 1 %}
+    // reset_solver
+    ssSetInputPortVectorDimension(S, {{ i_input }}, 1);
+  {%- endif -%}
+
+  {%- if simulink_opts.inputs.x_init -%}  {#- x_init #}
+    {%- set i_input = i_input + 1 %}
+    // x_init
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.nx * (dims.N+1) }});
+  {%- endif -%}
+
+  {%- if simulink_opts.inputs.u_init -%}  {#- u_init #}
+    {%- set i_input = i_input + 1 %}
+    // u_init
+    ssSetInputPortVectorDimension(S, {{ i_input }}, {{ dims.nu * (dims.N) }});
+  {%- endif -%}
+
+    /* specify dimension information for the OUTPUT ports */
+    {%- set i_output = -1 %}{# note here i_output is 0-based #}
+  {%- if dims.nu > 0 and simulink_opts.outputs.u0 == 1 %}
+    {%- set i_output = i_output + 1 %}
+    ssSetOutputPortVectorDimension(S, {{ i_output }}, {{ dims.nu }} );
+  {%- endif %}
+
+  {%- if simulink_opts.outputs.utraj == 1 %}
+    {%- set i_output = i_output + 1 %}
+    ssSetOutputPortVectorDimension(S, {{ i_output }}, {{ dims.nu * dims.N }} );
+  {%- endif %}
+
+  {%- if simulink_opts.outputs.xtraj == 1 %}
+    {%- set i_output = i_output + 1 %}
+    ssSetOutputPortVectorDimension(S, {{ i_output }}, {{ dims.nx * (dims.N+1) }} );
+  {%- endif %}
+
+  {%- if simulink_opts.outputs.solver_status == 1 %}
+    {%- set i_output = i_output + 1 %}
+    ssSetOutputPortVectorDimension(S, {{ i_output }}, 1 );
+  {%- endif %}
+
+  {%- if simulink_opts.outputs.cost_value == 1 %}
+    {%- set i_output = i_output + 1 %}
+    ssSetOutputPortVectorDimension(S, {{ i_output }}, 1 );
+  {%- endif %}
+
+  {%- if simulink_opts.outputs.KKT_residual == 1 %}
+    {%- set i_output = i_output + 1 %}
+    ssSetOutputPortVectorDimension(S, {{ i_output }}, 1 );
+  {%- endif %}
+
+  {%- if simulink_opts.outputs.KKT_residuals == 1 %}
+    {%- set i_output = i_output + 1 %}
+    ssSetOutputPortVectorDimension(S, {{ i_output }}, 4 );
+  {%- endif %}
+
+  {%- if dims.N > 0 and simulink_opts.outputs.x1 == 1 %}
+    {%- set i_output = i_output + 1 %}
+    ssSetOutputPortVectorDimension(S, {{ i_output }}, {{ dims.nx }} ); // state at shooting node 1
+  {%- endif %}
+
+  {%- if simulink_opts.outputs.CPU_time == 1 %}
+    {%- set i_output = i_output + 1 %}
+    ssSetOutputPortVectorDimension(S, {{ i_output }}, 1);
+  {%- endif %}
+
+  {%- if simulink_opts.outputs.CPU_time_sim == 1 %}
+    {%- set i_output = i_output + 1 %}
+    ssSetOutputPortVectorDimension(S, {{ i_output }}, 1);
+  {%- endif %}
+
+  {%- if simulink_opts.outputs.CPU_time_qp == 1 %}
+    {%- set i_output = i_output + 1 %}
+    ssSetOutputPortVectorDimension(S, {{ i_output }}, 1);
+  {%- endif %}
+
+  {%- if simulink_opts.outputs.CPU_time_lin == 1 %}
+    {%- set i_output = i_output + 1 %}
+    ssSetOutputPortVectorDimension(S, {{ i_output }}, 1);
+  {%- endif %}
+
+  {%- if simulink_opts.outputs.sqp_iter == 1 %}
+    {%- set i_output = i_output + 1 %}
+    ssSetOutputPortVectorDimension(S, {{ i_output }}, 1 );
+  {%- endif %}
+
+    // specify the direct feedthrough status
+    // should be set to 1 for all inputs used in mdlOutputs
+    {%- for i in range(end=n_inputs) %}
+    ssSetInputPortDirectFeedThrough(S, {{ i }}, 1);
+    {%- endfor %}
+
+    // one sample time
+    ssSetNumSampleTimes(S, 1);
+}
+
+
+#if defined(MATLAB_MEX_FILE)
+
+#define MDL_SET_INPUT_PORT_DIMENSION_INFO
+#define MDL_SET_OUTPUT_PORT_DIMENSION_INFO
+
+static void mdlSetInputPortDimensionInfo(SimStruct *S, int_T port, const DimsInfo_T *dimsInfo)
+{
+    if ( !ssSetInputPortDimensionInfo(S, port, dimsInfo) )
+         return;
+}
+
+static void mdlSetOutputPortDimensionInfo(SimStruct *S, int_T port, const DimsInfo_T *dimsInfo)
+{
+    if ( !ssSetOutputPortDimensionInfo(S, port, dimsInfo) )
+         return;
+}
+
+#endif /* MATLAB_MEX_FILE */
+
+
+static void mdlInitializeSampleTimes(SimStruct *S)
+{
+    ssSetSampleTime(S, 0, SAMPLINGTIME);
+    ssSetOffsetTime(S, 0, 0.0);
+}
+
+
+static void mdlStart(SimStruct *S)
+{
+    {{ model.name }}_solver_capsule *capsule = {{ model.name }}_acados_create_capsule();
+    {{ model.name }}_acados_create(capsule);
+
+    ssSetUserData(S, (void*)capsule);
+}
+
+
+static void mdlOutputs(SimStruct *S, int_T tid)
+{
+    {{ model.name }}_solver_capsule *capsule = ssGetUserData(S);
+    ocp_nlp_config *nlp_config = {{ model.name }}_acados_get_nlp_config(capsule);
+    ocp_nlp_dims *nlp_dims = {{ model.name }}_acados_get_nlp_dims(capsule);
+    ocp_nlp_in *nlp_in = {{ model.name }}_acados_get_nlp_in(capsule);
+    ocp_nlp_out *nlp_out = {{ model.name }}_acados_get_nlp_out(capsule);
+
+    InputRealPtrsType in_sign;
+
+    int N = {{ model.name | upper }}_N;
+
+    {%- set buffer_sizes = [dims.nbx_0, dims.np, dims.nbx, dims.nbx_e, dims.nbu, dims.ng, dims.nh, dims.ng_e, dims.nh_e] -%}
+
+  {%- if dims.ny_0 > 0 and simulink_opts.inputs.y_ref_0 %}  {# y_ref_0 #}
+    {%- set buffer_sizes = buffer_sizes | concat(with=(dims.ny_0)) %}
+  {%- endif %}
+  {%- if dims.ny > 0 and dims.N > 1 and simulink_opts.inputs.y_ref %}  {# y_ref #}
+    {%- set buffer_sizes = buffer_sizes | concat(with=(dims.ny)) %}
+  {%- endif %}
+  {%- if dims.ny_e > 0 and dims.N > 0 and simulink_opts.inputs.y_ref_e %}  {# y_ref_e #}
+    {%- set buffer_sizes = buffer_sizes | concat(with=(dims.ny_e)) %}
+  {%- endif %}
+
+  {%- if dims.ny_0 > 0 and simulink_opts.inputs.cost_W_0 %}  {#- cost_W_0 #}
+    {%- set buffer_sizes = buffer_sizes | concat(with=(dims.ny_0 * dims.ny_0)) %}
+  {%- endif %}
+  {%- if dims.ny > 0 and simulink_opts.inputs.cost_W %}  {#- cost_W #}
+    {%- set buffer_sizes = buffer_sizes | concat(with=(dims.ny * dims.ny)) %}
+  {%- endif %}
+  {%- if dims.ny_e > 0 and simulink_opts.inputs.cost_W_e %}  {#- cost_W_e #}
+    {%- set buffer_sizes = buffer_sizes | concat(with=(dims.ny_e * dims.ny_e)) %}
+  {%- endif %}
+
+    // local buffer
+    {%- set buffer_size = buffer_sizes | sort | last %}
+    real_t buffer[{{ buffer_size }}];
+
+    /* go through inputs */
+    {%- set i_input = -1 %}
+  {%- if dims.nbx_0 > 0 and simulink_opts.inputs.lbx_0 -%}  {#- lbx_0 #}
+    // lbx_0
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+    for (int i = 0; i < {{ dims.nbx_0 }}; i++)
+        buffer[i] = (double)(*in_sign[i]);
+
+    ocp_nlp_constraints_model_set(nlp_config, nlp_dims, nlp_in, 0, "lbx", buffer);
+  {%- endif %}
+
+  {%- if dims.nbx_0 > 0 and simulink_opts.inputs.ubx_0 -%}  {#- ubx_0 #}
+    // ubx_0
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+    for (int i = 0; i < {{ dims.nbx_0 }}; i++)
+        buffer[i] = (double)(*in_sign[i]);
+    ocp_nlp_constraints_model_set(nlp_config, nlp_dims, nlp_in, 0, "ubx", buffer);
+  {%- endif %}
+
+  {%- if dims.np > 0 and simulink_opts.inputs.parameter_traj -%}  {#- parameter_traj #}
+    // parameters - stage-variant !!!
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+
+    // update value of parameters
+    for (int ii = 0; ii <= N; ii++)
+    {
+        for (int jj = 0; jj < {{ dims.np }}; jj++)
+            buffer[jj] = (double)(*in_sign[ii*{{dims.np}}+jj]);
+        {{ model.name }}_acados_update_params(capsule, ii, buffer, {{ dims.np }});
+    }
+  {%- endif %}
+
+  {% if dims.ny_0 > 0 and simulink_opts.inputs.y_ref_0 %}
+    // y_ref_0
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+
+    for (int i = 0; i < {{ dims.ny_0 }}; i++)
+        buffer[i] = (double)(*in_sign[i]);
+
+    ocp_nlp_cost_model_set(nlp_config, nlp_dims, nlp_in, 0, "yref", (void *) buffer);
+  {%- endif %}
+
+  {% if dims.ny > 0 and dims.N > 1 and simulink_opts.inputs.y_ref %}
+    // y_ref - for stages 1 to N-1
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+
+    for (int ii = 1; ii < N; ii++)
+    {
+        for (int jj = 0; jj < {{ dims.ny }}; jj++)
+            buffer[jj] = (double)(*in_sign[(ii-1)*{{ dims.ny }}+jj]);
+        ocp_nlp_cost_model_set(nlp_config, nlp_dims, nlp_in, ii, "yref", (void *) buffer);
+    }
+  {%- endif %}
+
+  {% if dims.ny_e > 0 and dims.N > 0 and simulink_opts.inputs.y_ref_e %}
+    // y_ref_e
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+
+    for (int i = 0; i < {{ dims.ny_e }}; i++)
+        buffer[i] = (double)(*in_sign[i]);
+
+    ocp_nlp_cost_model_set(nlp_config, nlp_dims, nlp_in, N, "yref", (void *) buffer);
+  {%- endif %}
+
+  {%- if dims.nbx > 0 and dims.N > 1 and simulink_opts.inputs.lbx -%}  {#- lbx #}
+    // lbx
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+    for (int ii = 1; ii < N; ii++)
+    {
+        for (int jj = 0; jj < {{ dims.nbx }}; jj++)
+            buffer[jj] = (double)(*in_sign[(ii-1)*{{ dims.nbx }}+jj]);
+        ocp_nlp_constraints_model_set(nlp_config, nlp_dims, nlp_in, ii, "lbx", (void *) buffer);
+    }
+  {%- endif %}
+  {%- if dims.nbx > 0 and dims.N > 1 and simulink_opts.inputs.ubx -%}  {#- ubx #}
+    // ubx
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+    for (int ii = 1; ii < N; ii++)
+    {
+        for (int jj = 0; jj < {{ dims.nbx }}; jj++)
+            buffer[jj] = (double)(*in_sign[(ii-1)*{{ dims.nbx }}+jj]);
+        ocp_nlp_constraints_model_set(nlp_config, nlp_dims, nlp_in, ii, "ubx", (void *) buffer);
+    }
+  {%- endif %}
+
+
+  {%- if dims.nbx_e > 0 and dims.N > 0 and simulink_opts.inputs.lbx_e -%}  {#- lbx_e #}
+    // lbx_e
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+
+    for (int i = 0; i < {{ dims.nbx_e }}; i++)
+        buffer[i] = (double)(*in_sign[i]);
+    ocp_nlp_constraints_model_set(nlp_config, nlp_dims, nlp_in, N, "lbx", buffer);
+  {%- endif %}
+  {%- if dims.nbx_e > 0 and dims.N > 0 and simulink_opts.inputs.ubx_e -%}  {#- ubx_e #}
+    // ubx_e
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+
+    for (int i = 0; i < {{ dims.nbx_e }}; i++)
+        buffer[i] = (double)(*in_sign[i]);
+    ocp_nlp_constraints_model_set(nlp_config, nlp_dims, nlp_in, N, "ubx", buffer);
+  {%- endif %}
+
+
+  {%- if dims.nbu > 0 and dims.N > 0 and simulink_opts.inputs.lbu -%}  {#- lbu #}
+    // lbu
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+    for (int ii = 0; ii < N; ii++)
+    {
+        for (int jj = 0; jj < {{ dims.nbu }}; jj++)
+            buffer[jj] = (double)(*in_sign[ii*{{ dims.nbu }}+jj]);
+        ocp_nlp_constraints_model_set(nlp_config, nlp_dims, nlp_in, ii, "lbu", (void *) buffer);
+    }
+  {%- endif -%}
+  {%- if dims.nbu > 0 and dims.N > 0 and simulink_opts.inputs.ubu -%}  {#- ubu #}
+    // ubu
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+    for (int ii = 0; ii < N; ii++)
+    {
+        for (int jj = 0; jj < {{ dims.nbu }}; jj++)
+            buffer[jj] = (double)(*in_sign[ii*{{ dims.nbu }}+jj]);
+        ocp_nlp_constraints_model_set(nlp_config, nlp_dims, nlp_in, ii, "ubu", (void *) buffer);
+    }
+  {%- endif -%}
+
+  {%- if dims.ng > 0 and simulink_opts.inputs.lg -%}  {#- lg #}
+    // lg
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+
+    for (int ii = 0; ii < N; ii++)
+    {
+        for (int jj = 0; jj < {{ dims.ng }}; jj++)
+            buffer[jj] = (double)(*in_sign[ii*{{ dims.ng }}+jj]);
+        ocp_nlp_constraints_model_set(nlp_config, nlp_dims, nlp_in, ii, "lg", (void *) buffer);
+    }
+  {%- endif -%}
+  {%- if dims.ng > 0 and simulink_opts.inputs.ug -%}  {#- ug #}
+    // ug
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+
+    for (int ii = 0; ii < N; ii++)
+    {
+        for (int jj = 0; jj < {{ dims.ng }}; jj++)
+            buffer[jj] = (double)(*in_sign[ii*{{ dims.ng }}+jj]);
+        ocp_nlp_constraints_model_set(nlp_config, nlp_dims, nlp_in, ii, "ug", (void *) buffer);
+    }
+  {%- endif -%}
+
+  {%- if dims.nh > 0 and simulink_opts.inputs.lh -%}  {#- lh #}
+    // lh
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+
+    for (int ii = 0; ii < N; ii++)
+    {
+        for (int jj = 0; jj < {{ dims.nh }}; jj++)
+            buffer[jj] = (double)(*in_sign[ii*{{ dims.nh }}+jj]);
+        ocp_nlp_constraints_model_set(nlp_config, nlp_dims, nlp_in, ii, "lh", (void *) buffer);
+    }
+  {%- endif -%}
+  {%- if dims.nh > 0 and simulink_opts.inputs.uh -%}  {#- uh #}
+    // uh
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+
+    for (int ii = 0; ii < N; ii++)
+    {
+        for (int jj = 0; jj < {{ dims.nh }}; jj++)
+            buffer[jj] = (double)(*in_sign[ii*{{ dims.nh }}+jj]);
+        ocp_nlp_constraints_model_set(nlp_config, nlp_dims, nlp_in, ii, "uh", (void *) buffer);
+    }
+  {%- endif -%}
+
+
+  {%- if dims.nh_e > 0 and simulink_opts.inputs.lh_e -%}  {#- lh_e #}
+    // lh_e
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+    for (int i = 0; i < {{ dims.nh_e }}; i++)
+        buffer[i] = (double)(*in_sign[i]);
+    ocp_nlp_constraints_model_set(nlp_config, nlp_dims, nlp_in, N, "lh", buffer);
+  {%- endif -%}
+  {%- if dims.nh_e > 0 and simulink_opts.inputs.uh_e -%}  {#- uh_e #}
+    // uh_e
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+    for (int i = 0; i < {{ dims.nh_e }}; i++)
+        buffer[i] = (double)(*in_sign[i]);
+    ocp_nlp_constraints_model_set(nlp_config, nlp_dims, nlp_in, N, "uh", buffer);
+  {%- endif -%}
+
+  {%- if dims.ny_0 > 0 and simulink_opts.inputs.cost_W_0 %}  {#- cost_W_0 #}
+    // cost_W_0
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+    for (int i = 0; i < {{ dims.ny_0 * dims.ny_0 }}; i++)
+        buffer[i] = (double)(*in_sign[i]);
+
+    ocp_nlp_cost_model_set(nlp_config, nlp_dims, nlp_in, 0, "W", buffer);
+  {%- endif %}
+
+  {%- if dims.ny > 0 and simulink_opts.inputs.cost_W %}  {#- cost_W #}
+    // cost_W
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+    for (int i = 0; i < {{ dims.ny * dims.ny }}; i++)
+        buffer[i] = (double)(*in_sign[i]);
+
+    for (int ii = 1; ii < N; ii++)
+        ocp_nlp_cost_model_set(nlp_config, nlp_dims, nlp_in, ii, "W", buffer);
+  {%- endif %}
+
+  {%- if dims.ny_e > 0 and simulink_opts.inputs.cost_W_e %}  {#- cost_W_e #}
+    // cost_W_e
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+    for (int i = 0; i < {{ dims.ny_e * dims.ny_e }}; i++)
+        buffer[i] = (double)(*in_sign[i]);
+
+    ocp_nlp_cost_model_set(nlp_config, nlp_dims, nlp_in, N, "W", buffer);
+  {%- endif %}
+
+  {%- if simulink_opts.inputs.reset_solver %}  {#- reset_solver #}
+    // reset_solver
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+    double reset = (double)(*in_sign[0]);
+    if (reset)
+    {
+        {{ model.name }}_acados_reset(capsule, 1);
+    }
+  {%- endif %}
+
+  {%- if simulink_opts.inputs.x_init %}  {#- x_init #}
+    // x_init
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+    for (int ii = 0; ii < {{ dims.N + 1 }}; ii++)
+    {
+        for (int jj = 0; jj < {{ dims.nx }}; jj++)
+            buffer[jj] = (double)(*in_sign[(ii)*{{ dims.nx }}+jj]);
+        ocp_nlp_out_set(nlp_config, nlp_dims, nlp_out, ii, "x", (void *) buffer);
+    }
+  {%- endif %}
+
+  {%- if simulink_opts.inputs.u_init %}  {#- u_init #}
+    // u_init
+    {%- set i_input = i_input + 1 %}
+    in_sign = ssGetInputPortRealSignalPtrs(S, {{ i_input }});
+    for (int ii = 0; ii < N; ii++)
+    {
+        for (int jj = 0; jj < {{ dims.nu }}; jj++)
+            buffer[jj] = (double)(*in_sign[(ii)*{{ dims.nu }}+jj]);
+        ocp_nlp_out_set(nlp_config, nlp_dims, nlp_out, ii, "u", (void *) buffer);
+    }
+  {%- endif %}
+
+    /* call solver */
+    int rti_phase = 0;
+    ocp_nlp_solver_opts_set(nlp_config, capsule->nlp_opts, "rti_phase", &rti_phase);
+    int acados_status = {{ model.name }}_acados_solve(capsule);
+
+
+    /* set outputs */
+    // assign pointers to output signals
+    real_t *out_u0, *out_utraj, *out_xtraj, *out_status, *out_sqp_iter, *out_KKT_res, *out_KKT_residuals, *out_x1, *out_cpu_time, *out_cpu_time_sim, *out_cpu_time_qp, *out_cpu_time_lin, *out_cost_value;
+    int tmp_int;
+
+    {%- set i_output = -1 -%}{# note here i_output is 0-based #}
+  {%- if dims.nu > 0 and simulink_opts.outputs.u0 == 1 %}
+    {%- set i_output = i_output + 1 %}
+    out_u0 = ssGetOutputPortRealSignal(S, {{ i_output }});
+    ocp_nlp_out_get(nlp_config, nlp_dims, nlp_out, 0, "u", (void *) out_u0);
+  {%- endif %}
+
+  {%- if simulink_opts.outputs.utraj == 1 %}
+    {%- set i_output = i_output + 1 %}
+    out_utraj = ssGetOutputPortRealSignal(S, {{ i_output }});
+    for (int ii = 0; ii < N; ii++)
+        ocp_nlp_out_get(nlp_config, nlp_dims, nlp_out, ii,
+                        "u", (void *) (out_utraj + ii * {{ dims.nu }}));
+  {%- endif %}
+
+  {% if simulink_opts.outputs.xtraj == 1 %}
+    {%- set i_output = i_output + 1 %}
+
+    out_xtraj = ssGetOutputPortRealSignal(S, {{ i_output }});
+    for (int ii = 0; ii < {{ dims.N + 1 }}; ii++)
+        ocp_nlp_out_get(nlp_config, nlp_dims, nlp_out, ii,
+                        "x", (void *) (out_xtraj + ii * {{ dims.nx }}));
+  {%- endif %}
+
+  {%- if simulink_opts.outputs.solver_status == 1 %}
+    {%- set i_output = i_output + 1 %}
+    out_status = ssGetOutputPortRealSignal(S, {{ i_output }});
+    *out_status = (real_t) acados_status;
+  {%- endif %}
+
+  {%- if simulink_opts.outputs.cost_value == 1 %}
+    {%- set i_output = i_output + 1 %}
+    out_cost_value = ssGetOutputPortRealSignal(S, {{ i_output }});
+    ocp_nlp_eval_cost(capsule->nlp_solver, nlp_in, nlp_out);
+    ocp_nlp_get(nlp_config, capsule->nlp_solver, "cost_value", (void *) out_cost_value);
+  {%- endif %}
+
+  {%- if simulink_opts.outputs.KKT_residual == 1 %}
+    {%- set i_output = i_output + 1 %}
+    out_KKT_res = ssGetOutputPortRealSignal(S, {{ i_output }});
+    *out_KKT_res = (real_t) nlp_out->inf_norm_res;
+  {%- endif %}
+
+  {%- if simulink_opts.outputs.KKT_residuals == 1 %}
+    {%- set i_output = i_output + 1 %}
+    out_KKT_residuals = ssGetOutputPortRealSignal(S, {{ i_output }});
+
+    {%- if solver_options.nlp_solver_type == "SQP_RTI" %}
+    ocp_nlp_eval_residuals(capsule->nlp_solver, nlp_in, nlp_out);
+    {%- endif %}
+    ocp_nlp_get(nlp_config, capsule->nlp_solver, "res_stat", (void *) &out_KKT_residuals[0]);
+    ocp_nlp_get(nlp_config, capsule->nlp_solver, "res_eq", (void *) &out_KKT_residuals[1]);
+    ocp_nlp_get(nlp_config, capsule->nlp_solver, "res_ineq", (void *) &out_KKT_residuals[2]);
+    ocp_nlp_get(nlp_config, capsule->nlp_solver, "res_comp", (void *) &out_KKT_residuals[3]);
+  {%- endif %}
+
+  {%- if dims.N > 0 and simulink_opts.outputs.x1 == 1 %}
+    {%- set i_output = i_output + 1 %}
+    out_x1 = ssGetOutputPortRealSignal(S, {{ i_output }});
+    ocp_nlp_out_get(nlp_config, nlp_dims, nlp_out, 1, "x", (void *) out_x1);
+  {%- endif %}
+
+  {%- if simulink_opts.outputs.CPU_time == 1 %}
+    {%- set i_output = i_output + 1 %}
+    out_cpu_time = ssGetOutputPortRealSignal(S, {{ i_output }});
+    // get solution time
+    ocp_nlp_get(nlp_config, capsule->nlp_solver, "time_tot", (void *) out_cpu_time);
+  {%- endif -%}
+
+  {%- if simulink_opts.outputs.CPU_time_sim == 1 %}
+    {%- set i_output = i_output + 1 %}
+    out_cpu_time_sim = ssGetOutputPortRealSignal(S, {{ i_output }});
+    ocp_nlp_get(nlp_config, capsule->nlp_solver, "time_sim", (void *) out_cpu_time_sim);
+  {%- endif -%}
+
+  {%- if simulink_opts.outputs.CPU_time_qp == 1 %}
+    {%- set i_output = i_output + 1 %}
+    out_cpu_time_qp = ssGetOutputPortRealSignal(S, {{ i_output }});
+    ocp_nlp_get(nlp_config, capsule->nlp_solver, "time_qp", (void *) out_cpu_time_qp);
+  {%- endif -%}
+
+  {%- if simulink_opts.outputs.CPU_time_lin == 1 %}
+    {%- set i_output = i_output + 1 %}
+    out_cpu_time_lin = ssGetOutputPortRealSignal(S, {{ i_output }});
+    ocp_nlp_get(nlp_config, capsule->nlp_solver, "time_lin", (void *) out_cpu_time_lin);
+  {%- endif -%}
+
+  {%- if simulink_opts.outputs.sqp_iter == 1 %}
+    {%- set i_output = i_output + 1 %}
+    out_sqp_iter = ssGetOutputPortRealSignal(S, {{ i_output }});
+    // get sqp iter
+    ocp_nlp_get(nlp_config, capsule->nlp_solver, "sqp_iter", (void *) &tmp_int);
+    *out_sqp_iter = (real_t) tmp_int;
+  {%- endif %}
+
+}
+
+static void mdlTerminate(SimStruct *S)
+{
+    {{ model.name }}_solver_capsule *capsule = ssGetUserData(S);
+
+    {{ model.name }}_acados_free(capsule);
+    {{ model.name }}_acados_free_capsule(capsule);
+}
+
+
+#ifdef  MATLAB_MEX_FILE
+#include "simulink.c"
+#else
+#include "cg_sfun.h"
+#endif

third_party/acados/acados_template/c_templates_tera/matlab_templates/main_mex.in.c

@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) The acados authors.
+ *
+ * This file is part of acados.
+ *
+ * The 2-Clause BSD License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.;
+ */
+
+
+// standard
+#include <stdio.h>
+#include <stdlib.h>
+// acados
+#include "acados/utils/print.h"
+#include "acados/utils/math.h"
+#include "acados_c/ocp_nlp_interface.h"
+#include "acados_solver_{{ model.name }}.h"
+// mex
+#include "mex.h"
+
+/* auxilary mex */
+// prints a matrix in column-major format (exponential notation)
+void MEX_print_exp_mat(int m, int n, double *A, int lda)
+{
+	for (int i=0; i<m; i++)
+    {
+		for (int j=0; j<n; j++)
+        {
+			mexPrintf("%e\t", A[i+lda*j]);
+        }
+		mexPrintf("\n");
+    }
+	mexPrintf("\n");
+}
+
+// prints the transposed of a matrix in column-major format (exponential notation)
+void MEX_print_exp_tran_mat(int row, int col, double *A, int lda)
+{
+	for (int j=0; j<col; j++)
+    {
+		for (int i=0; i<row; i++)
+        {
+			mexPrintf("%e\t", A[i+lda*j]);
+        }
+		mexPrintf("\n");
+    }
+	mexPrintf("\n");
+}
+
+
+void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
+{
+
+    int status = 0;
+    status = {{ model.name }}_acados_create();
+
+    if (status)
+    {
+        mexPrintf("{{ model.name }}_acados_create() returned status %d. Exiting.\n", status);
+        exit(1);
+    }
+
+
+    // get pointers to nlp solver related objects
+    ocp_nlp_config *nlp_config = {{ model.name }}_acados_get_nlp_config();
+    ocp_nlp_dims *nlp_dims = {{ model.name }}_acados_get_nlp_dims();
+    ocp_nlp_in *nlp_in = {{ model.name }}_acados_get_nlp_in();
+    ocp_nlp_out *nlp_out = {{ model.name }}_acados_get_nlp_out();
+    ocp_nlp_solver *nlp_solver = {{ model.name }}_acados_get_nlp_solver();
+    void *nlp_opts = {{ model.name }}_acados_get_nlp_opts();
+
+    // initial condition
+    int idxbx0[{{ dims.nbx_0 }}];
+    {% for i in range(end=dims.nbx_0) %}
+    idxbx0[{{ i }}] = {{ constraints.idxbx_0[i] }};
+    {%- endfor %}
+
+    double lbx0[{{ dims.nbx_0 }}];
+    double ubx0[{{ dims.nbx_0 }}];
+    {% for i in range(end=dims.nbx_0) %}
+    lbx0[{{ i }}] = {{ constraints.lbx_0[i] }};
+    ubx0[{{ i }}] = {{ constraints.ubx_0[i] }};
+    {%- endfor %}
+
+    ocp_nlp_constraints_model_set(nlp_config, nlp_dims, nlp_in, 0, "idxbx", idxbx0);
+    ocp_nlp_constraints_model_set(nlp_config, nlp_dims, nlp_in, 0, "lbx", lbx0);
+    ocp_nlp_constraints_model_set(nlp_config, nlp_dims, nlp_in, 0, "ubx", ubx0);
+
+    // initialization for state values
+    double x_init[{{ dims.nx }}];
+    {%- for i in range(end=dims.nx) %}
+    x_init[{{ i }}] = 0.0;
+    {%- endfor %}
+
+    // initial value for control input
+    double u0[{{ dims.nu }}];
+    {%- for i in range(end=dims.nu) %}
+    u0[{{ i }}] = 0.0;
+    {%- endfor %}
+
+    // prepare evaluation
+    int NTIMINGS = 10;
+    double min_time = 1e12;
+    double kkt_norm_inf;
+    double elapsed_time;
+    int sqp_iter;
+
+    double xtraj[{{ dims.nx }} * ({{ dims.N }}+1)];
+    double utraj[{{ dims.nu }} * ({{ dims.N }})];
+
+    // solve ocp in loop
+    for (int ii = 0; ii < NTIMINGS; ii++)
+    {
+        // initialize primal solution
+        for (int i = 0; i <= nlp_dims->N; i++)
+        {
+            ocp_nlp_out_set(nlp_config, nlp_dims, nlp_out, i, "x", x_init);
+            ocp_nlp_out_set(nlp_config, nlp_dims, nlp_out, i, "u", u0);
+        }
+        status = {{ model.name }}_acados_solve();
+        ocp_nlp_get(nlp_config, nlp_solver, "time_tot", &elapsed_time);
+        min_time = MIN(elapsed_time, min_time);
+    }
+
+    /* print solution and statistics */
+    for (int ii = 0; ii <= nlp_dims->N; ii++)
+        ocp_nlp_out_get(nlp_config, nlp_dims, nlp_out, ii, "x", &xtraj[ii*{{ dims.nx }}]);
+    for (int ii = 0; ii < nlp_dims->N; ii++)
+        ocp_nlp_out_get(nlp_config, nlp_dims, nlp_out, ii, "u", &utraj[ii*{{ dims.nu }}]);
+
+    mexPrintf("\n--- xtraj ---\n");
+    MEX_print_exp_tran_mat( {{ dims.nx }}, {{ dims.N }}+1, xtraj, {{ dims.nx }} );
+    mexPrintf("\n--- utraj ---\n");
+    MEX_print_exp_tran_mat( {{ dims.nu }}, {{ dims.N }}, utraj, {{ dims.nu }} );
+
+    mexPrintf("\nsolved ocp %d times, solution printed above\n\n", NTIMINGS);
+
+    if (status == ACADOS_SUCCESS)
+        mexPrintf("{{ model.name }}_acados_solve(): SUCCESS!\n");
+    else
+        mexPrintf("{{ model.name }}_acados_solve() failed with status %d.\n", status);
+
+    // get solution
+    ocp_nlp_out_get(nlp_config, nlp_dims, nlp_out, 0, "kkt_norm_inf", &kkt_norm_inf);
+    ocp_nlp_get(nlp_config, nlp_solver, "sqp_iter", &sqp_iter);
+
+    mexPrintf("\nSolver info:\n");
+    mexPrintf(" SQP iterations %2d\n minimum time for 1 solve %f [ms]\n KKT %e\n",
+           sqp_iter, min_time*1000, kkt_norm_inf);
+
+    // free solver
+    status = {{ model.name }}_acados_free();
+    if (status)
+    {
+        mexPrintf("{{ model.name }}_acados_free() returned status %d.\n", status);
+    }
+
+    return;
+}

third_party/acados/acados_template/c_templates_tera/matlab_templates/make_main_mex.in.m

@@ -0,0 +1,103 @@
+%
+% Copyright (c) The acados authors.
+%
+% This file is part of acados.
+%
+% The 2-Clause BSD License
+%
+% Redistribution and use in source and binary forms, with or without
+% modification, are permitted provided that the following conditions are met:
+%
+% 1. Redistributions of source code must retain the above copyright notice,
+% this list of conditions and the following disclaimer.
+%
+% 2. Redistributions in binary form must reproduce the above copyright notice,
+% this list of conditions and the following disclaimer in the documentation
+% and/or other materials provided with the distribution.
+%
+% THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+% AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+% IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+% ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+% LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+% CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+% SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+% INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+% CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+% ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+% POSSIBILITY OF SUCH DAMAGE.;
+
+%
+
+function make_main_mex_{{ model.name }}()
+
+    opts.output_dir = pwd;
+
+    % get acados folder
+    acados_folder = getenv('ACADOS_INSTALL_DIR');
+
+    % set paths
+    acados_include = ['-I' fullfile(acados_folder, 'include')];
+    template_lib_include = ['-l' 'acados_solver_{{ model.name }}'];
+    template_lib_path = ['-L' fullfile(pwd)];
+
+    acados_lib_path = ['-L' fullfile(acados_folder, 'lib')];
+    external_include = ['-I', fullfile(acados_folder, 'external')];
+    blasfeo_include = ['-I', fullfile(acados_folder, 'external', 'blasfeo', 'include')];
+    hpipm_include = ['-I', fullfile(acados_folder, 'external', 'hpipm', 'include')];
+
+    mex_names = { ...
+        'main_mex_{{ model.name }}' ...
+    };
+
+    mex_files = cell(length(mex_names), 1);
+    for k=1:length(mex_names)
+        mex_files{k} = fullfile([mex_names{k}, '.c']);
+    end
+
+    %% octave C flags
+    if is_octave()
+        if ~exist(fullfile(opts.output_dir, 'cflags_octave.txt'), 'file')
+            diary(fullfile(opts.output_dir, 'cflags_octave.txt'));
+            diary on
+            mkoctfile -p CFLAGS
+            diary off
+            input_file = fopen(fullfile(opts.output_dir, 'cflags_octave.txt'), 'r');
+            cflags_tmp = fscanf(input_file, '%[^\n]s');
+            fclose(input_file);
+            if ~ismac()
+                cflags_tmp = [cflags_tmp, ' -std=c99 -fopenmp'];
+            else
+                cflags_tmp = [cflags_tmp, ' -std=c99'];
+            end
+            input_file = fopen(fullfile(opts.output_dir, 'cflags_octave.txt'), 'w');
+            fprintf(input_file, '%s', cflags_tmp);
+            fclose(input_file);
+        end
+        % read cflags from file
+        input_file = fopen(fullfile(opts.output_dir, 'cflags_octave.txt'), 'r');
+        cflags_tmp = fscanf(input_file, '%[^\n]s');
+        fclose(input_file);
+        setenv('CFLAGS', cflags_tmp);
+    end
+
+    %% compile mex
+    for ii=1:length(mex_files)
+        disp(['compiling ', mex_files{ii}])
+        if is_octave()
+    %        mkoctfile -p CFLAGS
+            mex(acados_include, template_lib_include, external_include, blasfeo_include, hpipm_include,...
+            acados_lib_path, template_lib_path, '-lacados', '-lhpipm', '-lblasfeo', mex_files{ii})
+        else
+            if ismac()
+                FLAGS = 'CFLAGS=$CFLAGS -std=c99';
+            else
+                FLAGS = 'CFLAGS=$CFLAGS -std=c99 -fopenmp';
+            end
+            mex(FLAGS, acados_include, template_lib_include, external_include, blasfeo_include, hpipm_include,...
+                acados_lib_path, template_lib_path, '-lacados', '-lhpipm', '-lblasfeo', mex_files{ii})
+        end
+    end
+
+
+end

third_party/acados/acados_template/c_templates_tera/matlab_templates/make_mex.in.m

@@ -0,0 +1,127 @@
+%
+% Copyright (c) The acados authors.
+%
+% This file is part of acados.
+%
+% The 2-Clause BSD License
+%
+% Redistribution and use in source and binary forms, with or without
+% modification, are permitted provided that the following conditions are met:
+%
+% 1. Redistributions of source code must retain the above copyright notice,
+% this list of conditions and the following disclaimer.
+%
+% 2. Redistributions in binary form must reproduce the above copyright notice,
+% this list of conditions and the following disclaimer in the documentation
+% and/or other materials provided with the distribution.
+%
+% THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+% AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+% IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+% ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+% LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+% CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+% SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+% INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+% CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+% ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+% POSSIBILITY OF SUCH DAMAGE.;
+
+%
+
+function make_mex_{{ model.name }}()
+
+    opts.output_dir = pwd;
+
+    % get acados folder
+    acados_folder = getenv('ACADOS_INSTALL_DIR');
+
+    % set paths
+    acados_include = ['-I' fullfile(acados_folder, 'include')];
+    template_lib_include = ['-l' 'acados_ocp_solver_{{ model.name }}'];
+    template_lib_path = ['-L' fullfile(pwd)];
+
+    acados_lib_path = ['-L' fullfile(acados_folder, 'lib')];
+    external_include = ['-I', fullfile(acados_folder, 'external')];
+    blasfeo_include = ['-I', fullfile(acados_folder, 'external', 'blasfeo', 'include')];
+    hpipm_include = ['-I', fullfile(acados_folder, 'external', 'hpipm', 'include')];
+
+    % load linking information of compiled acados
+    link_libs_core_filename = fullfile(acados_folder, 'lib', 'link_libs.json');
+    addpath(fullfile(acados_folder, 'external', 'jsonlab'));
+    link_libs = loadjson(link_libs_core_filename);
+
+    % add necessary link instructs
+    acados_lib_extra = {};
+    lib_names = fieldnames(link_libs);
+    for idx = 1 : numel(lib_names)
+        lib_name = lib_names{idx};
+        link_arg = link_libs.(lib_name);
+        if ~isempty(link_arg)
+            acados_lib_extra = [acados_lib_extra, link_arg];
+        end
+    end
+
+
+    mex_include = ['-I', fullfile(acados_folder, 'interfaces', 'acados_matlab_octave')];
+
+    mex_names = { ...
+        'acados_mex_create_{{ model.name }}' ...
+        'acados_mex_free_{{ model.name }}' ...
+        'acados_mex_solve_{{ model.name }}' ...
+        'acados_mex_set_{{ model.name }}' ...
+    };
+
+    mex_files = cell(length(mex_names), 1);
+    for k=1:length(mex_names)
+        mex_files{k} = fullfile([mex_names{k}, '.c']);
+    end
+
+    %% octave C flags
+    if is_octave()
+        if ~exist(fullfile(opts.output_dir, 'cflags_octave.txt'), 'file')
+            diary(fullfile(opts.output_dir, 'cflags_octave.txt'));
+            diary on
+            mkoctfile -p CFLAGS
+            diary off
+            input_file = fopen(fullfile(opts.output_dir, 'cflags_octave.txt'), 'r');
+            cflags_tmp = fscanf(input_file, '%[^\n]s');
+            fclose(input_file);
+            if ~ismac()
+                cflags_tmp = [cflags_tmp, ' -std=c99 -fopenmp'];
+            else
+                cflags_tmp = [cflags_tmp, ' -std=c99'];
+            end
+            input_file = fopen(fullfile(opts.output_dir, 'cflags_octave.txt'), 'w');
+            fprintf(input_file, '%s', cflags_tmp);
+            fclose(input_file);
+        end
+        % read cflags from file
+        input_file = fopen(fullfile(opts.output_dir, 'cflags_octave.txt'), 'r');
+        cflags_tmp = fscanf(input_file, '%[^\n]s');
+        fclose(input_file);
+        setenv('CFLAGS', cflags_tmp);
+    end
+
+    %% compile mex
+    for ii=1:length(mex_files)
+        disp(['compiling ', mex_files{ii}])
+        if is_octave()
+    %        mkoctfile -p CFLAGS
+            mex(acados_include, template_lib_include, external_include, blasfeo_include, hpipm_include,...
+                template_lib_path, mex_include, acados_lib_path, '-lacados', '-lhpipm', '-lblasfeo',...
+                acados_lib_extra{:}, mex_files{ii})
+        else
+            if ismac()
+                FLAGS = 'CFLAGS=$CFLAGS -std=c99';
+            else
+                FLAGS = 'CFLAGS=$CFLAGS -std=c99 -fopenmp';
+            end
+            mex(FLAGS, acados_include, template_lib_include, external_include, blasfeo_include, hpipm_include,...
+                template_lib_path, mex_include, acados_lib_path, '-lacados', '-lhpipm', '-lblasfeo',...
+                acados_lib_extra{:}, mex_files{ii})
+        end
+    end
+
+
+end

third_party/acados/acados_template/c_templates_tera/matlab_templates/make_sfun.in.m

@@ -0,0 +1,432 @@
+%
+% Copyright (c) The acados authors.
+%
+% This file is part of acados.
+%
+% The 2-Clause BSD License
+%
+% Redistribution and use in source and binary forms, with or without
+% modification, are permitted provided that the following conditions are met:
+%
+% 1. Redistributions of source code must retain the above copyright notice,
+% this list of conditions and the following disclaimer.
+%
+% 2. Redistributions in binary form must reproduce the above copyright notice,
+% this list of conditions and the following disclaimer in the documentation
+% and/or other materials provided with the distribution.
+%
+% THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+% AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+% IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+% ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+% LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+% CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+% SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+% INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+% CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+% ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+% POSSIBILITY OF SUCH DAMAGE.;
+
+%
+
+SOURCES = { ...
+        {%- if solver_options.integrator_type == 'ERK' %}
+            '{{ model.name }}_model/{{ model.name }}_expl_ode_fun.c', ...
+            '{{ model.name }}_model/{{ model.name }}_expl_vde_forw.c',...
+            {%- if solver_options.hessian_approx == 'EXACT' %}
+            '{{ model.name }}_model/{{ model.name }}_expl_ode_hess.c',...
+            {%- endif %}
+        {%- elif solver_options.integrator_type == "IRK" %}
+            '{{ model.name }}_model/{{ model.name }}_impl_dae_fun.c', ...
+            '{{ model.name }}_model/{{ model.name }}_impl_dae_fun_jac_x_xdot_z.c', ...
+            '{{ model.name }}_model/{{ model.name }}_impl_dae_jac_x_xdot_u_z.c', ...
+            {%- if solver_options.hessian_approx == 'EXACT' %}
+            '{{ model.name }}_model/{{ model.name }}_impl_dae_hess.c',...
+            {%- endif %}
+        {%- elif solver_options.integrator_type == "GNSF" %}
+            {% if model.gnsf.purely_linear != 1 %}
+            '{{ model.name }}_model/{{ model.name }}_gnsf_phi_fun.c',...
+            '{{ model.name }}_model/{{ model.name }}_gnsf_phi_fun_jac_y.c',...
+            '{{ model.name }}_model/{{ model.name }}_gnsf_phi_jac_y_uhat.c',...
+            {% if model.gnsf.nontrivial_f_LO == 1 %}
+            '{{ model.name }}_model/{{ model.name }}_gnsf_f_lo_fun_jac_x1k1uz.c',...
+            {%- endif %}
+            {%- endif %}
+            '{{ model.name }}_model/{{ model.name }}_gnsf_get_matrices_fun.c',...
+        {%- elif solver_options.integrator_type == "DISCRETE" %}
+            '{{ model.name }}_model/{{ model.name }}_dyn_disc_phi_fun.c',...
+            '{{ model.name }}_model/{{ model.name }}_dyn_disc_phi_fun_jac.c',...
+        {%- if solver_options.hessian_approx == "EXACT" %}
+            '{{ model.name }}_model/{{ model.name }}_dyn_disc_phi_fun_jac_hess.c',...
+        {%- endif %}
+        {%- endif %}
+        {%- if cost.cost_type_0 == "NONLINEAR_LS" %}
+            '{{ model.name }}_cost/{{ model.name }}_cost_y_0_fun.c',...
+            '{{ model.name }}_cost/{{ model.name }}_cost_y_0_fun_jac_ut_xt.c',...
+            '{{ model.name }}_cost/{{ model.name }}_cost_y_0_hess.c',...
+        {%- elif cost.cost_type_0 == "EXTERNAL" %}
+            '{{ model.name }}_cost/{{ model.name }}_cost_ext_cost_0_fun.c',...
+            '{{ model.name }}_cost/{{ model.name }}_cost_ext_cost_0_fun_jac.c',...
+            '{{ model.name }}_cost/{{ model.name }}_cost_ext_cost_0_fun_jac_hess.c',...
+        {%- endif %}
+
+        {%- if cost.cost_type == "NONLINEAR_LS" %}
+            '{{ model.name }}_cost/{{ model.name }}_cost_y_fun.c',...
+            '{{ model.name }}_cost/{{ model.name }}_cost_y_fun_jac_ut_xt.c',...
+            '{{ model.name }}_cost/{{ model.name }}_cost_y_hess.c',...
+        {%- elif cost.cost_type == "EXTERNAL" %}
+            '{{ model.name }}_cost/{{ model.name }}_cost_ext_cost_fun.c',...
+            '{{ model.name }}_cost/{{ model.name }}_cost_ext_cost_fun_jac.c',...
+            '{{ model.name }}_cost/{{ model.name }}_cost_ext_cost_fun_jac_hess.c',...
+        {%- endif %}
+        {%- if cost.cost_type_e == "NONLINEAR_LS" %}
+            '{{ model.name }}_cost/{{ model.name }}_cost_y_e_fun.c',...
+            '{{ model.name }}_cost/{{ model.name }}_cost_y_e_fun_jac_ut_xt.c',...
+            '{{ model.name }}_cost/{{ model.name }}_cost_y_e_hess.c',...
+        {%- elif cost.cost_type_e == "EXTERNAL" %}
+            '{{ model.name }}_cost/{{ model.name }}_cost_ext_cost_e_fun.c',...
+            '{{ model.name }}_cost/{{ model.name }}_cost_ext_cost_e_fun_jac.c',...
+            '{{ model.name }}_cost/{{ model.name }}_cost_ext_cost_e_fun_jac_hess.c',...
+        {%- endif %}
+        {%- if constraints.constr_type == "BGH"  and dims.nh > 0 %}
+            '{{ model.name }}_constraints/{{ model.name }}_constr_h_fun.c', ...
+            '{{ model.name }}_constraints/{{ model.name }}_constr_h_fun_jac_uxt_zt_hess.c', ...
+            '{{ model.name }}_constraints/{{ model.name }}_constr_h_fun_jac_uxt_zt.c', ...
+        {%- elif constraints.constr_type == "BGP" and dims.nphi > 0 %}
+            '{{ model.name }}_constraints/{{ model.name }}_phi_constraint.c', ...
+        {%- endif %}
+        {%- if constraints.constr_type_e == "BGH"  and dims.nh_e > 0 %}
+            '{{ model.name }}_constraints/{{ model.name }}_constr_h_e_fun.c', ...
+            '{{ model.name }}_constraints/{{ model.name }}_constr_h_e_fun_jac_uxt_zt_hess.c', ...
+            '{{ model.name }}_constraints/{{ model.name }}_constr_h_e_fun_jac_uxt_zt.c', ...
+        {%- elif constraints.constr_type_e == "BGP" and dims.nphi_e > 0 %}
+            '{{ model.name }}_constraints/{{ model.name }}_phi_e_constraint.c', ...
+        {%- endif %}
+            'acados_solver_sfunction_{{ model.name }}.c', ...
+            'acados_solver_{{ model.name }}.c'
+          };
+
+INC_PATH = '{{ acados_include_path }}';
+
+INCS = {['-I', fullfile(INC_PATH, 'blasfeo', 'include')], ...
+        ['-I', fullfile(INC_PATH, 'hpipm', 'include')], ...
+        ['-I', fullfile(INC_PATH, 'acados')], ...
+        ['-I', fullfile(INC_PATH)]};
+
+{% if solver_options.qp_solver is containing("QPOASES") %}
+INCS{end+1} = ['-I', fullfile(INC_PATH, 'qpOASES_e')];
+{% endif %}
+
+CFLAGS = 'CFLAGS=$CFLAGS';
+LDFLAGS = 'LDFLAGS=$LDFLAGS';
+COMPFLAGS = 'COMPFLAGS=$COMPFLAGS';
+COMPDEFINES = 'COMPDEFINES=$COMPDEFINES';
+
+{% if solver_options.qp_solver is containing("QPOASES") %}
+CFLAGS = [ CFLAGS, ' -DACADOS_WITH_QPOASES ' ];
+COMPDEFINES = [ COMPDEFINES, ' -DACADOS_WITH_QPOASES ' ];
+{%- elif solver_options.qp_solver is containing("OSQP") %}
+CFLAGS = [ CFLAGS, ' -DACADOS_WITH_OSQP ' ];
+COMPDEFINES = [ COMPDEFINES, ' -DACADOS_WITH_OSQP ' ];
+{%- elif solver_options.qp_solver is containing("QPDUNES") %}
+CFLAGS = [ CFLAGS, ' -DACADOS_WITH_QPDUNES ' ];
+COMPDEFINES = [ COMPDEFINES, ' -DACADOS_WITH_QPDUNES ' ];
+{%- elif solver_options.qp_solver is containing("DAQP") %}
+CFLAGS = [ CFLAGS, ' -DACADOS_WITH_DAQP' ];
+COMPDEFINES = [ COMPDEFINES, ' -DACADOS_WITH_DAQP' ];
+{%- elif solver_options.qp_solver is containing("HPMPC") %}
+CFLAGS = [ CFLAGS, ' -DACADOS_WITH_HPMPC ' ];
+COMPDEFINES = [ COMPDEFINES, ' -DACADOS_WITH_HPMPC ' ];
+{% endif %}
+
+LIB_PATH = ['-L', fullfile('{{ acados_lib_path }}')];
+
+LIBS = {'-lacados', '-lhpipm', '-lblasfeo'};
+
+% acados linking libraries and flags
+{%- if acados_link_libs and os and os == "pc" %}
+LDFLAGS = [LDFLAGS ' {{ acados_link_libs.openmp }}'];
+COMPFLAGS = [COMPFLAGS ' {{ acados_link_libs.openmp }}'];
+LIBS{end+1} = '{{ acados_link_libs.qpoases }}';
+LIBS{end+1} = '{{ acados_link_libs.hpmpc }}';
+LIBS{end+1} = '{{ acados_link_libs.osqp }}';
+{%- else %}
+    {% if solver_options.qp_solver is containing("QPOASES") %}
+LIBS{end+1} = '-lqpOASES_e';
+    {% endif %}
+    {% if solver_options.qp_solver is containing("DAQP") %}
+LIBS{end+1} = '-ldaqp';
+    {% endif %}
+{%- endif %}
+
+
+try
+    %     mex('-v', '-O', CFLAGS, LDFLAGS, COMPFLAGS, COMPDEFINES, INCS{:}, ...
+    mex('-O', CFLAGS, LDFLAGS, COMPFLAGS, COMPDEFINES, INCS{:}, ...
+            LIB_PATH, LIBS{:}, SOURCES{:}, ...
+            '-output', 'acados_solver_sfunction_{{ model.name }}' );
+catch exception
+    disp('make_sfun failed with the following exception:')
+    disp(exception);
+    disp('Try adding -v to the mex command above to get more information.')
+    keyboard
+end
+
+fprintf( [ '\n\nSuccessfully created sfunction:\nacados_solver_sfunction_{{ model.name }}', '.', ...
+    eval('mexext')] );
+
+
+%% print note on usage of s-function, and create I/O port names vectors
+fprintf('\n\nNote: Usage of Sfunction is as follows:\n')
+input_note = 'Inputs are:\n';
+i_in = 1;
+
+global sfun_input_names
+sfun_input_names = {};
+
+{%- if dims.nbx_0 > 0 and simulink_opts.inputs.lbx_0 -%}  {#- lbx_0 #}
+input_note = strcat(input_note, num2str(i_in), ') lbx_0 - lower bound on x for stage 0,',...
+                    ' size [{{ dims.nbx_0 }}]\n ');
+sfun_input_names = [sfun_input_names; 'lbx_0 [{{ dims.nbx_0 }}]'];
+i_in = i_in + 1;
+{%- endif %}
+
+{%- if dims.nbx_0 > 0 and simulink_opts.inputs.ubx_0 -%}  {#- ubx_0 #}
+input_note = strcat(input_note, num2str(i_in), ') ubx_0 - upper bound on x for stage 0,',...
+                    ' size [{{ dims.nbx_0 }}]\n ');
+sfun_input_names = [sfun_input_names; 'ubx_0 [{{ dims.nbx_0 }}]'];
+i_in = i_in + 1;
+{%- endif %}
+
+{%- if dims.np > 0 and simulink_opts.inputs.parameter_traj -%}  {#- parameter_traj #}
+input_note = strcat(input_note, num2str(i_in), ') parameters - concatenated for all shooting nodes 0 to N,',...
+                    ' size [{{ (dims.N+1)*dims.np }}]\n ');
+sfun_input_names = [sfun_input_names; 'parameter_traj [{{ (dims.N+1)*dims.np }}]'];
+i_in = i_in + 1;
+{%- endif %}
+
+{%- if dims.ny_0 > 0 and simulink_opts.inputs.y_ref_0 %}
+input_note = strcat(input_note, num2str(i_in), ') y_ref_0, size [{{ dims.ny_0 }}]\n ');
+sfun_input_names = [sfun_input_names; 'y_ref_0 [{{ dims.ny_0 }}]'];
+i_in = i_in + 1;
+{%- endif %}
+
+{%- if dims.ny > 0 and dims.N > 1 and simulink_opts.inputs.y_ref %}
+input_note = strcat(input_note, num2str(i_in), ') y_ref - concatenated for shooting nodes 1 to N-1,',...
+                    ' size [{{ (dims.N-1) * dims.ny }}]\n ');
+sfun_input_names = [sfun_input_names; 'y_ref [{{ (dims.N-1) * dims.ny }}]'];
+i_in = i_in + 1;
+{%- endif %}
+
+{%- if dims.ny_e > 0 and dims.N > 0 and simulink_opts.inputs.y_ref_e %}
+input_note = strcat(input_note, num2str(i_in), ') y_ref_e, size [{{ dims.ny_e }}]\n ');
+sfun_input_names = [sfun_input_names; 'y_ref_e [{{ dims.ny_e }}]'];
+i_in = i_in + 1;
+{%- endif %}
+
+{%- if dims.nbx > 0 and dims.N > 1 and simulink_opts.inputs.lbx -%}  {#- lbx #}
+input_note = strcat(input_note, num2str(i_in), ') lbx for shooting nodes 1 to N-1, size [{{ (dims.N-1) * dims.nbx }}]\n ');
+sfun_input_names = [sfun_input_names; 'lbx [{{ (dims.N-1) * dims.nbx }}]'];
+i_in = i_in + 1;
+{%- endif %}
+{%- if dims.nbx > 0 and dims.N > 1 and simulink_opts.inputs.ubx -%}  {#- ubx #}
+input_note = strcat(input_note, num2str(i_in), ') ubx for shooting nodes 1 to N-1, size [{{ (dims.N-1) * dims.nbx }}]\n ');
+sfun_input_names = [sfun_input_names; 'ubx [{{ (dims.N-1) * dims.nbx }}]'];
+i_in = i_in + 1;
+{%- endif %}
+
+
+{%- if dims.nbx_e > 0 and dims.N > 0 and simulink_opts.inputs.lbx_e -%}  {#- lbx_e #}
+input_note = strcat(input_note, num2str(i_in), ') lbx_e (lbx at shooting node N), size [{{ dims.nbx_e }}]\n ');
+sfun_input_names = [sfun_input_names; 'lbx_e [{{ dims.nbx_e }}]'];
+i_in = i_in + 1;
+{%- endif %}
+{%- if dims.nbx_e > 0 and dims.N > 0 and simulink_opts.inputs.ubx_e -%}  {#- ubx_e #}
+input_note = strcat(input_note, num2str(i_in), ') ubx_e (ubx at shooting node N), size [{{ dims.nbx_e }}]\n ');
+sfun_input_names = [sfun_input_names; 'ubx_e [{{ dims.nbx_e }}]'];
+i_in = i_in + 1;
+{%- endif %}
+
+{%- if dims.nbu > 0 and dims.N > 0 and simulink_opts.inputs.lbu -%}  {#- lbu #}
+input_note = strcat(input_note, num2str(i_in), ') lbu for shooting nodes 0 to N-1, size [{{ dims.N*dims.nbu }}]\n ');
+sfun_input_names = [sfun_input_names; 'lbu [{{ dims.N*dims.nbu }}]'];
+i_in = i_in + 1;
+{%- endif -%}
+{%- if dims.nbu > 0 and dims.N > 0 and simulink_opts.inputs.ubu -%}  {#- ubu #}
+input_note = strcat(input_note, num2str(i_in), ') ubu for shooting nodes 0 to N-1, size [{{ dims.N*dims.nbu }}]\n ');
+sfun_input_names = [sfun_input_names; 'ubu [{{ dims.N*dims.nbu }}]'];
+i_in = i_in + 1;
+{%- endif -%}
+
+{%- if dims.ng > 0 and simulink_opts.inputs.lg -%}  {#- lg #}
+input_note = strcat(input_note, num2str(i_in), ') lg for shooting nodes 0 to N-1, size [{{ dims.N*dims.ng }}]\n ');
+sfun_input_names = [sfun_input_names; 'lg [{{ dims.N*dims.ng }}]'];
+i_in = i_in + 1;
+{%- endif %}
+{%- if dims.ng > 0 and simulink_opts.inputs.ug -%}  {#- ug #}
+input_note = strcat(input_note, num2str(i_in), ') ug for shooting nodes 0 to N-1, size [{{ dims.N*dims.ng }}]\n ');
+sfun_input_names = [sfun_input_names; 'ug [{{ dims.N*dims.ng }}]'];
+i_in = i_in + 1;
+{%- endif %}
+
+{%- if dims.nh > 0 and simulink_opts.inputs.lh -%}  {#- lh #}
+input_note = strcat(input_note, num2str(i_in), ') lh for shooting nodes 0 to N-1, size [{{ dims.N*dims.nh }}]\n ');
+sfun_input_names = [sfun_input_names; 'lh [{{ dims.N*dims.nh }}]'];
+i_in = i_in + 1;
+{%- endif %}
+{%- if dims.nh > 0 and simulink_opts.inputs.uh -%}  {#- uh #}
+input_note = strcat(input_note, num2str(i_in), ') uh for shooting nodes 0 to N-1, size [{{ dims.N*dims.nh }}]\n ');
+sfun_input_names = [sfun_input_names; 'uh [{{ dims.N*dims.nh }}]'];
+i_in = i_in + 1;
+{%- endif %}
+
+{%- if dims.nh_e > 0 and simulink_opts.inputs.lh_e -%}  {#- lh_e #}
+input_note = strcat(input_note, num2str(i_in), ') lh_e, size [{{ dims.nh_e }}]\n ');
+sfun_input_names = [sfun_input_names; 'lh_e [{{ dims.nh_e }}]'];
+i_in = i_in + 1;
+{%- endif %}
+{%- if dims.nh_e > 0 and simulink_opts.inputs.uh_e -%}  {#- uh_e #}
+input_note = strcat(input_note, num2str(i_in), ') uh_e, size [{{ dims.nh_e }}]\n ');
+sfun_input_names = [sfun_input_names; 'uh_e [{{ dims.nh_e }}]'];
+i_in = i_in + 1;
+{%- endif %}
+
+{%- if dims.ny_0 > 0 and simulink_opts.inputs.cost_W_0 %}  {#- cost_W_0 #}
+input_note = strcat(input_note, num2str(i_in), ') cost_W_0 in column-major format, size [{{ dims.ny_0 * dims.ny_0 }}]\n ');
+sfun_input_names = [sfun_input_names; 'cost_W_0 [{{ dims.ny_0 * dims.ny_0 }}]'];
+i_in = i_in + 1;
+{%- endif %}
+
+{%- if dims.ny > 0 and simulink_opts.inputs.cost_W %}  {#- cost_W #}
+input_note = strcat(input_note, num2str(i_in), ') cost_W in column-major format, that is set for all intermediate shooting nodes: 1 to N-1, size [{{ dims.ny * dims.ny }}]\n ');
+sfun_input_names = [sfun_input_names; 'cost_W [{{ dims.ny * dims.ny }}]'];
+i_in = i_in + 1;
+{%- endif %}
+
+{%- if dims.ny_e > 0 and simulink_opts.inputs.cost_W_e %}  {#- cost_W_e #}
+input_note = strcat(input_note, num2str(i_in), ') cost_W_e in column-major format, size [{{ dims.ny_e * dims.ny_e }}]\n ');
+sfun_input_names = [sfun_input_names; 'cost_W_e [{{ dims.ny_e * dims.ny_e }}]'];
+i_in = i_in + 1;
+{%- endif %}
+
+{%- if simulink_opts.inputs.reset_solver %}  {#- reset_solver #}
+input_note = strcat(input_note, num2str(i_in), ') reset_solver determines if iterate is set to all zeros before other initializations (x_init, u_init) are set and before solver is called, size [1]\n ');
+sfun_input_names = [sfun_input_names; 'reset_solver [1]'];
+i_in = i_in + 1;
+{%- endif %}
+
+{%- if simulink_opts.inputs.x_init %}  {#- x_init #}
+input_note = strcat(input_note, num2str(i_in), ') initialization of x for all shooting nodes, size [{{ dims.nx * (dims.N+1) }}]\n ');
+sfun_input_names = [sfun_input_names; 'x_init [{{ dims.nx * (dims.N+1) }}]'];
+i_in = i_in + 1;
+{%- endif %}
+
+{%- if simulink_opts.inputs.u_init %}  {#- u_init #}
+input_note = strcat(input_note, num2str(i_in), ') initialization of u for shooting nodes 0 to N-1, size [{{ dims.nu * (dims.N) }}]\n ');
+sfun_input_names = [sfun_input_names; 'u_init [{{ dims.nu * (dims.N) }}]'];
+i_in = i_in + 1;
+{%- endif %}
+
+fprintf(input_note)
+
+disp(' ')
+
+output_note = 'Outputs are:\n';
+i_out = 0;
+
+global sfun_output_names
+sfun_output_names = {};
+
+{%- if dims.nu > 0 and simulink_opts.outputs.u0 == 1 %}
+i_out = i_out + 1;
+output_note = strcat(output_note, num2str(i_out), ') u0, control input at node 0, size [{{ dims.nu }}]\n ');
+sfun_output_names = [sfun_output_names; 'u0 [{{ dims.nu }}]'];
+{%- endif %}
+
+{%- if simulink_opts.outputs.utraj == 1 %}
+i_out = i_out + 1;
+output_note = strcat(output_note, num2str(i_out), ') utraj, control input concatenated for nodes 0 to N-1, size [{{ dims.nu * dims.N }}]\n ');
+sfun_output_names = [sfun_output_names; 'utraj [{{ dims.nu * dims.N }}]'];
+{%- endif %}
+
+{%- if simulink_opts.outputs.xtraj == 1 %}
+i_out = i_out + 1;
+output_note = strcat(output_note, num2str(i_out), ') xtraj, state concatenated for nodes 0 to N, size [{{ dims.nx * (dims.N + 1) }}]\n ');
+sfun_output_names = [sfun_output_names; 'xtraj [{{ dims.nx * (dims.N + 1) }}]'];
+{%- endif %}
+
+{%- if simulink_opts.outputs.solver_status == 1 %}
+i_out = i_out + 1;
+output_note = strcat(output_note, num2str(i_out), ') acados solver status (0 = SUCCESS)\n ');
+sfun_output_names = [sfun_output_names; 'solver_status'];
+{%- endif %}
+
+{%- if simulink_opts.outputs.cost_value == 1 %}
+i_out = i_out + 1;
+output_note = strcat(output_note, num2str(i_out), ') cost function value\n ');
+sfun_output_names = [sfun_output_names; 'cost_value'];
+{%- endif %}
+
+
+{%- if simulink_opts.outputs.KKT_residual == 1 %}
+i_out = i_out + 1;
+output_note = strcat(output_note, num2str(i_out), ') KKT residual\n ');
+sfun_output_names = [sfun_output_names; 'KKT_residual'];
+{%- endif %}
+
+{%- if simulink_opts.outputs.KKT_residuals == 1 %}
+i_out = i_out + 1;
+output_note = strcat(output_note, num2str(i_out), ') KKT residuals, size [4] (stat, eq, ineq, comp)\n ');
+sfun_output_names = [sfun_output_names; 'KKT_residuals [4]'];
+{%- endif %}
+
+{%- if dims.N > 0 and simulink_opts.outputs.x1 == 1 %}
+i_out = i_out + 1;
+output_note = strcat(output_note, num2str(i_out), ') x1, state at node 1\n ');
+sfun_output_names = [sfun_output_names; 'x1'];
+{%- endif %}
+
+{%- if simulink_opts.outputs.CPU_time == 1 %}
+i_out = i_out + 1;
+output_note = strcat(output_note, num2str(i_out), ') CPU time\n ');
+sfun_output_names = [sfun_output_names; 'CPU_time'];
+{%- endif %}
+
+{%- if simulink_opts.outputs.CPU_time_sim == 1 %}
+i_out = i_out + 1;
+output_note = strcat(output_note, num2str(i_out), ') CPU time integrator\n ');
+sfun_output_names = [sfun_output_names; 'CPU_time_sim'];
+{%- endif %}
+
+{%- if simulink_opts.outputs.CPU_time_qp == 1 %}
+i_out = i_out + 1;
+output_note = strcat(output_note, num2str(i_out), ') CPU time QP solution\n ');
+sfun_output_names = [sfun_output_names; 'CPU_time_qp'];
+{%- endif %}
+
+{%- if simulink_opts.outputs.CPU_time_lin == 1 %}
+i_out = i_out + 1;
+output_note = strcat(output_note, num2str(i_out), ') CPU time linearization (including integrator)\n ');
+sfun_output_names = [sfun_output_names; 'CPU_time_lin'];
+{%- endif %}
+
+{%- if simulink_opts.outputs.sqp_iter == 1 %}
+i_out = i_out + 1;
+output_note = strcat(output_note, num2str(i_out), ') SQP iterations\n ');
+sfun_output_names = [sfun_output_names; 'sqp_iter'];
+{%- endif %}
+
+fprintf(output_note)
+
+% The mask drawing command is:
+% ---
+% global sfun_input_names sfun_output_names
+% for i = 1:length(sfun_input_names)
+% 	port_label('input', i, sfun_input_names{i})
+% end
+% for i = 1:length(sfun_output_names)
+% 	port_label('output', i, sfun_output_names{i})
+% end
+% ---
+% It can be used by copying it in sfunction/Mask/Edit mask/Icon drawing commands
+%   (you can access it wirth ctrl+M on the s-function)

third_party/acados/acados_template/c_templates_tera/matlab_templates/make_sfun_sim.in.m

@@ -0,0 +1,137 @@
+%
+% Copyright (c) The acados authors.
+%
+% This file is part of acados.
+%
+% The 2-Clause BSD License
+%
+% Redistribution and use in source and binary forms, with or without
+% modification, are permitted provided that the following conditions are met:
+%
+% 1. Redistributions of source code must retain the above copyright notice,
+% this list of conditions and the following disclaimer.
+%
+% 2. Redistributions in binary form must reproduce the above copyright notice,
+% this list of conditions and the following disclaimer in the documentation
+% and/or other materials provided with the distribution.
+%
+% THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+% AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+% IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+% ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+% LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+% CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+% SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+% INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+% CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+% ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+% POSSIBILITY OF SUCH DAMAGE.;
+
+%
+
+SOURCES = [ 'acados_sim_solver_sfunction_{{ model.name }}.c ', ...
+            'acados_sim_solver_{{ model.name }}.c ', ...
+            {%- if  solver_options.integrator_type == 'ERK' %}
+            '{{ model.name }}_model/{{ model.name }}_expl_ode_fun.c ',...
+            '{{ model.name }}_model/{{ model.name }}_expl_vde_forw.c ',...
+            '{{ model.name }}_model/{{ model.name }}_expl_vde_adj.c ',...
+                {%- if solver_options.hessian_approx == 'EXACT' %}
+            '{{ model.name }}_model/{{ model.name }}_expl_ode_hess.c ',...
+                {%- endif %}
+            {%- elif solver_options.integrator_type == "IRK" %}
+            '{{ model.name }}_model/{{ model.name }}_impl_dae_fun.c ', ...
+            '{{ model.name }}_model/{{ model.name }}_impl_dae_fun_jac_x_xdot_z.c ', ...
+            '{{ model.name }}_model/{{ model.name }}_impl_dae_jac_x_xdot_u_z.c ', ...
+                {%- if solver_options.hessian_approx == 'EXACT' %}
+            '{{ model.name }}_model/{{ model.name }}_impl_dae_hess.c ',...
+                {%- endif %}
+            {%- elif solver_options.integrator_type == "GNSF" %}
+                {%- if model.gnsf.purely_linear != 1 %}
+            '{{ model.name }}_model/{{ model.name }}_gnsf_phi_fun.c ',...
+            '{{ model.name }}_model/{{ model.name }}_gnsf_phi_fun_jac_y.c ',...
+            '{{ model.name }}_model/{{ model.name }}_gnsf_phi_jac_y_uhat.c ',...
+                {%- if model.gnsf.nontrivial_f_LO == 1 %}
+            '{{ model.name }}_model/{{ model.name }}_gnsf_f_lo_fun_jac_x1k1uz.c ',...
+                {%- endif %}
+                {%- endif %}
+            '{{ model.name }}_model/{{ model.name }}_gnsf_get_matrices_fun.c ',...
+            {%- endif %}
+          ];
+
+INC_PATH = '{{ acados_include_path }}';
+
+INCS = [ ' -I', fullfile(INC_PATH, 'blasfeo', 'include'), ...
+         ' -I', fullfile(INC_PATH, 'hpipm', 'include'), ...
+        ' -I', INC_PATH, ' -I', fullfile(INC_PATH, 'acados'), ' '];
+
+CFLAGS  = ' -O';
+
+LIB_PATH = '{{ acados_lib_path }}';
+
+LIBS = '-lacados -lblasfeo -lhpipm';
+
+try
+    % eval( [ 'mex -v -output  acados_sim_solver_sfunction_{{ model.name }} ', ...
+    eval( [ 'mex -output  acados_sim_solver_sfunction_{{ model.name }} ', ...
+        CFLAGS, INCS, ' ', SOURCES, ' -L', LIB_PATH, ' ', LIBS ]);
+
+catch exception
+    disp('make_sfun failed with the following exception:')
+    disp(exception);
+    disp('Try adding -v to the mex command above to get more information.')
+    keyboard
+end
+
+
+fprintf( [ '\n\nSuccessfully created sfunction:\nacados_sim_solver_sfunction_{{ model.name }}', '.', ...
+    eval('mexext')] );
+
+
+global sfun_sim_input_names
+sfun_sim_input_names = {};
+
+%% print note on usage of s-function
+fprintf('\n\nNote: Usage of Sfunction is as follows:\n')
+input_note = 'Inputs are:\n1) x0, initial state, size [{{ dims.nx }}]\n ';
+i_in = 2;
+sfun_sim_input_names = [sfun_sim_input_names; 'x0 [{{ dims.nx }}]'];
+
+{%- if dims.nu > 0 %}
+input_note = strcat(input_note, num2str(i_in), ') u, size [{{ dims.nu }}]\n ');
+i_in = i_in + 1;
+sfun_sim_input_names = [sfun_sim_input_names; 'u [{{ dims.nu }}]'];
+{%- endif %}
+
+{%- if dims.np > 0 %}
+input_note = strcat(input_note, num2str(i_in), ') parameters, size [{{ dims.np }}]\n ');
+i_in = i_in + 1;
+sfun_sim_input_names = [sfun_sim_input_names; 'p [{{ dims.np }}]'];
+{%- endif %}
+
+
+fprintf(input_note)
+
+disp(' ')
+
+global sfun_sim_output_names
+sfun_sim_output_names = {};
+
+output_note = strcat('Outputs are:\n', ...
+                '1) x1 - simulated state, size [{{ dims.nx }}]\n');
+sfun_sim_output_names = [sfun_sim_output_names; 'x1 [{{ dims.nx }}]'];
+
+fprintf(output_note)
+
+
+% The mask drawing command is:
+% ---
+% global sfun_sim_input_names sfun_sim_output_names
+% for i = 1:length(sfun_sim_input_names)
+% 	port_label('input', i, sfun_sim_input_names{i})
+% end
+% for i = 1:length(sfun_sim_output_names)
+% 	port_label('output', i, sfun_sim_output_names{i})
+% end
+% ---
+% It can be used by copying it in sfunction/Mask/Edit mask/Icon drawing commands
+%   (you can access it wirth ctrl+M on the s-function)

third_party/acados/acados_template/c_templates_tera/matlab_templates/mex_solver.in.m

@@ -0,0 +1,270 @@
+%
+% Copyright (c) The acados authors.
+%
+% This file is part of acados.
+%
+% The 2-Clause BSD License
+%
+% Redistribution and use in source and binary forms, with or without
+% modification, are permitted provided that the following conditions are met:
+%
+% 1. Redistributions of source code must retain the above copyright notice,
+% this list of conditions and the following disclaimer.
+%
+% 2. Redistributions in binary form must reproduce the above copyright notice,
+% this list of conditions and the following disclaimer in the documentation
+% and/or other materials provided with the distribution.
+%
+% THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+% AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+% IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+% ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+% LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+% CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+% SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+% INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+% CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+% ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+% POSSIBILITY OF SUCH DAMAGE.;
+
+%
+
+classdef {{ model.name }}_mex_solver < handle
+
+    properties
+        C_ocp
+        C_ocp_ext_fun
+        cost_ext_fun_type
+        cost_ext_fun_type_e
+        N
+        name
+        code_gen_dir
+    end % properties
+
+
+
+    methods
+
+        % constructor
+        function obj = {{ model.name }}_mex_solver()
+            make_mex_{{ model.name }}();
+            [obj.C_ocp, obj.C_ocp_ext_fun] = acados_mex_create_{{ model.name }}();
+            % to have path to destructor when changing directory
+            addpath('.')
+            obj.cost_ext_fun_type = '{{ cost.cost_ext_fun_type }}';
+            obj.cost_ext_fun_type_e = '{{ cost.cost_ext_fun_type_e }}';
+            obj.N = {{ dims.N }};
+            obj.name = '{{ model.name }}';
+            obj.code_gen_dir = pwd();
+        end
+
+        % destructor
+        function delete(obj)
+            disp("delete template...");
+            return_dir = pwd();
+            cd(obj.code_gen_dir);
+            if ~isempty(obj.C_ocp)
+                acados_mex_free_{{ model.name }}(obj.C_ocp);
+            end
+            cd(return_dir);
+            disp("done.");
+        end
+
+        % solve
+        function solve(obj)
+            acados_mex_solve_{{ model.name }}(obj.C_ocp);
+        end
+
+        % set -- borrowed from MEX interface
+        function set(varargin)
+            obj = varargin{1};
+            field = varargin{2};
+            value = varargin{3};
+            if ~isa(field, 'char')
+                error('field must be a char vector, use '' ''');
+            end
+            if nargin==3
+                acados_mex_set_{{ model.name }}(obj.cost_ext_fun_type, obj.cost_ext_fun_type_e, obj.C_ocp, obj.C_ocp_ext_fun, field, value);
+            elseif nargin==4
+                stage = varargin{4};
+                acados_mex_set_{{ model.name }}(obj.cost_ext_fun_type, obj.cost_ext_fun_type_e, obj.C_ocp, obj.C_ocp_ext_fun, field, value, stage);
+            else
+                disp('acados_ocp.set: wrong number of input arguments (2 or 3 allowed)');
+            end
+        end
+
+        function value = get_cost(obj)
+            value = ocp_get_cost(obj.C_ocp);
+        end
+
+        % get -- borrowed from MEX interface
+        function value = get(varargin)
+            % usage:
+            % obj.get(field, value, [stage])
+            obj = varargin{1};
+            field = varargin{2};
+            if any(strfind('sens', field))
+                error('field sens* (sensitivities of optimal solution) not yet supported for templated MEX.')
+            end
+            if ~isa(field, 'char')
+                error('field must be a char vector, use '' ''');
+            end
+
+            if nargin==2
+                value = ocp_get(obj.C_ocp, field);
+            elseif nargin==3
+                stage = varargin{3};
+                value = ocp_get(obj.C_ocp, field, stage);
+            else
+                disp('acados_ocp.get: wrong number of input arguments (1 or 2 allowed)');
+            end
+        end
+
+
+        function [] = store_iterate(varargin)
+            %%%  Stores the current iterate of the ocp solver in a json file.
+            %%% param1: filename: if not set, use model_name + timestamp + '.json'
+            %%% param2: overwrite: if false and filename exists add timestamp to filename
+
+            obj = varargin{1};
+            filename = '';
+            overwrite = false;
+
+            if nargin>=2
+                filename = varargin{2};
+                if ~isa(filename, 'char')
+                    error('filename must be a char vector, use '' ''');
+                end
+            end
+
+            if nargin==3
+                overwrite = varargin{3};
+            end
+
+            if nargin > 3
+                disp('acados_ocp.get: wrong number of input arguments (1 or 2 allowed)');
+            end
+
+            if strcmp(filename,'')
+                filename = [obj.name '_iterate.json'];
+            end
+            if ~overwrite
+                % append timestamp
+                if exist(filename, 'file')
+                    filename = filename(1:end-5);
+                    filename = [filename '_' datestr(now,'yyyy-mm-dd-HH:MM:SS') '.json'];
+                end
+            end
+            filename = fullfile(pwd, filename);
+
+            % get iterate:
+            solution = struct();
+            for i=0:obj.N
+                solution.(['x_' num2str(i)]) = obj.get('x', i);
+                solution.(['lam_' num2str(i)]) = obj.get('lam', i);
+                solution.(['t_' num2str(i)]) = obj.get('t', i);
+                solution.(['sl_' num2str(i)]) = obj.get('sl', i);
+                solution.(['su_' num2str(i)]) = obj.get('su', i);
+            end
+            for i=0:obj.N-1
+                solution.(['z_' num2str(i)]) = obj.get('z', i);
+                solution.(['u_' num2str(i)]) = obj.get('u', i);
+                solution.(['pi_' num2str(i)]) = obj.get('pi', i);
+            end
+
+            acados_folder = getenv('ACADOS_INSTALL_DIR');
+            addpath(fullfile(acados_folder, 'external', 'jsonlab'));
+            savejson('', solution, filename);
+
+            json_string = savejson('', solution, 'ForceRootName', 0);
+
+            fid = fopen(filename, 'w');
+            if fid == -1, error('store_iterate: Cannot create JSON file'); end
+            fwrite(fid, json_string, 'char');
+            fclose(fid);
+
+            disp(['stored current iterate in ' filename]);
+        end
+
+
+        function [] = load_iterate(obj, filename)
+            %%%  Loads the iterate stored in json file with filename into the ocp solver.
+            acados_folder = getenv('ACADOS_INSTALL_DIR');
+            addpath(fullfile(acados_folder, 'external', 'jsonlab'));
+            filename = fullfile(pwd, filename);
+
+            if ~exist(filename, 'file')
+                error(['load_iterate: failed, file does not exist: ' filename])
+            end
+
+            solution = loadjson(filename);
+            keys = fieldnames(solution);
+
+            for k = 1:numel(keys)
+                key = keys{k};
+                key_parts = strsplit(key, '_');
+                field = key_parts{1};
+                stage = key_parts{2};
+
+                val = solution.(key);
+
+                % check if array is empty (can happen for z)
+                if numel(val) > 0
+                    obj.set(field, val, str2num(stage))
+                end
+            end
+        end
+
+
+        % print
+        function print(varargin)
+            if nargin < 2
+                field = 'stat';
+            else
+                field = varargin{2};
+            end
+
+            obj = varargin{1};
+
+            if strcmp(field, 'stat')
+                stat = obj.get('stat');
+                {%- if solver_options.nlp_solver_type == "SQP" %}
+                fprintf('\niter\tres_stat\tres_eq\t\tres_ineq\tres_comp\tqp_stat\tqp_iter\talpha');
+                if size(stat,2)>8
+                    fprintf('\tqp_res_stat\tqp_res_eq\tqp_res_ineq\tqp_res_comp');
+                end
+                fprintf('\n');
+                for jj=1:size(stat,1)
+                    fprintf('%d\t%e\t%e\t%e\t%e\t%d\t%d\t%e', stat(jj,1), stat(jj,2), stat(jj,3), stat(jj,4), stat(jj,5), stat(jj,6), stat(jj,7), stat(jj, 8));
+                    if size(stat,2)>8
+                        fprintf('\t%e\t%e\t%e\t%e', stat(jj,9), stat(jj,10), stat(jj,11), stat(jj,12));
+                    end
+                    fprintf('\n');
+                end
+                fprintf('\n');
+                {%- else %}
+                fprintf('\niter\tqp_status\tqp_iter');
+                if size(stat,2)>3
+                    fprintf('\tqp_res_stat\tqp_res_eq\tqp_res_ineq\tqp_res_comp');
+                end
+                fprintf('\n');
+                for jj=1:size(stat,1)
+                    fprintf('%d\t%d\t\t%d', stat(jj,1), stat(jj,2), stat(jj,3));
+                    if size(stat,2)>3
+                        fprintf('\t%e\t%e\t%e\t%e', stat(jj,4), stat(jj,5), stat(jj,6), stat(jj,7));
+                    end
+                    fprintf('\n');
+                end
+                {% endif %}
+
+            else
+                fprintf('unsupported field in function print of acados_ocp.print, got %s', field);
+                keyboard
+            end
+
+        end
+
+    end % methods
+
+end % class
+

third_party/acados/acados_template/c_templates_tera/model.in.h

@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) The acados authors.
+ *
+ * This file is part of acados.
+ *
+ * The 2-Clause BSD License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.;
+ */
+
+#ifndef {{ model.name }}_MODEL
+#define {{ model.name }}_MODEL
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+{%- if solver_options.hessian_approx %}
+	{%- set hessian_approx = solver_options.hessian_approx %}
+{%- elif solver_options.sens_hess %}
+	{%- set hessian_approx = "EXACT" %}
+{%- else %}
+	{%- set hessian_approx = "GAUSS_NEWTON" %}
+{%- endif %}
+
+{% if solver_options.integrator_type == "IRK" or solver_options.integrator_type == "LIFTED_IRK" %}
+  {% if model.dyn_ext_fun_type == "casadi" %}
+// implicit ODE: function
+int {{ model.name }}_impl_dae_fun(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_impl_dae_fun_work(int *, int *, int *, int *);
+const int *{{ model.name }}_impl_dae_fun_sparsity_in(int);
+const int *{{ model.name }}_impl_dae_fun_sparsity_out(int);
+int {{ model.name }}_impl_dae_fun_n_in(void);
+int {{ model.name }}_impl_dae_fun_n_out(void);
+
+// implicit ODE: function + jacobians
+int {{ model.name }}_impl_dae_fun_jac_x_xdot_z(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_impl_dae_fun_jac_x_xdot_z_work(int *, int *, int *, int *);
+const int *{{ model.name }}_impl_dae_fun_jac_x_xdot_z_sparsity_in(int);
+const int *{{ model.name }}_impl_dae_fun_jac_x_xdot_z_sparsity_out(int);
+int {{ model.name }}_impl_dae_fun_jac_x_xdot_z_n_in(void);
+int {{ model.name }}_impl_dae_fun_jac_x_xdot_z_n_out(void);
+
+// implicit ODE: jacobians only
+int {{ model.name }}_impl_dae_jac_x_xdot_u_z(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_impl_dae_jac_x_xdot_u_z_work(int *, int *, int *, int *);
+const int *{{ model.name }}_impl_dae_jac_x_xdot_u_z_sparsity_in(int);
+const int *{{ model.name }}_impl_dae_jac_x_xdot_u_z_sparsity_out(int);
+int {{ model.name }}_impl_dae_jac_x_xdot_u_z_n_in(void);
+int {{ model.name }}_impl_dae_jac_x_xdot_u_z_n_out(void);
+
+// implicit ODE - for lifted_irk
+int {{ model.name }}_impl_dae_fun_jac_x_xdot_u(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_impl_dae_fun_jac_x_xdot_u_work(int *, int *, int *, int *);
+const int *{{ model.name }}_impl_dae_fun_jac_x_xdot_u_sparsity_in(int);
+const int *{{ model.name }}_impl_dae_fun_jac_x_xdot_u_sparsity_out(int);
+int {{ model.name }}_impl_dae_fun_jac_x_xdot_u_n_in(void);
+int {{ model.name }}_impl_dae_fun_jac_x_xdot_u_n_out(void);
+
+	{%- if hessian_approx == "EXACT" %}
+// implicit ODE - hessian
+int {{ model.name }}_impl_dae_hess(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_impl_dae_hess_work(int *, int *, int *, int *);
+const int *{{ model.name }}_impl_dae_hess_sparsity_in(int);
+const int *{{ model.name }}_impl_dae_hess_sparsity_out(int);
+int {{ model.name }}_impl_dae_hess_n_in(void);
+int {{ model.name }}_impl_dae_hess_n_out(void);
+	{% endif %}
+  {% else %}{# ext_fun_type #}
+    {%- if hessian_approx == "EXACT" %}
+int {{ model.dyn_impl_dae_hess }}(void **, void **, void *);
+    {% endif %}
+int {{ model.dyn_impl_dae_fun_jac }}(void **, void **, void *);
+int {{ model.dyn_impl_dae_jac }}(void **, void **, void *);
+int {{ model.dyn_impl_dae_fun }}(void **, void **, void *);
+  {% endif %}{# ext_fun_type #}
+
+{% elif solver_options.integrator_type == "GNSF" %}
+/* GNSF Functions */
+	{% if model.gnsf.purely_linear != 1 %}
+// phi_fun
+int        {{ model.name }}_gnsf_phi_fun(const double** arg, double** res, int* iw, double* w, void *mem);
+int        {{ model.name }}_gnsf_phi_fun_work(int *, int *, int *, int *);
+const int *{{ model.name }}_gnsf_phi_fun_sparsity_in(int);
+const int *{{ model.name }}_gnsf_phi_fun_sparsity_out(int);
+int        {{ model.name }}_gnsf_phi_fun_n_in(void);
+int        {{ model.name }}_gnsf_phi_fun_n_out(void);
+
+// phi_fun_jac_y
+int        {{ model.name }}_gnsf_phi_fun_jac_y(const double** arg, double** res, int* iw, double* w, void *mem);
+int        {{ model.name }}_gnsf_phi_fun_jac_y_work(int *, int *, int *, int *);
+const int *{{ model.name }}_gnsf_phi_fun_jac_y_sparsity_in(int);
+const int *{{ model.name }}_gnsf_phi_fun_jac_y_sparsity_out(int);
+int        {{ model.name }}_gnsf_phi_fun_jac_y_n_in(void);
+int        {{ model.name }}_gnsf_phi_fun_jac_y_n_out(void);
+
+// phi_jac_y_uhat
+int        {{ model.name }}_gnsf_phi_jac_y_uhat(const double** arg, double** res, int* iw, double* w, void *mem);
+int        {{ model.name }}_gnsf_phi_jac_y_uhat_work(int *, int *, int *, int *);
+const int *{{ model.name }}_gnsf_phi_jac_y_uhat_sparsity_in(int);
+const int *{{ model.name }}_gnsf_phi_jac_y_uhat_sparsity_out(int);
+int        {{ model.name }}_gnsf_phi_jac_y_uhat_n_in(void);
+int        {{ model.name }}_gnsf_phi_jac_y_uhat_n_out(void);
+	{% if model.gnsf.nontrivial_f_LO == 1 %}
+// f_lo_fun_jac_x1k1uz
+int        {{ model.name }}_gnsf_f_lo_fun_jac_x1k1uz(const double** arg, double** res, int* iw, double* w, void *mem);
+int        {{ model.name }}_gnsf_f_lo_fun_jac_x1k1uz_work(int *, int *, int *, int *);
+const int *{{ model.name }}_gnsf_f_lo_fun_jac_x1k1uz_sparsity_in(int);
+const int *{{ model.name }}_gnsf_f_lo_fun_jac_x1k1uz_sparsity_out(int);
+int        {{ model.name }}_gnsf_f_lo_fun_jac_x1k1uz_n_in(void);
+int        {{ model.name }}_gnsf_f_lo_fun_jac_x1k1uz_n_out(void);
+	{%- endif %}
+	{%- endif %}
+// used to import model matrices
+int        {{ model.name }}_gnsf_get_matrices_fun(const double** arg, double** res, int* iw, double* w, void *mem);
+int        {{ model.name }}_gnsf_get_matrices_fun_work(int *, int *, int *, int *);
+const int *{{ model.name }}_gnsf_get_matrices_fun_sparsity_in(int);
+const int *{{ model.name }}_gnsf_get_matrices_fun_sparsity_out(int);
+int        {{ model.name }}_gnsf_get_matrices_fun_n_in(void);
+int        {{ model.name }}_gnsf_get_matrices_fun_n_out(void);
+
+{% elif solver_options.integrator_type == "ERK" %}
+/* explicit ODE */
+
+// explicit ODE
+int {{ model.name }}_expl_ode_fun(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_expl_ode_fun_work(int *, int *, int *, int *);
+const int *{{ model.name }}_expl_ode_fun_sparsity_in(int);
+const int *{{ model.name }}_expl_ode_fun_sparsity_out(int);
+int {{ model.name }}_expl_ode_fun_n_in(void);
+int {{ model.name }}_expl_ode_fun_n_out(void);
+
+// explicit forward VDE
+int {{ model.name }}_expl_vde_forw(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_expl_vde_forw_work(int *, int *, int *, int *);
+const int *{{ model.name }}_expl_vde_forw_sparsity_in(int);
+const int *{{ model.name }}_expl_vde_forw_sparsity_out(int);
+int {{ model.name }}_expl_vde_forw_n_in(void);
+int {{ model.name }}_expl_vde_forw_n_out(void);
+
+// explicit adjoint VDE
+int {{ model.name }}_expl_vde_adj(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_expl_vde_adj_work(int *, int *, int *, int *);
+const int *{{ model.name }}_expl_vde_adj_sparsity_in(int);
+const int *{{ model.name }}_expl_vde_adj_sparsity_out(int);
+int {{ model.name }}_expl_vde_adj_n_in(void);
+int {{ model.name }}_expl_vde_adj_n_out(void);
+
+{%- if hessian_approx == "EXACT" %}
+int {{ model.name }}_expl_ode_hess(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_expl_ode_hess_work(int *, int *, int *, int *);
+const int *{{ model.name }}_expl_ode_hess_sparsity_in(int);
+const int *{{ model.name }}_expl_ode_hess_sparsity_out(int);
+int {{ model.name }}_expl_ode_hess_n_in(void);
+int {{ model.name }}_expl_ode_hess_n_out(void);
+{%- endif %}
+
+{% elif solver_options.integrator_type == "DISCRETE" %}
+
+{% if model.dyn_ext_fun_type == "casadi" %}
+int {{ model.name }}_dyn_disc_phi_fun(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_dyn_disc_phi_fun_work(int *, int *, int *, int *);
+const int *{{ model.name }}_dyn_disc_phi_fun_sparsity_in(int);
+const int *{{ model.name }}_dyn_disc_phi_fun_sparsity_out(int);
+int {{ model.name }}_dyn_disc_phi_fun_n_in(void);
+int {{ model.name }}_dyn_disc_phi_fun_n_out(void);
+
+int {{ model.name }}_dyn_disc_phi_fun_jac(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_dyn_disc_phi_fun_jac_work(int *, int *, int *, int *);
+const int *{{ model.name }}_dyn_disc_phi_fun_jac_sparsity_in(int);
+const int *{{ model.name }}_dyn_disc_phi_fun_jac_sparsity_out(int);
+int {{ model.name }}_dyn_disc_phi_fun_jac_n_in(void);
+int {{ model.name }}_dyn_disc_phi_fun_jac_n_out(void);
+
+{%- if hessian_approx == "EXACT" %}
+int {{ model.name }}_dyn_disc_phi_fun_jac_hess(const real_t** arg, real_t** res, int* iw, real_t* w, void *mem);
+int {{ model.name }}_dyn_disc_phi_fun_jac_hess_work(int *, int *, int *, int *);
+const int *{{ model.name }}_dyn_disc_phi_fun_jac_hess_sparsity_in(int);
+const int *{{ model.name }}_dyn_disc_phi_fun_jac_hess_sparsity_out(int);
+int {{ model.name }}_dyn_disc_phi_fun_jac_hess_n_in(void);
+int {{ model.name }}_dyn_disc_phi_fun_jac_hess_n_out(void);
+{%- endif %}
+{% else %}
+  {%- if hessian_approx == "EXACT" %}
+int {{ model.dyn_disc_fun_jac_hess }}(void **, void **, void *);
+  {% endif %}
+int {{ model.dyn_disc_fun_jac }}(void **, void **, void *);
+int {{ model.dyn_disc_fun }}(void **, void **, void *);
+{% endif %}
+
+
+{% endif %}
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif  // {{ model.name }}_MODEL