Problem while Implementing MPC(model predictive control) in casadi-c++

[KirollosMedhat]

I have problem creating a solver in the last line in following code:

`Function nlp = Function("nlp", {OPT_variables, P}, {loss}, {"opt_variables", "parameters"}, {"loss"});
Dict opts;
// Options structure
opts["ipopt.max_iter"] = 100;
opts["ipopt.print_level"] = 0;
opts["print_time"] = false;
opts["ipopt.acceptable_tol"] = 1e-8;
opts["ipopt.acceptable_obj_change_tol"] = 1e-6;

// Solver object
Function solver = nlpsol("solver", "ipopt", nlp, opts);`

And here is the exception(i have no idea what is the problem):

terminate called after throwing an instance of 'casadi::CasadiException'
what(): .../casadi/core/function_internal.cpp:144: Error calling IpoptInterface::init for 'solver':
Error in Function::sparsity_out for 'nlp' [SXFunction] at .../casadi/core/function.cpp:913:
vector::_M_range_check: __n (which is 1) >= this->size() (which is 1)
Aborted (core dumped)

[jgillis]

Hi @KirollosMedhat
The overload with Function as nlp is not in the public API.
I suggest you switch over to the standard, expression based API cfr https://github.com/casadi/casadi/blob/master/docs/examples/cplusplus/rosenbrock.cpp

[KirollosMedhat]

Hello, thank your for your reply.
I edited the code and the problem was solved, but unfortunately i got another one.
now the code builds, but when i run it it says:

terminate called after throwing an instance of 'std::length_error'
what(): cannot create std::vector larger than max_size()
Aborted (core dumped)

Here's the code in case you wanted to check anything:

` #include <casadi/casadi.hpp>

using namespace casadi;

double dT = 0.2; double Tlim = 6; double rh = 0.375;
double N = 3; //--> Instantaneous prediction horizon
double I_lin = 25.305 + 360.29; //--> Linear inertia (mass + added mass)
double D_lin = 298.28; //--> Linear drag
double I_rot = 8.544; //--> Rotational inertia (moment of inertia + added mass)
double D_rot = 2.8145; //--> Rotational drag
double Fmax = 2cos(pi/4)Tlim;
double Tmax = 2rhTlim;

SX f(const SX& st, const SX& con){ //System model
SX rhs = SX::sym("rhs",5,1);
rhs(0) = st(3)*cos(st(2));
rhs(1) = st(3)sin(st(2));
rhs(2) = st(4);
rhs(3) = (con(0) - D_linst(3)fabs(st(3)))/I_lin;
rhs(4) = (con(1) - D_rotst(4)*fabs(st(4)))/I_rot;
return rhs;
}

int main() {
// Nonlinear programming problem definition
SX x = SX::sym("x"); SX y = SX::sym("y"); SX psi = SX::sym("psi"); // Global pose states
SX u = SX::sym("u"); SX r = SX::sym("r"); // Local velocity states
SXVector states {x, y, psi, u, r}; // Model internal states vector
int n_states = states.size(); // Number of internal states
SX F = SX::sym("F"); SX T = SX::sym("T"); // Kinetic controls (Force and Torque)
SXVector controls {F, T}; // Model controls
int n_controls = controls.size(); // Number of controls
SX rhs_1 = ucos(psi);
SX rhs_2 = usin(psi);
SX rhs_3 = r;
SX rhs_4 = (F - D_linufabs(u))/I_lin;
SX rhs_5 = (T - D_rotrfabs(r))/I_rot;
SXVector rhs {rhs_1, rhs_2, rhs_3, rhs_4, rhs_5}; // States rate of change

SX U = SX::sym("U", n_controls, N); // Sequence of predictive controls
SX P = SX::sym("P", n_states + 3); // Initial + desired states vector
SX X = SX::sym("X", n_states, N+1); // Sequence of state predictions

for (int i = 0; i < n_states; i++) {
    X(i, 0) = 1; // Initial kinematic states
}

for (int k = 0; k < N; k++) {
    SX st = X(Slice(), k);
    SX con = U(Slice(), k);
	SX f_value = f(st, con);
    SX st_next = st + (dT * f_value); // State evolution
    X(Slice(), k+1) = st_next;
}


SX loss = 0; // Objective function initialized to zero
SX g; // Constraints on states (none)

SX Q = SX::zeros(3, 3); Q(0, 0) = 700000; Q(1, 1) = 500000; Q(2, 2) = 50000; // Performance weight matrix

SX desiredPose = SX::sym("desiredPose", 3, 1);
desiredPose(0) = 10;
desiredPose(1) = 10;
desiredPose(2) = 10;
for (int k = 0; k < N; k++) {
    SX st = X(Slice(0, 3), k);
    loss = loss + mtimes( (st - desiredPose ).T(), mtimes(Q, (st - desiredPose)) );
}

// Optimization variables
SX OPT_variables = reshape(U, n_controls*N, 1);

// Nonlinear programming problem
SXDict nlp = {{"x", OPT_variables}, {"f", loss}, {"g", g}};

Dict opts;
// Options structure
opts["ipopt.max_iter"] = 100;
opts["ipopt.print_level"] = 0;
opts["print_time"] = false;
opts["ipopt.acceptable_tol"] = 1e-8;
opts["ipopt.acceptable_obj_change_tol"] = 1e-6;

// Solver object
Function solver = nlpsol("solver", "ipopt", nlp, opts);

DM initialControlValues = DM::zeros(N*2, 1);
DM lbx = DM::zeros(N*2, 1);
DM ubx = DM::zeros(N*2, 1);
for(int i=0; i<N; i++){
	if(i % 2 == 0){
		lbx(i) = -Tmax;
		ubx(i) = Tmax;
	}else {
		lbx(i) = -Fmax;
		ubx(i) = Fmax;
	}
}

DMDict arg;
arg["x0"] = initialControlValues;
arg["lbx"] = lbx;
arg["ubx"] = ubx;
DMDict res = solver(arg);
std::cout << "Optimal cost:                     " << double(res.at("f")) << std::endl;
std::cout << "Primal solution:                  " << std::vector<double>(res.at("x")) << std::endl;
std::cout << "Dual solution (simple bounds):    " << std::vector<double>(res.at("lam_x")) << std::endl;
std::cout << "Dual solution (nonlinear bounds): " << std::vector<double>(res.at("lam_g")) << std::endl;
return 0;	

} `

Thanks in advance