def test_parametrize_control_time_dependent_polynomial(model):
model.tau = SX.sym('tau')
model.create_control('u', 3)
# Test parametrize by a time dependent polynomial
u_par = SX.sym("u_par", 3, 2)
u_expr = model.tau * u_par[:, 0] + (1 - model.tau) * u_par[:, 1]
model.parametrize_control(model.u, u_expr, vec(u_par))
assert is_equal(model.u_par, vec(u_par))
assert is_equal(model.u_expr, u_expr, 30)
for ind in range(model.n_u):
assert is_equal(model._parametrized_controls[ind], model.u[ind])
def test_include_theta(model):
new_theta_1 = SX.sym("new_theta")
new_theta_2 = SX.sym("new_theta_2", 2)
model_n_theta = model.n_theta
model.include_theta(new_theta_1)
assert model.n_theta == model_n_theta + 1
assert is_equal(model.theta[-1], new_theta_1)
model.include_theta(new_theta_2)
assert model.n_theta == model_n_theta + 1 + 2
assert is_equal(model.theta[-3], new_theta_1)
assert is_equal(model.theta[-2:], new_theta_2)
def test_include_control(model: ControlMixin):
new_u_1 = SX.sym("new_u")
new_u_2 = SX.sym("new_u_2", 2)
model_n_u = model.n_u
model.include_control(new_u_1)
assert model.n_u == model_n_u + 1
assert (is_equal(model.u[-1], new_u_1))
model.include_control(new_u_2)
assert model.n_u == model_n_u + 1 + 2
assert is_equal(model.u[-3], new_u_1)
assert is_equal(model.u[-2:], new_u_2)
def test_include_parameter(model):
new_p_1 = SX.sym("new_p")
new_p_2 = SX.sym("new_p_2", 2)
model_n_p = model.n_p
model.include_parameter(new_p_1)
assert model.n_p == model_n_p + 1
assert is_equal(model.p[-1], new_p_1)
model.include_parameter(new_p_2)
assert model.n_p == model_n_p + 1 + 2
assert is_equal(model.p[-3], new_p_1)
assert is_equal(model.p[-2:], new_p_2)
def test_include_algebraic(model):
new_y_1 = SX.sym("new_y")
new_y_2 = SX.sym("new_y_2", 2)
model_n_y = model.n_y
alg = new_y_1 - 3
model.include_algebraic(new_y_1, alg=alg)
assert model.n_y == model_n_y + 1
assert is_equal(model.y[-1], new_y_1)
assert is_equal(model.alg[-1], alg, 10)
model.include_algebraic(new_y_2)
assert model.n_y == model_n_y + 1 + 2
assert is_equal(model.y[-3], new_y_1)
assert is_equal(model.y[-2:], new_y_2)
def test_parametrize_control_list_input(model):
model.tau = SX.sym('tau')
model.create_control('u', 3)
# Test for list inputs, parametrize by a time dependent polynomial
u_par = SX.sym("u_par", 3, 2)
u_expr = model.tau * u_par[:, 0] + (1 - model.tau) * u_par[:, 1]
model.parametrize_control(
[model.u[ind] for ind in range(model.n_u)],
[u_expr[ind] for ind in range(model.n_u)],
[vec(u_par)[ind] for ind in range(u_par.numel())],
)
assert is_equal(model.u_par, vec(u_par))
assert is_equal(model.u_expr, u_expr, 30)
for ind in range(model.n_u):
assert is_equal(model._parametrized_controls[ind], model.u[ind])
def test_replace_variable_u_par(model):
# replace a u_par
new_u_par = SX.sym("new_u", model.n_u)
new_u_expr = new_u_par
model.replace_variable(model.u_par, new_u_par)
assert is_equal(model.u_expr, new_u_expr, 30)
def test_include_state(model):
new_x_1 = SX.sym("new_x")
new_x_2 = SX.sym("new_x_2", 2)
model_n_x = model.n_x
new_x_0_1 = model.include_state(new_x_1)
assert model.n_x == model_n_x + 1
assert model.x_0.numel() == model_n_x + 1
assert new_x_0_1.numel() == new_x_1.numel()
assert is_equal(model.x[-1], new_x_1)
model_n_x = model.n_x
new_x_0_2 = model.include_state(new_x_2)
assert model.n_x == model_n_x + 2
assert model.x_0.numel(), model_n_x + 2
assert new_x_0_2.numel() == new_x_2.numel()
assert is_equal(model.x[-3], new_x_1)
assert is_equal(model.x[-2:], new_x_2)
def test_remove_theta(model):
model.create_theta("par", 3)
ind_to_remove = 0
to_remove = model.theta[ind_to_remove]
n_theta_original = model.n_theta
model.remove_theta(to_remove)
# removed var
assert model.n_theta == n_theta_original - 1
for ind in range(model.n_theta):
assert not is_equal(model.theta[ind], to_remove)
def test_remove_parameter(model):
model.create_parameter("par", 3)
ind_to_remove = 1
to_remove = model.p[ind_to_remove]
n_p_original = model.n_p
model.remove_parameter(to_remove)
# removed var
assert model.n_p == n_p_original - 1
for ind in range(model.n_p):
assert not is_equal(model.p[ind], to_remove)
def test_remove_control(model: ControlMixin):
model.create_control('u', 4)
ind_to_remove = 2
to_remove = model.u[ind_to_remove]
n_u_original = model.n_u
model.remove_control(to_remove)
# removed var
assert model.n_u == n_u_original - 1
for ind in range(model.n_u):
assert not is_equal(model.u[ind], to_remove)
def test_remove_algebraic(model):
y = model.create_algebraic_variable('y', 4)
model.include_equations(alg=[i * y_i for i, y_i in enumerate(y.nz)])
ind_to_remove = 3
to_remove = model.y[ind_to_remove]
to_remove_eq = model.alg[ind_to_remove]
n_y_original = model.n_y
n_alg_original = model.alg.numel()
model.remove_algebraic(to_remove, eq=to_remove_eq)
# removed var
assert model.n_y == n_y_original - 1
for ind in range(model.n_y):
assert not is_equal(model.y[ind], to_remove)
# removed alg
assert model.alg.numel() == n_alg_original - 1
for ind in range(model.alg.numel()):
assert not is_equal(model.alg[ind], to_remove_eq)
def test_remove_state(model: StateMixin):
x = model.create_state('x', 5)
model.include_equations(
ode=vertcat(*[i * x_i for i, x_i in enumerate(x.nz)]), x=x)
ind_to_remove = 3
to_remove = model.x[ind_to_remove]
to_remove_eq = model.ode[ind_to_remove]
n_x_original = model.n_x
n_ode_original = model.ode.numel()
model.remove_state(to_remove)
# removed var
assert model.n_x == n_x_original - 1
for ind in range(model.n_x):
assert not is_equal(model.x[ind], to_remove)
# removed ode
assert model.ode.numel() == n_ode_original - 1
for ind in range(model.ode.numel()):
assert not is_equal(model.ode[ind], to_remove_eq)
def control_is_parametrized(self, u):
"""
Check if the control "u" is parametrized
:param casadi.SX u:
:rtype bool:
"""
u = vertcat(u)
if not u.numel() == 1:
raise ValueError(
'The parameter "u" is expected to be of size 1x1, given: {}x{}'
.format(*u.shape))
if any([
is_equal(u, parametrized_u)
for parametrized_u in self._parametrized_controls
]):
return True
return False
def test_create_state(model: StateMixin):
n_x_initial = model.n_x
n_new_x = 4
x = model.create_state("x", n_new_x)
assert model.n_x == n_x_initial + n_new_x
assert is_equal(model.x[-n_new_x:], x)
def test_create_control(model: ControlMixin):
n_u_initial = model.n_u
n_new_u = 4
u = model.create_control("u", n_new_u)
assert model.n_u == n_u_initial + n_new_u
assert is_equal(model.u[-n_new_u:], u)
def test_include_equations_alg(model):
y = model.create_algebraic_variable('y')
alg = -y
model.include_equations(alg=alg)
assert is_equal(model.alg, -y, 20)
def test_include_equations_w_equality(model):
y = model.create_algebraic_variable('y')
model.include_equations(y == 2)
assert is_equal(model.alg, y - 2, 10)
def test_create_algebraic_variable(model):
n_y_initial = model.n_y
n_new_y = 4
y = model.create_algebraic_variable("y", n_new_y)
assert model.n_y == n_y_initial + n_new_y
assert is_equal(model.y[-n_new_y:], y)
def test_create_parameter(model):
n_p_initial = model.n_p
n_new_p = 4
p = model.create_parameter("p", n_new_p)
assert model.n_p == n_p_initial + n_new_p
assert is_equal(model.p[-n_new_p:], p)
def test_create_theta(model):
n_theta_initial = model.n_theta
n_new_theta = 4
theta = model.create_theta("theta", n_new_theta)
assert model.n_theta == n_theta_initial + n_new_theta
assert is_equal(model.theta[-n_new_theta:], theta)
