def run_demo(with_plots=True): """ Demonstrate how to solve a minimum time dynamic optimization problem based on a Van der Pol oscillator system. """ curr_dir = os.path.dirname(os.path.abspath(__file__)); jmu_name = compile_jmu("JMExamples_opt.VDP_Opt_Min_Time", (curr_dir+"/files/JMExamples_opt.mop",curr_dir+"/files/JMExamples.mo")) vdp = JMUModel(jmu_name) opts = vdp.optimize_options() opts["result_mode"] = "element_interpolation" res = vdp.optimize(options=opts) # Extract variable profiles x1 = res['x1'] x2 = res['x2'] u = res['u'] tf = res['finalTime'] t = res['time'] assert N.abs(res.final('finalTime') - 2.2811587) < 1e-3 if with_plots: # Plot plt.figure(1) plt.clf() plt.subplot(311) plt.plot(t,x1) plt.grid() plt.ylabel('x1') plt.subplot(312) plt.plot(t,x2) plt.grid() plt.ylabel('x2') plt.subplot(313) plt.plot(t,u,'x-') plt.grid() plt.ylabel('u') plt.xlabel('time') plt.show()
def run_demo(with_plots=True): """ This is the crystallizer example from Bieglers book in section 10.3. """ curr_dir = os.path.dirname(os.path.abspath(__file__)) # Compile and load model fmu_name = compile_fmu("Crystallizer.SimulateCrystallizer", os.path.join(curr_dir, "files", "Crystallizer.mop"), compiler_options={"enable_variable_scaling": True}) crys = load_fmu(fmu_name) # Simulate res = crys.simulate(final_time=25) time = res['time'] Ls = res['c.Ls'] Nc = res['c.Nc'] L = res['c.L'] Ac = res['c.Ac'] Vc = res['c.Vc'] Mc = res['c.Mc'] Cc = res['c.Cc'] Tc = res['c.Tc'] Ta = res['Ta'] Teq = res['c.Teq'] deltaT = res['c.deltaT'] Cbar = res['c.Cbar'] Tj = res['c.Tj'] if with_plots: plt.figure(1) plt.clf() plt.subplot(2, 1, 1) plt.plot(time, Ls) plt.grid() plt.subplot(2, 1, 2) plt.plot(time, Tj) plt.grid() plt.show() plt.figure(2) plt.clf() plt.subplot(4, 1, 1) plt.plot(time, Nc) plt.title('Nc') plt.grid() plt.subplot(4, 1, 2) plt.plot(time, L) plt.title('L') plt.grid() plt.subplot(4, 1, 3) plt.plot(time, Ac) plt.title('Ac') plt.grid() plt.subplot(4, 1, 4) plt.plot(time, Vc) plt.title('Vc') plt.grid() plt.figure(3) plt.clf() plt.subplot(4, 1, 1) plt.plot(time, Mc) plt.title('Mc') plt.grid() plt.subplot(4, 1, 2) plt.plot(time, Cc) plt.title('Cc') plt.grid() plt.subplot(4, 1, 3) plt.plot(time, Tc) plt.title('Tc') plt.grid() plt.subplot(4, 1, 4) plt.plot(time, Teq) plt.title('Teq') plt.grid() plt.show() plt.figure(4) plt.clf() plt.subplot(4, 1, 1) plt.plot(time, deltaT) plt.title('deltaT') plt.grid() plt.subplot(4, 1, 2) plt.plot(time, Cbar) plt.title('Cbar') plt.grid() plt.subplot(4, 1, 3) plt.plot(time, Teq - Tc) plt.title('Teq-Tc') plt.grid() plt.subplot(4, 1, 4) plt.plot(time, Ta) plt.title('Ta') plt.grid() plt.show() # Compile and load opt model jmu_name = compile_jmu("Crystallizer.OptCrystallizer", os.path.join(curr_dir, "files", "Crystallizer.mop"), compiler_options={"enable_variable_scaling": True}) crys_opt = JMUModel(jmu_name) # Set optimization options opt_opts = crys_opt.optimize_options() n_e = 20 opt_opts['n_e'] = n_e opt_opts['init_traj'] = res.result_data opt_opts['blocking_factors'] = N.ones(n_e, dtype=int) opt_opts['IPOPT_options']['max_iter'] = 1000 opt_opts['IPOPT_options']['tol'] = 1e-3 opt_opts['IPOPT_options']['dual_inf_tol'] = 1e-3 # Run optimization res_opt = crys_opt.optimize(options=opt_opts) # Get result data time = res_opt['time'] Ls = res_opt['c.Ls'] Nc = res_opt['c.Nc'] L = res_opt['c.L'] Ac = res_opt['c.Ac'] Vc = res_opt['c.Vc'] Mc = res_opt['c.Mc'] Cc = res_opt['c.Cc'] Tc = res_opt['c.Tc'] Teq = res_opt['c.Teq'] deltaT = res_opt['c.deltaT'] Cbar = res_opt['c.Cbar'] Tj = res_opt['c.Tj'] assert N.abs(res_opt.final('c.Tj') - 10.0) < 1e-3 if with_plots: plt.figure(1) plt.subplot(2, 1, 1) plt.hold(True) plt.plot(time, Ls) plt.subplot(2, 1, 2) plt.hold(True) plt.plot(time, Tj, 'x-') plt.figure(2) plt.subplot(4, 1, 1) plt.hold(True) plt.plot(time, Nc) plt.title('Nc') plt.subplot(4, 1, 2) plt.hold(True) plt.plot(time, L) plt.title('L') plt.subplot(4, 1, 3) plt.hold(True) plt.plot(time, Ac) plt.title('Ac') plt.subplot(4, 1, 4) plt.hold(True) plt.plot(time, Vc) plt.title('Vc') plt.figure(3) plt.subplot(4, 1, 1) plt.hold(True) plt.plot(time, Mc) plt.title('Mc') plt.subplot(4, 1, 2) plt.hold(True) plt.plot(time, Cc) plt.title('Cc') plt.subplot(4, 1, 3) plt.hold(True) plt.plot(time, Tc) plt.title('Tc') plt.subplot(4, 1, 4) plt.hold(True) plt.plot(time, Teq) plt.title('Teq') plt.show() plt.figure(4) plt.subplot(4, 1, 1) plt.hold(True) plt.plot(time, deltaT) plt.title('deltaT') plt.subplot(4, 1, 2) plt.hold(True) plt.plot(time, Cbar) plt.title('Cbar') plt.subplot(4, 1, 3) plt.hold(True) plt.plot(time, Teq - Tc) plt.title('Teq-Tc') plt.show()
def run_demo(with_plots=True, with_blocking_factors=False): """ Load change of a distillation column. The distillation column model is documented in the paper: @Article{hahn+02, title={An improved method for nonlinear model reduction using balancing of empirical gramians}, author={Hahn, J. and Edgar, T.F.}, journal={Computers and Chemical Engineering}, volume={26}, number={10}, pages={1379-1397}, year={2002} } Note: This example requires Ipopt with MA27. """ curr_dir = os.path.dirname(os.path.abspath(__file__)) # Compile the stationary initialization model into a JMU jmu_name = compile_jmu("DISTLib.Binary_Dist_initial", curr_dir + "/files/DISTLib.mo") # Load a model instance into Python init_model = JMUModel(jmu_name) # Set inputs for Stationary point A rr_0_A = 3.0 init_model.set('rr', rr_0_A) init_result = init_model.initialize() # Store stationary point A y_A = N.zeros(32) x_A = N.zeros(32) print(' *** Stationary point A ***') print '(Tray index, x_i_A, y_i_A)' for i in range(N.size(y_A)): y_A[i] = init_model.get('y[' + str(i + 1) + ']') x_A[i] = init_model.get('x[' + str(i + 1) + ']') print '(' + str(i + 1) + ', %f, %f)' % (x_A[i], y_A[i]) # Set inputs for stationary point B rr_0_B = 2.0 init_model.set('rr', rr_0_B) init_result = init_model.initialize() # Store stationary point B y_B = N.zeros(32) x_B = N.zeros(32) print(' *** Stationary point B ***') print '(Tray index, x_i_B, y_i_B)' for i in range(N.size(y_B)): y_B[i] = init_model.get('y[' + str(i + 1) + ']') x_B[i] = init_model.get('x[' + str(i + 1) + ']') print '(' + str(i + 1) + ', %f, %f)' % (x_B[i], y_B[i]) # Set up and solve an optimal control problem. # Compile the JMU jmu_name = compile_jmu( "DISTLib_Opt.Binary_Dist_Opt1", (curr_dir + "/files/DISTLib.mo", curr_dir + "/files/DISTLib_Opt.mop"), compiler_options={'state_start_values_fixed': True}) # Load the dynamic library and XML data model = JMUModel(jmu_name) # Initialize the model with parameters # Initialize the model to stationary point A for i in range(N.size(x_A)): model.set('x_0[' + str(i + 1) + ']', x_A[i]) # Set the target values to stationary point B model.set('rr_ref', rr_0_B) model.set('y1_ref', y_B[0]) n_e = 100 # Number of elements hs = N.ones(n_e) * 1. / n_e # Equidistant points n_cp = 3 # Number of collocation points in each element # Solve the optimization problem if with_blocking_factors: # Blocking factors for control parametrization blocking_factors = 4 * N.ones(n_e / 4, dtype=N.int) opt_opts = model.optimize_options() opt_opts['n_e'] = n_e opt_opts['n_cp'] = n_cp opt_opts['hs'] = hs opt_opts['blocking_factors'] = blocking_factors opt_res = model.optimize(options=opt_opts) else: opt_res = model.optimize(options={'n_e': n_e, 'n_cp': n_cp, 'hs': hs}) # Extract variable profiles u1_res = opt_res['rr'] u1_ref_res = opt_res['rr_ref'] y1_ref_res = opt_res['y1_ref'] time = opt_res['time'] x_res = [] x_ref_res = [] for i in range(N.size(x_B)): x_res.append(opt_res['x[' + str(i + 1) + ']']) y_res = [] for i in range(N.size(x_B)): y_res.append(opt_res['y[' + str(i + 1) + ']']) if with_blocking_factors: assert N.abs(opt_res.final('cost') / 1.e1 - 2.8549683) < 1e-3 else: assert N.abs(opt_res.final('cost') / 1.e1 - 2.8527469) < 1e-3 # Plot the results if with_plots: plt.figure(1) plt.clf() plt.hold(True) plt.subplot(311) plt.title('Liquid composition') plt.plot(time, x_res[0]) plt.ylabel('x1') plt.grid() plt.subplot(312) plt.plot(time, x_res[16]) plt.ylabel('x17') plt.grid() plt.subplot(313) plt.plot(time, x_res[31]) plt.ylabel('x32') plt.grid() plt.xlabel('t [s]') plt.show() # Plot the results plt.figure(2) plt.clf() plt.hold(True) plt.subplot(311) plt.title('Vapor composition') plt.plot(time, y_res[0]) plt.plot(time, y1_ref_res, '--') plt.ylabel('y1') plt.grid() plt.subplot(312) plt.plot(time, y_res[16]) plt.ylabel('y17') plt.grid() plt.subplot(313) plt.plot(time, y_res[31]) plt.ylabel('y32') plt.grid() plt.xlabel('t [s]') plt.show() plt.figure(3) plt.clf() plt.hold(True) plt.plot(time, u1_res) plt.ylabel('u') plt.plot(time, u1_ref_res, '--') plt.xlabel('t [s]') plt.title('Reflux ratio') plt.grid() plt.show()
def run_demo(with_plots=True): """ Load change of a distillation column. The distillation column model is documented in the paper: @Article{hahn+02, title={An improved method for nonlinear model reduction using balancing of empirical gramians}, author={Hahn, J. and Edgar, T.F.}, journal={Computers and Chemical Engineering}, volume={26}, number={10}, pages={1379-1397}, year={2002} } Note: This example requires Ipopt with MA27. """ curr_dir = os.path.dirname(os.path.abspath(__file__)); # Compile the stationary initialization model into a JMU jmu_name = compile_jmu("JMExamples.Distillation.Distillation1Input_init", curr_dir+"/files/JMExamples.mo") # Load a model instance into Python init_model = JMUModel(jmu_name) # Set inputs for Stationary point A rr_0_A = 3.0 init_model.set('rr',rr_0_A) init_result = init_model.initialize() # Store stationary point A y_A = N.zeros(32) x_A = N.zeros(32) print(' *** Stationary point A ***') print '(Tray index, x_i_A, y_i_A)' for i in range(32): y_A[i] = init_result['y['+ str(i+1) +']'][0] x_A[i] = init_result['x['+ str(i+1) +']'][0] print '(' + str(i+1) + ', %f, %f)' %(x_A[i], y_A[i]) # Set inputs for stationary point B rr_0_B = 2.0 init_model.set('rr',rr_0_B) init_result = init_model.initialize() # Store stationary point B y_B = N.zeros(32) x_B = N.zeros(32) print(' *** Stationary point B ***') print '(Tray index, x_i_B, y_i_B)' for i in range(32): y_B[i] = init_result['y[' + str(i+1) + ']'][0] x_B[i] = init_result['x[' + str(i+1) + ']'][0] print '(' + str(i+1) + ', %f, %f)' %(x_B[i], y_B[i]) # Set up and solve an optimal control problem. # Compile the JMU jmu_name = compile_jmu("JMExamples_opt.Distillation1_opt", (curr_dir+"/files/JMExamples.mo",curr_dir+"/files/JMExamples_opt.mop"), compiler_options={'state_start_values_fixed':True}) # Load the dynamic library and XML data model = JMUModel(jmu_name) # Initialize the model with parameters # Initialize the model to stationary point A for i in range(32): model.set('x_init[' + str(i+1) + ']', x_A[i]) # Set the target values to stationary point B model.set('rr_ref',rr_0_B) model.set('x1_ref',x_B[0]) # Solve the optimization problem opts = model.optimize_options() opts['hs'] = N.ones(100)*1./100 # Equidistant points opts['n_e'] = 100 # Number of elements opts['n_cp'] = 3 # Number of collocation points in each element opt_res = model.optimize() # Extract variable profiles x1 = opt_res['x[1]'] x8 = opt_res['x[8]'] x16 = opt_res['x[16]'] x24 = opt_res['x[24]'] x32 = opt_res['x[32]'] y1 = opt_res['y[1]'] y8 = opt_res['y[8]'] y16 = opt_res['y[16]'] y24 = opt_res['y[24]'] y32 = opt_res['y[32]'] t = opt_res['time'] rr = opt_res['rr'] assert N.abs(opt_res.final('rr') - 2.0) < 1e-3 # Plot the results if with_plots: plt.figure() plt.subplot(1,2,1) plt.plot(t,x16,t,x32,t,x1,t,x8,t,x24) plt.title('Liquid composition') plt.grid(True) plt.ylabel('x') plt.subplot(1,2,2) plt.plot(t,y16,t,y32,t,y1,t,y8,t,y24) plt.title('Vapor composition') plt.grid(True) plt.ylabel('y') plt.xlabel('time') plt.show() plt.figure(3) plt.clf() plt.hold(True) plt.plot(t,rr) plt.ylabel('rr') plt.xlabel('t [s]') plt.title('Reflux ratio') plt.show()
def run_demo(with_plots=True, with_blocking_factors = False): """ Load change of a distillation column. The distillation column model is documented in the paper: @Article{hahn+02, title={An improved method for nonlinear model reduction using balancing of empirical gramians}, author={Hahn, J. and Edgar, T.F.}, journal={Computers and Chemical Engineering}, volume={26}, number={10}, pages={1379-1397}, year={2002} } Note: This example requires Ipopt with MA27. """ curr_dir = os.path.dirname(os.path.abspath(__file__)); # Compile the stationary initialization model into a JMU jmu_name = compile_jmu("DISTLib.Binary_Dist_initial", curr_dir+"/files/DISTLib.mo") # Load a model instance into Python init_model = JMUModel(jmu_name) # Set inputs for Stationary point A rr_0_A = 3.0 init_model.set('rr',rr_0_A) init_result = init_model.initialize() # Store stationary point A y_A = N.zeros(32) x_A = N.zeros(32) print(' *** Stationary point A ***') print '(Tray index, x_i_A, y_i_A)' for i in range(N.size(y_A)): y_A[i] = init_model.get('y['+ str(i+1) +']') x_A[i] = init_model.get('x['+ str(i+1) +']') print '(' + str(i+1) + ', %f, %f)' %(x_A[i], y_A[i]) # Set inputs for stationary point B rr_0_B = 2.0 init_model.set('rr',rr_0_B) init_result = init_model.initialize() # Store stationary point B y_B = N.zeros(32) x_B = N.zeros(32) print(' *** Stationary point B ***') print '(Tray index, x_i_B, y_i_B)' for i in range(N.size(y_B)): y_B[i] = init_model.get('y[' + str(i+1) + ']') x_B[i] = init_model.get('x[' + str(i+1) + ']') print '(' + str(i+1) + ', %f, %f)' %(x_B[i], y_B[i]) # Set up and solve an optimal control problem. # Compile the JMU jmu_name = compile_jmu("DISTLib_Opt.Binary_Dist_Opt1", (curr_dir+"/files/DISTLib.mo",curr_dir+"/files/DISTLib_Opt.mop"), compiler_options={'state_start_values_fixed':True}) # Load the dynamic library and XML data model = JMUModel(jmu_name) # Initialize the model with parameters # Initialize the model to stationary point A for i in range(N.size(x_A)): model.set('x_0[' + str(i+1) + ']', x_A[i]) # Set the target values to stationary point B model.set('rr_ref',rr_0_B) model.set('y1_ref',y_B[0]) n_e = 100 # Number of elements hs = N.ones(n_e)*1./n_e # Equidistant points n_cp = 3; # Number of collocation points in each element # Solve the optimization problem if with_blocking_factors: # Blocking factors for control parametrization blocking_factors=4*N.ones(n_e/4,dtype=N.int) opt_opts = model.optimize_options() opt_opts['n_e'] = n_e opt_opts['n_cp'] = n_cp opt_opts['hs'] = hs opt_opts['blocking_factors'] = blocking_factors opt_res = model.optimize(options=opt_opts) else: opt_res = model.optimize(options={'n_e':n_e, 'n_cp':n_cp, 'hs':hs}) # Extract variable profiles u1_res = opt_res['rr'] u1_ref_res = opt_res['rr_ref'] y1_ref_res = opt_res['y1_ref'] time = opt_res['time'] x_res = [] x_ref_res = [] for i in range(N.size(x_B)): x_res.append(opt_res['x[' + str(i+1) + ']']) y_res = [] for i in range(N.size(x_B)): y_res.append(opt_res['y[' + str(i+1) + ']']) if with_blocking_factors: assert N.abs(opt_res.final('cost')/1.e1 - 2.8549683) < 1e-3 else: assert N.abs(opt_res.final('cost')/1.e1 - 2.8527469) < 1e-3 # Plot the results if with_plots: plt.figure(1) plt.clf() plt.hold(True) plt.subplot(311) plt.title('Liquid composition') plt.plot(time, x_res[0]) plt.ylabel('x1') plt.grid() plt.subplot(312) plt.plot(time, x_res[16]) plt.ylabel('x17') plt.grid() plt.subplot(313) plt.plot(time, x_res[31]) plt.ylabel('x32') plt.grid() plt.xlabel('t [s]') plt.show() # Plot the results plt.figure(2) plt.clf() plt.hold(True) plt.subplot(311) plt.title('Vapor composition') plt.plot(time, y_res[0]) plt.plot(time, y1_ref_res, '--') plt.ylabel('y1') plt.grid() plt.subplot(312) plt.plot(time, y_res[16]) plt.ylabel('y17') plt.grid() plt.subplot(313) plt.plot(time, y_res[31]) plt.ylabel('y32') plt.grid() plt.xlabel('t [s]') plt.show() plt.figure(3) plt.clf() plt.hold(True) plt.plot(time, u1_res) plt.ylabel('u') plt.plot(time, u1_ref_res, '--') plt.xlabel('t [s]') plt.title('Reflux ratio') plt.grid() plt.show()
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): """ Demonstrate how to solve a simple parameter estimation problem. """ # Locate model file curr_dir = os.path.dirname(os.path.abspath(__file__)); model_path = curr_dir + "/files/ParameterEstimation_1.mop" # Compile the model into an FMU and JMU fmu = compile_fmu("ParEst.SecondOrder", model_path) jmu = compile_jmu("ParEst.ParEst", model_path) # Load the model sim_model = load_fmu(fmu) opt_model = JMUModel(jmu) # Simulate model with nominal parameters sim_res = sim_model.simulate(final_time=10) # Extract nominal trajectories t_sim = sim_res['time'] x1_sim = sim_res['x1'] x2_sim = sim_res['x2'] # Get measurement data with 1 Hz and add measurement noise sim_model = load_fmu(fmu) meas_res = sim_model.simulate(final_time=10, options={'ncp': 10}) x1_meas = meas_res['x1'] noise = [0.01463904, 0.0139424, 0.09834249, 0.0768069, 0.01971631, -0.03827911, 0.05266659, -0.02608245, 0.05270525, 0.04717024, 0.0779514] t_meas = N.linspace(0, 10, 11) y_meas = x1_meas + noise if with_plots: # Plot simulation plt.close(1) plt.figure(1) plt.subplot(2, 1, 1) plt.plot(t_sim, x1_sim) plt.grid() plt.plot(t_meas, y_meas, 'x') plt.ylabel('x1') plt.subplot(2, 1, 2) plt.plot(t_sim, x2_sim) plt.grid() plt.ylabel('x2') plt.show() # Insert measurement data for i in xrange(11): opt_model.set('t[' + repr(i+1) + ']', t_meas[i]) opt_model.set('y[' + repr(i+1) + ']', y_meas[i]) # Set optimization options opts = opt_model.optimize_options() opts['n_e'] = 16 # Optimize opt_res = opt_model.optimize(options=opts) # Extract variable profiles x1_opt = opt_res['sys.x1'] x2_opt = opt_res['sys.x2'] w_opt = opt_res.final('sys.w') z_opt = opt_res.final('sys.z') t_opt = opt_res['time'] # Assert results assert N.abs(opt_res.final('sys.x1') - 1.) < 1e-2 assert N.abs(w_opt - 1.05) < 1e-2 assert N.abs(z_opt - 0.45) < 1e-2 # Plot optimization result if with_plots: plt.close(2) plt.figure(2) plt.subplot(2, 1, 1) plt.plot(t_opt, x1_opt, 'g') plt.plot(t_sim, x1_sim) plt.plot(t_meas, y_meas, 'x') plt.grid() plt.subplot(2, 1, 2) plt.plot(t_opt, x2_opt, 'g') plt.grid() plt.plot(t_sim, x2_sim) plt.show() print("** Optimal parameter values: **") print("w = %f" % w_opt) print("z = %f" % z_opt)
def run_demo(with_plots=True): """ Demonstrate how to solve a simple parameter estimation problem in form of a model of catalytic cracking of gas oil. Reference: Benchmarking Optimization Software with COPS Elizabeth D. Dolan and Jorge J. More ARGONNE NATIONAL LABORATORY """ curr_dir = os.path.dirname(os.path.abspath(__file__)); # Compile the Optimica model to a JMU jmu_name = compile_jmu("JMExamples_opt.CatalyticCracking_opt", (os.path.join(curr_dir, 'files', 'JMExamples_opt.mop'), os.path.join(curr_dir, 'files', 'JMExamples.mo'))) # Load the dynamic library cc = JMUModel(jmu_name) # optimize opts = cc.optimize_options() opts['n_e'] = 20 res = cc.optimize(options=opts) # Extract variable profiles y1 = res['sys.y1'] y2 = res['sys.y2'] theta1 = res['sys.theta1'] theta2 = res['sys.theta2'] theta3 = res['sys.theta3'] t = res['time'] y1m = [1, 0.8105, 0.6208, 0.5258, 0.4345, 0.3903, 0.3342, 0.3034, 0.2735, 0.2405, 0.2283, 0.2071, 0.1669, 0.1530, 0.1339, 0.1265, 0.1200, 0.0990, 0.0870, 0.077, 0.069]; y2m = [0, 0.2, 0.2886, 0.301, 0.3215, 0.3123, 0.2716, 0.2551, 0.2258, 0.1959, 0.1789, 0.1457, 0.1198, 0.0909, 0.0719, 0.0561, 0.0460, 0.0280, 0.0190, 0.0140, 0.01]; tm = [0, 0.025, 0.05, 0.075, 0.1, 0.125, 0.15, 0.175, 0.2, 0.225, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.65, 0.75, 0.85, 0.95]; assert N.abs(res.final('sys.theta1') - 11.835148) < 1e-5 assert N.abs(res.final('sys.theta2') - 8.338887) < 1e-5 assert N.abs(res.final('sys.theta3') - 1.007536) < 1e-5 if with_plots: plt.figure(1) plt.clf() plt.subplot(211) plt.plot(t, y1, tm, y1m, 'x') plt.grid() plt.ylabel('y1') plt.xlabel('time') plt.subplot(212) plt.plot(t, y2, tm, y2m, 'x') plt.grid() plt.ylabel('y2') plt.xlabel('time') plt.show() print("\n** Optimal parameter values: **") print("theta1 = %f" %res.final('sys.theta1')) print("theta2 = %f" %res.final('sys.theta2')) print("theta3 = %f" %res.final('sys.theta3'))
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 is the crystallizer example from Bieglers book in section 10.3. """ curr_dir = os.path.dirname(os.path.abspath(__file__)); # Compile and load model fmu_name = compile_fmu("Crystallizer.SimulateCrystallizer", os.path.join(curr_dir, "files", "Crystallizer.mop"), compiler_options={"enable_variable_scaling":True}) crys = load_fmu(fmu_name) # Simulate res = crys.simulate(final_time=25) time = res['time'] Ls = res['c.Ls'] Nc = res['c.Nc'] L = res['c.L'] Ac = res['c.Ac'] Vc = res['c.Vc'] Mc = res['c.Mc'] Cc = res['c.Cc'] Tc = res['c.Tc'] Ta = res['Ta'] Teq = res['c.Teq'] deltaT = res['c.deltaT'] Cbar = res['c.Cbar'] Tj = res['c.Tj'] if with_plots: plt.figure(1) plt.clf() plt.subplot(2,1,1) plt.plot(time,Ls) plt.grid() plt.subplot(2,1,2) plt.plot(time,Tj) plt.grid() plt.show() plt.figure(2) plt.clf() plt.subplot(4,1,1) plt.plot(time,Nc) plt.title('Nc') plt.grid() plt.subplot(4,1,2) plt.plot(time,L) plt.title('L') plt.grid() plt.subplot(4,1,3) plt.plot(time,Ac) plt.title('Ac') plt.grid() plt.subplot(4,1,4) plt.plot(time,Vc) plt.title('Vc') plt.grid() plt.figure(3) plt.clf() plt.subplot(4,1,1) plt.plot(time,Mc) plt.title('Mc') plt.grid() plt.subplot(4,1,2) plt.plot(time,Cc) plt.title('Cc') plt.grid() plt.subplot(4,1,3) plt.plot(time,Tc) plt.title('Tc') plt.grid() plt.subplot(4,1,4) plt.plot(time,Teq) plt.title('Teq') plt.grid() plt.show() plt.figure(4) plt.clf() plt.subplot(4,1,1) plt.plot(time,deltaT) plt.title('deltaT') plt.grid() plt.subplot(4,1,2) plt.plot(time,Cbar) plt.title('Cbar') plt.grid() plt.subplot(4,1,3) plt.plot(time,Teq-Tc) plt.title('Teq-Tc') plt.grid() plt.subplot(4,1,4) plt.plot(time,Ta) plt.title('Ta') plt.grid() plt.show() # Compile and load opt model jmu_name = compile_jmu("Crystallizer.OptCrystallizer", os.path.join(curr_dir, "files", "Crystallizer.mop"), compiler_options={"enable_variable_scaling":True}) crys_opt = JMUModel(jmu_name) # Set optimization options opt_opts = crys_opt.optimize_options() n_e = 20 opt_opts['n_e'] = n_e opt_opts['init_traj'] = res.result_data opt_opts['blocking_factors'] = N.ones(n_e,dtype=int) opt_opts['IPOPT_options']['max_iter'] = 1000 opt_opts['IPOPT_options']['tol'] = 1e-3 opt_opts['IPOPT_options']['dual_inf_tol'] = 1e-3 # Run optimization res_opt = crys_opt.optimize(options=opt_opts) # Get result data time = res_opt['time'] Ls = res_opt['c.Ls'] Nc = res_opt['c.Nc'] L = res_opt['c.L'] Ac = res_opt['c.Ac'] Vc = res_opt['c.Vc'] Mc = res_opt['c.Mc'] Cc = res_opt['c.Cc'] Tc = res_opt['c.Tc'] Teq = res_opt['c.Teq'] deltaT = res_opt['c.deltaT'] Cbar = res_opt['c.Cbar'] Tj = res_opt['c.Tj'] assert N.abs(res_opt.final('c.Tj') - 10.0) < 1e-3 if with_plots: plt.figure(1) plt.subplot(2,1,1) plt.hold(True) plt.plot(time,Ls) plt.subplot(2,1,2) plt.hold(True) plt.plot(time,Tj,'x-') plt.figure(2) plt.subplot(4,1,1) plt.hold(True) plt.plot(time,Nc) plt.title('Nc') plt.subplot(4,1,2) plt.hold(True) plt.plot(time,L) plt.title('L') plt.subplot(4,1,3) plt.hold(True) plt.plot(time,Ac) plt.title('Ac') plt.subplot(4,1,4) plt.hold(True) plt.plot(time,Vc) plt.title('Vc') plt.figure(3) plt.subplot(4,1,1) plt.hold(True) plt.plot(time,Mc) plt.title('Mc') plt.subplot(4,1,2) plt.hold(True) plt.plot(time,Cc) plt.title('Cc') plt.subplot(4,1,3) plt.hold(True) plt.plot(time,Tc) plt.title('Tc') plt.subplot(4,1,4) plt.hold(True) plt.plot(time,Teq) plt.title('Teq') plt.show() plt.figure(4) plt.subplot(4,1,1) plt.hold(True) plt.plot(time,deltaT) plt.title('deltaT') plt.subplot(4,1,2) plt.hold(True) plt.plot(time,Cbar) plt.title('Cbar') plt.subplot(4,1,3) plt.hold(True) plt.plot(time,Teq-Tc) plt.title('Teq-Tc') 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 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): """ Demonstrate how to solve a simple parameter estimation problem in form of a model of catalytic cracking of gas oil. Reference: Benchmarking Optimization Software with COPS Elizabeth D. Dolan and Jorge J. More ARGONNE NATIONAL LABORATORY """ curr_dir = os.path.dirname(os.path.abspath(__file__)) # Compile the Optimica model to a JMU jmu_name = compile_jmu( "JMExamples_opt.CatalyticCracking_opt", (os.path.join(curr_dir, 'files', 'JMExamples_opt.mop'), os.path.join(curr_dir, 'files', 'JMExamples.mo'))) # Load the dynamic library cc = JMUModel(jmu_name) # optimize opts = cc.optimize_options() opts['n_e'] = 20 res = cc.optimize(options=opts) # Extract variable profiles y1 = res['sys.y1'] y2 = res['sys.y2'] theta1 = res['sys.theta1'] theta2 = res['sys.theta2'] theta3 = res['sys.theta3'] t = res['time'] y1m = [ 1, 0.8105, 0.6208, 0.5258, 0.4345, 0.3903, 0.3342, 0.3034, 0.2735, 0.2405, 0.2283, 0.2071, 0.1669, 0.1530, 0.1339, 0.1265, 0.1200, 0.0990, 0.0870, 0.077, 0.069 ] y2m = [ 0, 0.2, 0.2886, 0.301, 0.3215, 0.3123, 0.2716, 0.2551, 0.2258, 0.1959, 0.1789, 0.1457, 0.1198, 0.0909, 0.0719, 0.0561, 0.0460, 0.0280, 0.0190, 0.0140, 0.01 ] tm = [ 0, 0.025, 0.05, 0.075, 0.1, 0.125, 0.15, 0.175, 0.2, 0.225, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.65, 0.75, 0.85, 0.95 ] assert N.abs(res.final('sys.theta1') - 11.835148) < 1e-5 assert N.abs(res.final('sys.theta2') - 8.338887) < 1e-5 assert N.abs(res.final('sys.theta3') - 1.007536) < 1e-5 if with_plots: plt.figure(1) plt.clf() plt.subplot(211) plt.plot(t, y1, tm, y1m, 'x') plt.grid() plt.ylabel('y1') plt.xlabel('time') plt.subplot(212) plt.plot(t, y2, tm, y2m, 'x') plt.grid() plt.ylabel('y2') plt.xlabel('time') plt.show() print("\n** Optimal parameter values: **") print("theta1 = %f" % res.final('sys.theta1')) print("theta2 = %f" % res.final('sys.theta2')) print("theta3 = %f" % res.final('sys.theta3'))