def run_demo(with_plots=True):
"""
Static calibration of the quad tank model.
"""
curr_dir = os.path.dirname(os.path.abspath(__file__))
jmu_name = compile_jmu("QuadTank_pack.QuadTank_Static",
curr_dir + "/files/QuadTank.mop")
# Load static calibration model
qt_static = JMUModel(jmu_name)
# Set control inputs
qt_static.set("u1", 2.5)
qt_static.set("u2", 2.5)
# Save nominal values
a1_nom = qt_static.get("a1")
a2_nom = qt_static.get("a2")
init_res = qt_static.initialize(options={'stat': 1})
print "Optimal parameter values:"
print "a1: %2.2e (nominal: %2.2e)" % (qt_static.get("a1"), a1_nom)
print "a2: %2.2e (nominal: %2.2e)" % (qt_static.get("a2"), a2_nom)
assert N.abs(qt_static.get("a1") - 7.95797110936e-06) < 1e-3
assert N.abs(qt_static.get("a2") - 7.73425542448e-06) < 1e-3
def run_demo(with_plots=True):
"""
Static calibration of the quad tank model.
"""
curr_dir = os.path.dirname(os.path.abspath(__file__))
jmu_name = compile_jmu("QuadTank_pack.QuadTank_Static", curr_dir + "/files/QuadTank.mop")
# Load static calibration model
qt_static = JMUModel(jmu_name)
# Set control inputs
qt_static.set("u1", 2.5)
qt_static.set("u2", 2.5)
# Save nominal values
a1_nom = qt_static.get("a1")
a2_nom = qt_static.get("a2")
init_res = qt_static.initialize(options={"stat": 1})
print "Optimal parameter values:"
print "a1: %2.2e (nominal: %2.2e)" % (qt_static.get("a1"), a1_nom)
print "a2: %2.2e (nominal: %2.2e)" % (qt_static.get("a2"), a2_nom)
assert N.abs(qt_static.get("a1") - 7.95797110936e-06) < 1e-3
assert N.abs(qt_static.get("a2") - 7.73425542448e-06) < 1e-3
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):
"""
Optimal control of the quadruple tank process.
"""
curr_dir = os.path.dirname(os.path.abspath(__file__));
# Compile the Optimica model to JMU
jmu_name = compile_jmu("QuadTank_pack.QuadTank_Opt",
curr_dir+"/files/QuadTank.mop")
# Load the dynamic library and XML data
qt = JMUModel(jmu_name)
# 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.real_x[i+1] = y[i]
qt.jmimodel.ode_f()
return qt.real_dx[1:5]
# Compute stationary state values for operating point A
qt.real_u = u_A
t_sim = N.linspace(0.,2000.,500)
y_sim = integr.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.real_u = u_B
t_sim = N.linspace(0.,2000.,500)
y_sim = integr.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.set("x1_0",x_A[0])
qt.set("x2_0",x_A[1])
qt.set("x3_0",x_A[2])
qt.set("x4_0",x_A[3])
qt.set("x1_r",x_B[0])
qt.set("x2_r",x_B[1])
qt.set("x3_r",x_B[2])
qt.set("x4_r",x_B[3])
qt.set("u1_r",u_B[0])
qt.set("u2_r",u_B[1])
# Solve optimal control problem
res = qt.optimize(options={'IPOPT_options':{'max_iter':500}})
# Extract variable profiles
x1=res['x1']
x2=res['x2']
x3=res['x3']
x4=res['x4']
u1=res['u1']
u2=res['u2']
t =res['time']
assert N.abs(res.final('cost') - 5.0333257e+02) < 1e-3
if with_plots:
# Plot
plt.figure(2)
plt.clf()
plt.subplot(411)
plt.plot(t,x1)
plt.grid()
plt.ylabel('x1')
plt.subplot(412)
plt.plot(t,x2)
plt.grid()
plt.ylabel('x2')
plt.subplot(413)
plt.plot(t,x3)
plt.grid()
plt.ylabel('x3')
plt.subplot(414)
plt.plot(t,x4)
plt.grid()
plt.ylabel('x4')
plt.show()
plt.figure(3)
plt.clf()
plt.subplot(211)
plt.plot(t,u1)
plt.grid()
plt.ylabel('u1')
plt.subplot(212)
plt.plot(t,u2)
plt.grid()
plt.ylabel('u2')
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):
"""
Distillation4 optimization model
"""
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 the simulation problem.
fmu_name1 = compile_fmu("JMExamples.Distillation.Distillation1Inputstep",
curr_dir+"/files/JMExamples.mo")
dist1 = load_fmu(fmu_name1)
# Initialize the model with parameters
# Initialize the model to stationary point A
for i in range(32):
dist1.set('x_init[' + str(i+1) + ']', x_A[i])
res = dist1.simulate(final_time=50)
# Extract variable profiles
x1 = res['x[1]']
x8 = res['x[8]']
x16 = res['x[16]']
x24 = res['x[24]']
x32 = res['x[32]']
y1 = res['y[1]']
y8 = res['y[8]']
y16 = res['y[16]']
y24 = res['y[24]']
y32 = res['y[32]']
t = res['time']
rr = res['rr']
print "t = ", repr(N.array(t))
print "x1 = ", repr(N.array(x1))
print "x8 = ", repr(N.array(x8))
print "x16 = ", repr(N.array(x16))
print "x32 = ", repr(N.array(x32))
if with_plots:
# Plot
plt.figure()
plt.subplot(1,3,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,3,2)
plt.plot(t,y16,t,y32,t,y1,t,y8,t,y24)
plt.title('Vapor composition')
plt.grid(True)
plt.ylabel('y')
plt.subplot(1,3,3)
plt.plot(t,rr)
plt.title('Reflux ratio')
plt.grid(True)
plt.ylabel('rr')
plt.xlabel('time')
plt.show()
def run_demo(with_plots=True):
"""
Distillation4 optimization model
"""
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 the simulation problem.
fmu_name1 = compile_fmu("JMExamples.Distillation.Distillation1Inputstep",
curr_dir + "/files/JMExamples.mo")
dist1 = load_fmu(fmu_name1)
# Initialize the model with parameters
# Initialize the model to stationary point A
for i in range(32):
dist1.set('x_init[' + str(i + 1) + ']', x_A[i])
res = dist1.simulate(final_time=50)
# Extract variable profiles
x1 = res['x[1]']
x8 = res['x[8]']
x16 = res['x[16]']
x24 = res['x[24]']
x32 = res['x[32]']
y1 = res['y[1]']
y8 = res['y[8]']
y16 = res['y[16]']
y24 = res['y[24]']
y32 = res['y[32]']
t = res['time']
rr = res['rr']
print "t = ", repr(N.array(t))
print "x1 = ", repr(N.array(x1))
print "x8 = ", repr(N.array(x8))
print "x16 = ", repr(N.array(x16))
print "x32 = ", repr(N.array(x32))
if with_plots:
# Plot
plt.figure()
plt.subplot(1, 3, 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, 3, 2)
plt.plot(t, y16, t, y32, t, y1, t, y8, t, y24)
plt.title('Vapor composition')
plt.grid(True)
plt.ylabel('y')
plt.subplot(1, 3, 3)
plt.plot(t, rr)
plt.title('Reflux ratio')
plt.grid(True)
plt.ylabel('rr')
plt.xlabel('time')
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__));
# Compile the stationary initialization model into a DLL
jmu_name = compile_jmu("CSTRLib.Components.Two_CSTRs_stat_init",
os.path.join(curr_dir, "files", "CSTRLib.mo"))
# Load a JMU model instance
init_model = JMUModel(jmu_name)
# Set inputs for Stationary point A
u1_0_A = 1
u2_0_A = 1
init_model.set('u1',u1_0_A)
init_model.set('u2',u2_0_A)
# Solve the DAE initialization system with Ipopt
init_result = init_model.initialize()
# Store stationary point A
CA1_0_A = init_model.get('CA1')
CA2_0_A = init_model.get('CA2')
T1_0_A = init_model.get('T1')
T2_0_A = init_model.get('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('u1',u1_0_B)
init_model.set('u2',u2_0_B)
# Solve the DAE initialization system with Ipopt
init_result = init_model.initialize()
# Stationary point B
CA1_0_B = init_model.get('CA1')
CA2_0_B = init_model.get('CA2')
T1_0_B = init_model.get('T1')
T2_0_B = init_model.get('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.
# Compile the Model
jmu_name = compile_jmu("CSTR2_Opt",
[os.path.join(curr_dir, "files", "CSTRLib.mo"), os.path.join(curr_dir, "files", "CSTR2_Opt.mop")],
compiler_options={'enable_variable_scaling':True, 'index_reduction':True})
# Load the dynamic library and XML data
model = JMUModel(jmu_name)
# Initialize the model with parameters
# Initialize the model to stationary point A
model.set('cstr.two_CSTRs_Series.CA1_0',CA1_0_A)
model.set('cstr.two_CSTRs_Series.CA2_0',CA2_0_A)
model.set('cstr.two_CSTRs_Series.T1_0',T1_0_A)
model.set('cstr.two_CSTRs_Series.T2_0',T2_0_A)
# Set the target values to stationary point B
model.set('u1_ref',u1_0_B)
model.set('u2_ref',u2_0_B)
model.set('CA1_ref',CA1_0_B)
model.set('CA2_ref',CA2_0_B)
# 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
res = model.optimize(
options={'n_e':n_e, 'hs':hs, 'n_cp':n_cp,
'blocking_factors':2*N.ones(n_e/2,dtype=N.int),
'IPOPT_options':{'tol':1e-4}})
# Extract variable profiles
CA1_res=res['cstr.two_CSTRs_Series.CA1']
CA2_res=res['cstr.two_CSTRs_Series.CA2']
T1_res=res['cstr.two_CSTRs_Series.T1']
T2_res=res['cstr.two_CSTRs_Series.T2']
u1_res=res['cstr.two_CSTRs_Series.u1']
u2_res=res['cstr.two_CSTRs_Series.u2']
der_u2_res=res['der_u2']
CA1_ref_res=res['CA1_ref']
CA2_ref_res=res['CA2_ref']
u1_ref_res=res['u1_ref']
u2_ref_res=res['u2_ref']
cost=res['cost']
time=res['time']
assert N.abs(res.final('cost') - 1.4745648e+01) < 1e-3
# Plot the results
if with_plots:
plt.figure(1)
plt.clf()
plt.hold(True)
plt.subplot(211)
plt.plot(time,CA1_res)
plt.plot([time[0],time[-1]],[CA1_ref_res, CA1_ref_res],'--')
plt.ylabel('Concentration reactor 1 [J/l]')
plt.grid()
plt.subplot(212)
plt.plot(time,CA2_res)
plt.plot([time[0],time[-1]],[CA2_ref_res, CA2_ref_res],'--')
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(time,T1_res)
plt.ylabel('Temperature reactor 1 [K]')
plt.grid()
plt.subplot(212)
plt.plot(time,T2_res)
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(time,u2_res)
plt.ylabel('Input 2')
plt.plot([time[0],time[-1]],[u2_ref_res, u2_ref_res],'--')
plt.grid()
plt.subplot(212)
plt.plot(time,der_u2_res)
plt.ylabel('Derivative of input 2')
plt.xlabel('t [s]')
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__))
# Compile the stationary initialization model into a DLL
jmu_name = compile_jmu("CSTRLib.Components.Two_CSTRs_stat_init",
os.path.join(curr_dir, "files", "CSTRLib.mo"))
# Load a JMU model instance
init_model = JMUModel(jmu_name)
# Set inputs for Stationary point A
u1_0_A = 1
u2_0_A = 1
init_model.set('u1', u1_0_A)
init_model.set('u2', u2_0_A)
# Solve the DAE initialization system with Ipopt
init_result = init_model.initialize()
# Store stationary point A
CA1_0_A = init_model.get('CA1')
CA2_0_A = init_model.get('CA2')
T1_0_A = init_model.get('T1')
T2_0_A = init_model.get('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('u1', u1_0_B)
init_model.set('u2', u2_0_B)
# Solve the DAE initialization system with Ipopt
init_result = init_model.initialize()
# Stationary point B
CA1_0_B = init_model.get('CA1')
CA2_0_B = init_model.get('CA2')
T1_0_B = init_model.get('T1')
T2_0_B = init_model.get('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.
# Compile the Model
jmu_name = compile_jmu("CSTR2_Opt", [
os.path.join(curr_dir, "files", "CSTRLib.mo"),
os.path.join(curr_dir, "files", "CSTR2_Opt.mop")
],
compiler_options={
'enable_variable_scaling': True,
'index_reduction': True
})
# Load the dynamic library and XML data
model = JMUModel(jmu_name)
# Initialize the model with parameters
# Initialize the model to stationary point A
model.set('cstr.two_CSTRs_Series.CA1_0', CA1_0_A)
model.set('cstr.two_CSTRs_Series.CA2_0', CA2_0_A)
model.set('cstr.two_CSTRs_Series.T1_0', T1_0_A)
model.set('cstr.two_CSTRs_Series.T2_0', T2_0_A)
# Set the target values to stationary point B
model.set('u1_ref', u1_0_B)
model.set('u2_ref', u2_0_B)
model.set('CA1_ref', CA1_0_B)
model.set('CA2_ref', CA2_0_B)
# 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
res = model.optimize(
options={
'n_e': n_e,
'hs': hs,
'n_cp': n_cp,
'blocking_factors': 2 * N.ones(n_e / 2, dtype=N.int),
'IPOPT_options': {
'tol': 1e-4
}
})
# Extract variable profiles
CA1_res = res['cstr.two_CSTRs_Series.CA1']
CA2_res = res['cstr.two_CSTRs_Series.CA2']
T1_res = res['cstr.two_CSTRs_Series.T1']
T2_res = res['cstr.two_CSTRs_Series.T2']
u1_res = res['cstr.two_CSTRs_Series.u1']
u2_res = res['cstr.two_CSTRs_Series.u2']
der_u2_res = res['der_u2']
CA1_ref_res = res['CA1_ref']
CA2_ref_res = res['CA2_ref']
u1_ref_res = res['u1_ref']
u2_ref_res = res['u2_ref']
cost = res['cost']
time = res['time']
assert N.abs(res.final('cost') - 1.4745648e+01) < 1e-3
# Plot the results
if with_plots:
plt.figure(1)
plt.clf()
plt.hold(True)
plt.subplot(211)
plt.plot(time, CA1_res)
plt.plot([time[0], time[-1]], [CA1_ref_res, CA1_ref_res], '--')
plt.ylabel('Concentration reactor 1 [J/l]')
plt.grid()
plt.subplot(212)
plt.plot(time, CA2_res)
plt.plot([time[0], time[-1]], [CA2_ref_res, CA2_ref_res], '--')
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(time, T1_res)
plt.ylabel('Temperature reactor 1 [K]')
plt.grid()
plt.subplot(212)
plt.plot(time, T2_res)
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(time, u2_res)
plt.ylabel('Input 2')
plt.plot([time[0], time[-1]], [u2_ref_res, u2_ref_res], '--')
plt.grid()
plt.subplot(212)
plt.plot(time, der_u2_res)
plt.ylabel('Derivative of input 2')
plt.xlabel('t [s]')
plt.grid()
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):
"""
Model predicitve control of the Hicks-Ray CSTR reactor. This example
demonstrates how to use the blocking factor feature of the collocation
algorithm.
This example also shows how to use classes for initialization, simulation
and optimization directly rather than calling then through the high-level
classes 'initialialize', 'simulate' and 'optimize'.
"""
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"))
# Load a JMUModel instance
init_model = JMUModel(jmu_name)
# 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)
def compute_stationary(Tc_stat):
init_model.set('Tc', Tc_stat)
# Solve the DAE initialization system with Ipopt
init_nlp_ipopt.init_opt_ipopt_solve()
return (init_model.get('c'), init_model.get('T'))
# Set inputs for Stationary point A
Tc_0_A = 250
c_0_A, T_0_A = compute_stationary(Tc_0_A)
# 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
c_0_B, T_0_B = compute_stationary(Tc_0_B)
# 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)
jmu_name = compile_jmu("CSTR.CSTR_Opt_MPC",
os.path.join(curr_dir, "files", "CSTR.mop"))
cstr = JMUModel(jmu_name)
cstr.set('Tc_ref', Tc_0_B)
cstr.set('c_ref', c_0_B)
cstr.set('T_ref', T_0_B)
cstr.set('cstr.c_init', c_0_A)
cstr.set('cstr.T_init', T_0_A)
# 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
# The length of the optimization interval is 50s and the
# number of elements is 50, which gives a blocking factor
# vector of 2*ones(n_e/2) to match the sampling interval
# of 2s.
nlp = ipopt.NLPCollocationLagrangePolynomials(cstr,
n_e,
hs,
n_cp,
blocking_factors=2 *
N.ones(n_e / 2, dtype=N.int))
# Create an Ipopt NLP object
nlp_ipopt = ipopt.CollocationOptimizer(nlp)
nlp_ipopt.opt_coll_ipopt_set_int_option("max_iter", 500)
h = 2. # Sampling interval
T_final = 180. # Final time of simulation
t_mpc = N.linspace(0, T_final, T_final / h + 1)
n_samples = N.size(t_mpc)
ref_mpc = N.zeros(n_samples)
ref_mpc[0:3] = N.ones(3) * Tc_0_A
ref_mpc[3:] = N.ones(n_samples - 3) * Tc_0_B
cstr.set('cstr.c_init', c_0_A)
cstr.set('cstr.T_init', T_0_A)
# Compile the simulation model into a DLL
jmu_name = compile_jmu("CSTR.CSTR",
os.path.join(curr_dir, "files", "CSTR.mop"))
# Load a model instance into Python
sim_model = JMUModel(jmu_name)
sim_model.set('c_init', c_0_A)
sim_model.set('T_init', T_0_A)
global cstr_mod
global cstr_sim
cstr_mod = JMIDAE(sim_model) # Create an Assimulo problem
cstr_sim = IDA(cstr_mod) # Create an IDA solver
i = 0
if with_plots:
plt.figure(4)
plt.clf()
for t in t_mpc[0:-1]:
Tc_ref = ref_mpc[i]
c_ref, T_ref = compute_stationary(Tc_ref)
cstr.set('Tc_ref', Tc_ref)
cstr.set('c_ref', c_ref)
cstr.set('T_ref', T_ref)
# Solve the optimization problem
nlp_ipopt.opt_coll_ipopt_solve()
# Write to file.
nlp.export_result_dymola()
# Load the file we just wrote to file
res = ResultDymolaTextual('CSTR_CSTR_Opt_MPC_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')
# Get the first Tc sample
Tc_ctrl = Tc_res.x[0]
# Set the value to the model
sim_model.set('Tc', Tc_ctrl)
# Simulate
cstr_sim.simulate(t_mpc[i + 1])
t_T_sim = cstr_sim.t_sol
# Set terminal values of the states
cstr.set('cstr.c_init', cstr_sim.y[0])
cstr.set('cstr.T_init', cstr_sim.y[1])
sim_model.set('c_init', cstr_sim.y[0])
sim_model.set('T_init', cstr_sim.y[1])
if with_plots:
plt.figure(4)
plt.subplot(3, 1, 1)
plt.plot(t_T_sim, N.array(cstr_sim.y_sol)[:, 0], 'b')
plt.subplot(3, 1, 2)
plt.plot(t_T_sim, N.array(cstr_sim.y_sol)[:, 1], 'b')
if t_mpc[i] == 0:
plt.subplot(3, 1, 3)
plt.plot([t_mpc[i], t_mpc[i + 1]], [Tc_ctrl, Tc_ctrl], 'b')
else:
plt.subplot(3, 1, 3)
plt.plot([t_mpc[i], t_mpc[i], t_mpc[i + 1]],
[Tc_ctrl_old, Tc_ctrl, Tc_ctrl], 'b')
Tc_ctrl_old = Tc_ctrl
i = i + 1
assert N.abs(Tc_ctrl - 279.097186038194) < 1e-6
assert N.abs(N.array(cstr_sim.y_sol)[:, 0][-1] - 350.89028563) < 1e-6
assert N.abs(N.array(cstr_sim.y_sol)[:, 1][-1] - 283.15229948) < 1e-6
if with_plots:
plt.figure(4)
plt.subplot(3, 1, 1)
plt.ylabel('c')
plt.plot([0, T_final], [c_0_B, c_0_B], '--')
plt.grid()
plt.subplot(3, 1, 2)
plt.ylabel('T')
plt.plot([0, T_final], [T_0_B, T_0_B], '--')
plt.grid()
plt.subplot(3, 1, 3)
plt.ylabel('Tc')
plt.plot([0, T_final], [Tc_0_B, Tc_0_B], '--')
plt.grid()
plt.xlabel('t')
plt.show()
def run_demo(with_plots=True):
"""
Model predicitve control of the Hicks-Ray CSTR reactor. This example
demonstrates how to use the blocking factor feature of the collocation
algorithm.
This example also shows how to use classes for initialization, simulation
and optimization directly rather than calling then through the high-level
classes 'initialialize', 'simulate' and 'optimize'.
"""
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"))
# Load a JMUModel instance
init_model = JMUModel(jmu_name)
# 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)
def compute_stationary(Tc_stat):
init_model.set('Tc',Tc_stat)
# Solve the DAE initialization system with Ipopt
init_nlp_ipopt.init_opt_ipopt_solve()
return (init_model.get('c'),init_model.get('T'))
# Set inputs for Stationary point A
Tc_0_A = 250
c_0_A, T_0_A = compute_stationary(Tc_0_A)
# 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
c_0_B, T_0_B = compute_stationary(Tc_0_B)
# 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)
jmu_name = compile_jmu("CSTR.CSTR_Opt_MPC", os.path.join(curr_dir, "files", "CSTR.mop"))
cstr = JMUModel(jmu_name)
cstr.set('Tc_ref',Tc_0_B)
cstr.set('c_ref',c_0_B)
cstr.set('T_ref',T_0_B)
cstr.set('cstr.c_init',c_0_A)
cstr.set('cstr.T_init',T_0_A)
# 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
# The length of the optimization interval is 50s and the
# number of elements is 50, which gives a blocking factor
# vector of 2*ones(n_e/2) to match the sampling interval
# of 2s.
nlp = ipopt.NLPCollocationLagrangePolynomials(
cstr, n_e, hs, n_cp, blocking_factors=2*N.ones(n_e/2,dtype=N.int))
# Create an Ipopt NLP object
nlp_ipopt = ipopt.CollocationOptimizer(nlp)
nlp_ipopt.opt_coll_ipopt_set_int_option("max_iter",500)
h = 2. # Sampling interval
T_final = 180. # Final time of simulation
t_mpc = N.linspace(0,T_final,T_final/h+1)
n_samples = N.size(t_mpc)
ref_mpc = N.zeros(n_samples)
ref_mpc[0:3] = N.ones(3)*Tc_0_A
ref_mpc[3:] = N.ones(n_samples-3)*Tc_0_B
cstr.set('cstr.c_init',c_0_A)
cstr.set('cstr.T_init',T_0_A)
# Compile the simulation model into a DLL
jmu_name = compile_jmu("CSTR.CSTR", os.path.join(curr_dir, "files", "CSTR.mop"))
# Load a model instance into Python
sim_model = JMUModel(jmu_name)
sim_model.set('c_init',c_0_A)
sim_model.set('T_init',T_0_A)
global cstr_mod
global cstr_sim
cstr_mod = JMIDAE(sim_model) # Create an Assimulo problem
cstr_sim = IDA(cstr_mod) # Create an IDA solver
i = 0
if with_plots:
plt.figure(4)
plt.clf()
for t in t_mpc[0:-1]:
Tc_ref = ref_mpc[i]
c_ref, T_ref = compute_stationary(Tc_ref)
cstr.set('Tc_ref',Tc_ref)
cstr.set('c_ref',c_ref)
cstr.set('T_ref',T_ref)
# Solve the optimization problem
nlp_ipopt.opt_coll_ipopt_solve()
# Write to file.
nlp.export_result_dymola()
# Load the file we just wrote to file
res = ResultDymolaTextual('CSTR_CSTR_Opt_MPC_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')
# Get the first Tc sample
Tc_ctrl = Tc_res.x[0]
# Set the value to the model
sim_model.set('Tc',Tc_ctrl)
# Simulate
cstr_sim.simulate(t_mpc[i+1])
t_T_sim = cstr_sim.t_sol
# Set terminal values of the states
cstr.set('cstr.c_init',cstr_sim.y[0])
cstr.set('cstr.T_init',cstr_sim.y[1])
sim_model.set('c_init',cstr_sim.y[0])
sim_model.set('T_init',cstr_sim.y[1])
if with_plots:
plt.figure(4)
plt.subplot(3,1,1)
plt.plot(t_T_sim,N.array(cstr_sim.y_sol)[:,0],'b')
plt.subplot(3,1,2)
plt.plot(t_T_sim,N.array(cstr_sim.y_sol)[:,1],'b')
if t_mpc[i]==0:
plt.subplot(3,1,3)
plt.plot([t_mpc[i],t_mpc[i+1]],[Tc_ctrl,Tc_ctrl],'b')
else:
plt.subplot(3,1,3)
plt.plot(
[t_mpc[i],t_mpc[i],t_mpc[i+1]],
[Tc_ctrl_old,Tc_ctrl,Tc_ctrl],
'b')
Tc_ctrl_old = Tc_ctrl
i = i+1
assert N.abs(Tc_ctrl - 279.097186038194) < 1e-6
assert N.abs(N.array(cstr_sim.y_sol)[:,0][-1] - 350.89028563) < 1e-6
assert N.abs(N.array(cstr_sim.y_sol)[:,1][-1] - 283.15229948) < 1e-6
if with_plots:
plt.figure(4)
plt.subplot(3,1,1)
plt.ylabel('c')
plt.plot([0,T_final],[c_0_B,c_0_B],'--')
plt.grid()
plt.subplot(3,1,2)
plt.ylabel('T')
plt.plot([0,T_final],[T_0_B,T_0_B],'--')
plt.grid()
plt.subplot(3,1,3)
plt.ylabel('Tc')
plt.plot([0,T_final],[Tc_0_B,Tc_0_B],'--')
plt.grid()
plt.xlabel('t')
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):
"""
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):
"""
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, 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):
"""
Optimal control of the quadruple tank process.
"""
curr_dir = os.path.dirname(os.path.abspath(__file__))
# Compile the Optimica model to JMU
jmu_name = compile_jmu("QuadTank_pack.QuadTank_Opt",
curr_dir + "/files/QuadTank.mop")
# Load the dynamic library and XML data
qt = JMUModel(jmu_name)
# 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.real_x[i + 1] = y[i]
qt.jmimodel.ode_f()
return qt.real_dx[1:5]
# Compute stationary state values for operating point A
qt.real_u = u_A
t_sim = N.linspace(0., 2000., 500)
y_sim = integr.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.real_u = u_B
t_sim = N.linspace(0., 2000., 500)
y_sim = integr.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.set("x1_0", x_A[0])
qt.set("x2_0", x_A[1])
qt.set("x3_0", x_A[2])
qt.set("x4_0", x_A[3])
qt.set("x1_r", x_B[0])
qt.set("x2_r", x_B[1])
qt.set("x3_r", x_B[2])
qt.set("x4_r", x_B[3])
qt.set("u1_r", u_B[0])
qt.set("u2_r", u_B[1])
# Solve optimal control problem
res = qt.optimize(options={'IPOPT_options': {'max_iter': 500}})
# Extract variable profiles
x1 = res['x1']
x2 = res['x2']
x3 = res['x3']
x4 = res['x4']
u1 = res['u1']
u2 = res['u2']
t = res['time']
assert N.abs(res.final('cost') - 5.0333257e+02) < 1e-3
if with_plots:
# Plot
plt.figure(2)
plt.clf()
plt.subplot(411)
plt.plot(t, x1)
plt.grid()
plt.ylabel('x1')
plt.subplot(412)
plt.plot(t, x2)
plt.grid()
plt.ylabel('x2')
plt.subplot(413)
plt.plot(t, x3)
plt.grid()
plt.ylabel('x3')
plt.subplot(414)
plt.plot(t, x4)
plt.grid()
plt.ylabel('x4')
plt.show()
plt.figure(3)
plt.clf()
plt.subplot(211)
plt.plot(t, u1)
plt.grid()
plt.ylabel('u1')
plt.subplot(212)
plt.plot(t, u2)
plt.grid()
plt.ylabel('u2')
