def run_demo(with_plots=True): """ An example on how to simulate a model using the DAE simulator. The result can be compared with that of sim_rlc.py which has solved the same problem using dymola. Also writes information to a file. """ curr_dir = os.path.dirname(os.path.abspath(__file__)) model_name = "RLC_Circuit" mofile = curr_dir + "/files/RLC_Circuit.mo" jmu_name = compile_jmu(model_name, mofile) model = JMUModel(jmu_name) init_res = model.initialize() (E_dae, A_dae, B_dae, F_dae, g_dae, state_names, input_names, algebraic_names, dx0, x0, u0, w0, t0) = linearize_dae( init_res.model ) (A_ode, B_ode, g_ode, H_ode, M_ode, q_ode) = linear_dae_to_ode(E_dae, A_dae, B_dae, F_dae, g_dae) res1 = model.simulate() jmu_name = compile_jmu("RLC_Circuit_Linearized", mofile) lin_model = JMUModel(jmu_name) res2 = lin_model.simulate() c_v_1 = res1["capacitor.v"] i_p_i_1 = res1["inductor.p.i"] i_p1_i_1 = res1["inductor1.p.i"] t_1 = res1["time"] c_v_2 = res2["x[1]"] i_p_i_2 = res2["x[2]"] i_p1_i_2 = res2["x[3]"] t_2 = res2["time"] assert N.abs(res1.final("capacitor.v") - res2.final("x[1]")) < 1e-3 if with_plots: p.figure(1) p.hold(True) p.subplot(311) p.plot(t_1, c_v_1) p.plot(t_2, c_v_2, "g") p.ylabel("c.v") p.legend(("original model", "linearized ODE")) p.grid() p.subplot(312) p.plot(t_1, i_p_i_1) p.plot(t_2, i_p_i_2, "g") p.ylabel("i.p.i") p.grid() p.subplot(313) p.plot(t_1, i_p1_i_1) p.plot(t_2, i_p1_i_2, "g") p.ylabel("i.p1.i") p.grid() p.show()
def run_demo(with_plots=True): """ Demonstrate how to solve and calculate sensitivity for initial conditions. See "http://sundials.2283335.n4.nabble.com/Forward-sensitivities-for- \ initial-conditions-td3239724.html" """ curr_dir = os.path.dirname(os.path.abspath(__file__)); jmu_name = compile_jmu("LeadTransport", curr_dir+"/files/leadtransport.mop") model = JMUModel(jmu_name) opts = model.simulate_options() opts["IDA_options"]["sensitivity"] = True opts["IDA_options"]["rtol"] = 1e-7 opts["IDA_options"]["suppress_sens"] = False #Use the sensitivity variablers #in the error test. res = model.simulate(final_time=400, options=opts) # Extract variable profiles y1,y2,y3 = res['y1'], res["y2"], res["y3"] dy1p1,dy2p1,dy3p1 = res['dy1/dp1'], res['dy2/dp1'], res['dy3/dp1'] dy1p2,dy2p2,dy3p2 = res['dy1/dp2'], res['dy2/dp2'], res['dy3/dp2'] dy1p3,dy2p3,dy3p3 = res['dy1/dp3'], res['dy2/dp3'], res['dy3/dp3'] t=res['time'] assert N.abs(res.initial('dy1/dp1') - 1.000) < 1e-3 assert N.abs(res.initial('dy1/dp2') - 1.000) < 1e-3 assert N.abs(res.initial('dy2/dp2') - 1.000) < 1e-3 if with_plots: # Plot plt.figure(1) plt.clf() plt.subplot(221) plt.plot(t,y1,t,y2,t,y3) plt.grid() plt.legend(("y1","y2","y3")) plt.subplot(222) plt.plot(t,dy1p1,t,dy2p1,t,dy3p1) plt.grid() plt.legend(("dy1/dp1","dy2/dp1","dy3/dp1")) plt.subplot(223) plt.plot(t,dy1p2,t,dy2p2,t,dy3p2) plt.grid() plt.legend(("dy1/dp2","dy2/dp2","dy3/dp2")) plt.subplot(224) plt.plot(t,dy1p3,t,dy2p3,t,dy3p3) plt.grid() plt.legend(("dy1/dp3","dy2/dp3","dy3/dp3")) plt.suptitle("Lead transport through the body") plt.show()
def run_simulation_with_inputs(time, price, pv, bldg, plot = False): """ This function runs a simulation that uses inputs data series """ # get current directory curr_dir = os.path.dirname(os.path.abspath(__file__)); # compile FMU path = os.path.join(curr_dir,"..","Models","ElectricalNetwork.mop") jmu_model = compile_jmu('ElectricNetwork.Network', path) # Load the model instance into Python model = JMUModel(jmu_model) # create input data series for price and current battery Npoints = len(time) # for the simulation no current flow Ibatt = np.zeros(Npoints) # Build input trajectory matrix for use in simulation u = np.transpose(np.vstack((t_data, Ibatt, price, np.squeeze(pv[:,0]), np.squeeze(pv[:,1]), \ np.squeeze(pv[:,2]), np.squeeze(bldg[:,0]), np.squeeze(bldg[:,1]), np.squeeze(bldg[:,2])))) # Solve the DAE initialization system model.initialize() # Simulate res = model.simulate(input=(['Ibatt', 'price', 'pv1', 'pv2', 'pv3', 'bldg1', 'bldg2', 'bldg3'], u), start_time=0., final_time=24.0*3600.0) # Extract variable profiles Vs_init_sim = res['Vs'] V1_init_sim = res['V1'] V2_init_sim = res['V2'] V3_init_sim = res['V3'] E_init_sim = res['E'] SOC_init_sim = res['SOC'] Money_init_sim = res['Money'] price_init_sim = res['price'] t_init_sim = res['time'] # plot results if plot: plotFunction(t_init_sim, Vs_init_sim, V1_init_sim, V2_init_sim, \ V3_init_sim, E_init_sim, SOC_init_sim, Money_init_sim, price_init_sim) return res
def run_simulation_with_inputs(time, price, pv, bldg, plot = False, usePV = True): """ This function runs a simulation that uses inputs data series """ # get current directory curr_dir = os.path.dirname(os.path.abspath(__file__)); # compile FMU path = os.path.join(curr_dir,"..","Models","ElectricalNetwork.mop") jmu_model = compile_jmu('ElectricNetwork.ACnetwork', path) # Load the model instance into Python model = JMUModel(jmu_model) # create input data series for price and current battery Npoints = len(time) # for the simulation no power flow in the battery P = np.zeros(Npoints) Q = np.zeros(Npoints) # if pv panels are not used then remove power if usePV == False: pv = np.zeros(np.shape(pv)) # Build input trajectory matrix for use in simulation u = np.transpose(np.vstack((t_data, P, Q, price, -np.squeeze(bldg[:,0]), -np.squeeze(bldg[:,1]), -np.squeeze(bldg[:,2]), \ np.squeeze(pv[:,0]), np.squeeze(pv[:,1]), np.squeeze(pv[:,2])))) # Solve the DAE initialization system model.initialize() # Simulate res = model.simulate(input=(['P_batt', 'Q_batt', 'price', 'P_bldg1', 'P_bldg2', 'P_bldg3', 'P_pv1', 'P_pv2', 'P_pv3'], u), start_time=0., final_time=24.0*3600.0) # Extract variable profiles if plot: plotFunction(res) return res
def run_simulation(plot = False): """ This function runs a simple simulation without input data """ # get current directory curr_dir = os.path.dirname(os.path.abspath(__file__)); # compile FMU path = os.path.join(curr_dir,"..","Models","ElectricalNetwork.mop") jmu_model = compile_jmu('ElectricNetwork.NetworkSim', path) # Load the model instance into Python model = JMUModel(jmu_model) # Solve the DAE initialization system model.initialize() # Simulate res = model.simulate(start_time=0., final_time=24.0*3600.0) # Extract variable profiles Vs_init_sim = res['n.Vs'] V1_init_sim = res['n.V1'] V2_init_sim = res['n.V2'] V3_init_sim = res['n.V3'] E_init_sim = res['n.E'] SOC_init_sim = res['n.SOC'] Money_init_sim = res['n.Money'] price_init_sim = res['n.price'] t_init_sim = res['time'] # plot results if plot: plotFunction(t_init_sim, Vs_init_sim, V1_init_sim, V2_init_sim, \ V3_init_sim, E_init_sim, SOC_init_sim, Money_init_sim, price_init_sim)
def run_demo(with_plots=True): """ This example is based on the Hicks-Ray Continuously Stirred Tank Reactors (CSTR) system. The system has two states, the concentration and the temperature. The control input to the system is the temperature of the cooling flow in the reactor jacket. The chemical reaction in the reactor is exothermic, and also temperature dependent; high temperature results in high reaction rate. The example demonstrates the following steps: 1. How to solve a DAE initialization problem. The initialization model have equations specifying that all derivatives should be identically zero, which implies that a stationary solution is obtained. Two stationary points, corresponding to different inputs, are computed. We call the stationary points A and B respectively. point A corresponds to operating conditions where the reactor is cold and the reaction rate is low, whereas point B corresponds to a higher temperature where the reaction rate is high. For more information about the DAE initialization algorithm, see http://www.jmodelica.org/page/10. 2. How to generate an initial guess for a direct collocation method by means of simulation. The trajectories resulting from simulation are used to initialize the variables in the transcribed NLP. 3. An optimal control problem is solved where the objective Is to transfer the state of the system from stationary point A to point B. The challenge is to ignite the reactor while avoiding uncontrolled temperature increase. It is also demonstrated how to set parameter and variable values in a model. More information about the simultaneous optimization algorithm can be found at http://www.jmodelica.org/page/10. 4. The optimization result is saved to file and then the important variables are plotted. 5. Simulate the system with the optimal control profile. This step is important in order to verify that the approximation in the transcription step is valid. """ curr_dir = os.path.dirname(os.path.abspath(__file__)); # Compile the stationary initialization model into a JMU jmu_name = compile_jmu("CSTR.CSTR_Init", os.path.join(curr_dir,"files", "CSTR.mop"), compiler_options={"enable_variable_scaling":True}) # load the JMU init_model = JMUModel(jmu_name) # Set inputs for Stationary point A Tc_0_A = 250 init_model.set('Tc',Tc_0_A) # Solve the DAE initialization system with Ipopt init_result = init_model.initialize() # Store stationary point A c_0_A = init_result['c'][0] T_0_A = init_result['T'][0] # Print some data for stationary point A print(' *** Stationary point A ***') print('Tc = %f' % Tc_0_A) print('c = %f' % c_0_A) print('T = %f' % T_0_A) # Set inputs for Stationary point B Tc_0_B = 280 init_model.set('Tc',Tc_0_B) # Solve the DAE initialization system with Ipopt init_result = init_model.initialize() # Store stationary point B c_0_B = init_result['c'][0] T_0_B = init_result['T'][0] # Print some data for stationary point B print(' *** Stationary point B ***') print('Tc = %f' % Tc_0_B) print('c = %f' % c_0_B) print('T = %f' % T_0_B) # Compute initial guess trajectories by means of simulation # Compile the optimization initialization model jmu_name = compile_jmu("CSTR.CSTR_Init_Optimization", os.path.join(curr_dir, "files", "CSTR.mop")) # Load the model init_sim_model = JMUModel(jmu_name) # Set model parameters init_sim_model.set('cstr.c_init',c_0_A) init_sim_model.set('cstr.T_init',T_0_A) init_sim_model.set('c_ref',c_0_B) init_sim_model.set('T_ref',T_0_B) init_sim_model.set('Tc_ref',Tc_0_B) res = init_sim_model.simulate(start_time=0.,final_time=150.) # Extract variable profiles c_init_sim=res['cstr.c'] T_init_sim=res['cstr.T'] Tc_init_sim=res['cstr.Tc'] t_init_sim = res['time'] # Plot the results if with_plots: plt.figure(1) plt.clf() plt.hold(True) plt.subplot(311) plt.plot(t_init_sim,c_init_sim) plt.grid() plt.ylabel('Concentration') plt.subplot(312) plt.plot(t_init_sim,T_init_sim) plt.grid() plt.ylabel('Temperature') plt.subplot(313) plt.plot(t_init_sim,Tc_init_sim) plt.grid() plt.ylabel('Cooling temperature') plt.xlabel('time') plt.show() # Solve the optimal control problem # Compile model jmu_name = compile_jmu("CSTR.CSTR_Opt", curr_dir+"/files/CSTR.mop") # Load model cstr = JMUModel(jmu_name) # Set reference values cstr.set('Tc_ref',Tc_0_B) cstr.set('c_ref',c_0_B) cstr.set('T_ref',T_0_B) # Set initial values cstr.set('cstr.c_init',c_0_A) cstr.set('cstr.T_init',T_0_A) n_e = 100 # Number of elements # Set options opt_opts = cstr.optimize_options() opt_opts['n_e'] = n_e opt_opts['init_traj'] = res.result_data res = cstr.optimize(options=opt_opts) # Extract variable profiles c_res=res['cstr.c'] T_res=res['cstr.T'] Tc_res=res['cstr.Tc'] time_res = res['time'] c_ref=res['c_ref'] T_ref=res['T_ref'] Tc_ref=res['Tc_ref'] assert N.abs(res.final('cost')/1.e7 - 1.8585429) < 1e-3 # Plot the results if with_plots: plt.figure(2) plt.clf() plt.hold(True) plt.subplot(311) plt.plot(time_res,c_res) plt.plot([time_res[0],time_res[-1]],[c_ref,c_ref],'--') plt.grid() plt.ylabel('Concentration') plt.subplot(312) plt.plot(time_res,T_res) plt.plot([time_res[0],time_res[-1]],[T_ref,T_ref],'--') plt.grid() plt.ylabel('Temperature') plt.subplot(313) plt.plot(time_res,Tc_res) plt.plot([time_res[0],time_res[-1]],[Tc_ref,Tc_ref],'--') plt.grid() plt.ylabel('Cooling temperature') plt.xlabel('time') plt.show() # Simulate to verify the optimal solution # Set up the input trajectory t = time_res u = Tc_res u_traj = N.transpose(N.vstack((t,u))) # Compile the Modelica model to a JMU jmu_name = compile_jmu("CSTR.CSTR", curr_dir+"/files/CSTR.mop") # Load model sim_model = JMUModel(jmu_name) sim_model.set('c_init',c_0_A) sim_model.set('T_init',T_0_A) sim_model.set('Tc',u[0]) res = sim_model.simulate(start_time=0.,final_time=150., input=('Tc',u_traj)) # Extract variable profiles c_sim=res['c'] T_sim=res['T'] Tc_sim=res['Tc'] time_sim = res['time'] # Plot the results if with_plots: plt.figure(3) plt.clf() plt.hold(True) plt.subplot(311) plt.plot(time_res,c_res,'--') plt.plot(time_sim,c_sim) plt.legend(('optimized','simulated')) plt.grid() plt.ylabel('Concentration') plt.subplot(312) plt.plot(time_res,T_res,'--') plt.plot(time_sim,T_sim) plt.legend(('optimized','simulated')) plt.grid() plt.ylabel('Temperature') plt.subplot(313) plt.plot(time_res,Tc_res,'--') plt.plot(time_sim,Tc_sim) plt.legend(('optimized','simulated')) plt.grid() plt.ylabel('Cooling temperature') plt.xlabel('time') plt.show()
def run_demo(with_plots=True): """ This example demonstrates how to solve parameter estimation problmes. The data used in the example was recorded by Kristian Soltesz at the Department of Automatic Control. """ curr_dir = os.path.dirname(os.path.abspath(__file__)); # Load measurement data from file data = loadmat(curr_dir+'/files/qt_par_est_data.mat',appendmat=False) # Extract data series t_meas = data['t'][6000::100,0]-60 y1_meas = data['y1_f'][6000::100,0]/100 y2_meas = data['y2_f'][6000::100,0]/100 y3_meas = data['y3_d'][6000::100,0]/100 y4_meas = data['y4_d'][6000::100,0]/100 u1 = data['u1_d'][6000::100,0] u2 = data['u2_d'][6000::100,0] # Plot measurements and inputs if with_plots: plt.figure(1) plt.clf() plt.subplot(2,2,1) plt.plot(t_meas,y3_meas) plt.title('x3') plt.grid() plt.subplot(2,2,2) plt.plot(t_meas,y4_meas) plt.title('x4') plt.grid() plt.subplot(2,2,3) plt.plot(t_meas,y1_meas) plt.title('x1') plt.xlabel('t[s]') plt.grid() plt.subplot(2,2,4) plt.plot(t_meas,y2_meas) plt.title('x2') plt.xlabel('t[s]') plt.grid() plt.figure(2) plt.clf() plt.subplot(2,1,1) plt.plot(t_meas,u1) plt.hold(True) plt.title('u1') plt.grid() plt.subplot(2,1,2) plt.plot(t_meas,u2) plt.title('u2') plt.xlabel('t[s]') plt.hold(True) plt.grid() # Build input trajectory matrix for use in simulation u = N.transpose(N.vstack((t_meas,u1,u2))) # compile FMU fmu_name = compile_fmu('QuadTankPack.Sim_QuadTank', curr_dir+'/files/QuadTankPack.mop') # Load model model = load_fmu(fmu_name) # Simulate model response with nominal parameters res = model.simulate(input=(['u1','u2'],u),start_time=0.,final_time=60) # Load simulation result x1_sim = res['qt.x1'] x2_sim = res['qt.x2'] x3_sim = res['qt.x3'] x4_sim = res['qt.x4'] t_sim = res['time'] u1_sim = res['u1'] u2_sim = res['u2'] # Plot simulation result if with_plots: plt.figure(1) plt.subplot(2,2,1) plt.plot(t_sim,x3_sim) plt.subplot(2,2,2) plt.plot(t_sim,x4_sim) plt.subplot(2,2,3) plt.plot(t_sim,x1_sim) plt.subplot(2,2,4) plt.plot(t_sim,x2_sim) plt.figure(2) plt.subplot(2,1,1) plt.plot(t_sim,u1_sim,'r') plt.subplot(2,1,2) plt.plot(t_sim,u2_sim,'r') # Compile parameter optimization model jmu_name = compile_jmu("QuadTankPack.QuadTank_ParEst", curr_dir+"/files/QuadTankPack.mop") # Load the model qt_par_est = JMUModel(jmu_name) # Number of measurement points N_meas = N.size(u1,0) # Set measurement data into model for i in range(0,N_meas): qt_par_est.set("t_meas["+`i+1`+"]",t_meas[i]) qt_par_est.set("y1_meas["+`i+1`+"]",y1_meas[i]) qt_par_est.set("y2_meas["+`i+1`+"]",y2_meas[i]) n_e = 30 # Numer of element in collocation algorithm # Get an options object for the optimization algorithm opt_opts = qt_par_est.optimize_options() # Set the number of collocation points opt_opts['n_e'] = n_e opt_opts['init_traj'] = res.result_data # Solve parameter optimization problem res = qt_par_est.optimize(options=opt_opts) # Extract optimal values of parameters a1_opt = res.final("qt.a1") a2_opt = res.final("qt.a2") # Print optimal parameter values print('a1: ' + str(a1_opt*1e4) + 'cm^2') print('a2: ' + str(a2_opt*1e4) + 'cm^2') assert N.abs(a1_opt*1.e6 - 2.6574) < 1e-3 assert N.abs(a2_opt*1.e6 - 2.7130) < 1e-3 # Load state profiles x1_opt = res["qt.x1"] x2_opt = res["qt.x2"] x3_opt = res["qt.x3"] x4_opt = res["qt.x4"] u1_opt = res["qt.u1"] u2_opt = res["qt.u2"] t_opt = res["time"] # Plot if with_plots: plt.figure(1) plt.subplot(2,2,1) plt.plot(t_opt,x3_opt,'k') plt.subplot(2,2,2) plt.plot(t_opt,x4_opt,'k') plt.subplot(2,2,3) plt.plot(t_opt,x1_opt,'k') plt.subplot(2,2,4) plt.plot(t_opt,x2_opt,'k') # Compile second parameter estimation model jmu_name = compile_jmu("QuadTankPack.QuadTank_ParEst2", curr_dir+"/files/QuadTankPack.mop") # Load model qt_par_est2 = JMUModel(jmu_name) # Number of measurement points N_meas = N.size(u1,0) # Set measurement data into model for i in range(0,N_meas): qt_par_est2.set("t_meas["+`i+1`+"]",t_meas[i]) qt_par_est2.set("y1_meas["+`i+1`+"]",y1_meas[i]) qt_par_est2.set("y2_meas["+`i+1`+"]",y2_meas[i]) qt_par_est2.set("y3_meas["+`i+1`+"]",y3_meas[i]) qt_par_est2.set("y4_meas["+`i+1`+"]",y4_meas[i]) # Solve parameter estimation problem res_opt2 = qt_par_est2.optimize(options=opt_opts) # Get optimal parameter values a1_opt2 = res_opt2.final("qt.a1") a2_opt2 = res_opt2.final("qt.a2") a3_opt2 = res_opt2.final("qt.a3") a4_opt2 = res_opt2.final("qt.a4") # Print optimal parameter values print('a1:' + str(a1_opt2*1e4) + 'cm^2') print('a2:' + str(a2_opt2*1e4) + 'cm^2') print('a3:' + str(a3_opt2*1e4) + 'cm^2') print('a4:' + str(a4_opt2*1e4) + 'cm^2') assert N.abs(a1_opt2*1.e6 - 2.6579) < 1e-3, "Wrong value of parameter a1" assert N.abs(a2_opt2*1.e6 - 2.7038) < 1e-3, "Wrong value of parameter a2" assert N.abs(a3_opt2*1.e6 - 3.0031) < 1e-3, "Wrong value of parameter a3" assert N.abs(a4_opt2*1.e6 - 2.9342) < 1e-3, "Wrong value of parameter a4" # Extract state and input profiles x1_opt2 = res_opt2["qt.x1"] x2_opt2 = res_opt2["qt.x2"] x3_opt2 = res_opt2["qt.x3"] x4_opt2 = res_opt2["qt.x4"] u1_opt2 = res_opt2["qt.u1"] u2_opt2 = res_opt2["qt.u2"] t_opt2 = res_opt2["time"] # Plot if with_plots: plt.figure(1) plt.subplot(2,2,1) plt.plot(t_opt2,x3_opt2,'r') plt.subplot(2,2,2) plt.plot(t_opt2,x4_opt2,'r') plt.subplot(2,2,3) plt.plot(t_opt2,x1_opt2,'r') plt.subplot(2,2,4) plt.plot(t_opt2,x2_opt2,'r') plt.show() # Compute parameter standard deviations for case 1 # compile JMU jmu_name = compile_jmu('QuadTankPack.QuadTank_Sens1', curr_dir+'/files/QuadTankPack.mop') # Load model model = JMUModel(jmu_name) model.set('a1',a1_opt) model.set('a2',a2_opt) sens_opts = model.simulate_options() # Enable sensitivity computations sens_opts['IDA_options']['sensitivity'] = True #sens_opts['IDA_options']['atol'] = 1e-12 # Simulate sensitivity equations sens_res = model.simulate(input=(['u1','u2'],u),start_time=0.,final_time=60, options = sens_opts) # Get result trajectories x1_sens = sens_res['x1'] x2_sens = sens_res['x2'] dx1da1 = sens_res['dx1/da1'] dx1da2 = sens_res['dx1/da2'] dx2da1 = sens_res['dx2/da1'] dx2da2 = sens_res['dx2/da2'] t_sens = sens_res['time'] # Compute Jacobian # Create a trajectory object for interpolation traj=TrajectoryLinearInterpolation(t_sens,N.transpose(N.vstack((x1_sens,x2_sens,dx1da1,dx1da2,dx2da1,dx2da2)))) # Jacobian jac = N.zeros((61*2,2)) # Error vector err = N.zeros(61*2) # Extract Jacobian and error information i = 0 for t_p in t_meas: vals = traj.eval(t_p) for j in range(2): for k in range(2): jac[i+j,k] = vals[0,2*j+k+2] err[i] = vals[0,0] - y1_meas[i/2] err[i+1] = vals[0,1] - y2_meas[i/2] i = i + 2 # Compute estimated variance of measurement noice v_err = N.sum(err**2)/(61*2-2) # Compute J^T*J A = N.dot(N.transpose(jac),jac) # Compute parameter covariance matrix P = v_err*N.linalg.inv(A) # Compute standard deviations for parameters sigma_a1 = N.sqrt(P[0,0]) sigma_a2 = N.sqrt(P[1,1]) print "a1: " + str(sens_res['a1']) + ", standard deviation: " + str(sigma_a1) print "a2: " + str(sens_res['a2']) + ", standard deviation: " + str(sigma_a2) # Compute parameter standard deviations for case 2 # compile JMU jmu_name = compile_jmu('QuadTankPack.QuadTank_Sens2', curr_dir+'/files/QuadTankPack.mop') # Load model model = JMUModel(jmu_name) model.set('a1',a1_opt2) model.set('a2',a2_opt2) model.set('a3',a3_opt2) model.set('a4',a4_opt2) sens_opts = model.simulate_options() # Enable sensitivity computations sens_opts['IDA_options']['sensitivity'] = True #sens_opts['IDA_options']['atol'] = 1e-12 # Simulate sensitivity equations sens_res = model.simulate(input=(['u1','u2'],u),start_time=0.,final_time=60, options = sens_opts) # Get result trajectories x1_sens = sens_res['x1'] x2_sens = sens_res['x2'] x3_sens = sens_res['x3'] x4_sens = sens_res['x4'] dx1da1 = sens_res['dx1/da1'] dx1da2 = sens_res['dx1/da2'] dx1da3 = sens_res['dx1/da3'] dx1da4 = sens_res['dx1/da4'] dx2da1 = sens_res['dx2/da1'] dx2da2 = sens_res['dx2/da2'] dx2da3 = sens_res['dx2/da3'] dx2da4 = sens_res['dx2/da4'] dx3da1 = sens_res['dx3/da1'] dx3da2 = sens_res['dx3/da2'] dx3da3 = sens_res['dx3/da3'] dx3da4 = sens_res['dx3/da4'] dx4da1 = sens_res['dx4/da1'] dx4da2 = sens_res['dx4/da2'] dx4da3 = sens_res['dx4/da3'] dx4da4 = sens_res['dx4/da4'] t_sens = sens_res['time'] # Compute Jacobian # Create a trajectory object for interpolation traj=TrajectoryLinearInterpolation(t_sens,N.transpose(N.vstack((x1_sens,x2_sens,x3_sens,x4_sens, dx1da1,dx1da2,dx1da3,dx1da4, dx2da1,dx2da2,dx2da3,dx2da4, dx3da1,dx3da2,dx3da3,dx3da4, dx4da1,dx4da2,dx4da3,dx4da4)))) # Jacobian jac = N.zeros((61*4,4)) # Error vector err = N.zeros(61*4) # Extract Jacobian and error information i = 0 for t_p in t_meas: vals = traj.eval(t_p) for j in range(4): for k in range(4): jac[i+j,k] = vals[0,4*j+k+4] err[i] = vals[0,0] - y1_meas[i/4] err[i+1] = vals[0,1] - y2_meas[i/4] err[i+2] = vals[0,2] - y3_meas[i/4] err[i+3] = vals[0,3] - y4_meas[i/4] i = i + 4 # Compute estimated variance of measurement noice v_err = N.sum(err**2)/(61*4-4) # Compute J^T*J A = N.dot(N.transpose(jac),jac) # Compute parameter covariance matrix P = v_err*N.linalg.inv(A) # Compute standard deviations for parameters sigma_a1 = N.sqrt(P[0,0]) sigma_a2 = N.sqrt(P[1,1]) sigma_a3 = N.sqrt(P[2,2]) sigma_a4 = N.sqrt(P[3,3]) print "a1: " + str(sens_res['a1']) + ", standard deviation: " + str(sigma_a1) print "a2: " + str(sens_res['a2']) + ", standard deviation: " + str(sigma_a2) print "a3: " + str(sens_res['a3']) + ", standard deviation: " + str(sigma_a3) print "a4: " + str(sens_res['a4']) + ", standard deviation: " + str(sigma_a4)
def run_demo(with_plots=True): """ This example demonstrates how to solve parameter estimation problmes. The data used in the example was recorded by Kristian Soltesz at the Department of Automatic Control. """ curr_dir = os.path.dirname(os.path.abspath(__file__)) # Load measurement data from file data = loadmat(curr_dir + '/files/qt_par_est_data.mat', appendmat=False) # Extract data series t_meas = data['t'][6000::100, 0] - 60 y1_meas = data['y1_f'][6000::100, 0] / 100 y2_meas = data['y2_f'][6000::100, 0] / 100 y3_meas = data['y3_d'][6000::100, 0] / 100 y4_meas = data['y4_d'][6000::100, 0] / 100 u1 = data['u1_d'][6000::100, 0] u2 = data['u2_d'][6000::100, 0] # Plot measurements and inputs if with_plots: plt.figure(1) plt.clf() plt.subplot(2, 2, 1) plt.plot(t_meas, y3_meas) plt.title('x3') plt.grid() plt.subplot(2, 2, 2) plt.plot(t_meas, y4_meas) plt.title('x4') plt.grid() plt.subplot(2, 2, 3) plt.plot(t_meas, y1_meas) plt.title('x1') plt.xlabel('t[s]') plt.grid() plt.subplot(2, 2, 4) plt.plot(t_meas, y2_meas) plt.title('x2') plt.xlabel('t[s]') plt.grid() plt.figure(2) plt.clf() plt.subplot(2, 1, 1) plt.plot(t_meas, u1) plt.hold(True) plt.title('u1') plt.grid() plt.subplot(2, 1, 2) plt.plot(t_meas, u2) plt.title('u2') plt.xlabel('t[s]') plt.hold(True) plt.grid() # Build input trajectory matrix for use in simulation u = N.transpose(N.vstack((t_meas, u1, u2))) # compile FMU fmu_name = compile_fmu('QuadTankPack.Sim_QuadTank', curr_dir + '/files/QuadTankPack.mop') # Load model model = load_fmu(fmu_name) # Simulate model response with nominal parameters res = model.simulate(input=(['u1', 'u2'], u), start_time=0., final_time=60) # Load simulation result x1_sim = res['qt.x1'] x2_sim = res['qt.x2'] x3_sim = res['qt.x3'] x4_sim = res['qt.x4'] t_sim = res['time'] u1_sim = res['u1'] u2_sim = res['u2'] # Plot simulation result if with_plots: plt.figure(1) plt.subplot(2, 2, 1) plt.plot(t_sim, x3_sim) plt.subplot(2, 2, 2) plt.plot(t_sim, x4_sim) plt.subplot(2, 2, 3) plt.plot(t_sim, x1_sim) plt.subplot(2, 2, 4) plt.plot(t_sim, x2_sim) plt.figure(2) plt.subplot(2, 1, 1) plt.plot(t_sim, u1_sim, 'r') plt.subplot(2, 1, 2) plt.plot(t_sim, u2_sim, 'r') # Compile parameter optimization model jmu_name = compile_jmu("QuadTankPack.QuadTank_ParEst", curr_dir + "/files/QuadTankPack.mop") # Load the model qt_par_est = JMUModel(jmu_name) # Number of measurement points N_meas = N.size(u1, 0) # Set measurement data into model for i in range(0, N_meas): qt_par_est.set("t_meas[" + ` i + 1 ` + "]", t_meas[i]) qt_par_est.set("y1_meas[" + ` i + 1 ` + "]", y1_meas[i]) qt_par_est.set("y2_meas[" + ` i + 1 ` + "]", y2_meas[i]) n_e = 30 # Numer of element in collocation algorithm # Get an options object for the optimization algorithm opt_opts = qt_par_est.optimize_options() # Set the number of collocation points opt_opts['n_e'] = n_e opt_opts['init_traj'] = res.result_data # Solve parameter optimization problem res = qt_par_est.optimize(options=opt_opts) # Extract optimal values of parameters a1_opt = res.final("qt.a1") a2_opt = res.final("qt.a2") # Print optimal parameter values print('a1: ' + str(a1_opt * 1e4) + 'cm^2') print('a2: ' + str(a2_opt * 1e4) + 'cm^2') assert N.abs(a1_opt * 1.e6 - 2.6574) < 1e-3 assert N.abs(a2_opt * 1.e6 - 2.7130) < 1e-3 # Load state profiles x1_opt = res["qt.x1"] x2_opt = res["qt.x2"] x3_opt = res["qt.x3"] x4_opt = res["qt.x4"] u1_opt = res["qt.u1"] u2_opt = res["qt.u2"] t_opt = res["time"] # Plot if with_plots: plt.figure(1) plt.subplot(2, 2, 1) plt.plot(t_opt, x3_opt, 'k') plt.subplot(2, 2, 2) plt.plot(t_opt, x4_opt, 'k') plt.subplot(2, 2, 3) plt.plot(t_opt, x1_opt, 'k') plt.subplot(2, 2, 4) plt.plot(t_opt, x2_opt, 'k') # Compile second parameter estimation model jmu_name = compile_jmu("QuadTankPack.QuadTank_ParEst2", curr_dir + "/files/QuadTankPack.mop") # Load model qt_par_est2 = JMUModel(jmu_name) # Number of measurement points N_meas = N.size(u1, 0) # Set measurement data into model for i in range(0, N_meas): qt_par_est2.set("t_meas[" + ` i + 1 ` + "]", t_meas[i]) qt_par_est2.set("y1_meas[" + ` i + 1 ` + "]", y1_meas[i]) qt_par_est2.set("y2_meas[" + ` i + 1 ` + "]", y2_meas[i]) qt_par_est2.set("y3_meas[" + ` i + 1 ` + "]", y3_meas[i]) qt_par_est2.set("y4_meas[" + ` i + 1 ` + "]", y4_meas[i]) # Solve parameter estimation problem res_opt2 = qt_par_est2.optimize(options=opt_opts) # Get optimal parameter values a1_opt2 = res_opt2.final("qt.a1") a2_opt2 = res_opt2.final("qt.a2") a3_opt2 = res_opt2.final("qt.a3") a4_opt2 = res_opt2.final("qt.a4") # Print optimal parameter values print('a1:' + str(a1_opt2 * 1e4) + 'cm^2') print('a2:' + str(a2_opt2 * 1e4) + 'cm^2') print('a3:' + str(a3_opt2 * 1e4) + 'cm^2') print('a4:' + str(a4_opt2 * 1e4) + 'cm^2') assert N.abs(a1_opt2 * 1.e6 - 2.6579) < 1e-3, "Wrong value of parameter a1" assert N.abs(a2_opt2 * 1.e6 - 2.7038) < 1e-3, "Wrong value of parameter a2" assert N.abs(a3_opt2 * 1.e6 - 3.0031) < 1e-3, "Wrong value of parameter a3" assert N.abs(a4_opt2 * 1.e6 - 2.9342) < 1e-3, "Wrong value of parameter a4" # Extract state and input profiles x1_opt2 = res_opt2["qt.x1"] x2_opt2 = res_opt2["qt.x2"] x3_opt2 = res_opt2["qt.x3"] x4_opt2 = res_opt2["qt.x4"] u1_opt2 = res_opt2["qt.u1"] u2_opt2 = res_opt2["qt.u2"] t_opt2 = res_opt2["time"] # Plot if with_plots: plt.figure(1) plt.subplot(2, 2, 1) plt.plot(t_opt2, x3_opt2, 'r') plt.subplot(2, 2, 2) plt.plot(t_opt2, x4_opt2, 'r') plt.subplot(2, 2, 3) plt.plot(t_opt2, x1_opt2, 'r') plt.subplot(2, 2, 4) plt.plot(t_opt2, x2_opt2, 'r') plt.show() # Compute parameter standard deviations for case 1 # compile JMU jmu_name = compile_jmu('QuadTankPack.QuadTank_Sens1', curr_dir + '/files/QuadTankPack.mop') # Load model model = JMUModel(jmu_name) model.set('a1', a1_opt) model.set('a2', a2_opt) sens_opts = model.simulate_options() # Enable sensitivity computations sens_opts['IDA_options']['sensitivity'] = True #sens_opts['IDA_options']['atol'] = 1e-12 # Simulate sensitivity equations sens_res = model.simulate(input=(['u1', 'u2'], u), start_time=0., final_time=60, options=sens_opts) # Get result trajectories x1_sens = sens_res['x1'] x2_sens = sens_res['x2'] dx1da1 = sens_res['dx1/da1'] dx1da2 = sens_res['dx1/da2'] dx2da1 = sens_res['dx2/da1'] dx2da2 = sens_res['dx2/da2'] t_sens = sens_res['time'] # Compute Jacobian # Create a trajectory object for interpolation traj = TrajectoryLinearInterpolation( t_sens, N.transpose( N.vstack((x1_sens, x2_sens, dx1da1, dx1da2, dx2da1, dx2da2)))) # Jacobian jac = N.zeros((61 * 2, 2)) # Error vector err = N.zeros(61 * 2) # Extract Jacobian and error information i = 0 for t_p in t_meas: vals = traj.eval(t_p) for j in range(2): for k in range(2): jac[i + j, k] = vals[0, 2 * j + k + 2] err[i] = vals[0, 0] - y1_meas[i / 2] err[i + 1] = vals[0, 1] - y2_meas[i / 2] i = i + 2 # Compute estimated variance of measurement noice v_err = N.sum(err**2) / (61 * 2 - 2) # Compute J^T*J A = N.dot(N.transpose(jac), jac) # Compute parameter covariance matrix P = v_err * N.linalg.inv(A) # Compute standard deviations for parameters sigma_a1 = N.sqrt(P[0, 0]) sigma_a2 = N.sqrt(P[1, 1]) print "a1: " + str( sens_res['a1']) + ", standard deviation: " + str(sigma_a1) print "a2: " + str( sens_res['a2']) + ", standard deviation: " + str(sigma_a2) # Compute parameter standard deviations for case 2 # compile JMU jmu_name = compile_jmu('QuadTankPack.QuadTank_Sens2', curr_dir + '/files/QuadTankPack.mop') # Load model model = JMUModel(jmu_name) model.set('a1', a1_opt2) model.set('a2', a2_opt2) model.set('a3', a3_opt2) model.set('a4', a4_opt2) sens_opts = model.simulate_options() # Enable sensitivity computations sens_opts['IDA_options']['sensitivity'] = True #sens_opts['IDA_options']['atol'] = 1e-12 # Simulate sensitivity equations sens_res = model.simulate(input=(['u1', 'u2'], u), start_time=0., final_time=60, options=sens_opts) # Get result trajectories x1_sens = sens_res['x1'] x2_sens = sens_res['x2'] x3_sens = sens_res['x3'] x4_sens = sens_res['x4'] dx1da1 = sens_res['dx1/da1'] dx1da2 = sens_res['dx1/da2'] dx1da3 = sens_res['dx1/da3'] dx1da4 = sens_res['dx1/da4'] dx2da1 = sens_res['dx2/da1'] dx2da2 = sens_res['dx2/da2'] dx2da3 = sens_res['dx2/da3'] dx2da4 = sens_res['dx2/da4'] dx3da1 = sens_res['dx3/da1'] dx3da2 = sens_res['dx3/da2'] dx3da3 = sens_res['dx3/da3'] dx3da4 = sens_res['dx3/da4'] dx4da1 = sens_res['dx4/da1'] dx4da2 = sens_res['dx4/da2'] dx4da3 = sens_res['dx4/da3'] dx4da4 = sens_res['dx4/da4'] t_sens = sens_res['time'] # Compute Jacobian # Create a trajectory object for interpolation traj = TrajectoryLinearInterpolation( t_sens, N.transpose( N.vstack( (x1_sens, x2_sens, x3_sens, x4_sens, dx1da1, dx1da2, dx1da3, dx1da4, dx2da1, dx2da2, dx2da3, dx2da4, dx3da1, dx3da2, dx3da3, dx3da4, dx4da1, dx4da2, dx4da3, dx4da4)))) # Jacobian jac = N.zeros((61 * 4, 4)) # Error vector err = N.zeros(61 * 4) # Extract Jacobian and error information i = 0 for t_p in t_meas: vals = traj.eval(t_p) for j in range(4): for k in range(4): jac[i + j, k] = vals[0, 4 * j + k + 4] err[i] = vals[0, 0] - y1_meas[i / 4] err[i + 1] = vals[0, 1] - y2_meas[i / 4] err[i + 2] = vals[0, 2] - y3_meas[i / 4] err[i + 3] = vals[0, 3] - y4_meas[i / 4] i = i + 4 # Compute estimated variance of measurement noice v_err = N.sum(err**2) / (61 * 4 - 4) # Compute J^T*J A = N.dot(N.transpose(jac), jac) # Compute parameter covariance matrix P = v_err * N.linalg.inv(A) # Compute standard deviations for parameters sigma_a1 = N.sqrt(P[0, 0]) sigma_a2 = N.sqrt(P[1, 1]) sigma_a3 = N.sqrt(P[2, 2]) sigma_a4 = N.sqrt(P[3, 3]) print "a1: " + str( sens_res['a1']) + ", standard deviation: " + str(sigma_a1) print "a2: " + str( sens_res['a2']) + ", standard deviation: " + str(sigma_a2) print "a3: " + str( sens_res['a3']) + ", standard deviation: " + str(sigma_a3) print "a4: " + str( sens_res['a4']) + ", standard deviation: " + str(sigma_a4)
def run_demo(with_plots=True): """ This example is based on the Hicks-Ray Continuously Stirred Tank Reactors (CSTR) system. The system has two states, the concentration and the temperature. The control input to the system is the temperature of the cooling flow in the reactor jacket. The chemical reaction in the reactor is exothermic, and also temperature dependent; high temperature results in high reaction rate. The example demonstrates the following steps: 1. How to solve a DAE initialization problem. The initialization model have equations specifying that all derivatives should be identically zero, which implies that a stationary solution is obtained. Two stationary points, corresponding to different inputs, are computed. We call the stationary points A and B respectively. point A corresponds to operating conditions where the reactor is cold and the reaction rate is low, whereas point B corresponds to a higher temperature where the reaction rate is high. For more information about the DAE initialization algorithm, see http://www.jmodelica.org/page/10. 2. How to generate an initial guess for a direct collocation method by means of simulation. The trajectories resulting from simulation are used to initialize the variables in the transcribed NLP. 3. An optimal control problem is solved where the objective Is to transfer the state of the system from stationary point A to point B. The challenge is to ignite the reactor while avoiding uncontrolled temperature increase. It is also demonstrated how to set parameter and variable values in a model. More information about the simultaneous optimization algorithm can be found at http://www.jmodelica.org/page/10. 4. The optimization result is saved to file and then the important variables are plotted. 5. Simulate the system with the optimal control profile. This step is important in order to verify that the approximation in the transcription step is valid. """ curr_dir = os.path.dirname(os.path.abspath(__file__)) # Compile the stationary initialization model into a JMU jmu_name = compile_jmu("CSTR.CSTR_Init", os.path.join(curr_dir, "files", "CSTR.mop"), compiler_options={"enable_variable_scaling": True}) # load the JMU init_model = JMUModel(jmu_name) # Set inputs for Stationary point A Tc_0_A = 250 init_model.set('Tc', Tc_0_A) # Solve the DAE initialization system with Ipopt init_result = init_model.initialize() # Store stationary point A c_0_A = init_result['c'][0] T_0_A = init_result['T'][0] # Print some data for stationary point A print(' *** Stationary point A ***') print('Tc = %f' % Tc_0_A) print('c = %f' % c_0_A) print('T = %f' % T_0_A) # Set inputs for Stationary point B Tc_0_B = 280 init_model.set('Tc', Tc_0_B) # Solve the DAE initialization system with Ipopt init_result = init_model.initialize() # Store stationary point B c_0_B = init_result['c'][0] T_0_B = init_result['T'][0] # Print some data for stationary point B print(' *** Stationary point B ***') print('Tc = %f' % Tc_0_B) print('c = %f' % c_0_B) print('T = %f' % T_0_B) # Compute initial guess trajectories by means of simulation # Compile the optimization initialization model jmu_name = compile_jmu("CSTR.CSTR_Init_Optimization", os.path.join(curr_dir, "files", "CSTR.mop")) # Load the model init_sim_model = JMUModel(jmu_name) # Set model parameters init_sim_model.set('cstr.c_init', c_0_A) init_sim_model.set('cstr.T_init', T_0_A) init_sim_model.set('c_ref', c_0_B) init_sim_model.set('T_ref', T_0_B) init_sim_model.set('Tc_ref', Tc_0_B) res = init_sim_model.simulate(start_time=0., final_time=150.) # Extract variable profiles c_init_sim = res['cstr.c'] T_init_sim = res['cstr.T'] Tc_init_sim = res['cstr.Tc'] t_init_sim = res['time'] # Plot the results if with_plots: plt.figure(1) plt.clf() plt.hold(True) plt.subplot(311) plt.plot(t_init_sim, c_init_sim) plt.grid() plt.ylabel('Concentration') plt.subplot(312) plt.plot(t_init_sim, T_init_sim) plt.grid() plt.ylabel('Temperature') plt.subplot(313) plt.plot(t_init_sim, Tc_init_sim) plt.grid() plt.ylabel('Cooling temperature') plt.xlabel('time') plt.show() # Solve the optimal control problem # Compile model jmu_name = compile_jmu("CSTR.CSTR_Opt", curr_dir + "/files/CSTR.mop") # Load model cstr = JMUModel(jmu_name) # Set reference values cstr.set('Tc_ref', Tc_0_B) cstr.set('c_ref', c_0_B) cstr.set('T_ref', T_0_B) # Set initial values cstr.set('cstr.c_init', c_0_A) cstr.set('cstr.T_init', T_0_A) n_e = 100 # Number of elements # Set options opt_opts = cstr.optimize_options() opt_opts['n_e'] = n_e opt_opts['init_traj'] = res.result_data res = cstr.optimize(options=opt_opts) # Extract variable profiles c_res = res['cstr.c'] T_res = res['cstr.T'] Tc_res = res['cstr.Tc'] time_res = res['time'] c_ref = res['c_ref'] T_ref = res['T_ref'] Tc_ref = res['Tc_ref'] assert N.abs(res.final('cost') / 1.e7 - 1.8585429) < 1e-3 # Plot the results if with_plots: plt.figure(2) plt.clf() plt.hold(True) plt.subplot(311) plt.plot(time_res, c_res) plt.plot([time_res[0], time_res[-1]], [c_ref, c_ref], '--') plt.grid() plt.ylabel('Concentration') plt.subplot(312) plt.plot(time_res, T_res) plt.plot([time_res[0], time_res[-1]], [T_ref, T_ref], '--') plt.grid() plt.ylabel('Temperature') plt.subplot(313) plt.plot(time_res, Tc_res) plt.plot([time_res[0], time_res[-1]], [Tc_ref, Tc_ref], '--') plt.grid() plt.ylabel('Cooling temperature') plt.xlabel('time') plt.show() # Simulate to verify the optimal solution # Set up the input trajectory t = time_res u = Tc_res u_traj = N.transpose(N.vstack((t, u))) # Compile the Modelica model to a JMU jmu_name = compile_jmu("CSTR.CSTR", curr_dir + "/files/CSTR.mop") # Load model sim_model = JMUModel(jmu_name) sim_model.set('c_init', c_0_A) sim_model.set('T_init', T_0_A) sim_model.set('Tc', u[0]) res = sim_model.simulate(start_time=0., final_time=150., input=('Tc', u_traj)) # Extract variable profiles c_sim = res['c'] T_sim = res['T'] Tc_sim = res['Tc'] time_sim = res['time'] # Plot the results if with_plots: plt.figure(3) plt.clf() plt.hold(True) plt.subplot(311) plt.plot(time_res, c_res, '--') plt.plot(time_sim, c_sim) plt.legend(('optimized', 'simulated')) plt.grid() plt.ylabel('Concentration') plt.subplot(312) plt.plot(time_res, T_res, '--') plt.plot(time_sim, T_sim) plt.legend(('optimized', 'simulated')) plt.grid() plt.ylabel('Temperature') plt.subplot(313) plt.plot(time_res, Tc_res, '--') plt.plot(time_sim, Tc_sim) plt.legend(('optimized', 'simulated')) plt.grid() plt.ylabel('Cooling temperature') plt.xlabel('time') plt.show()