def model(): """ -------------------------------------------------------------------------- template_model: define the non-uncertain parameters -------------------------------------------------------------------------- """ R = 8.314 #gas constant T_F = 25 + 273.15 #feed temperature E_a = 8500.0 #activation energy delH_R = 950.0*1.00 #sp reaction enthalpy A_tank = 65.0 #area heat exchanger surface jacket 65 k_0 = 7.0*1.00 #sp reaction rate k_U2 = 32.0 #reaction parameter 1 k_U1 = 4.0 #reaction parameter 2 w_WF = .333 #mass fraction water in feed w_AF = .667 #mass fraction of A in feed m_M_KW = 5000.0 #mass of coolant in jacket fm_M_KW = 300000.0 #coolant flow in jacket 300000; m_AWT_KW = 1000.0 #mass of coolant in EHE fm_AWT_KW = 100000.0 #coolant flow in EHE m_AWT = 200.0 #mass of product in EHE fm_AWT = 20000.0 #product flow in EHE m_S = 39000.0 #mass of reactor steel c_pW = 4.2 #sp heat cap coolant c_pS = .47 #sp heat cap steel c_pF = 3.0 #sp heat cap feed c_pR = 5.0 #sp heat cap reactor contents k_WS = 17280.0 #heat transfer coeff water-steel k_AS = 3600.0 #heat transfer coeff monomer-steel k_PS = 360.0 #heat transfer coeff product-steel alfa = 5*20e4*3.6 p_1 = 1.0 """ -------------------------------------------------------------------------- template_model: define uncertain parameters, states and controls as symbols -------------------------------------------------------------------------- """ # Define the uncertainties as CasADi symbols delH_R = SX.sym("delH_R") k_0 = SX.sym("k_0") bias_term = SX.sym("bias_term") # Define the differential states as CasADi symbols m_W = SX.sym("m_W") m_A = SX.sym("m_A") m_P = SX.sym("m_P") T_R = SX.sym("T_R") T_S = SX.sym("T_S") Tout_M = SX.sym("Tout_M") T_EK = SX.sym("T_EK") Tout_AWT = SX.sym("Tout_AWT") accum_momom = SX.sym("accum_monom") T_adiab = SX.sym("T_adiab") # Define the algebraic states as CasADi symbols # Define the control inputs as CasADi symbols m_dot_f = SX.sym("m_dot_f") T_in_M = SX.sym("T_in_M") T_in_EK = SX.sym("T_in_EK") # Define time-varying parameters that can change at each step of the prediction and at each sampling time of the MPC controller. For example, future weather predictions tv_param_1 = SX.sym("tv_param_1") tv_param_2 = SX.sym("tv_param_2") """ -------------------------------------------------------------------------- template_model: define algebraic and differential equations -------------------------------------------------------------------------- """ # Time constant for the hks is different if cooling or if heating ## --- Algebraic equations --- U_m = m_P / (m_A + m_P) m_ges = m_W + m_A + m_P k_R1 = k_0 * exp(- E_a/(R*T_R)) * ((k_U1 * (1 - U_m)) + (k_U2 * U_m)) k_R2 = k_0 * exp(- E_a/(R*T_EK))* ((k_U1 * (1 - U_m)) + (k_U2 * U_m)) k_K = ((m_W / m_ges) * k_WS) + ((m_A/m_ges) * k_AS) + ((m_P/m_ges) * k_PS) ## --- Differential equations --- ddm_W = m_dot_f * w_WF ddm_A = (m_dot_f * w_AF) - (k_R1 * (m_A-((m_A*m_AWT)/(m_W+m_A+m_P)))) - (p_1 * k_R2 * (m_A/m_ges) * m_AWT) ddm_P = (k_R1 * (m_A-((m_A*m_AWT)/(m_W+m_A+m_P)))) + (p_1 * k_R2 * (m_A/m_ges) * m_AWT) ddT_R = 1./(c_pR * m_ges) * ((m_dot_f * c_pF * (T_F - T_R)) - (k_K *A_tank* (T_R - T_S)) - (fm_AWT * c_pR * (T_R - T_EK)) + (delH_R * k_R1 * (m_A-((m_A*m_AWT)/(m_W+m_A+m_P))))) ddT_S = 1./(c_pS * m_S) * ((k_K *A_tank* (T_R - T_S)) - (k_K *A_tank* (T_S - Tout_M))) ddTout_M = 1./(c_pW * m_M_KW) * ((fm_M_KW * c_pW * (T_in_M - Tout_M)) + (k_K *A_tank* (T_S - Tout_M))) ddT_EK = 1./(c_pR * m_AWT) * ((fm_AWT * c_pR * (T_R - T_EK)) - (alfa * (T_EK - Tout_AWT)) + (p_1 * k_R2 * (m_A/m_ges) * m_AWT * delH_R)) ddTout_AWT= 1./(c_pW * m_AWT_KW)* ((fm_AWT_KW * c_pW * (T_in_EK - Tout_AWT)) - (alfa * (Tout_AWT - T_EK))) ddaccum_momom = m_dot_f ddT_adiab = delH_R/(m_ges*c_pR)*ddm_A-(ddm_A+ddm_W+ddm_P)*(m_A*delH_R/(m_ges*m_ges*c_pR))+ddT_R # Concatenate differential states, algebraic states, control inputs and right-hand-sides _x = vertcat(m_W, m_A, m_P, T_R, T_S, Tout_M, T_EK, Tout_AWT, accum_momom, T_adiab) _u = vertcat(m_dot_f,T_in_M,T_in_EK) _xdot = vertcat(ddm_W, ddm_A, ddm_P, ddT_R, ddT_S, ddTout_M, ddT_EK, ddTout_AWT, ddaccum_momom, ddT_adiab) _p = vertcat(delH_R, k_0) _z = [] _tv_p = vertcat(tv_param_1, tv_param_2) """ -------------------------------------------------------------------------- template_model: initial condition and constraints -------------------------------------------------------------------------- """ # Initial condition for the states # Initial conditions m_W_0 = 10000.0 m_A_0 = 853.0*1.0 #3700.0 m_P_0 = 26.5 T_R_0 = 90 + 273.15 T_S_0 = 90 + 273.15 Tout_M_0 = 90 + 273.15 T_EK_0 = 35 + 273.15 Tout_AWT_0= 35 + 273.15 accum_momom_0 = 300.0 # This value is used here only to compute the initial condition of this state # This should be changed in case the real value is different delH_R_real = 950.0*1.00 T_adiab_0 = m_A_0*delH_R_real/((m_W_0+m_A_0+m_P_0)*c_pR)+T_R_0 x0 = NP.array([m_W_0, m_A_0, m_P_0, T_R_0, T_S_0, Tout_M_0, T_EK_0, Tout_AWT_0, accum_momom_0,T_adiab_0]) # Bounds for the states and initial guess temp_range = 2.0 m_W_lb = 0; m_W_ub = inf # Kg m_A_lb = 0; m_A_ub = inf # Kg m_P_lb = 26.0; m_P_ub = inf # Kg T_R_lb = 363.15-temp_range; T_R_ub = 363.15+temp_range+10 # K T_S_lb = 298.0; T_S_ub = 400.0 # K Tout_M_lb = 298.0; Tout_M_ub = 400.0 # K T_EK_lb = 288.0; T_EK_ub = 400.0 # K Tout_AWT_lb = 288.0; Tout_AWT_ub = 400.0 # K accum_momom_lb = 0; accum_momom_ub = 30000 T_adiab_lb =-inf; T_adiab_ub = 382.15 + 10 # (implemented as soft constraint) x_lb = NP.array([m_W_lb, m_A_lb, m_P_lb, T_R_lb, T_S_lb, Tout_M_lb, T_EK_lb, Tout_AWT_lb, accum_momom_lb,T_adiab_lb]) x_ub = NP.array([m_W_ub, m_A_ub, m_P_ub, T_R_ub, T_S_ub, Tout_M_ub, T_EK_ub, Tout_AWT_ub, accum_momom_ub,T_adiab_ub]) # Bounds for inputs m_dot_f_lb = 0.0; m_dot_f_ub = 3.0e4; T_in_M_lb = 333.15; T_in_M_ub = 373.15; T_in_EK_lb = 333.15; T_in_EK_ub = 373.15; u_lb=NP.array([m_dot_f_lb, T_in_M_lb, T_in_EK_lb]) u_ub=NP.array([m_dot_f_ub, T_in_M_ub, T_in_EK_ub]) # Initial guess for input (or initial condition if penalty for control movements) m_dot_f_0 = 0 T_in_M_0 = 363.0 T_in_EK_0 = 323.0 u0 = NP.array([m_dot_f_0 , T_in_M_0, T_in_EK_0]) # Scaling factors for the states and control inputs. Important if the system is ill-conditioned x_scaling=NP.array([10.0, 10.0, 10.0, 1.0, 1.0, 1.0, 1.0, 1.0, 10,1]) u_scaling = NP.array([100.0, 1.0, 1.0]) # Other possibly nonlinear constraints in the form cons(x,u,p) <= cons_ub # Define the expresion of the constraint (leave it empty if not necessary) cons = vertcat(T_R, T_adiab) # Define the upper bounds of the constraint (leave it empty if not necessary) cons_ub = NP.array([363.15+temp_range, 382.15]) #cons_ub = NP.array([]) # Activate if the nonlinear constraints should be implemented as soft constraints soft_constraint = 1 # l1 - Penalty term to add in the cost function for the constraints (it should be the same size as cons) penalty_term_cons = NP.array([1e5, 1e5]) # Maximum violation for the soft constraints maximum_violation = NP.array([10, 10]) # Define the terminal constraint (leave it empty if not necessary) cons_terminal = vertcat([]) # Define the lower and upper bounds of the constraint (leave it empty if not necessary) cons_terminal_lb = NP.array([]) cons_terminal_ub = NP.array([]) """ -------------------------------------------------------------------------- template_model: cost function -------------------------------------------------------------------------- """ # Define the cost function # Lagrange term lterm = - m_P # Mayer term mterm = - m_P # Penalty term for the control movements rterm = 0.04 * NP.array([.05,.1,.05]) """ -------------------------------------------------------------------------- template_model: pass information (not necessary to edit) -------------------------------------------------------------------------- """ model_dict = {'x':_x,'u': _u, 'rhs':_xdot,'p': _p, 'z':_z,'x0': x0,'x_lb': x_lb,'x_ub': x_ub, 'u0':u0, 'u_lb':u_lb, 'u_ub':u_ub, 'x_scaling':x_scaling, 'u_scaling':u_scaling, 'cons':cons, "cons_ub": cons_ub, 'cons_terminal':cons_terminal, 'cons_terminal_lb': cons_terminal_lb,'tv_p':_tv_p, 'cons_terminal_ub':cons_terminal_ub, 'soft_constraint': soft_constraint, 'penalty_term_cons': penalty_term_cons, 'maximum_violation': maximum_violation, 'mterm': mterm,'lterm':lterm, 'rterm':rterm} model = core_do_mpc.model(model_dict) return model
def model(): """ -------------------------------------------------------------------------- template_model: define the non-uncertain parameters -------------------------------------------------------------------------- """ M = 5.0 # mass of the cart [kg] m = 1.0 # mass of the pendulum [kg] l = 1.0 # length of lever arm [m] h = 0.5 # height of rod connection point [m] g = 9.81 # grav acceleration [m/s^2] """ -------------------------------------------------------------------------- template_model: define uncertain parameters, states and controls as symbols -------------------------------------------------------------------------- """ # Define the uncertain/varying parameters as CasADi symbols alpha = SX.sym("alpha") # can be used for implementing uncertainty tv_param_1 = SX.sym("tv_param_1") # can be used to implement setpoint change # Define the differential states as CasADi symbols x = SX.sym("x") # x position of the mass y = SX.sym("y") # y position of the mass v = SX.sym("v") # linear velocity of the mass theta = SX.sym("theta") # angle of the metal rod omega = SX.sym("omega") # angular velocity of the mass # Define the algebraic states as CasADi symbols #y = SX.sym("y") # the y coordinate is considered algebraic # Define the control inputs as CasADi symbols F = SX.sym("F") # control force applied to the lever """ -------------------------------------------------------------------------- template_model: define algebraic and differential equations -------------------------------------------------------------------------- """ # Define the differential equations dd = SX.sym("dd",4) dd[0] = v dd[1] = (1.0/(M+m-m*casadi.cos(theta)))*(m*g*casadi.sin(theta)-m*l*casadi.sin(theta)*omega**2 +F) dd[2] = omega dd[3] = (1.0/l)*(dd[1]*casadi.cos(theta)+g*casadi.sin(theta)) # Define the algebraic equations dy = h+l*casadi.cos(theta) - y # the coordinates must fulfil the constraint of the lever arm length # Concatenate differential states, algebraic states, control inputs and right-hand-sides _x = vertcat(x,v,theta,omega) _z = [] # toggle if there are no AE in your model #_z = vertcat(y) _u = vertcat(F) _p = vertcat(alpha) _xdot = vertcat(dd) _zdot = [] # toggle if there are no AE in your model #_zdot = vertcat(dtrajectory) _tv_p = vertcat(tv_param_1) """ -------------------------------------------------------------------------- template_model: initial condition and constraints -------------------------------------------------------------------------- """ # Initial conditions for Differential States x_init = 2.5 v_init = 0.0 t_init = 1.5 o_init = 0.0 #Initial conditions for Algebraic States y_init = sqrt(3.0)/2.0 x0 = NP.array([x_init, v_init, t_init, o_init]) z0 = NP.array([]) # Bounds on the states. Use "inf" for unconstrained states x_lb = -10.0; x_ub = 10.0 v_lb = -10.0; v_ub = 10.0 t_lb = -100*pi; t_ub = 100*pi o_lb = -10.0; o_ub = 10.0 x_lb = NP.array([x_lb, v_lb, t_lb, o_lb]) x_ub = NP.array([x_ub, v_ub, t_ub, o_ub]) z_lb = NP.array([]) z_ub = NP.array([]) # Bounds on the control inputs. Use "inf" for unconstrained inputs F_lb = -250.0; F_ub = 250.00 ; F_init = 0.0 ; u_lb=NP.array([F_lb]) u_ub=NP.array([F_ub]) u0 = NP.array([F_init]) # Scaling factors for the states and control inputs. Important if the system is ill-conditioned x_scaling = NP.array([1.0, 1.0, 1.0, 1.0]) z_scaling = NP.array([]) u_scaling = NP.array([1.0]) # Other possibly nonlinear constraints in the form cons(x,u,p) <= cons_ub # Define the expresion of the constraint (leave it empty if not necessary) cons = vertcat([]) # Define the lower and upper bounds of the constraint (leave it empty if not necessary) cons_ub = NP.array([]) # Activate if the nonlinear constraints should be implemented as soft constraints soft_constraint = 0 # Penalty term to add in the cost function for the constraints (it should be the same size as cons) penalty_term_cons = NP.array([]) # Maximum violation for the constraints maximum_violation = NP.array([0]) # Define the terminal constraint (leave it empty if not necessary) cons_terminal = vertcat([]) # Define the lower and upper bounds of the constraint (leave it empty if not necessary) cons_terminal_lb = NP.array([]) cons_terminal_ub = NP.array([]) """ -------------------------------------------------------------------------- template_model: cost function -------------------------------------------------------------------------- """ # Define the cost function # Lagrange term ##-----Distance to vertical position--------------------- lterm = (x-tv_param_1)**2 + (theta-pi/2)**2 # Mayer term mterm = 0 # Penalty term for the control movements rterm = 0.0001*NP.array([1.0]) """ -------------------------------------------------------------------------- template_model: pass information (not necessary to edit) -------------------------------------------------------------------------- """ model_dict = {'x':_x,'u': _u, 'rhs':_xdot,'p': _p, 'z':_z,'x0': x0,'x_lb': x_lb,'x_ub': x_ub, 'u0':u0, 'u_lb':u_lb, 'u_ub':u_ub, 'x_scaling':x_scaling, 'u_scaling':u_scaling, 'cons':cons, "cons_ub": cons_ub, 'cons_terminal':cons_terminal, 'cons_terminal_lb': cons_terminal_lb,'tv_p':_tv_p, 'cons_terminal_ub':cons_terminal_ub, 'soft_constraint': soft_constraint, 'penalty_term_cons': penalty_term_cons, 'maximum_violation': maximum_violation, 'mterm': mterm,'lterm':lterm, 'rterm':rterm} model = core_do_mpc.model(model_dict) return model
def model(): """ -------------------------------------------------------------------------- template_model: define the non-uncertain parameters -------------------------------------------------------------------------- """ K0_ab = 1.287e12 # K0 [h^-1] K0_bc = 1.287e12 # K0 [h^-1] K0_ad = 9.043e9 # K0 [l/mol.h] R_gas = 8.3144621e-3 # Universal gas constant E_A_ab = 9758.3 * 1.00 #* R_gas# [kj/mol] E_A_bc = 9758.3 * 1.00 #* R_gas# [kj/mol] E_A_ad = 8560.0 * 1.0 #* R_gas# [kj/mol] H_R_ab = 4.2 # [kj/mol A] H_R_bc = -11.0 # [kj/mol B] Exothermic H_R_ad = -41.85 # [kj/mol A] Exothermic Rou = 0.9342 # Density [kg/l] Cp = 3.01 # Specific Heat capacity [kj/Kg.K] Cp_k = 2.0 # Coolant heat capacity [kj/kg.k] A_R = 0.215 # Area of reactor wall [m^2] V_R = 10.01 #0.01 # Volume of reactor [l] m_k = 5.0 # Coolant mass[kg] T_in = 130.0 # Temp of inflow [Celsius] K_w = 4032.0 # [kj/h.m^2.K] C_A0 = ( 5.7 + 4.5 ) / 2.0 * 1.0 # Concentration of A in input Upper bound 5.7 lower bound 4.5 [mol/l] """ -------------------------------------------------------------------------- template_model: define uncertain parameters, states and controls as symbols -------------------------------------------------------------------------- """ # Define the uncertainties as CasADi symbols alpha = SX.sym("alpha") beta = SX.sym("beta") # Define the differential states as CasADi symbols C_a = SX.sym("C_a") # Concentration A C_b = SX.sym("C_b") # Concentration B T_R = SX.sym("T_R") # Reactor Temprature T_K = SX.sym("T_K") # Jacket Temprature # Define the algebraic states as CasADi symbols # Define the control inputs as CasADi symbols F = SX.sym("F") # Vdot/V_R [h^-1] Q_dot = SX.sym("Q_dot") #Q_dot second control input # Define time-varying parameters that can change at each step of the prediction and at each sampling time of the MPC controller. For example, future weather predictions tv_param_1 = SX.sym("tv_param_1") tv_param_2 = SX.sym("tv_param_2") """ -------------------------------------------------------------------------- template_model: define algebraic and differential equations -------------------------------------------------------------------------- """ # Define the algebraic equations K_1 = beta * K0_ab * exp((-E_A_ab) / ((T_R + 273.15))) K_2 = K0_bc * exp((-E_A_bc) / ((T_R + 273.15))) K_3 = K0_ad * exp((-alpha * E_A_ad) / ((T_R + 273.15))) # Define the differential equations dC_a = F * (C_A0 - C_a) - K_1 * C_a - K_3 * (C_a**2) dC_b = -F * C_b + K_1 * C_a - K_2 * C_b dT_R = ((K_1 * C_a * H_R_ab + K_2 * C_b * H_R_bc + K_3 * (C_a**2) * H_R_ad) / (-Rou * Cp)) + F * (T_in - T_R) + (((K_w * A_R) * (T_K - T_R)) / (Rou * Cp * V_R)) dT_K = (Q_dot + K_w * A_R * (T_R - T_K)) / (m_k * Cp_k) # Concatenate differential states, algebraic states, control inputs and right-hand-sides _x = vertcat(C_a, C_b, T_R, T_K) _z = vertcat([]) _u = vertcat(F, Q_dot) _xdot = vertcat(dC_a, dC_b, dT_R, dT_K) _p = vertcat(alpha, beta) _tv_p = vertcat(tv_param_1, tv_param_2) """ -------------------------------------------------------------------------- template_model: initial condition and constraints -------------------------------------------------------------------------- """ # Initial condition for the states C_a_0 = 0.8 # This is the initial concentration inside the tank [mol/l] C_b_0 = 0.5 # This is the controlled variable [mol/l] T_R_0 = 134.14 #[C] T_K_0 = 130.0 #[C] x0 = NP.array([C_a_0, C_b_0, T_R_0, T_K_0]) # No algebraic states z0 = NP.array([]) # Bounds on the states. Use "inf" for unconstrained states C_a_lb = 0.1 C_a_ub = 2.0 C_b_lb = 0.1 C_b_ub = 2.0 T_R_lb = 50.0 T_R_ub = 180 T_K_lb = 50.0 T_K_ub = 180 x_lb = NP.array([C_a_lb, C_b_lb, T_R_lb, T_K_lb]) x_ub = NP.array([C_a_ub, C_b_ub, T_R_ub, T_K_ub]) # No algebraic states z_lb = NP.array([]) z_ub = NP.array([]) # Bounds on the control inputs. Use "inf" for unconstrained inputs F_lb = 5.0 F_ub = +100.0 Q_dot_lb = -8500.0 Q_dot_ub = 0.0 u_lb = NP.array([F_lb, Q_dot_lb]) u_ub = NP.array([F_ub, Q_dot_ub]) u0 = NP.array([30.0, -6000.0]) # Scaling factors for the states and control inputs. Important if the system is ill-conditioned x_scaling = NP.array([1.0, 1.0, 1.0, 1.0]) z_scaling = NP.array([]) u_scaling = NP.array([1.0, 1.0]) # Other possibly nonlinear constraints in the form cons(x,u,p) <= cons_ub # Define the expresion of the constraint (leave it empty if not necessary) cons = vertcat([]) # Define the lower and upper bounds of the constraint (leave it empty if not necessary) cons_ub = NP.array([]) # Activate if the nonlinear constraints should be implemented as soft constraints soft_constraint = 0 # Penalty term to add in the cost function for the constraints (it should be the same size as cons) penalty_term_cons = NP.array([]) # Maximum violation for the constraints maximum_violation = NP.array([0]) # Define the terminal constraint (leave it empty if not necessary) cons_terminal = vertcat() # Define the lower and upper bounds of the constraint (leave it empty if not necessary) cons_terminal_lb = NP.array([]) cons_terminal_ub = NP.array([]) """ -------------------------------------------------------------------------- template_model: cost function -------------------------------------------------------------------------- """ # Define the cost function # Lagrange term lterm = (C_b - tv_param_1)**2 #lterm = - C_b # Mayer term mterm = (C_b - tv_param_1)**2 #mterm = - C_b # Penalty term for the control movements rterm = NP.array([0.0, 0.0]) """ -------------------------------------------------------------------------- template_model: pass information (not necessary to edit) -------------------------------------------------------------------------- """ model_dict = { 'x': _x, 'u': _u, 'rhs': _xdot, 'p': _p, 'z': _z, 'x0': x0, 'x_lb': x_lb, 'x_ub': x_ub, 'u0': u0, 'u_lb': u_lb, 'u_ub': u_ub, 'x_scaling': x_scaling, 'u_scaling': u_scaling, 'cons': cons, 'tv_p': _tv_p, "cons_ub": cons_ub, 'cons_terminal': cons_terminal, 'cons_terminal_lb': cons_terminal_lb, 'cons_terminal_ub': cons_terminal_ub, 'soft_constraint': soft_constraint, 'penalty_term_cons': penalty_term_cons, 'maximum_violation': maximum_violation, 'mterm': mterm, 'lterm': lterm, 'rterm': rterm } model = core_do_mpc.model(model_dict) return model
def model(): """ -------------------------------------------------------------------------- template_model: define the non-uncertain parameters -------------------------------------------------------------------------- """ mu_m = 0.02 K_m = 0.05 K_i = 5.0 v_par = 0.004 Y_p = 1.2 """ -------------------------------------------------------------------------- template_model: define uncertain parameters, states and controls as symbols -------------------------------------------------------------------------- """ # Define the uncertainties as CasADi symbols Y_x = SX.sym("Y_x") S_in = SX.sym("S_in") # Define the differential states as CasADi symbols X_s = SX.sym("X_s") # Concentration A S_s = SX.sym("S_s") # Concentration B P_s = SX.sym("P_s") # Reactor Temprature V_s = SX.sym("V_s") # Jacket Temprature # Define the algebraic states as CasADi symbols # Define the control inputs as CasADi symbols inp = SX.sym("inp") # Vdot/V_R [h^-1] """ -------------------------------------------------------------------------- template_model: define algebraic and differential equations -------------------------------------------------------------------------- """ # Define the algebraic equations mu_S = mu_m*S_s/(K_m+S_s+(S_s**2/K_i)) # Define the differential equations dX_s = mu_S*X_s - inp/V_s*X_s dS_s = -mu_S*X_s/Y_x - v_par*X_s/Y_p + inp/V_s*(S_in-S_s) dP_s = v_par*X_s - inp/V_s*P_s dV_s = inp # Concatenate differential states, algebraic states, control inputs and right-hand-sides _x = vertcat(X_s, S_s, P_s, V_s) _u = vertcat(inp) _xdot = vertcat(dX_s, dS_s, dP_s, dV_s) _p = vertcat(Y_x, S_in) _z = [] """ -------------------------------------------------------------------------- template_model: initial condition and constraints -------------------------------------------------------------------------- """ # Initial condition for the states X_s_0 = 1.0 S_s_0 = 0.5 P_s_0 = 0.0 V_s_0 = 120.0 x0 = NP.array([X_s_0, S_s_0, P_s_0, V_s_0]) # Bounds on the states. Use "inf" for unconstrained states X_s_lb = 0.0; X_s_ub = 3.7 S_s_lb = -0.01; S_s_ub = inf P_s_lb = 0.0; P_s_ub = 3.0 V_s_lb = 0.0; V_s_ub = inf x_lb = NP.array([X_s_lb, S_s_lb, P_s_lb, V_s_lb]) x_ub = NP.array([X_s_ub, S_s_ub, P_s_ub, V_s_ub]) # Bounds on the control inputs. Use "inf" for unconstrained inputs inp_lb = 0.0; inp_ub = 0.2; u_lb = NP.array([inp_lb]) u_ub = NP.array([inp_ub]) u0 = NP.array([0.03]) # Scaling factors for the states and control inputs. Important if the system is ill-conditioned x_scaling = NP.array([1.0, 1.0, 1.0, 1.0]) u_scaling = NP.array([1.0]) # Other possibly nonlinear constraints in the form cons(x,u,p) <= cons_ub # Define the expresion of the constraint (leave it empty if not necessary) cons = vertcat([]) # Define the upper bounds of the constraint (leave it empty if not necessary) cons_ub = NP.array([]) # Activate if the nonlinear constraints should be implemented as soft constraints soft_constraint = 0 # l1 - Penalty term to add in the cost function for the constraints (it should be the same size as cons) penalty_term_cons = NP.array([1e4]) # Maximum violation for the upper and lower bounds maximum_violation = NP.array([10]) # Define the terminal constraint (leave it empty if not necessary) cons_terminal = vertcat([]) # Define the lower and upper bounds of the constraint (leave it empty if not necessary) cons_terminal_lb = NP.array([]) cons_terminal_ub = NP.array([]) """ -------------------------------------------------------------------------- template_model: cost function -------------------------------------------------------------------------- """ # Define the cost function # Lagrange term lterm = -P_s #lterm = - C_b # Mayer term mterm = -P_s #mterm = - C_b # Penalty term for the control movements rterm = NP.array([0.0]) """ -------------------------------------------------------------------------- template_model: pass information (not necessary to edit) -------------------------------------------------------------------------- """ model_dict = {'x':_x,'u': _u, 'rhs':_xdot,'p': _p, 'z':_z,'x0': x0,'x_lb': x_lb,'x_ub': x_ub, 'u0':u0, 'u_lb':u_lb, 'u_ub':u_ub, 'x_scaling':x_scaling, 'u_scaling':u_scaling, 'cons':cons, "cons_ub": cons_ub, 'cons_terminal':cons_terminal, 'cons_terminal_lb': cons_terminal_lb, 'cons_terminal_ub':cons_terminal_ub, 'soft_constraint': soft_constraint, 'penalty_term_cons': penalty_term_cons, 'maximum_violation': maximum_violation, 'mterm': mterm,'lterm':lterm, 'rterm':rterm} model = core_do_mpc.model(model_dict) return model
def model(): lbub = NP.load('Neural_Network\lbub_60.npy') x_lb_NN = lbub[0] x_ub_NN = lbub[1] y_lb_NN = lbub[2] y_ub_NN = lbub[3] json_file = open('Neural_Network\model_60.json', 'r') model_json = json_file.read() json_file.close() model = model_from_json(model_json) # load weights into new model model.load_weights("Neural_Network\model_60.h5") Theta = {} i = 0 for j in range(len(model.layers)): weights = model.layers[j].get_weights() Theta['Theta' + str(i + 1)] = NP.insert(weights[0].transpose(), 0, weights[1].transpose(), axis=1) i += 1 """ -------------------------------------------------------------------------- template_model: define uncertain parameters, states and controls as symbols -------------------------------------------------------------------------- """ # Define the uncertainties as CasADi symbols alpha = MX.sym("alpha") # Define the differential states as CasADi symbols # T(t-1) + u_rad(t-1) + u_ahu(t-1) + v_IG(t-1) + u_blinds(t-1) + v(t-1) #+ len(zones_Heating) + len(zones_ahu) + len(zones) x = MX.sym("x", (numbers - 1) * (len(zones) + 12)) # Define the control inputs as CasADi symbols u_blinds_E = MX.sym("u_blinds_E") u_blinds_N = MX.sym("u_blinds_N") u_blinds_S = MX.sym("u_blinds_S") u_blinds_W = MX.sym("u_blinds_W") u = vertcat(u_blinds_E, u_blinds_N, u_blinds_S, u_blinds_W) for i in range(len(zones_ahu)): tmp = 'u_AHU_' + zones_ahu[i] vars()[tmp] = MX.sym(tmp) u = vertcat(u, vars()[tmp]) for i in range(len(zones_Heating)): tmp = 'u_rad_' + zones_Heating[i] vars()[tmp] = MX.sym(tmp) u = vertcat(u, vars()[tmp]) if i == 0: u_rad = MX.sym('u_rad') u_rad = vars()[tmp] else: u_rad = vertcat(u_rad, vars()[tmp]) # Define time-varying parameters that can chance at each step of the prediction and at each sampling time of the MPC controller. For example, future weather predictions for i in range(len(zones)): tmp = 'v_IG_' + zones[i] vars()[tmp] = MX.sym(tmp) if i == 0: v = vars()[tmp] else: v = vertcat(v, vars()[tmp]) v_Tamb = MX.sym("v_Tamb") v_solGlobFac_S = MX.sym("v_solGlobFac_S") v_solGlobFac_W = MX.sym("v_solGlobFac_W") v_solGlobFac_N = MX.sym("v_solGlobFac_N") v_solGlobFac_E = MX.sym("v_solGlobFac_E") v_windspeed = MX.sym("v_windspeed") v_Hum_amb = MX.sym("v_Hum_amb") v_P_amb = MX.sym("v_P_amb") u_ahu_ub = MX.sym("u_ahu_ub") setp_ub = MX.sym("setp_ub") setp_lb = MX.sym("setp_lb") v = vertcat(v, v_Tamb, v_solGlobFac_E, v_solGlobFac_N, v_solGlobFac_S, v_solGlobFac_W, v_windspeed, v_Hum_amb, v_P_amb) """ -------------------------------------------------------------------------- template_model: define algebraic and differential equations -------------------------------------------------------------------------- """ input = vertcat(x, u, v) input = NP.divide(input - x_lb_NN, x_ub_NN - x_lb_NN) for i in range(1, len(model.layers)): tmp_a = 'a' + str(i) + '_' if i == 1: vars()[tmp_a] = input vars()[tmp_a] = vertcat(1, vars()[tmp_a]) tmp_z = 'z' + str(i) + '_' vars()[tmp_z] = mtimes(Theta['Theta' + str(i)], vars()[tmp_a]) tmp_a = 'a' + str(i + 1) + '_' if i < len(model.layers): vars()[tmp_a] = tanh(vars()[tmp_z]) else: vars()[tmp_a] = vars()[tmp_z] dT = MX.sym('dT') dHeatrate = MX.sym('dHeatrate') for i in range(len(zones) + len(zones_Heating)): if i < len(zones): tmp = 'dT_' + zones[i] else: tmp = 'dHeatrate_' + zones_Heating[i - len(zones)] vars()[tmp] = MX.sym(tmp) vars()[tmp] = vars()[tmp_a][i] vars()[tmp] = NP.multiply(vars()[tmp_a][i], y_ub_NN[i] - y_lb_NN[i]) + y_lb_NN[i] if i == 0: dT = vars()[tmp] elif i < len(zones): dT = vertcat(dT, vars()[tmp]) elif i == len(zones): dHeatrate = vars()[tmp] else: dHeatrate = vertcat(dHeatrate, vars()[tmp]) # dT = vars()[tmp_a][0:14] dx = vertcat(dT, u[0:4], v[len(zones):]) # Concatenate differential states, algebraic states, control inputs and right-hand-sides _x = x _z = vertcat([]) _u = u _xdot = dx _zdot = vertcat([]) _p = vertcat(alpha) _tv_p = vertcat(v, u_ahu_ub, setp_ub, setp_lb) """ -------------------------------------------------------------------------- template_model: initial condition and constraints -------------------------------------------------------------------------- """ # Initial condition for the states disturbances = NP.load('Neural_Network\disturbances.npy').squeeze() x0 = NP.concatenate( (18 * NP.ones(len(zones)), NP.zeros(4), disturbances[len(zones):, 0])) # No algebraic states z0 = NP.array([]) # Bounds on the states. Use "inf" for unconstrained states disturbances_lb = NP.min(disturbances, axis=1) disturbances_ub = NP.max(disturbances, axis=1) x_lb = NP.concatenate( (x_lb_NN[0:len(zones) + 0 * len(zones_Heating) + 0 * len(zones_ahu)] - 1e-2, NP.zeros(4), disturbances_lb[len(zones):])) x_ub = NP.concatenate( (x_ub_NN[0:len(zones) + 0 * len(zones_Heating) + 0 * len(zones_ahu)] + 1e-2, NP.ones(4), disturbances_ub[len(zones):])) # No algebraic states z_lb = NP.array([]) z_ub = NP.array([]) # Bounds on the control inputs. Use "inf" for unconstrained inputs u_lb = NP.array([0, 0, 0, 0]) u_lb = NP.concatenate( (u_lb, NP.zeros(len(zones_ahu)), 16 * NP.ones(len(zones_Heating)))) u_ub = NP.array([1, 1, 1, 1]) u_ub = NP.concatenate( (u_ub, NP.ones(len(zones_ahu)), 22 * NP.ones(len(zones_Heating)))) u0 = NP.concatenate( (NP.zeros(4 + len(zones_ahu)), 18 * NP.ones(len(zones_Heating)))) # Scaling factors for the states and control inputs. Important if the system is ill-conditioned x_scaling = NP.ones(x.shape[0]) z_scaling = NP.array([]) u_scaling = NP.ones(4 + len(zones_ahu) + len(zones_Heating)) # Other possibly nonlinear constraints in the form cons(x,u,p) <= cons_ub # Define the expresion of the constraint (leave it empty if not necessary) # cons = vertcat(x[0:len(zones)]-setp_ub, -(x[0:len(zones)]-setp_lb)) cons = vertcat(x[0] - setp_ub, -(x[0] - setp_lb)) # Define the lower and upper bounds of the constraint (leave it empty if not necessary) # cons_ub = NP.zeros(2*len(zones)) cons_ub = NP.zeros(2) # Activate if the nonlinear constraints should be implemented as soft constraints soft_constraint = 1 # Penalty term to add in the cost function for the constraints (it should be the same size as cons) penalty_term_cons = 1e6 * NP.ones(2) # Maximum violation for the constraints maximum_violation = 20 * NP.ones(2) # Define the terminal constraint (leave it empty if not necessary) cons_terminal = vertcat() # Define the lower and upper bounds of the constraint (leave it empty if not necessary) cons_terminal_lb = NP.array([]) cons_terminal_ub = NP.array([]) """ -------------------------------------------------------------------------- template_model: cost function -------------------------------------------------------------------------- """ # Define the cost function lterm = mtimes(0.5 * NP.ones( (dHeatrate.shape[1], dHeatrate.shape[0])), dHeatrate) + mtimes( 10 * NP.ones((u_rad.shape[1], u_rad.shape[0])), u_rad) mterm = mtimes(0.5 * NP.ones( (dHeatrate.shape[1], dHeatrate.shape[0])), dHeatrate) + mtimes( 10 * NP.ones((u_rad.shape[1], u_rad.shape[0])), u_rad) # Penalty term for the control movements 1e4, 100 rterm = NP.concatenate((1e4 * NP.ones(4), 1e4 * NP.ones(len(zones_ahu)), 20 * NP.ones(len(zones_Heating)))) """ -------------------------------------------------------------------------- template_model: pass information (not necessary to edit) -------------------------------------------------------------------------- """ bp() model_dict = { 'x': _x, 'u': _u, 'rhs': _xdot, 'p': _p, 'z': _z, 'aes': _zdot, 'x0': x0, 'z0': z0, 'x_lb': x_lb, 'x_ub': x_ub, 'z_lb': z_lb, 'z_ub': z_ub, 'u0': u0, 'u_lb': u_lb, 'u_ub': u_ub, 'x_scaling': x_scaling, 'z_scaling': z_scaling, 'u_scaling': u_scaling, 'cons': cons, 'tv_p': _tv_p, "cons_ub": cons_ub, 'cons_terminal': cons_terminal, 'cons_terminal_lb': cons_terminal_lb, 'cons_terminal_ub': cons_terminal_ub, 'soft_constraint': soft_constraint, 'penalty_term_cons': penalty_term_cons, 'maximum_violation': maximum_violation, 'mterm': mterm, 'lterm': lterm, 'rterm': rterm } model = core_do_mpc.model(model_dict) return model
def model(waypoint, obstacles,pose,twist,wt): """ -------------------------------------------------------------------------- template_model: define the non-uncertain parameters -------------------------------------------------------------------------- """ """ -------------------------------------------------------------------------- template_model: define uncertain parameters, states and controls as symbols -------------------------------------------------------------------------- """ # Define the uncertainties as CasADi symbols alpha = SX.sym("alpha") beta = SX.sym("beta") # Define the differential states as CasADi symbols x = SX.sym("x") # Concentration A y = SX.sym("y") # Concentration B theta = SX.sym("theta") # Reactor Temprature #T_K = SX.sym("T_K") # Jacket Temprature # Define the algebraic states as CasADi symbols # Define the control inputs as CasADi symbols u = SX.sym("u") # Vdot/V_R [h^-1] w = SX.sym("w") #Q_dot second control input # Define time-varying parameters that can change at each step of the prediction and at each sampling time of the MPC controller. For example, future weather predictions tv_param_1 = SX.sym("tv_param_1") tv_param_2 = SX.sym("tv_param_2") """ -------------------------------------------------------------------------- template_model: define algebraic and differential equations -------------------------------------------------------------------------- """ # Define the algebraic equations #K_1 = beta * K0_ab * exp((-E_A_ab)/((T_R+273.15))) #K_2 = K0_bc * exp((-E_A_bc)/((T_R+273.15))) #K_3 = K0_ad * exp((-alpha*E_A_ad)/((T_R+273.15))) # Define the differential equations dx=u*cos(theta) dy=u*sin(theta) dtheta=w #dC_a = F*(C_A0 - C_a) -K_1*C_a - K_3*(C_a**2) #dC_b = -F*C_b + K_1*C_a -K_2*C_b #dT_R = ((K_1*C_a*H_R_ab + K_2*C_b*H_R_bc + K_3*(C_a**2)*H_R_ad)/(-Rou*Cp)) + F*(T_in-T_R) +(((K_w*A_R)*(T_K-T_R))/(Rou*Cp*V_R)) #dT_K = (Q_dot + K_w*A_R*(T_R-T_K))/(m_k*Cp_k) # Concatenate differential states, algebraic states, control inputs and right-hand-sides _x = vertcat(x, y, theta) _u = vertcat(u, w) _xdot = vertcat(dx, dy, dtheta) _p = vertcat(alpha, beta) #_p = [] _z = [] _tv_p = vertcat(tv_param_1, tv_param_2) #_tv_p = vertcat() """ -------------------------------------------------------------------------- template_model: initial condition and constraints -------------------------------------------------------------------------- """ # Initial condition for the states print "pose",pose x_0 = pose[0] # This is the initial concentration inside the tank [mol/l] y_0 = pose[1] # This is the controlled variable [mol/l] theta_0 = pose[2] #[C] # T_K_0 = 130.0 #[C] x0 = NP.array([x_0, y_0, theta_0]) # Bounds on the states. Use "inf" for unconstrained states x_lb = -100; x_ub = 100.0 y_lb = -100; y_ub = 100.0 theta_lb = -3.14; theta_ub = 3.14 #T_K_lb = 50.0; T_K_ub = 180 X_lb = NP.array([x_lb, y_lb, theta_lb]) X_ub = NP.array([x_ub, y_ub, theta_ub]) # Bounds on the control inputs. Use "inf" for unconstrained inputs u_lb = 0.0; u_ub = 1.0; w_lb = -1.0; w_ub = 1.0; U_lb = NP.array([u_lb, w_lb]) U_ub = NP.array([u_ub, w_ub]) u0 = NP.array(twist) # Scaling factors for the states and control inputs. Important if the system is ill-conditioned x_scaling = NP.array([1.0, 1.0, 1.0]) u_scaling = NP.array([1.0, 1.0]) # Other possibly nonlinear constraints in the form cons(x,u,p) <= cons_ub # Define the expresion of the constraint (leave it empty if not necessary) cons = vertcat([]) # Define the lower and upper bounds of the constraint (leave it empty if not necessary) cons_ub = NP.array([]) # Activate if the nonlinear constraints should be implemented as soft constraints soft_constraint = 0 # Penalty term to add in the cost function for the constraints (it should be the same size as cons) penalty_term_cons = NP.array([]) # Maximum violation for the constraints maximum_violation = NP.array([0]) # Define the terminal constraint (leave it empty if not necessary) cons_terminal = vertcat() # Define the lower and upper bounds of the constraint (leave it empty if not necessary) cons_terminal_lb = NP.array([]) cons_terminal_ub = NP.array([]) """ -------------------------------------------------------------------------- template_model: cost function -------------------------------------------------------------------------- """ Y_ref=waypoint # Define the cost function # Lagrange term #lterm = 1e4*((C_b - 0.9)**2 + (C_a - 1.1)**2) #lterm = 10*(x-Y_ref[0])**2+10*(y-Y_ref[1])**2+(theta-Y_ref[2])**2 + (lam)*exp(-(gamma+((xo[0]-x)**2)/(rx**2)+((xo[1]-y)**2)/(ry**2))) if len(obstacles.a): lam=wt[3] gamma=1 V = 0 for i in xrange(len(obstacles.a)): if obstacles.a[i]: rx=obstacles.a[i] ry=obstacles.b[i] phi = atan(obstacles.m[i]) xo=obstacles.centroid[i] R = [[cos(theta_0), -sin(theta_0)],[sin(theta_0),cos(theta_0)]] xo = np.matmul(R,xo) + pose[0:2] print "obs position",xo V = V + (lam)/((gamma+(( (xo[0]-x)*cos(phi) + (xo[1]-y)*sin(phi) )**2)/(rx**2) + (( (xo[0]-x)*sin(phi) - (xo[1]-y)*cos(phi) )**2)/(ry**2) )) lterm = wt[0]*(x-Y_ref[0])**2 + \ wt[1]*(y-Y_ref[1])**2 + \ wt[2]*(theta-Y_ref[2])**2 + \ V else: lterm = wt[0]*(x-Y_ref[0])**2 + \ wt[1]*(y-Y_ref[1])**2 + \ wt[2]*(theta-Y_ref[2])**2 #lterm = - C_b # Mayer term # mterm = 1e4*((C_b - 0.9)**2 + (C_a - 1.1)**2) mterm = 0 #mterm = - C_b # Penalty term for the control movements rterm = NP.array([0.0, 0.0]) """ -------------------------------------------------------------------------- template_model: pass information (not necessary to edit) -------------------------------------------------------------------------- """ model_dict = {'x':_x,'u': _u, 'rhs':_xdot,'p': _p, 'z':_z,'x0': x0,'x_lb': X_lb,'x_ub': X_ub, 'u0':u0, 'u_lb':U_lb, 'u_ub':U_ub, 'x_scaling':x_scaling, 'u_scaling':u_scaling, 'cons':cons, "cons_ub": cons_ub, 'cons_terminal':cons_terminal, 'cons_terminal_lb': cons_terminal_lb,'tv_p':_tv_p, 'cons_terminal_ub':cons_terminal_ub, 'soft_constraint': soft_constraint, 'penalty_term_cons': penalty_term_cons, 'maximum_violation': maximum_violation, 'mterm': mterm,'lterm':lterm, 'rterm':rterm} model = core_do_mpc.model(model_dict) return model
def model(): # Load Discrete_Time_Model Discrete_Time_Model = scipy.io.loadmat('RKF_Discrete_Time_Model.mat') """ -------------------------------------------------------------------------- template_model: define the non-uncertain parameters -------------------------------------------------------------------------- """ """ -------------------------------------------------------------------------- template_model: define uncertain parameters, states and controls as symbols -------------------------------------------------------------------------- """ # Define the uncertainties as CasADi symbols alpha = SX.sym("alpha") # beta = SX.sym("beta") # Define the differential states as CasADi symbols x = SX.sym("x", 37) # Define the algebraic states as CasADi symbols # Define the control inputs as CasADi symbols u_rad_OfficesZ1 = SX.sym("u_rad_OfficesZ1") u_AHU1_noERC = SX.sym("u_AHU1_noERC") u_blinds_N = SX.sym("u_blinds_N") u_blinds_W = SX.sym("u_blinds_W") u = vertcat(u_blinds_N, u_blinds_W, u_AHU1_noERC, u_rad_OfficesZ1) # Define time-varying parameters that can chance at each step of the prediction and at each sampling time of the MPC controller. For example, future weather predictions v_IG_Offices = SX.sym("V_IG_Offices") v_Tamb = SX.sym("v_Tamb") v_Tgnd = SX.sym("v_Tgnd") v_solGlobFac_S = SX.sym("v_solGlobFac_S") v_solGlobFac_W = SX.sym("v_solGlobFac_W") v_solGlobFac_N = SX.sym("v_solGlobFac_N") v_solGlobFac_E = SX.sym("v_solGlobFac_E") v_windspeed = SX.sym('v_windspeed') setp_ub = SX.sym("setp_ub") setp_lb = SX.sym("setp_lb") u_ahu_ub = SX.sym("u_ahu_ub") v = vertcat(v_IG_Offices, v_Tamb, v_Tgnd, v_solGlobFac_E, v_solGlobFac_N, v_solGlobFac_S, v_solGlobFac_W, v_windspeed, u_ahu_ub, setp_ub, setp_lb) """ -------------------------------------------------------------------------- template_model: define algebraic and differential equations -------------------------------------------------------------------------- """ # Define the differential equations Bvu = Discrete_Time_Model["Bvu"] Bxu = Discrete_Time_Model["Bxu"] dx = mtimes(Discrete_Time_Model["A"], x) + mtimes( Discrete_Time_Model["Bu"], u) + mtimes(Discrete_Time_Model["Bv"], v[0:7]) sum = 0 for i in range(u.shape[0]): sum = sum + (mtimes(Bvu[:, :, i], v[0:7]) + mtimes(Bxu[:, :, i], x)) * u[i] dx = dx + sum # Concatenate differential states, algebraic states, control inputs and right-hand-sides _x = x _z = vertcat([]) _u = u _xdot = dx _zdot = vertcat([]) # _p = vertcat(alpha, beta) _p = vertcat(alpha) # _tv_p = vertcat([]) _tv_p = v """ -------------------------------------------------------------------------- template_model: initial condition and constraints -------------------------------------------------------------------------- """ # Initial condition for the states x0 = 18 * NP.ones(37) x0[[3, 4, 7, 8, 11, 12, 15, 16, 19, 20, 23, 24, 27, 28, 31, 32, 35]] = 5 # No algebraic states z0 = NP.array([]) # Bounds on the states. Use "inf" for unconstrained states x_lb = -50 * NP.ones(37) x_ub = 60 * NP.ones(37) # No algebraic states z_lb = NP.array([]) z_ub = NP.array([]) # Bounds on the control inputs. Use "inf" for unconstrained inputs u_lb = NP.array([0, 0, 0, 0]) u_ub = NP.array([1, 1, 0.2016, inf]) u0 = NP.array([1, 1, 0, 0]) # Scaling factors for the states and control inputs. Important if the system is ill-conditioned x_scaling = NP.ones(37) z_scaling = NP.array([]) u_scaling = NP.array([1, 1, 1, 1]) # Other possibly nonlinear constraints in the form cons(x,u,p) <= cons_ub # Define the expresion of the constraint (leave it empty if not necessary) cons = vertcat(x[0] - v[-2], -(x[0] - v[-1])) # cons = vertcat(x[0], x[1], -x[0], -x[1]) # Define the lower and upper bounds of the constraint (leave it empty if not necessary) cons_ub = NP.array([0, -0]) # Activate if the nonlinear constraints should be implemented as soft constraints soft_constraint = 1 # Penalty term to add in the cost function for the constraints (it should be the same size as cons) penalty_term_cons = NP.array([1e5, 1e5]) # Maximum violation for the constraints maximum_violation = 100 * NP.array([1, 1]) # Define the terminal constraint (leave it empty if not necessary) cons_terminal = vertcat() # Define the lower and upper bounds of the constraint (leave it empty if not necessary) cons_terminal_lb = NP.array([]) cons_terminal_ub = NP.array([]) """ -------------------------------------------------------------------------- template_model: cost function -------------------------------------------------------------------------- """ # Define the cost function # Lagrange term # Mayer term lterm = u_rad_OfficesZ1 + u_AHU1_noERC #+ u_blinds_E + u_blinds_N + u_blinds_S + u_blinds_W #(5-u_rad_OfficesZ1)**2 + (5-u_rad_OfficesZ2)**2 + (0.7-u_blinds_S)**2 + (0.7-u_blinds_W)**2 + (0.7-u_blinds_N)**2 + (0.7-u_blinds_E)**2 + (0.1-u_AHU1_noERC)**2 + (0.1-u_AHU2_noERC)**2 mterm = u_rad_OfficesZ1 + u_AHU1_noERC #+ u_blinds_E + u_blinds_N + u_blinds_S + u_blinds_W #(5-u_rad_OfficesZ1)**2 + (5-u_rad_OfficesZ2)**2 + (0.7-u_blinds_S)**2 + (0.7-u_blinds_W)**2 + (0.7-u_blinds_N)**2 + (0.7-u_blinds_E)**2 + (0.1-u_AHU1_noERC)**2 + (0.1-u_AHU2_noERC)**2 # Penalty term for the control movements rterm = 1e-3 * NP.array([1, 1, 1, 1]) """ -------------------------------------------------------------------------- template_model: pass information (not necessary to edit) -------------------------------------------------------------------------- """ model_dict = { 'x': _x, 'u': _u, 'rhs': _xdot, 'p': _p, 'z': _z, 'aes': _zdot, 'x0': x0, 'z0': z0, 'x_lb': x_lb, 'x_ub': x_ub, 'z_lb': z_lb, 'z_ub': z_ub, 'u0': u0, 'u_lb': u_lb, 'u_ub': u_ub, 'x_scaling': x_scaling, 'z_scaling': z_scaling, 'u_scaling': u_scaling, 'cons': cons, 'tv_p': _tv_p, "cons_ub": cons_ub, 'cons_terminal': cons_terminal, 'cons_terminal_lb': cons_terminal_lb, 'cons_terminal_ub': cons_terminal_ub, 'soft_constraint': soft_constraint, 'penalty_term_cons': penalty_term_cons, 'maximum_violation': maximum_violation, 'mterm': mterm, 'lterm': lterm, 'rterm': rterm } model = core_do_mpc.model(model_dict) return model
def model(): """ -------------------------------------------------------------------------- template_model: define the non-uncertain parameters -------------------------------------------------------------------------- """ K0_ab = 1.287e12 # K0 [h^-1] K0_bc = 1.287e12 # K0 [h^-1] K0_ad = 9.043e9 # K0 [l/mol.h] R_gas = 8.3144621e-3 # Universal gas constant E_A_ab = 9758.3*1.00 #* R_gas# [kj/mol] E_A_bc = 9758.3*1.00 #* R_gas# [kj/mol] E_A_ad = 8560.0*1.0 #* R_gas# [kj/mol] H_R_ab = 4.2 # [kj/mol A] H_R_bc = -11.0 # [kj/mol B] Exothermic H_R_ad = -41.85 # [kj/mol A] Exothermic Rou = 0.9342 # Density [kg/l] Cp = 3.01 # Specific Heat capacity [kj/Kg.K] Cp_k = 2.0 # Coolant heat capacity [kj/kg.k] A_R = 0.215 # Area of reactor wall [m^2] V_R = 10.01 #0.01 # Volume of reactor [l] m_k = 5.0 # Coolant mass[kg] T_in = 130.0 # Temp of inflow [Celsius] K_w = 4032.0 # [kj/h.m^2.K] C_A0 = (5.7+4.5)/2.0*1.0 # Concentration of A in input Upper bound 5.7 lower bound 4.5 [mol/l] """ -------------------------------------------------------------------------- template_model: define uncertain parameters, states and controls as symbols -------------------------------------------------------------------------- """ # Define the uncertainties as CasADi symbols alpha = SX.sym("alpha") beta = SX.sym("beta") # Define the differential states as CasADi symbols C_a = SX.sym("C_a") # Concentration A C_b = SX.sym("C_b") # Concentration B T_R = SX.sym("T_R") # Reactor Temprature T_K = SX.sym("T_K") # Jacket Temprature # Define the algebraic states as CasADi symbols # Define the control inputs as CasADi symbols F = SX.sym("F") # Vdot/V_R [h^-1] Q_dot = SX.sym("Q_dot") #Q_dot second control input # Define time-varying parameters that can change at each step of the prediction and at each sampling time of the MPC controller. For example, future weather predictions tv_param_1 = SX.sym("tv_param_1") tv_param_2 = SX.sym("tv_param_2") """ -------------------------------------------------------------------------- template_model: define algebraic and differential equations -------------------------------------------------------------------------- """ # Define the algebraic equations K_1 = beta * K0_ab * exp((-E_A_ab)/((T_R+273.15))) K_2 = K0_bc * exp((-E_A_bc)/((T_R+273.15))) K_3 = K0_ad * exp((-alpha*E_A_ad)/((T_R+273.15))) # Define the differential equations dC_a = F*(C_A0 - C_a) -K_1*C_a - K_3*(C_a**2) dC_b = -F*C_b + K_1*C_a -K_2*C_b dT_R = ((K_1*C_a*H_R_ab + K_2*C_b*H_R_bc + K_3*(C_a**2)*H_R_ad)/(-Rou*Cp)) + F*(T_in-T_R) +(((K_w*A_R)*(T_K-T_R))/(Rou*Cp*V_R)) dT_K = (Q_dot + K_w*A_R*(T_R-T_K))/(m_k*Cp_k) # Concatenate differential states, algebraic states, control inputs and right-hand-sides _x = vertcat(C_a, C_b, T_R,T_K) _u = vertcat(F, Q_dot) _xdot = vertcat(dC_a, dC_b, dT_R, dT_K) _p = vertcat(alpha, beta) _z = [] _tv_p = vertcat(tv_param_1, tv_param_2) """ -------------------------------------------------------------------------- template_model: initial condition and constraints -------------------------------------------------------------------------- """ # Initial condition for the states C_a_0 = 0.8 # This is the initial concentration inside the tank [mol/l] C_b_0 = 0.5 # This is the controlled variable [mol/l] T_R_0 = 134.14 #[C] T_K_0 = 130.0 #[C] x0 = NP.array([C_a_0, C_b_0, T_R_0, T_K_0]) # Bounds on the states. Use "inf" for unconstrained states C_a_lb = 0.1; C_a_ub = 2.0 C_b_lb = 0.1; C_b_ub = 2.0 T_R_lb = 50.0; T_R_ub = 180 T_K_lb = 50.0; T_K_ub = 180 x_lb = NP.array([C_a_lb, C_b_lb, T_R_lb, T_K_lb]) x_ub = NP.array([C_a_ub, C_b_ub, T_R_ub, T_K_ub]) # Bounds on the control inputs. Use "inf" for unconstrained inputs F_lb = 5.0; F_ub = +100.0; Q_dot_lb = -8500.0; Q_dot_ub = 0.0; u_lb = NP.array([F_lb, Q_dot_lb]) u_ub = NP.array([F_ub, Q_dot_ub]) u0 = NP.array([30.0,-6000.0]) # Scaling factors for the states and control inputs. Important if the system is ill-conditioned x_scaling = NP.array([1.0, 1.0, 1.0, 1.0]) u_scaling = NP.array([1.0, 1.0]) # Other possibly nonlinear constraints in the form cons(x,u,p) <= cons_ub # Define the expresion of the constraint (leave it empty if not necessary) cons = vertcat([]) # Define the lower and upper bounds of the constraint (leave it empty if not necessary) cons_ub = NP.array([]) # Activate if the nonlinear constraints should be implemented as soft constraints soft_constraint = 0 # Penalty term to add in the cost function for the constraints (it should be the same size as cons) penalty_term_cons = NP.array([]) # Maximum violation for the constraints maximum_violation = NP.array([0]) # Define the terminal constraint (leave it empty if not necessary) cons_terminal = vertcat() # Define the lower and upper bounds of the constraint (leave it empty if not necessary) cons_terminal_lb = NP.array([]) cons_terminal_ub = NP.array([]) """ -------------------------------------------------------------------------- template_model: cost function -------------------------------------------------------------------------- """ # Define the cost function # Lagrange term lterm = 1e4*((C_b - 0.9)**2 + (C_a - 1.1)**2) #lterm = - C_b # Mayer term mterm = 1e4*((C_b - 0.9)**2 + (C_a - 1.1)**2) #mterm = - C_b # Penalty term for the control movements rterm = NP.array([0.0, 0.0]) """ -------------------------------------------------------------------------- template_model: pass information (not necessary to edit) -------------------------------------------------------------------------- """ model_dict = {'x':_x,'u': _u, 'rhs':_xdot,'p': _p, 'z':_z,'x0': x0,'x_lb': x_lb,'x_ub': x_ub, 'u0':u0, 'u_lb':u_lb, 'u_ub':u_ub, 'x_scaling':x_scaling, 'u_scaling':u_scaling, 'cons':cons, "cons_ub": cons_ub, 'cons_terminal':cons_terminal, 'cons_terminal_lb': cons_terminal_lb,'tv_p':_tv_p, 'cons_terminal_ub':cons_terminal_ub, 'soft_constraint': soft_constraint, 'penalty_term_cons': penalty_term_cons, 'maximum_violation': maximum_violation, 'mterm': mterm,'lterm':lterm, 'rterm':rterm} model = core_do_mpc.model(model_dict) return model
def model(): """ -------------------------------------------------------------------------- template_model: define the non-uncertain parameters -------------------------------------------------------------------------- """ # K0_ab = 1.287e12 # K0 [h^-1] # K0_bc = 1.287e12 # K0 [h^-1] # K0_ad = 9.043e9 # K0 [l/mol.h] # R_gas = 8.3144621e-3 # Universal gas constant # E_A_ab = 9758.3*1.00 #* R_gas# [kj/mol] # E_A_bc = 9758.3*1.00 #* R_gas# [kj/mol] # E_A_ad = 8560.0*1.0 #* R_gas# [kj/mol] # H_R_ab = 4.2 # [kj/mol A] # H_R_bc = -11.0 # [kj/mol B] Exothermic # H_R_ad = -41.85 # [kj/mol A] Exothermic # Rou = 0.9342 # Density [kg/l] # Cp = 3.01 # Specific Heat capacity [kj/Kg.K] # Cp_k = 2.0 # Coolant heat capacity [kj/kg.k] # A_R = 0.215 # Area of reactor wall [m^2] # V_R = 10.01 #0.01 # Volume of reactor [l] # m_k = 5.0 # Coolant mass[kg] # T_in = 130.0 # Temp of inflow [Celsius] # K_w = 4032.0 # [kj/h.m^2.K] # C_A0 = (5.7+4.5)/2.0*1.0 # Concentration of A in input Upper bound 5.7 lower bound 4.5 [mol/l] """ -------------------------------------------------------------------------- template_model: define uncertain parameters, states and controls as symbols -------------------------------------------------------------------------- """ # Define the uncertainties as CasADi symbols alpha = SX.sym("alpha") beta = SX.sym("beta") # Define the differential states as CasADi symbols x = SX.sym("x") # x position of the robot y = SX.sym("y") # y position of the robot theta = SX.sym("theta") # heading angle of the robot # Define the algebraic states as CasADi symbols # Define the control inputs as CasADi symbols v = SX.sym("v") # linear velocity of the robot w = SX.sym("w") # angular velocity of the robot # Define time-varying parameters that can change at each step of the prediction and at each sampling time of the MPC controller. For example, future weather predictions tv_param_1 = SX.sym("tv_param_1") tv_param_2 = SX.sym("tv_param_2") """ -------------------------------------------------------------------------- template_model: define algebraic and differential equations -------------------------------------------------------------------------- """ # Define the algebraic equations # K_1 = beta * K0_ab * exp((-E_A_ab)/((T_R+273.15))) # K_2 = K0_bc * exp((-E_A_bc)/((T_R+273.15))) # K_3 = K0_ad * exp((-alpha*E_A_ad)/((T_R+273.15))) # Define the differential equations dd = SX.sym("dd", 3) dd[0] = v * cos(theta) * alpha dd[1] = v * sin(theta) * beta dd[2] = w # Concatenate differential states, algebraic states, control inputs and right-hand-sides _x = vertcat(x, y, theta) _u = vertcat(v, w) _xdot = vertcat(dd) _p = vertcat(alpha, beta) _z = [] # toggle if there are no AE in your model _tv_p = vertcat(tv_param_1, tv_param_2) """ -------------------------------------------------------------------------- template_model: initial condition and constraints -------------------------------------------------------------------------- """ # Initial condition for the states x_init = 5.0 y_init = 5.0 theta_init = 0.0 x0 = NP.array([x_init, y_init, theta_init]) # Bounds on the states. Use "inf" for unconstrained states x_lb = 0.0 x_ub = 30.0 y_lb = 0.0 y_ub = 30.0 theta_lb = -2 * pi theta_ub = 2 * pi x_lb = NP.array([x_lb, y_lb, theta_lb]) x_ub = NP.array([x_ub, y_ub, theta_ub]) # Bounds on the control inputs. Use "inf" for unconstrained inputs v_lb = -1.4 v_ub = 1.4 v_init = 0.0 w_lb = -1.0 w_ub = 1.0 w_init = 0.0 u_lb = NP.array([v_lb, w_lb]) u_ub = NP.array([v_ub, w_ub]) u0 = NP.array([v_init, w_init]) # Scaling factors for the states and control inputs. Important if the system is ill-conditioned x_scaling = NP.array([1.0, 1.0, 1.0]) u_scaling = NP.array([1.0, 1.0]) # Other possibly nonlinear constraints in the form cons(x,u,p) <= cons_ub # Define the expresion of the constraint (leave it empty if not necessary) cons = vertcat([]) # Define the lower and upper bounds of the constraint (leave it empty if not necessary) cons_ub = NP.array([]) # Activate if the nonlinear constraints should be implemented as soft constraints soft_constraint = 0 # Penalty term to add in the cost function for the constraints (it should be the same size as cons) penalty_term_cons = NP.array([]) # Maximum violation for the constraints maximum_violation = NP.array([0]) # Define the terminal constraint (leave it empty if not necessary) cons_terminal = vertcat() # Define the lower and upper bounds of the constraint (leave it empty if not necessary) cons_terminal_lb = NP.array([]) cons_terminal_ub = NP.array([]) """ -------------------------------------------------------------------------- template_model: cost function -------------------------------------------------------------------------- """ # Define the cost function # Lagrange term lterm = 14 * (x - 15)**2 + 6 * (y - 15)**2 + 8 * (theta - pi / 2)**2 + v**2 + w**2 # Mayer term mterm = 0 # Penalty term for the control movements rterm = NP.array([0.0001, 0.0001]) """ -------------------------------------------------------------------------- template_model: pass information (not necessary to edit) -------------------------------------------------------------------------- """ model_dict = { 'x': _x, 'u': _u, 'rhs': _xdot, 'p': _p, 'z': _z, 'x0': x0, 'x_lb': x_lb, 'x_ub': x_ub, 'u0': u0, 'u_lb': u_lb, 'u_ub': u_ub, 'x_scaling': x_scaling, 'u_scaling': u_scaling, 'cons': cons, "cons_ub": cons_ub, 'cons_terminal': cons_terminal, 'cons_terminal_lb': cons_terminal_lb, 'tv_p': _tv_p, 'cons_terminal_ub': cons_terminal_ub, 'soft_constraint': soft_constraint, 'penalty_term_cons': penalty_term_cons, 'maximum_violation': maximum_violation, 'mterm': mterm, 'lterm': lterm, 'rterm': rterm } model = core_do_mpc.model(model_dict) return model
def model(): lbub = NP.load('Neural_Network\lbub.npy') x_lb_NN = lbub[0] x_ub_NN = lbub[1] y_lb_NN = lbub[2] y_ub_NN = lbub[3] json_file = open('Neural_Network\model_3.json', 'r') model_json = json_file.read() json_file.close() model = model_from_json(model_json) # load weights into new model model.load_weights("Neural_Network\model_3.h5") Theta = {} # for i in range(len(model.layers)): i = 0 for j in [0, 2, 4, 6, 8]: weights = model.layers[j].get_weights() Theta['Theta' + str(i + 1)] = NP.insert(weights[0].transpose(), 0, weights[1].transpose(), axis=1) i += 1 """ -------------------------------------------------------------------------- template_model: define uncertain parameters, states and controls as symbols -------------------------------------------------------------------------- """ # Define the uncertainties as CasADi symbols alpha = MX.sym("alpha") # Define the differential states as CasADi symbols # x = MX.sym("x", Theta['Theta1'].shape[1]-1) features = 15 numbers = 2 - 1 x = MX.sym("x", features * numbers) # Define the algebraic states as CasADi symbols # Define the control inputs as CasADi symbols u_rad_OfficesZ1 = MX.sym("u_rad_OfficesZ1") u_AHU1_noERC = MX.sym("u_AHU1_noERC") u_blinds_E = MX.sym("u_blinds_E") u_blinds_N = MX.sym("u_blinds_N") u_blinds_S = MX.sym("u_blinds_S") u_blinds_W = MX.sym("u_blinds_W") u = vertcat(u_blinds_E, u_blinds_N, u_blinds_S, u_blinds_W, u_AHU1_noERC, u_rad_OfficesZ1) # Define time-varying parameters that can chance at each step of the prediction and at each sampling time of the MPC controller. For example, future weather predictions v_IG_Offices = MX.sym("V_IG_Offices") v_Tamb = MX.sym("v_Tamb") v_solGlobFac_S = MX.sym("v_solGlobFac_S") v_solGlobFac_W = MX.sym("v_solGlobFac_W") v_solGlobFac_N = MX.sym("v_solGlobFac_N") v_solGlobFac_E = MX.sym("v_solGlobFac_E") v_windspeed = MX.sym("v_windspeed") setp_ub = MX.sym("setp_ub") setp_lb = MX.sym("setp_lb") u_ahu_ub = MX.sym("u_ahu_ub") v = vertcat(v_IG_Offices, v_Tamb, v_solGlobFac_E, v_solGlobFac_N, v_solGlobFac_S, v_solGlobFac_W, v_windspeed, u_ahu_ub, setp_ub, setp_lb) """ -------------------------------------------------------------------------- template_model: define algebraic and differential equations -------------------------------------------------------------------------- """ input = vertcat(x, u, v[0:7]) input = NP.divide(input - x_lb_NN, x_ub_NN - x_lb_NN) #(input - x_lb_NN)*float(1)/(x_ub_NN - x_lb_NN) a1 = input a1 = vertcat(1, a1) z1 = mtimes(Theta['Theta1'], a1) a2 = tanh(z1) a2 = vertcat(1, a2) z2 = mtimes(Theta['Theta2'], a2) a3 = tanh(z2) a3 = vertcat(1, a3) z3 = mtimes(Theta['Theta3'], a3) a4 = tanh(z3) a4 = vertcat(1, a4) z4 = mtimes(Theta['Theta4'], a4) a5 = tanh(z4) a5 = vertcat(1, a5) z5 = mtimes(Theta['Theta5'], a5) a6 = z5 dx1 = MX.sym("dx1") dx2 = MX.sym("dx2") dx1 = NP.multiply(a6[0], y_ub_NN[0] - y_lb_NN[0]) + y_lb_NN[0] #dx*(y_ub_NN-y_lb_NN) + y_lb_NN dx2 = NP.multiply(a6[1], y_ub_NN[1] - y_lb_NN[1]) + y_lb_NN[1] dx = vertcat(dx1, dx2, u, v[0:7]) # Concatenate differential states, algebraic states, control inputs and right-hand-sides _x = x _z = vertcat([]) _u = u _xdot = dx _zdot = vertcat([]) # _p = vertcat(alpha, beta) _p = vertcat(alpha) # _tv_p = vertcat([]) _tv_p = vertcat(v) """ -------------------------------------------------------------------------- template_model: initial condition and constraints -------------------------------------------------------------------------- """ # Initial condition for the states x0 = NP.array([18, 0, 0, 0, 0, 0, 0, 18, 141, 5, 0, 0, 0, 0, 2]) # No algebraic states z0 = NP.array([]) # Bounds on the states. Use "inf" for unconstrained states x_lb = -20000 * NP.ones(features * numbers) #x_lb_NN[0:features*numbers] x_lb[1] = 0 x_ub = 20000 * NP.ones(features * numbers) #x_ub_NN[0:features*numbers] # No algebraic states z_lb = NP.array([]) z_ub = NP.array([]) # Bounds on the control inputs. Use "inf" for unconstrained inputs u_lb = NP.array([0, 0, 0, 0, 0, 16]) u_ub = NP.array([1, 1, 1, 1, 1, 23]) u0 = NP.array([0, 0, 0, 0, 0, 21]) # Scaling factors for the states and control inputs. Important if the system is ill-conditioned x_scaling = NP.ones(features * numbers) z_scaling = NP.array([]) u_scaling = NP.array([1, 1, 1, 1, 1, 1]) # Other possibly nonlinear constraints in the form cons(x,u,p) <= cons_ub # Define the expresion of the constraint (leave it empty if not necessary) cons = vertcat(x[features * (numbers - 1)] - v[-2], -(x[features * (numbers - 1)] - v[-1])) # cons = vertcat(x[0], -x[0]) # Define the lower and upper bounds of the constraint (leave it empty if not necessary) cons_ub = NP.array([0, -0]) # Activate if the nonlinear constraints should be implemented as soft constraints soft_constraint = 1 # Penalty term to add in the cost function for the constraints (it should be the same size as cons) penalty_term_cons = NP.array([1e5, 1e5]) # Maximum violation for the constraints maximum_violation = 100 * NP.array([1, 1]) # Define the terminal constraint (leave it empty if not necessary) cons_terminal = vertcat() # Define the lower and upper bounds of the constraint (leave it empty if not necessary) cons_terminal_lb = NP.array([]) cons_terminal_ub = NP.array([]) """ -------------------------------------------------------------------------- template_model: cost function -------------------------------------------------------------------------- """ # Define the cost function # Lagrange term # Mayer term lterm = 1 * u_rad_OfficesZ1 + 0.1 * x[ 1] #+ u_AHU1_noERC # + (u_rad_OfficesZ1-18)*u_AHU1_noERC #+ u_blinds_E + u_blinds_N + u_blinds_S + u_blinds_W # - (u_AHU1_noERC-25)**2 #(5-u_rad_OfficesZ1)**2 + (5-u_rad_OfficesZ2)**2 + (0.7-u_blinds_S)**2 + (0.7-u_blinds_W)**2 + (0.7-u_blinds_N)**2 + (0.7-u_blinds_E)**2 + (0.1-u_AHU1_noERC)**2 + (0.1-u_AHU2_noERC)**2 mterm = 1 * u_rad_OfficesZ1 + 0.1 * x[ 1] #+ u_AHU1_noERC # + (u_rad_OfficesZ1-18)*u_AHU1_noERC #+ u_blinds_E + u_blinds_N + u_blinds_S + u_blinds_W #- (u_AHU1_noERC-25)**2 #(5-u_rad_OfficesZ1)**2 + (5-u_rad_OfficesZ2)**2 + (0.7-u_blinds_S)**2 + (0.7-u_blinds_W)**2 + (0.7-u_blinds_N)**2 + (0.7-u_blinds_E)**2 + (0.1-u_AHU1_noERC)**2 + (0.1-u_AHU2_noERC)**2 # Penalty term for the control movements 1e4, 100 rterm = 5e1 * NP.array([1, 1, 1, 1, 1e-1, 1e-1]) """ -------------------------------------------------------------------------- template_model: pass information (not necessary to edit) -------------------------------------------------------------------------- """ model_dict = { 'x': _x, 'u': _u, 'rhs': _xdot, 'p': _p, 'z': _z, 'aes': _zdot, 'x0': x0, 'z0': z0, 'x_lb': x_lb, 'x_ub': x_ub, 'z_lb': z_lb, 'z_ub': z_ub, 'u0': u0, 'u_lb': u_lb, 'u_ub': u_ub, 'x_scaling': x_scaling, 'z_scaling': z_scaling, 'u_scaling': u_scaling, 'cons': cons, 'tv_p': _tv_p, "cons_ub": cons_ub, 'cons_terminal': cons_terminal, 'cons_terminal_lb': cons_terminal_lb, 'cons_terminal_ub': cons_terminal_ub, 'soft_constraint': soft_constraint, 'penalty_term_cons': penalty_term_cons, 'maximum_violation': maximum_violation, 'mterm': mterm, 'lterm': lterm, 'rterm': rterm } model = core_do_mpc.model(model_dict) return model
def model(): """ -------------------------------------------------------------------------- template_model: define the non-uncertain parameters -------------------------------------------------------------------------- """ mu_m = 0.02 K_m = 0.05 K_i = 5.0 v_par = 0.004 Y_p = 1.2 """ -------------------------------------------------------------------------- template_model: define uncertain parameters, states and controls as symbols -------------------------------------------------------------------------- """ # Define the uncertainties as CasADi symbols Y_x = SX.sym("Y_x") S_in = SX.sym("S_in") # Define the differential states as CasADi symbols X_s = SX.sym("X_s") # Concentration A S_s = SX.sym("S_s") # Concentration B P_s = SX.sym("P_s") # Reactor Temprature V_s = SX.sym("V_s") # Jacket Temprature # Define the algebraic states as CasADi symbols # Define the control inputs as CasADi symbols inp = SX.sym("inp") # Vdot/V_R [h^-1] # Define time-varying parameters that can change at each step of the prediction and at each sampling time of the MPC controller. For example, future weather predictions tv_param_1 = SX.sym("tv_param_1") tv_param_2 = SX.sym("tv_param_2") """ -------------------------------------------------------------------------- template_model: define algebraic and differential equations -------------------------------------------------------------------------- """ # Define the algebraic equations mu_S = mu_m*S_s/(K_m+S_s+(S_s**2/K_i)) # Define the differential equations dX_s = mu_S*X_s - inp/V_s*X_s dS_s = -mu_S*X_s/Y_x - v_par*X_s/Y_p + inp/V_s*(S_in-S_s) dP_s = v_par*X_s - inp/V_s*P_s dV_s = inp # Concatenate differential states, algebraic states, control inputs and right-hand-sides _x = vertcat(X_s, S_s, P_s, V_s) _u = vertcat(inp) _xdot = vertcat(dX_s, dS_s, dP_s, dV_s) _p = vertcat(Y_x, S_in) _z = [] _tv_p = vertcat(tv_param_1, tv_param_2) """ -------------------------------------------------------------------------- template_model: initial condition and constraints -------------------------------------------------------------------------- """ # Initial condition for the states X_s_0 = 1.0 S_s_0 = 0.5 P_s_0 = 0.0 V_s_0 = 120.0 x0 = NP.array([X_s_0, S_s_0, P_s_0, V_s_0]) # Bounds on the states. Use "inf" for unconstrained states X_s_lb = 0.0; X_s_ub = 3.7 S_s_lb = -0.01; S_s_ub = inf P_s_lb = 0.0; P_s_ub = 3.0 V_s_lb = 0.0; V_s_ub = inf x_lb = NP.array([X_s_lb, S_s_lb, P_s_lb, V_s_lb]) x_ub = NP.array([X_s_ub, S_s_ub, P_s_ub, V_s_ub]) # Bounds on the control inputs. Use "inf" for unconstrained inputs inp_lb = 0.0; inp_ub = 0.2; u_lb = NP.array([inp_lb]) u_ub = NP.array([inp_ub]) u0 = NP.array([0.03]) # Scaling factors for the states and control inputs. Important if the system is ill-conditioned x_scaling = NP.array([1.0, 1.0, 1.0, 1.0]) u_scaling = NP.array([1.0]) # Other possibly nonlinear constraints in the form cons(x,u,p) <= cons_ub # Define the expresion of the constraint (leave it empty if not necessary) cons = vertcat([]) # Define the upper bounds of the constraint (leave it empty if not necessary) cons_ub = NP.array([]) # Activate if the nonlinear constraints should be implemented as soft constraints soft_constraint = 0 # l1 - Penalty term to add in the cost function for the constraints (it should be the same size as cons) penalty_term_cons = NP.array([1e4]) # Maximum violation for the upper and lower bounds maximum_violation = NP.array([10]) # Define the terminal constraint (leave it empty if not necessary) cons_terminal = vertcat([]) # Define the lower and upper bounds of the constraint (leave it empty if not necessary) cons_terminal_lb = NP.array([]) cons_terminal_ub = NP.array([]) """ -------------------------------------------------------------------------- template_model: cost function -------------------------------------------------------------------------- """ # Define the cost function # Lagrange term lterm = -P_s #lterm = - C_b # Mayer term mterm = -P_s #mterm = - C_b # Penalty term for the control movements rterm = NP.array([0.0]) """ -------------------------------------------------------------------------- template_model: pass information (not necessary to edit) -------------------------------------------------------------------------- """ model_dict = {'x':_x,'u': _u, 'rhs':_xdot,'p': _p, 'z':_z,'x0': x0,'x_lb': x_lb,'x_ub': x_ub, 'u0':u0, 'u_lb':u_lb, 'u_ub':u_ub, 'x_scaling':x_scaling, 'u_scaling':u_scaling, 'cons':cons, "cons_ub": cons_ub, 'cons_terminal':cons_terminal, 'cons_terminal_lb': cons_terminal_lb,'tv_p':_tv_p, 'cons_terminal_ub':cons_terminal_ub, 'soft_constraint': soft_constraint, 'penalty_term_cons': penalty_term_cons, 'maximum_violation': maximum_violation, 'mterm': mterm,'lterm':lterm, 'rterm':rterm} model = core_do_mpc.model(model_dict) return model