def test_simulation_with_algebraic_variables(self): """Run a simulation with a model with algebraic variables""" libname = 'RLC_Circuit' mofile = 'files' + sep + 'RLC_Circuit.mo' optpackage = 'RLC_Circuit' # Comile the Modelica model first to C code and # then to a dynamic library mc.compile_model(os.path.join(path_to_examples, mofile), libname) # Load the dynamic library and XML data model = jmi.Model(optpackage) # Running a simulation with the attribute return_last = True (Only the final result should be returned) simulator = SundialsDAESimulator(model, start_time=0.0, final_time=30.0, time_step=0.01, return_last=True, verbosity=4) simulator.run() memory = simulator.solver_memory simulator.run(30.0, 40.0) assert memory is simulator.solver_memory Ts, ys = simulator.get_solution() assert len(Ts) == len(ys) #Length of the vectors should be the same assert len(ys[0, :]) == 20 #Number of variables in the example #NO LONGER VALID """
def test_state_start_values_fixed(self): """ Test of the compiler option state_start_values_fixed """ """ Test of the dae_get_sizes in Model """ model = os.path.join("files", "VDP_pack.mo") fpath = os.path.join(path_to_tests, model) cpath = "VDP_pack.VDP" fname = cpath.replace('.', '_', 1) mc = ModelicaCompiler() mc.set_boolean_option('state_start_values_fixed', False) mc.compile_model(fpath, cpath) # Load the dynamic library and XML data vdp = jmi.Model(fname) res_n_eq_F = 2 n_eq_F, n_eq_R = vdp.jmimodel.dae_get_sizes() assert n_eq_F==res_n_eq_F, \ "test_jmi.py: test_Model_dae_get_sizes: Wrong number of DAE equations." res_n_eq_F0 = 2 res_n_eq_F1 = 5 res_n_eq_Fp = 0 res_n_eq_R0 = 0 n_eq_F0, n_eq_F1, n_eq_Fp, n_eq_R0 = vdp.jmimodel.init_get_sizes() assert n_eq_F0==res_n_eq_F0 and n_eq_F1==res_n_eq_F1 and n_eq_Fp==res_n_eq_Fp and n_eq_R0==res_n_eq_R0, \ "test_jmi.py: test_Model_dae_get_sizes: Wrong number of DAE initialization equations."
def test_Model_dae_get_sizes(): """ Test of the dae_get_sizes in Model """ model = "files" + sep + "VDP.mo" fpath = os.path.join(path_to_examples, model) cpath = "VDP_pack.VDP_Opt" fname = cpath.replace('.', '_', 1) oc.compile_model(fpath, cpath, target='ipopt') # Load the dynamic library and XML data vdp = jmi.Model(fname) res_n_eq_F = 3 n_eq_F = vdp.jmimodel.dae_get_sizes() assert n_eq_F==res_n_eq_F, \ "test_jmi.py: test_Model_dae_get_sizes: Wrong number of DAE equations." res_n_eq_F0 = 6 res_n_eq_F1 = 4 res_n_eq_Fp = 0 n_eq_F0, n_eq_F1, n_eq_Fp = vdp.jmimodel.init_get_sizes() assert n_eq_F0==res_n_eq_F0 and n_eq_F1==res_n_eq_F1 and n_eq_Fp==res_n_eq_Fp, \ "test_jmi.py: test_Model_dae_get_sizes: Wrong number of DAE initialization equations." res_n_eq_Ceq = 0 res_n_eq_Cineq = 1 res_n_eq_Heq = 0 res_n_eq_Hineq = 0 n_eq_Ceq, n_eq_Cineq, n_eq_Heq, n_eq_Hineq = vdp.jmimodel.opt_get_sizes() assert n_eq_Ceq==res_n_eq_Ceq and n_eq_Cineq==res_n_eq_Cineq and n_eq_Heq==res_n_eq_Heq and n_eq_Hineq==res_n_eq_Hineq, \ "test_jmi.py: test_Model_dae_get_sizes: Wrong number of constraints."
def test_f_gradient_elements(certainindex=None): """Basic testing of gradients (disabled by default). This tests takes slightly less than an hour to run on my computer unless certainindex is defined (whereas only the element of index certainindex will be tested). Therefor it is turned off by default. Set run_huge_test variable to True to run this test by default. Also note that this test is not really supposed to test functionality per se. It is rather a test that can be used to visually verify that gradients behave the way they are expected to. """ run_huge_test = False if run_huge_test is False and certainindex is None: return # m = load_example_standard_model('VDP_pack_VDP_Opt', 'VDP.mo', # 'VDP_pack.VDP_Opt') modelf = "files" + sep + "VDP.mo" fpath = os.path.join(path_to_examples, modelf) cpath = "VDP_pack.VDP_Opt" fname = cpath.replace('.', '_', 1) oc.compile_model(fpath, cpath, target='ipopt') # Load the dynamic library and XML data m = jmi.Model(fname) grid = [ (0, 0.1), (0.1, 0.2), (0.2, 0.3), (0.3, 0.4), (0.4, 0.5), (0.5, 0.6), (0.6, 0.7), (0.7, 0.8), (0.8, 0.9), (0.9, 1.0), ] initial_u = [0.25] * len(grid) shooter = MultipleShooter(m, initial_u, grid) p0 = shooter.get_p0() if certainindex is not None: indices = [certainindex] else: indices = range(len(p0)) for index in indices: fig = p.figure() evaluator = _PartialEvaluator(shooter.f, shooter.df, p0, index) p.suptitle('Partial derivative test (of gradient elements, index=%s)' % index) _verify_gradient(evaluator.f, evaluator.df, -10, 10) fig.savefig('test_f_gradient_elements_%s.png' % index) fig.savefig('test_f_gradient_elements_%s.eps' % index)
def setUp(self): """Load the test model.""" package = "VDP_pack_VDP_Opt" # Load the dynamic library and XML data self.m = jmi.Model(package) self.simulator = SundialsODESimulator(self.m, start_time=0.0, final_time=20.0)
def setUp(self): """Load the test model for DAE.""" package = "Pendulum_pack_Pendulum" # Load the dynamic library and XML data self.m = jmi.Model(package) self.simulator = SundialsDAESimulator(self.m, start_time=0.0, final_time=10.0)
def setUp(self): """Test setUp. Load the test model.""" self.cstr = jmi.Model(fname_cstr) # Initialize the mesh n_e = 150 # Number of elements hs = N.ones(n_e)*1./n_e # Equidistant points n_cp = 3; # Number of collocation points in each element # Create an NLP object self.nlp = ipopt.NLPCollocationLagrangePolynomials(self.cstr,n_e,hs,n_cp)
def test_set_get_model(self): """Test the model setter/getter.""" simulator = self.simulator assert simulator.get_model() == self.m package = "VDP_pack_VDP_Opt" # Load the dynamic library and XML data another_model = jmi.Model(package) simulator.set_model(another_model) assert simulator.get_model() == another_model nose.tools.assert_raises(jmodelica.simulation.SimulationException, simulator.set_model, None) # Load the dynamic library and XML data another_model = jmi.Model(package) simulator.model = another_model # testing property assert another_model == simulator.get_model()
def setUp(self): """Test setUp. Load the test model.""" self.vdp = jmi.Model(fname_vdp) # Initialize the mesh n_e = 100 # Number of elements hs = N.ones(n_e)*1./n_e # Equidistant points self.hs = hs n_cp = 3; # Number of collocation points in each element # Create an NLP object self.nlp = ipopt.NLPCollocationLagrangePolynomials(self.vdp,n_e,hs,n_cp) self.nlp_ipopt = ipopt.CollocationOptimizer(self.nlp)
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' mc = ModelicaCompiler() # Comile the Modelica model first to C code and # then to a dynamic library mc.compile_model(mofile,model_name,target='ipopt') # Load the dynamic library and XML data model=jmi.Model(model_name) # Create DAE initialization object. init_nlp = NLPInitialization(model) # Create an Ipopt solver object for the DAE initialization system init_nlp_ipopt = InitializationOptimizer(init_nlp) # Solve the DAE initialization system with Ipopt init_nlp_ipopt.init_opt_ipopt_solve() simulator = SundialsDAESimulator(model, verbosity=3, start_time=0.0, final_time=30.0, time_step=0.01) simulator.run() simulator.write_data() # Load the file we just wrote to file res = jmodelica.io.ResultDymolaTextual('RLC_Circuit_result.txt') sine_y = res.get_variable_data('sine.y') resistor_v = res.get_variable_data('resistor.v') inductor1_i = res.get_variable_data('inductor1.i') assert N.abs(resistor_v.x[-1] - 0.159255008028) < 1e-3, \ "Wrong value in simulation result in RLC.py" #Ts, ys = simulator.get_solution('sine.y','resistor.v','inductor1.i') fig = p.figure() p.plot(sine_y.t, sine_y.x, resistor_v.t, resistor_v.x, inductor1_i.t, inductor1_i.x) p.legend(('sine.y','resistor.v','inductor1.i')) p.show()
def run_demo(with_plots=True): mc = ModelicaCompiler() # Comile the Modelica model first to C code and # then to a dynamic library mofile = 'RLC_Circuit.mo' optpackage = 'RLC_Circuit' path = get_example_path() os.chdir(path) mc.compile_model(os.path.join(path, mofile), optpackage, target='ipopt') # Load the dynamic library and XML data rlc=jmi.Model('RLC_Circuit') # Create DAE initialization object. init_rlc = NLPInitialization(rlc) # Create an Ipopt solver object for the DAE initialization system init_rlc_ipopt = InitializationOptimizer(init_rlc) # Solve the DAE initialization system with Ipopt init_rlc_ipopt.init_opt_ipopt_solve() # Simulate system... # Verify solution by loading result file generated by dymola res = jmodelica.io.ResultDymolaBinary('RLC_Circuit_dymola.mat') # Get result variables V_in = res.get_variable_data('sine.y') V_resistor = res.get_variable_data('resistor.v') I_inductor1 = res.get_variable_data('inductor1.i') if with_plots: plt.figure(1) plt.clf() plt.hold(True) plt.plot(V_in.t,V_in.x) plt.plot(V_resistor.t,V_resistor.x) plt.plot(I_inductor1.t,I_inductor1.x) plt.show()
def test_plot_control_solutions(): """Testing plot_control_solutions(...).""" # m = load_example_standard_model('VDP_pack_VDP_Opt', 'VDP.mo', # 'VDP_pack.VDP_Opt') modelf = "files" + sep + "VDP.mo" fpath = os.path.join(path_to_examples, modelf) cpath = "VDP_pack.VDP_Opt" fname = cpath.replace('.', '_', 1) oc.compile_model(fpath, cpath, target='ipopt') # Load the dynamic library and XML data m = jmi.Model(fname) m.reset() grid = [ (0, 0.1), (0.1, 0.2), (0.2, 0.3), (0.3, 0.4), (0.4, 0.5), (0.5, 0.6), (0.6, 0.7), (0.7, 0.8), (0.8, 0.9), (0.9, 1.0), ] grid = N.array(grid) * (m.opt_interval_get_final_time() - m.opt_interval_get_start_time()) + \ m.opt_interval_get_start_time() # Used to be: N.array([1, 1, 1, 1]*len(grid)) us = [ -1.86750972e+00, -1.19613740e+00, 3.21955502e+01, 1.15871750e+00, -9.56876370e-01, 7.82651050e+01, -3.35655693e-01, 1.95491165e+00, 1.47923425e+02, -2.32963068e+00, -1.65371763e-01, 1.94340923e+02, 6.82953492e-01, -1.57360749e+00, 2.66717232e+02, 1.46549806e+00, 1.74702679e+00, 3.29995167e+02, -1.19712096e+00, 9.57726717e-01, 3.80947471e+02, 3.54379487e-01, -1.95842811e+00, 4.52105868e+02, 2.34170339e+00, 1.77754406e-01, 4.98700011e+02, 2.50000000e-01, 2.50000000e-01, 2.50000000e-01, 2.50000000e-01, 2.50000000e-01, 1.36333570e-01, 2.50000000e-01, 2.50000000e-01, 2.50000000e-01, 2.50000000e-01 ] us = N.array(us) plot_control_solutions(m, grid, us, doshow=False)
def setUp(self): # DLLFILE = 'VDP_pack_VDP_Opt' # MODELICA_FILE = 'VDP.mo' # MODEL_PACKAGE = 'VDP_pack.VDP_Opt' # # model = load_example_standard_model(DLLFILE, MODELICA_FILE, # MODEL_PACKAGE) modelf = "files" + sep + "VDP.mo" fpath = os.path.join(path_to_examples, modelf) cpath = "VDP_pack.VDP_Opt" fname = cpath.replace('.', '_', 1) oc.compile_model(fpath, cpath, target='ipopt') # Load the dynamic library and XML data model = jmi.Model(fname) self._model = model
def setUp(self): #DLLFILE = 'VDP_pack_VDP_Opt' #MODELICA_FILE = 'VDP.mo' #MODEL_PACKAGE = 'VDP_pack.VDP_Opt' #model = load_example_standard_model(DLLFILE, MODELICA_FILE, # MODEL_PACKAGE) modelf = "files" + sep + "VDP.mo" fpath = os.path.join(path_to_examples, modelf) cpath = "VDP_pack.VDP_Opt" fname = cpath.replace('.', '_', 1) oc.compile_model(fpath, cpath, target='ipopt') #oc.compile_model(fpath, cpath) # Load the dynamic library and XML data model = jmi.Model(fname) GRIDSIZE = 10 shooter = _lazy_init_shooter(model, GRIDSIZE) p0 = shooter.get_p0() self._shooter = shooter self._p0 = p0
def test_dymola_export_import(): # Load the dynamic library and XML data vdp = jmi.Model(fname) # Initialize the mesh n_e = 50 # Number of elements hs = N.ones(n_e) * 1. / n_e # Equidistant points n_cp = 3 # Number of collocation points in each element # Create an NLP object nlp = ipopt.NLPCollocationLagrangePolynomials(vdp, n_e, hs, n_cp) # Create an Ipopt NLP object nlp_ipopt = ipopt.CollocationOptimizer(nlp) # Solve the optimization problem nlp_ipopt.opt_sim_ipopt_solve() # Get the result p_opt, traj = nlp.get_result() # Write to file nlp.export_result_dymola() # Load the file we just wrote res = jmodelica.io.ResultDymolaTextual(fname + '_result.txt') # Check that one of the trajectories match. assert max(N.abs(traj[:,3]-res.get_variable_data('x1').x))<1e-12, \ "The result in the loaded result file does not match that of the loaded file." # Check that the value of the cost function is correct assert N.abs(p_opt[0]-2.2811587)<1e-5, \ "The optimal value is not correct."
def __init__(self): self.vdp = jmi.Model(fname_vdp)
def __init__(self): # Load the dynamic library and XML data self.vdp = jmi.Model(fname_vdp)
def __init__(self): """Load the test model.""" # Load the dynamic library and XML data self.cstr = jmi.Model(fname_cstr)
def run_demo(with_plots=True): """Demonstrate how to solve a dynamic optimization problem based on an inverted pendulum system.""" oc = OptimicaCompiler() oc.set_boolean_option('state_start_values_fixed', True) curr_dir = os.path.dirname(os.path.abspath(__file__)) # Comile the Optimica model first to C code and # then to a dynamic library oc.compile_model(curr_dir + "/files/Pendulum_pack.mo", "Pendulum_pack.Pendulum_Opt", target='ipopt') # Load the dynamic library and XML data pend = jmi.Model("Pendulum_pack_Pendulum_Opt") # Initialize the mesh n_e = 50 # Number of elements hs = N.ones(n_e) * 1. / n_e # Equidistant points n_cp = 3 # Number of collocation points in each element # Create an NLP object nlp = ipopt.NLPCollocationLagrangePolynomials(pend, n_e, hs, n_cp) # Create an Ipopt NLP object nlp_ipopt = ipopt.CollocationOptimizer(nlp) # Solve the optimization problem nlp_ipopt.opt_sim_ipopt_solve() # Write to file. The resulting file can also be # loaded into Dymola. nlp.export_result_dymola() # Load the file we just wrote to file res = jmodelica.io.ResultDymolaTextual( 'Pendulum_pack_Pendulum_Opt_result.txt') # Extract variable profiles theta = res.get_variable_data('pend.theta') dtheta = res.get_variable_data('pend.dtheta') x = res.get_variable_data('pend.x') dx = res.get_variable_data('pend.dx') u = res.get_variable_data('u') cost = res.get_variable_data('cost') assert N.abs(cost.x[-1] - 1.2921683e-01) < 1e-3, \ "Wrong value of cost function in pendulum.py" if with_plots: # Plot plt.figure(1) plt.clf() plt.subplot(211) plt.plot(theta.t, theta.x) plt.grid() plt.ylabel('th') plt.subplot(212) plt.plot(theta.t, theta.x) plt.grid() plt.ylabel('dth') plt.xlabel('time') plt.show() plt.figure(2) plt.clf() plt.subplot(311) plt.plot(x.t, x.x) plt.grid() plt.ylabel('x') plt.subplot(312) plt.plot(dx.t, dx.x) plt.grid() plt.ylabel('dx') plt.xlabel('time') plt.subplot(313) plt.plot(u.t, u.x) plt.grid() plt.ylabel('u') plt.xlabel('time') plt.show()
def run_demo(with_plots=True): """Optimal control of the quadruple tank process.""" oc = OptimicaCompiler() oc.set_boolean_option('state_start_values_fixed', True) curr_dir = os.path.dirname(os.path.abspath(__file__)) # Compile the Optimica model first to C code and # then to a dynamic library oc.compile_model(curr_dir + "/files/QuadTank.mo", "QuadTank_pack.QuadTank_Opt", target='ipopt') # Load the dynamic library and XML data qt = jmi.Model("QuadTank_pack_QuadTank_Opt") # Define inputs for operating point A u_A = N.array([2., 2]) # Define inputs for operating point B u_B = N.array([2.5, 2.5]) x_0 = N.ones(4) * 0.01 def res(y, t): for i in range(4): qt.get_x()[i] = y[i] qt.jmimodel.ode_f() return qt.get_dx()[0:4] # Compute stationary state values for operating point A qt.set_u(u_A) #qt.getPI()[21] = u_A[0] #qt.getPI()[22] = u_A[1] t_sim = N.linspace(0., 2000., 500) y_sim = int.odeint(res, x_0, t_sim) x_A = y_sim[-1, :] if with_plots: # Plot plt.figure(1) plt.clf() plt.subplot(211) plt.plot(t_sim, y_sim[:, 0:4]) plt.grid() # Compute stationary state values for operating point A qt.set_u(u_B) t_sim = N.linspace(0., 2000., 500) y_sim = int.odeint(res, x_0, t_sim) x_B = y_sim[-1, :] if with_plots: # Plot plt.figure(1) plt.subplot(212) plt.plot(t_sim, y_sim[:, 0:4]) plt.grid() plt.show() qt.get_pi()[13] = x_A[0] qt.get_pi()[14] = x_A[1] qt.get_pi()[15] = x_A[2] qt.get_pi()[16] = x_A[3] qt.get_pi()[17] = x_B[0] qt.get_pi()[18] = x_B[1] qt.get_pi()[19] = x_B[2] qt.get_pi()[20] = x_B[3] qt.get_pi()[21] = u_B[0] qt.get_pi()[22] = u_B[1] # Solve optimal control problem # Initialize the mesh n_e = 50 # Number of elements hs = N.ones(n_e) * 1. / n_e # Equidistant points n_cp = 3 # Number of collocation points in each element # Create an NLP object nlp = ipopt.NLPCollocationLagrangePolynomials(qt, n_e, hs, n_cp) # Create an Ipopt NLP object nlp_ipopt = ipopt.CollocationOptimizer(nlp) #nlp_ipopt.opt_sim_ipopt_set_string_option("derivative_test","first-order") nlp_ipopt.opt_sim_ipopt_set_int_option("max_iter", 500) # Solve the optimization problem nlp_ipopt.opt_sim_ipopt_solve() # Write to file. The resulting file can also be # loaded into Dymola. nlp.export_result_dymola() # Load the file we just wrote to file res = jmodelica.io.ResultDymolaTextual( 'QuadTank_pack_QuadTank_Opt_result.txt') # Extract variable profiles x1 = res.get_variable_data('x1') x2 = res.get_variable_data('x2') x3 = res.get_variable_data('x3') x4 = res.get_variable_data('x4') u1 = res.get_variable_data('u1') u2 = res.get_variable_data('u2') cost = res.get_variable_data('cost') assert N.abs(cost.x[-1] - 5.0333257e+02) < 1e-3, \ "Wrong value of cost function in quadtank.py" if with_plots: # Plot plt.figure(2) plt.clf() plt.subplot(411) plt.plot(x1.t, x1.x) plt.grid() plt.ylabel('x1') plt.subplot(412) plt.plot(x2.t, x2.x) plt.grid() plt.ylabel('x2') plt.subplot(413) plt.plot(x3.t, x3.x) plt.grid() plt.ylabel('x3') plt.subplot(414) plt.plot(x4.t, x4.x) plt.grid() plt.ylabel('x4') plt.show() plt.figure(3) plt.clf() plt.subplot(211) plt.plot(u1.t, u1.x) plt.grid() plt.ylabel('u1') plt.subplot(212) plt.plot(u2.t, u2.x) plt.grid() plt.ylabel('u2') if __name__ == "__main__": run_demo()
def run_demo(with_plots=True): """Demonstrate how to solve a minimum time dynamic optimization problem based on a Van der Pol oscillator system.""" oc = OptimicaCompiler() oc.set_boolean_option('state_start_values_fixed',True) curr_dir = os.path.dirname(os.path.abspath(__file__)); # Compile the Optimica model first to C code and # then to a dynamic library oc.compile_model(curr_dir+"/files/VDP.mo", "VDP_pack.VDP_Opt", target='ipopt') # Load the dynamic library and XML data vdp=jmi.Model("VDP_pack_VDP_Opt") # Initialize the mesh n_e = 50 # Number of elements hs = N.ones(n_e)*1./n_e # Equidistant points n_cp = 3; # Number of collocation points in each element # Create an NLP object nlp = ipopt.NLPCollocationLagrangePolynomials(vdp,n_e,hs,n_cp) # Create an Ipopt NLP object nlp_ipopt = ipopt.CollocationOptimizer(nlp) # nlp_ipopt.opt_sim_ipopt_set_string_option("derivative_test","first-order") nlp_ipopt.opt_sim_ipopt_set_int_option("max_iter",500) # Solve the optimization problem nlp_ipopt.opt_sim_ipopt_solve() # Retreive the number of points in each column in the # result matrix n_points = nlp.opt_sim_get_result_variable_vector_length() # Write to file. The resulting file can also be # loaded into Dymola. nlp.export_result_dymola() # Load the file we just wrote to file res = jmodelica.io.ResultDymolaTextual('VDP_pack_VDP_Opt_result.txt') # Extract variable profiles x1=res.get_variable_data('x1') x2=res.get_variable_data('x2') u=res.get_variable_data('u') cost=res.get_variable_data('cost') assert N.abs(cost.x[-1] - 2.3469089e+01) < 1e-3, \ "Wrong value of cost function in vdp.py" if with_plots: # Plot plt.figure(1) plt.clf() plt.subplot(311) plt.plot(x1.t,x1.x) plt.grid() plt.ylabel('x1') plt.subplot(312) plt.plot(x2.t,x2.x) plt.grid() plt.ylabel('x2') plt.subplot(313) plt.plot(u.t,u.x) plt.grid() plt.ylabel('u') plt.xlabel('time') plt.show()
def test_init_opt(self): """ Test of DAE initialization optimization problem """ model_daeinit = os.path.join("files", "DAEInitTest.mo") fpath_daeinit = os.path.join(path_to_tests, model_daeinit) cpath_daeinit = "DAEInitTest" fname_daeinit = cpath_daeinit.replace('.', '_', 1) oc.set_boolean_option('state_start_values_fixed', True) oc.compile_model(fpath_daeinit, cpath_daeinit, target='ipopt') # Load the dynamic library and XML data dae_init_test = jmi.Model(fname_daeinit) init_nlp = NLPInitialization(dae_init_test) # Test init_opt_get_dimensions res_n_x = 8 res_n_h = 8 res_dh_n_nz = 17 n_x, n_h, dh_n_nz = init_nlp.init_opt_get_dimensions() assert N.abs(res_n_x-n_x) + N.abs(res_n_h-n_h) + \ N.abs(res_dh_n_nz-dh_n_nz)==0, \ "test_jmi.py: test_init_opt: init_opt_get_dimensions returns wrong problem dimensions." # Test init_opt_get_x_init res_x_init = N.array([0, 0, 3, 4, 1, 0, 0, 0]) x_init = N.zeros(n_x) init_nlp.init_opt_get_initial(x_init) assert N.sum(N.abs(res_x_init-x_init))<1e-3, \ "test_jmi.py: test_init_opt: init_opt_get_x_init returns wrong values." # Test init_opt_set_x_init res_x_init = N.ones(n_x) x_init = N.ones(n_x) init_nlp.init_opt_set_initial(x_init) init_nlp.init_opt_get_initial(x_init) assert N.sum(N.abs(res_x_init-x_init))<1e-3, \ "test_jmi.py: test_init_opt: init_opt_get_x_init returns wrong values after setting the initial values with init_opt_get_x_init." # Test init_opt_get_bounds res_x_lb = -1e20 * N.ones(n_x) res_x_ub = 1e20 * N.ones(n_x) x_lb = N.zeros(n_x) x_ub = N.zeros(n_x) init_nlp.init_opt_get_bounds(x_lb, x_ub) assert N.sum(N.abs(res_x_lb-x_lb))<1e-3, \ "test_jmi.py: test_init_opt: init_opt_get_bounds returns wrong lower bounds." assert N.sum(N.abs(res_x_lb-x_lb))<1e-3, \ "test_jmi.py: test_init_opt: init_opt_get_bounds returns wrong upper bounds." # Test init_opt_set_bounds res_x_lb = -5000 * N.ones(n_x) res_x_ub = 5000 * N.ones(n_x) x_lb = -5000 * N.ones(n_x) x_ub = 5000 * N.ones(n_x) init_nlp.init_opt_set_bounds(x_lb, x_ub) init_nlp.init_opt_get_bounds(x_lb, x_ub) assert N.sum(N.abs(res_x_lb-x_lb))<1e-3, \ "test_jmi.py: test_init_opt: init_opt_get_bounds returns wrong lower bounds after calling init_opt_set_bounds." assert N.sum(N.abs(res_x_lb-x_lb))<1e-3, \ "test_jmi.py: test_init_opt: init_opt_get_bounds returns wrong upper bounds after calling init_opt_set_bounds." # Test init_opt_f res_f = N.array([0.]) f = N.zeros(1) init_nlp.init_opt_f(f) assert N.sum(N.abs(res_f-f))<1e-3, \ "test_jmi.py: test_init_opt: init_opt_f returns wrong value" # Test init_opt_df res_df = N.array([0., 0, 0, 0, 0, 0, 0, 0]) df = N.ones(n_x) init_nlp.init_opt_df(df) assert N.sum(N.abs(res_df-df))<1e-3, \ "test_jmi.py: test_init_opt: init_opt_df returns wrong value" # Test init_opt_h res_h = N.array([ -1.98158529e+02, -2.43197505e-01, 5.12000000e+02, 5.00000000e+00, 1.41120008e-01, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00 ]) h = N.zeros(n_h) init_nlp.init_opt_h(h) assert N.sum(N.abs(res_h-h))<1e-3, \ "test_jmi.py: test_init_opt: init_opt_h returns wrong value" # Test init_opt_dh res_dh = N.array([ -1., -1., -135., 192., -0.9899925, -1., -48., 0.65364362, -1., 0.54030231, -2., -1., -1., 0.9899925, 192., -1., -1., ]) dh = N.ones(dh_n_nz) init_nlp.init_opt_dh(dh) assert N.sum(N.abs(res_dh-dh))<1e-3, \ "test_jmi.py: test_init_opt: init_opt_dh returns wrong value" # Test init_opt_dh_nz_inidices res_dh_irow = N.array( [1, 2, 1, 3, 5, 7, 1, 2, 8, 1, 2, 6, 3, 5, 3, 4, 5]) res_dh_icol = N.array( [1, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 7, 7, 8]) dh_irow = N.zeros(dh_n_nz, dtype=N.int32) dh_icol = N.zeros(dh_n_nz, dtype=N.int32) init_nlp.init_opt_dh_nz_indices(dh_irow, dh_icol) assert N.sum(N.abs(res_dh_irow-dh_irow))<1e-3, \ "test_jmi.py: test_init_opt: init_opt_dh_nz_indices returns wrong values for the row indices." assert N.sum(N.abs(res_dh_icol-dh_icol))<1e-3, \ "test_jmi.py: test_init_opt: init_opt_dh_nz_indices returns wrong values for the column indices" # Test optimization of initialization system init_nlp_ipopt = InitializationOptimizer(init_nlp) # init_nlp_ipopt.init_opt_ipopt_set_string_option("derivative_test","first-order") init_nlp_ipopt.init_opt_ipopt_solve() res_Z = N.array([ 5., -198.1585290151921, -0.2431975046920718, 3.0, 4.0, 1.0, 2197.0, 5.0, -0.92009689684513785, 0. ]) assert max(N.abs(res_Z-dae_init_test.get_z()))<1e-3, \ "test_jmi.py: test_init_opt: Wrong solution to initialization system."
def run_demo(with_plots=True): """Demonstrate how to solve a dynamic optimization problem based on an inverted pendulum system.""" oc = OptimicaCompiler() oc.set_boolean_option('state_start_values_fixed', True) curr_dir = os.path.dirname(os.path.abspath(__file__)) # Comile the Optimica model first to C code and # then to a dynamic library oc.compile_model(curr_dir + "/files/Pendulum_pack.mo", "Pendulum_pack.Pendulum_Opt", target='ipopt') # Load the dynamic library and XML data pend = jmi.Model("Pendulum_pack_Pendulum_Opt") # Initialize the mesh n_e = 50 # Number of elements hs = N.ones(n_e) * 1. / n_e # Equidistant points n_cp = 3 # Number of collocation points in each element # Create an NLP object nlp = jmi.SimultaneousOptLagPols(pend, n_e, hs, n_cp) # Create an Ipopt NLP object nlp_ipopt = jmi.JMISimultaneousOptIPOPT(nlp.jmi_simoptlagpols) # Solve the optimization problem nlp_ipopt.opt_sim_ipopt_solve() # Retreive the number of points in each column in the # result matrix n_points = nlp.jmi_simoptlagpols.opt_sim_get_result_variable_vector_length( ) n_points = n_points.value # Create result data vectors p_opt = N.zeros(1) t_ = N.zeros(n_points) dx_ = N.zeros(5 * n_points) x_ = N.zeros(5 * n_points) u_ = N.zeros(n_points) w_ = N.zeros(n_points) # Get the result nlp.jmi_simoptlagpols.opt_sim_get_result(p_opt, t_, dx_, x_, u_, w_) if with_plots: # Plot plt.figure(1) plt.clf() plt.subplot(211) plt.plot(t_, x_[n_points:2 * n_points]) plt.grid() plt.ylabel('th') plt.subplot(212) plt.plot(t_, x_[n_points * 2:n_points * 3]) plt.grid() plt.ylabel('dth') plt.xlabel('time') plt.show() plt.figure(2) plt.clf() plt.subplot(311) plt.plot(t_, x_[n_points * 3:n_points * 4]) plt.grid() plt.ylabel('x') plt.subplot(312) plt.plot(t_, x_[n_points * 4:n_points * 5]) plt.grid() plt.ylabel('dx') plt.xlabel('time') plt.subplot(313) plt.plot(t_, u_) plt.grid() plt.ylabel('u') plt.xlabel('time') 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__)); # Create a Modelica compiler instance oc = OptimicaCompiler() # Compile the stationary initialization model into a DLL oc.compile_model(curr_dir+"/files/CSTR.mo", "CSTR.CSTR_Init", target='ipopt') # Load a model instance into Python init_model = jmi.Model("CSTR_CSTR_Init") # Create DAE initialization object. init_nlp = NLPInitialization(init_model) # Create an Ipopt solver object for the DAE initialization system init_nlp_ipopt = InitializationOptimizer(init_nlp) # Set inputs for Stationary point A Tc_0_A = 250 init_model.set_value('Tc',Tc_0_A) # init_nlp_ipopt.init_opt_ipopt_set_string_option("derivative_test","first-order") # init_nlp_ipopt.init_opt_ipopt_set_int_option("max_iter",5) # Solve the DAE initialization system with Ipopt init_nlp_ipopt.init_opt_ipopt_solve() # Store stationary point A c_0_A = init_model.get_value('c') T_0_A = init_model.get_value('T') # 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_value('Tc',Tc_0_B) # Solve the DAE initialization system with Ipopt init_nlp_ipopt.init_opt_ipopt_solve() # Store stationary point A c_0_B = init_model.get_value('c') T_0_B = init_model.get_value('T') # 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 # Create the time vector t = N.linspace(1,150.,100) # Create the input vector from the target input value. The # target input value is here increased in order to get a # better initial guess. u = (Tc_0_B+35)*N.ones(N.size(t,0)) u = N.array([u]) u = N.transpose(u) # Create a Trajectory object that can be passed to the simulator u_traj = TrajectoryLinearInterpolation(t,u) # Comile the Modelica model first to C code and # then to a dynamic library oc.compile_model(curr_dir+"/files/CSTR.mo","CSTR.CSTR_Init_Optimization",target='ipopt') # Load the dynamic library and XML data init_sim_model=jmi.Model("CSTR_CSTR_Init_Optimization") # Set model parameters init_sim_model.set_value('cstr.c_init',c_0_A) init_sim_model.set_value('cstr.T_init',T_0_A) init_sim_model.set_value('Tc_0',Tc_0_A) init_sim_model.set_value('c_ref',c_0_B) init_sim_model.set_value('T_ref',T_0_B) init_sim_model.set_value('Tc_ref',u_traj.eval(0.)[0]) # Create DAE initialization object. init_nlp = NLPInitialization(init_sim_model) # Create an Ipopt solver object for the DAE initialization system init_nlp_ipopt = InitializationOptimizer(init_nlp) # Solve the DAE initialization system with Ipopt init_nlp_ipopt.init_opt_ipopt_solve() # Create a simulator simulator = SundialsDAESimulator(init_sim_model, verbosity=3, start_time=0.0, \ final_time=150, time_step=0.01,input=u_traj) # Run simulation simulator.run() # Write data to file simulator.write_data() # Load the file we just wrote to file res = jmodelica.io.ResultDymolaTextual('CSTR_CSTR_Init_Optimization_result.txt') # Extract variable profiles c_init_sim=res.get_variable_data('cstr.c') T_init_sim=res.get_variable_data('cstr.T') Tc_init_sim=res.get_variable_data('cstr.Tc') # Plot the results if with_plots: plt.figure(1) plt.clf() plt.hold(True) plt.subplot(311) plt.plot(c_init_sim.t,c_init_sim.x) plt.grid() plt.ylabel('Concentration') plt.subplot(312) plt.plot(T_init_sim.t,T_init_sim.x) plt.grid() plt.ylabel('Temperature') plt.subplot(313) plt.plot(Tc_init_sim.t,Tc_init_sim.x) plt.grid() plt.ylabel('Cooling temperature') plt.xlabel('time') plt.show() # Solve optimal control problem oc.compile_model(curr_dir+"/files/CSTR.mo", "CSTR.CSTR_Opt", target='ipopt') cstr = jmi.Model("CSTR_CSTR_Opt") cstr.set_value('Tc_ref',Tc_0_B) cstr.set_value('c_ref',c_0_B) cstr.set_value('T_ref',T_0_B) cstr.set_value('cstr.c_init',c_0_A) cstr.set_value('cstr.T_init',T_0_A) # Initialize the mesh 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 # Create an NLP object nlp = ipopt.NLPCollocationLagrangePolynomials(cstr,n_e,hs,n_cp) # Use the simulated trajectories to initialize the model nlp.set_initial_from_dymola(res, hs, 0, 0) # Create an Ipopt NLP object nlp_ipopt = ipopt.CollocationOptimizer(nlp) nlp_ipopt.opt_sim_ipopt_set_int_option("max_iter",500) # Solve the optimization problem nlp_ipopt.opt_sim_ipopt_solve() # Write to file. The resulting file (CSTR_CSTR_Opt_result.txt) can also be # loaded into Dymola. nlp.export_result_dymola() # Load the file we just wrote to file res = jmodelica.io.ResultDymolaTextual('CSTR_CSTR_Opt_result.txt') # Extract variable profiles c_res=res.get_variable_data('cstr.c') T_res=res.get_variable_data('cstr.T') Tc_res=res.get_variable_data('cstr.Tc') c_ref=res.get_variable_data('c_ref') T_ref=res.get_variable_data('T_ref') Tc_ref=res.get_variable_data('Tc_ref') cost=res.get_variable_data('cost') assert N.abs(cost.x[-1]/1.e7 - 1.8585429) < 1e-3, \ "Wrong value of cost function in cstr.py" # Plot the results if with_plots: plt.figure(2) plt.clf() plt.hold(True) plt.subplot(311) plt.plot(c_res.t,c_res.x) plt.plot(c_ref.t,c_ref.x,'--') plt.grid() plt.ylabel('Concentration') plt.subplot(312) plt.plot(T_res.t,T_res.x) plt.plot(T_ref.t,T_ref.x,'--') plt.grid() plt.ylabel('Temperature') plt.subplot(313) plt.plot(Tc_res.t,Tc_res.x) plt.plot(Tc_ref.t,Tc_ref.x,'--') plt.grid() plt.ylabel('Cooling temperature') plt.xlabel('time') plt.show() # Simulate to verify the optimal solution # Set up input trajectory t = Tc_res.t u = Tc_res.x u = N.array([u]) u = N.transpose(u) u_traj = TrajectoryLinearInterpolation(t,u) # Comile the Modelica model first to C code and # then to a dynamic library oc.compile_model(curr_dir+"/files/CSTR.mo","CSTR.CSTR",target='ipopt') # Load the dynamic library and XML data sim_model=jmi.Model("CSTR_CSTR") sim_model.set_value('c_init',c_0_A) sim_model.set_value('T_init',T_0_A) sim_model.set_value('Tc',u_traj.eval(0.)[0]) # Create DAE initialization object. init_nlp = NLPInitialization(sim_model) # Create an Ipopt solver object for the DAE initialization system init_nlp_ipopt = InitializationOptimizer(init_nlp) # Solve the DAE initialization system with Ipopt init_nlp_ipopt.init_opt_ipopt_solve() simulator = SundialsDAESimulator(sim_model, verbosity=3, start_time=0.0, \ final_time=150, time_step=0.01,input=u_traj) # Run simulation simulator.run() # Store simulation data to file simulator.write_data() # Load the file we just wrote to file res = jmodelica.io.ResultDymolaTextual('CSTR_CSTR_result.txt') # Extract variable profiles c_sim=res.get_variable_data('c') T_sim=res.get_variable_data('T') Tc_sim=res.get_variable_data('Tc') # Plot the results if with_plots: plt.figure(3) plt.clf() plt.hold(True) plt.subplot(311) plt.plot(c_res.t,c_res.x,'--') plt.plot(c_sim.t,c_sim.x) plt.legend(('optimized','simulated')) plt.grid() plt.ylabel('Concentration') plt.subplot(312) plt.plot(T_res.t,T_res.x,'--') plt.plot(T_sim.t,T_sim.x) plt.legend(('optimized','simulated')) plt.grid() plt.ylabel('Temperature') plt.subplot(313) plt.plot(Tc_res.t,Tc_res.x,'--') plt.plot(Tc_sim.t,Tc_sim.x) plt.legend(('optimized','simulated')) plt.grid() plt.ylabel('Cooling temperature') plt.xlabel('time') 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} } """ curr_dir = os.path.dirname(os.path.abspath(__file__)) # Create a Modelica compiler instance mc = ModelicaCompiler() # Compile the stationary initialization model into a DLL mc.compile_model(curr_dir + "/files/DISTLib.mo", "DISTLib.Binary_Dist_initial", target='ipopt') # Load a model instance into Python init_model = jmi.Model("DISTLib_Binary_Dist_initial") # Create DAE initialization object. init_nlp = NLPInitialization(init_model) # Create an Ipopt solver object for the DAE initialization system init_nlp_ipopt = InitializationOptimizer(init_nlp) # Set inputs for Stationary point A u1_0_A = 3.0 init_model.set_value('u1', u1_0_A) # init_nlp_ipopt.init_opt_ipopt_set_string_option("derivative_test","first-order") #init_nlp_ipopt.init_opt_ipopt_set_int_option("max_iter",5) # Solve the DAE initialization system with Ipopt init_nlp_ipopt.init_opt_ipopt_solve() # 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_value('y' + str(i + 1)) x_A[i] = init_model.get_value('x' + str(i + 1)) print '(' + str(i + 1) + ', %f, %f)' % (x_A[i], y_A[i]) # Set inputs for stationary point B u1_0_B = 3.0 - 1 init_model.set_value('u1', u1_0_B) # init_nlp_ipopt.init_opt_ipopt_set_string_option("derivative_test","first-order") #init_nlp_ipopt.init_opt_ipopt_set_int_option("max_iter",5) # Solve the DAE initialization system with Ipopt init_nlp_ipopt.init_opt_ipopt_solve() # 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_value('y' + str(i + 1)) x_B[i] = init_model.get_value('x' + str(i + 1)) print '(' + str(i + 1) + ', %f, %f)' % (x_B[i], y_B[i]) # ## Set up and solve an optimal control problem. # Create an OptimicaCompiler instance oc = OptimicaCompiler() # Generate initial equations for states even if fixed=false oc.set_boolean_option('state_start_values_fixed', True) # Compil the Model oc.compile_model( (curr_dir + "/files/DISTLib.mo", curr_dir + "/files/DISTLib_Opt.mo"), "DISTLib_Opt.Binary_Dist_Opt1", target='ipopt') # Load the dynamic library and XML data model = jmi.Model("DISTLib_Opt_Binary_Dist_Opt1") # Initialize the model with parameters # Initialize the model to stationary point A for i in range(N.size(x_A)): model.set_value('x' + str(i + 1) + '_0', x_A[i]) # Set the target values to stationary point B model.set_value('u1_ref', u1_0_B) model.set_value('y1_ref', y_B[0]) # Initialize the optimization mesh n_e = 50 # Number of elements hs = N.ones(n_e) * 1. / n_e # Equidistant points n_cp = 3 # Number of collocation points in each element # Create an NLP object representing the discretized problem nlp = ipopt.NLPCollocationLagrangePolynomials(model, n_e, hs, n_cp) # Create an Ipopt NLP object nlp_ipopt = ipopt.CollocationOptimizer(nlp) #nlp_ipopt.opt_sim_ipopt_set_string_option("derivative_test","first-order") # If the convergence is slow, may increase tolerance. #nlp_ipopt.opt_sim_ipopt_set_num_option("tol",0.0001) #Solve the optimization problem nlp_ipopt.opt_sim_ipopt_solve() # Write to file. The resulting file can be # loaded into Dymola. nlp.export_result_dymola() # Load the file we just wrote res = jmodelica.io.ResultDymolaTextual( 'DISTLib_Opt_Binary_Dist_Opt1_result.txt') # Extract variable profiles u1_res = res.get_variable_data('u1') u1_ref_res = res.get_variable_data('u1_ref') y1_ref_res = res.get_variable_data('y1_ref') x_res = [] x_ref_res = [] for i in range(N.size(x_B)): x_res.append(res.get_variable_data('x' + str(i + 1))) y_res = [] for i in range(N.size(x_B)): y_res.append(res.get_variable_data('y' + str(i + 1))) # Plot the results if with_plots: plt.figure(1) plt.clf() plt.hold(True) plt.subplot(311) plt.title('Liquid composition') plt.plot(x_res[0].t, x_res[0].x) plt.ylabel('x1') plt.grid() plt.subplot(312) plt.plot(x_res[16].t, x_res[16].x) plt.ylabel('x17') plt.grid() plt.subplot(313) plt.plot(x_res[31].t, x_res[31].x) 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(y_res[0].t, y_res[0].x) plt.plot(y1_ref_res.t, y1_ref_res.x, '--') plt.ylabel('y1') plt.grid() plt.subplot(312) plt.plot(y_res[16].t, y_res[16].x) plt.ylabel('y17') plt.grid() plt.subplot(313) plt.plot(y_res[31].t, y_res[31].x) plt.ylabel('y32') plt.grid() plt.xlabel('t [s]') plt.show() plt.figure(3) plt.clf() plt.hold(True) plt.plot(u1_res.t, u1_res.x) plt.ylabel('u') plt.plot(u1_ref_res.t, u1_ref_res.x, '--') plt.xlabel('t [s]') plt.title('Reflux ratio') plt.grid() plt.show()
def run_demo(with_plots=True): """This example is based on a system composed of two Continously Stirred Tank Reactors (CSTRs) in series. 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. For more information about the DAE initialization algorithm, see http://www.jmodelica.org/page/10. 2. An optimal control problem is solved where the objective Is to transfer the state of the system from stationary point A to point B. Here, it is also demonstrated how to set parameter values in a model. More information about the simultaneous optimization algorithm can be found at http://www.jmodelica.org/page/10. 3. The optimization result is saved to file and then the important variables are plotted.""" curr_dir = os.path.dirname(os.path.abspath(__file__)) # Create a Modelica compiler instance mc = ModelicaCompiler() # Compile the stationary initialization model into a DLL mc.compile_model(curr_dir + "/files/CSTRLib.mo", "CSTRLib.Components.Two_CSTRs_stat_init", target='ipopt') # Load a model instance into Python init_model = jmi.Model("CSTRLib_Components_Two_CSTRs_stat_init") # Create DAE initialization object. init_nlp = NLPInitialization(init_model) # Create an Ipopt solver object for the DAE initialization system init_nlp_ipopt = InitializationOptimizer(init_nlp) # Set inputs for Stationary point A u1_0_A = 1 u2_0_A = 1 init_model.set_value('u1', u1_0_A) init_model.set_value('u2', u2_0_A) # init_nlp_ipopt.init_opt_ipopt_set_string_option("derivative_test","first-order") #init_nlp_ipopt.init_opt_ipopt_set_int_option("max_iter",5) # Solve the DAE initialization system with Ipopt init_nlp_ipopt.init_opt_ipopt_solve() # Store stationary point A CA1_0_A = init_model.get_value('CA1') CA2_0_A = init_model.get_value('CA2') T1_0_A = init_model.get_value('T1') T2_0_A = init_model.get_value('T2') # Print some data for stationary point A print(' *** Stationary point A ***') print('u = [%f,%f]' % (u1_0_A, u2_0_A)) print('CAi = [%f,%f]' % (CA1_0_A, CA2_0_A)) print('Ti = [%f,%f]' % (T1_0_A, T2_0_A)) # Set inputs for stationary point B u1_0_B = 1.1 u2_0_B = 0.9 init_model.set_value('u1', u1_0_B) init_model.set_value('u2', u2_0_B) # init_nlp_ipopt.init_opt_ipopt_set_string_option("derivative_test","first-order") #init_nlp_ipopt.init_opt_ipopt_set_int_option("max_iter",5) # Solve the DAE initialization system with Ipopt init_nlp_ipopt.init_opt_ipopt_solve() # Stationary point B CA1_0_B = init_model.get_value('CA1') CA2_0_B = init_model.get_value('CA2') T1_0_B = init_model.get_value('T1') T2_0_B = init_model.get_value('T2') # Print some data for stationary point B print(' *** Stationary point B ***') print('u = [%f,%f]' % (u1_0_B, u2_0_B)) print('CAi = [%f,%f]' % (CA1_0_B, CA2_0_B)) print('Ti = [%f,%f]' % (T1_0_B, T2_0_B)) ## Set up and solve an optimal control problem. # Create an OptimicaCompiler instance oc = OptimicaCompiler() # Compil the Model oc.compile_model( (curr_dir + "/files/CSTRLib.mo", curr_dir + "/files/CSTR2_Opt.mo"), "CSTR2_Opt", target='ipopt') # Load the dynamic library and XML data model = jmi.Model("CSTR2_Opt") # Initialize the model with parameters # Initialize the model to stationary point A model.set_value('two_CSTRs_Series.CA1_0', CA1_0_A) model.set_value('two_CSTRs_Series.CA2_0', CA2_0_A) model.set_value('two_CSTRs_Series.T1_0', T1_0_A) model.set_value('two_CSTRs_Series.T2_0', T2_0_A) # Set the target values to stationary point B model.set_value('u1_ref', u1_0_B) model.set_value('u2_ref', u2_0_B) model.set_value('CA1_ref', CA1_0_B) model.set_value('CA2_ref', CA2_0_B) # Initialize the optimization mesh n_e = 30 # Number of elements hs = N.ones(n_e) * 1. / n_e # Equidistant points n_cp = 3 # Number of collocation points in each element # Create an NLP object representing the discretized problem nlp = ipopt.NLPCollocationLagrangePolynomials(model, n_e, hs, n_cp) # Create an Ipopt NLP object nlp_ipopt = ipopt.CollocationOptimizer(nlp) #nlp_ipopt.opt_sim_ipopt_set_string_option("derivative_test","first-order") # The convergence is slow, for some reason, increasing tolerance. nlp_ipopt.opt_sim_ipopt_set_num_option("tol", 0.0001) #Solve the optimization problem nlp_ipopt.opt_sim_ipopt_solve() # Write to file. The resulting file (CSTR2_Opt_result.txt) can be # loaded into Dymola. nlp.export_result_dymola() # Load the file we just wrote res = jmodelica.io.ResultDymolaTextual('CSTR2_Opt_result.txt') # Extract variable profiles CA1_res = res.get_variable_data('two_CSTRs_Series.CA1') CA2_res = res.get_variable_data('two_CSTRs_Series.CA2') T1_res = res.get_variable_data('two_CSTRs_Series.T1') T2_res = res.get_variable_data('two_CSTRs_Series.T2') u1_res = res.get_variable_data('two_CSTRs_Series.u1') u2_res = res.get_variable_data('two_CSTRs_Series.u2') CA1_ref_res = res.get_variable_data('CA1_ref') CA2_ref_res = res.get_variable_data('CA2_ref') u1_ref_res = res.get_variable_data('u1_ref') u2_ref_res = res.get_variable_data('u2_ref') # Plot the results if with_plots: plt.figure(1) plt.clf() plt.hold(True) plt.subplot(211) plt.plot(CA1_res.t, CA1_res.x) plt.plot(CA1_ref_res.t, CA1_ref_res.x, '--') plt.ylabel('Concentration reactor 1 [J/l]') plt.grid() plt.subplot(212) plt.plot(CA2_res.t, CA2_res.x) plt.plot(CA2_ref_res.t, CA2_ref_res.x, '--') plt.ylabel('Concentration reactor 2 [J/l]') plt.xlabel('t [s]') plt.grid() plt.show() plt.figure(2) plt.clf() plt.hold(True) plt.subplot(211) plt.plot(T1_res.t, T1_res.x) plt.ylabel('Temperature reactor 1 [K]') plt.grid() plt.subplot(212) plt.plot(T2_res.t, T2_res.x) plt.ylabel('Temperature reactor 2 [K]') plt.grid() plt.xlabel('t [s]') plt.show() plt.figure(3) plt.clf() plt.hold(True) plt.subplot(211) plt.plot(u1_res.t, u1_res.x) plt.ylabel('Input 1') plt.plot(u1_ref_res.t, u1_ref_res.x, '--') plt.grid() plt.subplot(212) plt.plot(u2_res.t, u2_res.x) plt.ylabel('Input 2') plt.plot(u2_ref_res.t, u2_ref_res.x, '--') plt.xlabel('t [s]') plt.grid() plt.show()
curr_dir = os.path.dirname(os.path.abspath(__file__)) # Create a Modelica compiler instance mc = ModelicaCompiler() # Don't generate initial equations for states if fixed=false mc.set_boolean_option('state_start_values_fixed', False) # Compile the stationary initialization model into a DLL mc.compile_model(curr_dir + "/files/CSTRLib.mo", "CSTRLib.Components.Two_CSTRs_stat_init", target='ipopt') #mc.compile_dll("CSTRLib_Components_Two_CSTRs_stat_init",target='ipopt') # Load a model instance into Python init_model = jmi.Model("CSTRLib_Components_Two_CSTRs_stat_init") # Create DAE initialization object. init_nlp = jmi.DAEInitializationOpt(init_model) # Create an Ipopt solver object for the DAE initialization system init_nlp_ipopt = jmi.JMIDAEInitializationOptIPOPT(init_nlp) # Set inputs for Stationary point A u1_0_A = 1 u2_0_A = 1 init_model.set_value('u1', u1_0_A) init_model.set_value('u2', u2_0_A) # init_nlp_ipopt.init_opt_ipopt_set_string_option("derivative_test","first-order") #init_nlp_ipopt.init_opt_ipopt_set_int_option("max_iter",5)
def run_demo(with_plots=True): """Optimal control of the quadruple tank process.""" oc = OptimicaCompiler() oc.set_boolean_option('state_start_values_fixed', True) curr_dir = os.path.dirname(os.path.abspath(__file__)) # Compile the Optimica model first to C code and # then to a dynamic library oc.compile_model(curr_dir + "/files/QuadTank.mo", "QuadTank_pack.QuadTank_Opt", target='ipopt') # Load the dynamic library and XML data qt = jmi.Model("QuadTank_pack_QuadTank_Opt") # Define inputs for operating point A u_A = N.array([2., 2]) # Define inputs for operating point B u_B = N.array([2.5, 2.5]) x_0 = N.ones(4) * 0.01 def res(y, t): for i in range(4): qt.get_x()[i] = y[i] qt.jmimodel.ode_f() return qt.get_dx()[0:4] # Compute stationary state values for operating point A qt.set_u(u_A) #qt.getPI()[21] = u_A[0] #qt.getPI()[22] = u_A[1] t_sim = N.linspace(0., 2000., 500) y_sim = int.odeint(res, x_0, t_sim) x_A = y_sim[-1, :] if with_plots: # Plot plt.figure(1) plt.clf() plt.subplot(211) plt.plot(t_sim, y_sim[:, 0:4]) plt.grid() # Compute stationary state values for operating point A qt.set_u(u_B) t_sim = N.linspace(0., 2000., 500) y_sim = int.odeint(res, x_0, t_sim) x_B = y_sim[-1, :] if with_plots: # Plot plt.figure(1) plt.subplot(212) plt.plot(t_sim, y_sim[:, 0:4]) plt.grid() plt.show() qt.get_pi()[13] = x_A[0] qt.get_pi()[14] = x_A[1] qt.get_pi()[15] = x_A[2] qt.get_pi()[16] = x_A[3] qt.get_pi()[17] = x_B[0] qt.get_pi()[18] = x_B[1] qt.get_pi()[19] = x_B[2] qt.get_pi()[20] = x_B[3] qt.get_pi()[21] = u_B[0] qt.get_pi()[22] = u_B[1] # Solve optimal control problem # Initialize the mesh n_e = 50 # Number of elements hs = N.ones(n_e) * 1. / n_e # Equidistant points n_cp = 3 # Number of collocation points in each element # Create an NLP object nlp = jmi.SimultaneousOptLagPols(qt, n_e, hs, n_cp) # Create an Ipopt NLP object nlp_ipopt = jmi.JMISimultaneousOptIPOPT(nlp.jmi_simoptlagpols) #nlp_ipopt.opt_sim_ipopt_set_string_option("derivative_test","first-order") nlp_ipopt.opt_sim_ipopt_set_int_option("max_iter", 500) # Solve the optimization problem nlp_ipopt.opt_sim_ipopt_solve() # Retreive the number of points in each column in the # result matrix n_points = nlp.jmi_simoptlagpols.opt_sim_get_result_variable_vector_length( ) n_points = n_points.value # Create result data vectors p_opt = N.zeros(1) t_ = N.zeros(n_points) dx_ = N.zeros(5 * n_points) x_ = N.zeros(5 * n_points) u_ = N.zeros(2 * n_points) w_ = N.zeros(n_points) # Get the result nlp.jmi_simoptlagpols.opt_sim_get_result(p_opt, t_, dx_, x_, u_, w_) if with_plots: # Plot plt.figure(2) plt.clf() plt.subplot(411) plt.plot(t_, x_[0:n_points]) plt.grid() plt.ylabel('x1') plt.subplot(412) plt.plot(t_, x_[n_points:n_points * 2]) plt.grid() plt.ylabel('x2') plt.subplot(413) plt.plot(t_, x_[n_points * 2:n_points * 3]) plt.grid() plt.ylabel('x3') plt.subplot(414) plt.plot(t_, x_[n_points * 3:n_points * 4]) plt.grid() plt.ylabel('x4') plt.show() plt.figure(3) plt.clf() plt.subplot(211) plt.plot(t_, u_[0:n_points]) plt.grid() plt.ylabel('u1') plt.subplot(212) plt.plot(t_, u_[n_points:n_points * 2]) plt.grid() plt.ylabel('u2') if __name__ == "__main__": run_demo()
def __init__(self): """Test setUp. Load the test model.""" self.vdp = jmi.Model(fname_vdp)
def setUp(self): """Test setUp. Load the test model.""" cstr = jmi.Model(fname) self.init_nlp = NLPInitialization(cstr)