def check_active_bound_noisy(self):
"""Checks if the dof_(super-basic) have active bounds, if so, add them to the exclusion list"""
if hasattr(self.lsmhe, "dof_v"):
self.lsmhe.dof_v.clear()
else:
self.lsmhe.dof_v = Suffix(direction=Suffix.EXPORT) #: dof_v
if hasattr(self.lsmhe, "rh_name"):
self.lsmhe.rh_name.clear()
else:
self.lsmhe.rh_name = Suffix(direction=Suffix.IMPORT) #: Red_hess_name
self.xkN_nexcl = []
k = 0
for x in self.x_noisy:
v = getattr(self.lsmhe, x)
for j in self.x_vars[x]:
active_bound = False
if v[(2, 0) + j].lb:
if v[(2, 0) + j].value - v[(2, 0) + j].lb < 1e-08:
active_bound = True
if v[(2, 0) + j].ub:
if v[(2, 0) + j].ub - v[(2, 0) + j].value < 1e-08:
active_bound = True
if active_bound:
print("Active bound {:s}, {:d}, value {:f}".format(x, j[0], v[(2, 0) + j].value), file=sys.stderr)
v[(2, 0) + j].set_suffix_value(self.lsmhe.dof_v, 0)
self.xkN_nexcl.append(0)
k += 1
else:
v[(2, 0) + j].set_suffix_value(self.lsmhe.dof_v, 1)
self.xkN_nexcl.append(1) #: Not active, add it to the non-exclusion list.
if k > 0:
print("I[[check_active_bound_noisy]] {:d} Active bounds.".format(k))
def sens_dot_nmpc(self):
self.journalist("I", self._iteration_count, "sens_dot_nmpc", "Set-up")
if hasattr(self.olnmpc, "npdp"):
self.olnmpc.npdp.clear()
else:
self.olnmpc.npdp = Suffix(direction=Suffix.EXPORT)
for x in self.states:
con_name = x + "_icc"
con_ = getattr(self.olnmpc, con_name)
for j in self.state_vars[x]:
con_[j].set_suffix_value(self.olnmpc.npdp, self.curr_state_offset[(x, j)])
if hasattr(self.olnmpc, "f_timestamp"):
self.olnmpc.f_timestamp.clear()
else:
self.olnmpc.f_timestamp = Suffix(direction=Suffix.EXPORT,
datatype=Suffix.INT)
self.olnmpc.set_suffix_value(self.olnmpc.f_timestamp, self.int_file_nmpc_suf)
self.olnmpc.f_timestamp.display(ostream=sys.stderr)
self.journalist("I", self._iteration_count, "sens_dot_nmpc", self.olnmpc.name)
results = self.dot_driver.solve(self.olnmpc, tee=True, symbolic_solver_labels=True)
self.olnmpc.solutions.load_from(results)
self.olnmpc.f_timestamp.display(ostream=sys.stderr)
ftiming = open("timings_dot_driver.txt", "r")
s = ftiming.readline()
ftiming.close()
k = s.split()
self._dot_timing = k[0]
def create_rh_sfx(self, set_suffix=True):
"""Creates relevant suffixes for k_aug (prior at fe=2) (Reduced_Hess)
Args:
set_suffix (bool): True if update must be done
Returns:
None
"""
if hasattr(self.lsmhe, "dof_v"):
self.lsmhe.dof_v.clear()
else:
self.lsmhe.dof_v = Suffix(direction=Suffix.EXPORT) #: dof_v
if hasattr(self.lsmhe, "rh_name"):
self.lsmhe.rh_name.clear()
else:
self.lsmhe.rh_name = Suffix(direction=Suffix.IMPORT) #: Red_hess_name
if hasattr(self.lsmhe, "f_timestamp"):
self.lsmhe.f_timestamp.clear()
else:
self.lsmhe.f_timestamp = Suffix(direction=Suffix.EXPORT,
datatype=Suffix.INT)
if set_suffix:
for key in self.x_noisy:
var = getattr(self.lsmhe, key)
for j in self.x_vars[key]:
var[(2, 0) + j].set_suffix_value(self.lsmhe.dof_v, 1)
def create_suffixes_nmpc(self):
"""Creates the required suffixes for the olnmpc problem"""
if hasattr(self.olnmpc, "npdp"):
pass
else:
self.olnmpc.npdp = Suffix(direction=Suffix.EXPORT)
if hasattr(self.olnmpc, "dof_v"):
pass
else:
self.olnmpc.dof_v = Suffix(direction=Suffix.EXPORT)
for u in self.u:
uv = getattr(self.olnmpc, u)
uv[0].set_suffix_value(self.olnmpc.dof_v, 1)
def sens_dot_mhe(self):
"""Updates suffixes, solves using the dot_driver"""
self.journalizer("I", self._c_it, "sens_dot_mhe", "Set-up")
if hasattr(self.lsmhe, "npdp"):
self.lsmhe.npdp.clear()
else:
self.lsmhe.npdp = Suffix(direction=Suffix.EXPORT)
self.create_sens_suffix_mhe()
for y in self.y:
for j in self.y_vars[y]:
k = self.yk_key[(y, j)]
self.lsmhe.hyk_c_mhe[self.nfe_t, k].set_suffix_value(
self.lsmhe.npdp, self.curr_y_offset[(y, j)])
# with open("somefile0.txt", "w") as f:
# self.lsmhe.x.display(ostream=f)
# self.lsmhe.M.display(ostream=f)
# f.close()
if hasattr(self.lsmhe, "f_timestamp"):
self.lsmhe.f_timestamp.clear()
else:
self.lsmhe.f_timestamp = Suffix(direction=Suffix.EXPORT,
datatype=Suffix.INT)
#: Looks for the file with the timestamp
self.lsmhe.set_suffix_value(self.lsmhe.f_timestamp,
self.int_file_mhe_suf)
self.lsmhe.f_timestamp.display(ostream=sys.stderr)
self.journalizer("I", self._c_it, "sens_dot_mhe", self.lsmhe.name)
results = self.dot_driver.solve(self.lsmhe,
tee=True,
symbolic_solver_labels=True)
self.lsmhe.solutions.load_from(results)
self.lsmhe.f_timestamp.display(ostream=sys.stderr)
# with open("somefile1.txt", "w") as f:
# self.lsmhe.x.display(ostream=f)
# self.lsmhe.M.display(ostream=f)
# f.close()
ftiming = open("timings_dot_driver.txt", "r")
s = ftiming.readline()
ftiming.close()
k = s.split()
self._dot_timing = k[0]
def _GDPopt_initialize_master(self, solve_data, config):
"""Initialize the decomposition algorithm.
This includes generating the initial cuts require to build the master
problem.
"""
config.logger.info("---Starting GDPopt initialization---")
m = solve_data.working_model
if not hasattr(m, 'dual'): # Set up dual value reporting
m.dual = Suffix(direction=Suffix.IMPORT)
m.dual.activate()
# Set up the linear GDP model
solve_data.linear_GDP = m.clone()
# deactivate nonlinear constraints
for c in solve_data.linear_GDP.GDPopt_utils.\
working_nonlinear_constraints:
c.deactivate()
# Initialization strategies
init_strategy = valid_init_strategies.get(config.init_strategy, None)
if init_strategy is not None:
init_strategy(solve_data, config)
else:
raise ValueError('Unknown initialization strategy: %s. '
'Valid strategies include: %s' %
(config.init_strategy, ", ".join(
valid_init_strategies.keys())))
def _apply_to(self, model, **kwds):
options = kwds.pop('options', {})
if kwds.get('undo', options.get('undo', False)):
for v, d in itervalues(model._relaxed_discrete_vars[None]):
v.domain = d
model.del_component("_relaxed_discrete_vars")
return
# Relax the model
relaxed_vars = {}
_base_model_vars = model.component_data_objects(Var,
active=True,
descend_into=True)
for var in _base_model_vars:
if var.domain in _discrete_relaxation_map:
if var.domain is Binary or var.domain is Boolean:
var.setlb(0)
var.setub(1)
# Note: some indexed components can only have their
# domain set on the parent component (the individual
# indices cannot be set independently)
_c = var.parent_component()
if id(_c) in _discrete_relaxation_map:
continue
try:
_domain = var.domain
var.domain = _discrete_relaxation_map[_domain]
relaxed_vars[id(var)] = (var, _domain)
except:
_domain = _c.domain
_c.domain = _discrete_relaxation_map[_domain]
relaxed_vars[id(_c)] = (_c, _domain)
model._relaxed_discrete_vars = Suffix(direction=Suffix.LOCAL)
model._relaxed_discrete_vars[None] = relaxed_vars
def load_covariance_prior(self):
"""Computes the reduced-hessian (inverse of the prior-covariance)
Reads the result_hessian.txt file that contains the covariance information"""
self.journalizer("I", self._c_it, "load_covariance_prior", "K_AUG w red_hess")
self.k_aug.options["compute_inv"] = ""
if hasattr(self.lsmhe, "f_timestamp"):
self.lsmhe.f_timestamp.clear()
else:
self.lsmhe.f_timestamp = Suffix(direction=Suffix.EXPORT,
datatype=Suffix.INT)
self.create_rh_sfx()
self.k_aug.solve(self.lsmhe, tee=True)
self.lsmhe.f_timestamp.display(ostream=sys.stderr)
self._PI.clear()
with open("inv_.in", "r") as rh:
ll = []
l = rh.readlines()
row = 0
for i in l:
ll = i.split()
col = 0
for j in ll:
self._PI[row, col] = float(j)
col += 1
row += 1
rh.close()
print("-" * 120)
print("I[[load covariance]] e-states nrows {:d} ncols {:d}".format(len(l), len(ll)))
print("-" * 120)
def sens_k_aug_mhe(self):
self.journalizer("I", self._c_it, "sens_k_aug_mhe",
"k_aug sensitivity")
self.lsmhe.ipopt_zL_in.update(self.lsmhe.ipopt_zL_out)
self.lsmhe.ipopt_zU_in.update(self.lsmhe.ipopt_zU_out)
self.journalizer("I", self._c_it, "sens_k_aug_mhe", self.lsmhe.name)
if hasattr(self.lsmhe, "f_timestamp"):
self.lsmhe.f_timestamp.clear()
else:
self.lsmhe.f_timestamp = Suffix(direction=Suffix.EXPORT,
datatype=Suffix.INT)
#: Now, the sensitivity step will have the timestamp for dot_in
self.lsmhe.set_suffix_value(self.lsmhe.f_timestamp,
self.int_file_mhe_suf)
self.lsmhe.f_timestamp.display(ostream=sys.stderr)
self.create_sens_suffix_mhe()
results = self.k_aug_sens.solve(self.lsmhe,
tee=True,
symbolic_solver_labels=True)
self.lsmhe.solutions.load_from(results)
self.lsmhe.f_timestamp.display(ostream=sys.stderr)
ftimings = open("timings_k_aug.txt", "r")
s = ftimings.readline()
ftimings.close()
self._k_timing = s.split()
def create_sens_suffix_mhe(self, set_suffix=True):
"""Creates relevant suffixes for k_aug (Sensitivity)
Args:
set_suffix (bool): True if update must be done
Returns:
None"""
if hasattr(self.lsmhe, "dof_v"):
self.lsmhe.dof_v.clear()
else:
self.lsmhe.dof_v = Suffix(direction=Suffix.EXPORT) #: dof_v
if hasattr(self.lsmhe, "rh_name"):
self.lsmhe.rh_name.clear()
else:
self.lsmhe.rh_name = Suffix(direction=Suffix.IMPORT) #: Red_hess_name
if set_suffix:
for key in self.x_noisy:
var = getattr(self.lsmhe, key)
for j in self.x_vars[key]:
var[(self.nfe_t, self.ncp_t) + j].set_suffix_value(self.lsmhe.dof_v, 1)
def _load_rc(self, vars_to_load=None):
if not hasattr(self._pyomo_model, 'rc'):
self._pyomo_model.rc = Suffix(direction=Suffix.IMPORT)
var_map = self._pyomo_var_to_solver_var_map
ref_vars = self._referenced_variables
rc = self._pyomo_model.rc
if vars_to_load is None:
vars_to_load = var_map.keys()
cplex_vars_to_load = [var_map[pyomo_var] for pyomo_var in vars_to_load]
vals = self._solver_model.solution.get_reduced_costs(cplex_vars_to_load)
for i, pyomo_var in enumerate(vars_to_load):
if ref_vars[pyomo_var] > 0:
rc[pyomo_var] = vals[i]
def _load_slacks(self, cons_to_load=None):
if not hasattr(self._pyomo_model, 'slack'):
self._pyomo_model.slack = Suffix(direction=Suffix.IMPORT)
con_map = self._pyomo_con_to_solver_con_map
reverse_con_map = self._solver_con_to_pyomo_con_map
slack = self._pyomo_model.slack
if cons_to_load is None:
linear_cons_to_load = self._solver_model.linear_constraints.get_names(
)
linear_vals = self._solver_model.solution.get_linear_slacks()
quadratic_cons_to_load = self._solver_model.quadratic_constraints.get_names(
)
quadratic_vals = self._solver_model.solution.get_quadratic_slacks()
else:
cplex_cons_to_load = set(
[con_map[pyomo_con] for pyomo_con in cons_to_load])
linear_cons_to_load = cplex_cons_to_load.intersection(
set(self._solver_model.linear_constraints.get_names()))
linear_vals = self._solver_model.solution.get_linear_slacks(
linear_cons_to_load)
quadratic_cons_to_load = cplex_cons_to_load.intersection(
set(self._solver_model.quadratic_constraints.get_names()))
quadratic_vals = self._solver_model.solution.get_quadratic_slacks(
quadratic_cons_to_load)
for i, cplex_con in enumerate(linear_cons_to_load):
pyomo_con = reverse_con_map[cplex_con]
if pyomo_con in self._range_constraints:
R_ = self._solver_model.linear_constraints.get_range_values(
cplex_con)
if R_ == 0:
slack[pyomo_con] = linear_vals[i]
else:
Ls_ = linear_vals[i]
Us_ = R_ - Ls_
if abs(Us_) > abs(Ls_):
slack[pyomo_con] = Us_
else:
slack[pyomo_con] = -Ls_
else:
slack[pyomo_con] = linear_vals[i]
for i, cplex_con in enumerate(quadratic_cons_to_load):
pyomo_con = reverse_con_map[cplex_con]
slack[pyomo_con] = quadratic_vals[i]
def _apply_to(self, model, **kwds):
options = kwds.pop('options', {})
if kwds.get('undo', options.get('undo', False)):
for v, d in model._relaxed_integer_vars[None].values():
bounds = v.bounds
v.domain = d
v.setlb(bounds[0])
v.setub(bounds[1])
model.del_component("_relaxed_integer_vars")
return
# True by default, you can specify False if you want
descend = kwds.get('transform_deactivated_blocks',
options.get('transform_deactivated_blocks', True))
active = None if descend else True
# Relax the model
relaxed_vars = {}
_base_model_vars = model.component_data_objects(Var,
active=active,
descend_into=True)
for var in _base_model_vars:
if not var.is_integer():
continue
# Note: some indexed components can only have their
# domain set on the parent component (the individual
# indices cannot be set independently)
_c = var.parent_component()
try:
lb, ub = var.bounds
_domain = var.domain
var.domain = Reals
var.setlb(lb)
var.setub(ub)
relaxed_vars[id(var)] = (var, _domain)
except:
if id(_c) in relaxed_vars:
continue
_domain = _c.domain
lb, ub = _c.bounds
_c.domain = Reals
_c.setlb(lb)
_c.setub(ub)
relaxed_vars[id(_c)] = (_c, _domain)
model._relaxed_integer_vars = Suffix(direction=Suffix.LOCAL)
model._relaxed_integer_vars[None] = relaxed_vars
def _apply_to(self, model, **kwds):
options = kwds.pop('options', {})
if kwds.get('undo', options.get('undo', False)):
for v in model._fixed_discrete_vars[None]:
v.unfix()
model.del_component("_fixed_discrete_vars")
return
fixed_vars = []
_base_model_vars = model.component_data_objects(Var,
active=True,
descend_into=True)
for var in _base_model_vars:
if var.domain in _discrete_relaxation_map and not var.is_fixed():
fixed_vars.append(var)
var.fix()
model._fixed_discrete_vars = Suffix(direction=Suffix.LOCAL)
model._fixed_discrete_vars[None] = fixed_vars
def _load_duals(self, cons_to_load=None):
if not hasattr(self._pyomo_model, 'dual'):
self._pyomo_model.dual = Suffix(direction=Suffix.IMPORT)
con_map = self._pyomo_con_to_solver_con_map
reverse_con_map = self._solver_con_to_pyomo_con_map
dual = self._pyomo_model.dual
if cons_to_load is None:
linear_cons_to_load = self._solver_model.linear_constraints.get_names()
vals = self._solver_model.solution.get_dual_values()
else:
cplex_cons_to_load = set([con_map[pyomo_con] for pyomo_con in cons_to_load])
linear_cons_to_load = cplex_cons_to_load.intersection(set(self._solver_model.linear_constraints.get_names()))
vals = self._solver_model.solution.get_dual_values(linear_cons_to_load)
for i, cplex_con in enumerate(linear_cons_to_load):
pyomo_con = reverse_con_map[cplex_con]
dual[pyomo_con] = vals[i]
def sens_k_aug_nmpc(self):
self.journalist("I", self._iteration_count, "sens_k_aug_nmpc", "k_aug sensitivity")
self.olnmpc.ipopt_zL_in.update(self.olnmpc.ipopt_zL_out)
self.olnmpc.ipopt_zU_in.update(self.olnmpc.ipopt_zU_out)
self.journalist("I", self._iteration_count, "solve_k_aug_nmpc", self.olnmpc.name)
if hasattr(self.olnmpc, "f_timestamp"):
self.olnmpc.f_timestamp.clear()
else:
self.olnmpc.f_timestamp = Suffix(direction=Suffix.EXPORT,
datatype=Suffix.INT)
self.olnmpc.set_suffix_value(self.olnmpc.f_timestamp, self.int_file_nmpc_suf)
self.olnmpc.f_timestamp.display(ostream=sys.stderr)
results = self.k_aug_sens.solve(self.olnmpc, tee=True, symbolic_solver_labels=True)
self.olnmpc.solutions.load_from(results)
self.olnmpc.f_timestamp.display(ostream=sys.stderr)
ftimings = open("timings_k_aug.txt", "r")
s = ftimings.readline()
ftimings.close()
self._k_timing = s.split()
def _apply_to(self, model, **kwds):
options = kwds.pop('options', {})
if kwds.get('undo', options.get('undo', False)):
for v in model._fixed_discrete_vars[None]:
v.unfix()
model.del_component("_fixed_discrete_vars")
return
fixed_vars = []
_base_model_vars = model.component_data_objects(Var,
active=True,
descend_into=True)
for var in _base_model_vars:
# Instead of checking against `_discrete_relaxation_map.keys()`
# we just check the item properties to fix #995
# When #326 has been resolved, we can check against the dict-keys again
if not var.is_continuous() and not var.is_fixed():
fixed_vars.append(var)
var.fix()
model._fixed_discrete_vars = Suffix(direction=Suffix.LOCAL)
model._fixed_discrete_vars[None] = fixed_vars
def __init__(self, nfe_t, ncp_t, **kwargs):
ConcreteModel.__init__(self)
steady = kwargs.pop('steady', False)
_t = kwargs.pop('_t', 1.0)
Ntray = kwargs.pop('Ntray', 42)
# --------------------------------------------------------------------------------------------------------------
# Orthogonal Collocation Parameters section
# Radau
self._alp_gauB_t = 1
self._bet_gauB_t = 0
if steady:
print("[I] " + str(self.__class__.__name__) + " NFE and NCP Overriden - Steady state mode")
self.nfe_t = 1
self.ncp_t = 1
else:
self.nfe_t = nfe_t
self.ncp_t = ncp_t
self.tau_t = collptsgen(self.ncp_t, self._alp_gauB_t, self._bet_gauB_t)
# start at zero
self.tau_i_t = {0: 0.}
# create a list
for ii in range(1, self.ncp_t + 1):
self.tau_i_t[ii] = self.tau_t[ii - 1]
# ======= SETS ======= #
# For finite element = 1 .. NFE
# This has to be > 0
self.fe_t = Set(initialize=[ii for ii in range(1, self.nfe_t + 1)])
# collocation points
# collocation points for differential variables
self.cp_t = Set(initialize=[ii for ii in range(0, self.ncp_t + 1)])
# collocation points for algebraic variables
self.cp_ta = Set(within=self.cp_t, initialize=[ii for ii in range(1, self.ncp_t + 1)])
# create collocation param
self.taucp_t = Param(self.cp_t, initialize=self.tau_i_t)
self.ldot_t = Param(self.cp_t, self.cp_t, initialize=
(lambda m, j, k: lgrdot(k, m.taucp_t[j], self.ncp_t, self._alp_gauB_t, self._bet_gauB_t))) #: watch out for this!
self.l1_t = Param(self.cp_t, initialize=
(lambda m, j: lgr(j, 1, self.ncp_t, self._alp_gauB_t, self._bet_gauB_t)))
# --------------------------------------------------------------------------------------------------------------
# Model parameters
self.Ntray = Ntray
self.tray = Set(initialize=[i for i in range(1, Ntray + 1)])
self.feed = Param(self.tray,
initialize=lambda m, t: 57.5294 if t == 21 else 0.0,
mutable=True)
self.xf = Param(initialize=0.32, mutable=True) # feed mole fraction
self.hf = Param(initialize=9081.3) # feed enthalpy
self.hlm0 = Param(initialize=2.6786e-04)
self.hlma = Param(initialize=-0.14779)
self.hlmb = Param(initialize=97.4289)
self.hlmc = Param(initialize=-2.1045e04)
self.hln0 = Param(initialize=4.0449e-04)
self.hlna = Param(initialize=-0.1435)
self.hlnb = Param(initialize=121.7981)
self.hlnc = Param(initialize=-3.0718e04)
self.r = Param(initialize=8.3147)
self.a = Param(initialize=6.09648)
self.b = Param(initialize=1.28862)
self.c1 = Param(initialize=1.016)
self.d = Param(initialize=15.6875)
self.l = Param(initialize=13.4721)
self.f = Param(initialize=2.615)
self.gm = Param(initialize=0.557)
self.Tkm = Param(initialize=512.6)
self.Pkm = Param(initialize=8.096e06)
self.gn = Param(initialize=0.612)
self.Tkn = Param(initialize=536.7)
self.Pkn = Param(initialize=5.166e06)
self.CapAm = Param(initialize=23.48)
self.CapBm = Param(initialize=3626.6)
self.CapCm = Param(initialize=-34.29)
self.CapAn = Param(initialize=22.437)
self.CapBn = Param(initialize=3166.64)
self.CapCn = Param(initialize=-80.15)
self.pstrip = Param(initialize=250)
self.prect = Param(initialize=190)
def _p_init(m, t):
ptray = 9.39e04
if t <= 20:
return _p_init(m, 21) + m.pstrip * (21 - t)
elif 20 < t < m.Ntray:
return ptray + m.prect * (m.Ntray - t)
elif t == m.Ntray:
return 9.39e04
self.p = Param(self.tray, initialize=_p_init)
self.T29_des = Param(initialize=343.15)
self.T15_des = Param(initialize=361.15)
self.Dset = Param(initialize=1.83728)
self.Qcset = Param(initialize=1.618890)
self.Qrset = Param(initialize=1.786050)
# self.Recset = Param()
self.alpha_T29 = Param(initialize=1)
self.alpha_T15 = Param(initialize=1)
self.alpha_D = Param(initialize=1)
self.alpha_Qc = Param(initialize=1)
self.alpha_Qr = Param(initialize=1)
self.alpha_Rec = Param(initialize=1)
def _alpha_init(m, i):
if i <= 21:
return 0.62
else:
return 0.35
self.alpha = Param(self.tray,
initialize=lambda m, t: 0.62 if t <= 21 else 0.35)
# --------------------------------------------------------------------------------------------------------------
#: First define differential state variables (state: x, ic-Param: x_ic, derivative-Var:dx_dt
#: States (differential) section
zero_tray = dict.fromkeys(self.tray)
zero3 = dict.fromkeys(self.fe_t * self.cp_t * self.tray)
for key in zero3.keys():
zero3[key] = 0.0
def __m_init(m, i, j, t):
if t < m.Ntray:
return 4000.
elif t == 1:
return 104340.
elif t == m.Ntray:
return 5000.
#: Liquid hold-up
self.M = Var(self.fe_t, self.cp_t, self.tray,
initialize=__m_init)
#: Mole-fraction
self.x = Var(self.fe_t, self.cp_t, self.tray, initialize=lambda m, i, j, t: 0.999 * t / m.Ntray)
#: Initial state-Param
self.M_ic = zero_tray if steady else Param(self.tray, initialize=0.0, mutable=True)
self.x_ic = zero_tray if steady else Param(self.tray, initialize=0.0, mutable=True)
#: Derivative-var
self.dM_dt = zero3 if steady else Var(self.fe_t, self.cp_t, self.tray, initialize=0.0)
self.dx_dt = zero3 if steady else Var(self.fe_t, self.cp_t, self.tray, initialize=0.0)
# --------------------------------------------------------------------------------------------------------------
# States (algebraic) section
# Tray temperature
self.T = Var(self.fe_t, self.cp_ta, self.tray,
initialize=lambda m, i, j, t: ((370.781 - 335.753) / m.Ntray) * t + 370.781)
self.Tdot = Var(self.fe_t, self.cp_ta, self.tray, initialize=1e-05) #: Not really a der_var
# saturation pressures
self.pm = Var(self.fe_t, self.cp_ta, self.tray, initialize=1e4)
self.pn = Var(self.fe_t, self.cp_ta, self.tray, initialize=1e4)
# Vapor mole flowrate
self.V = Var(self.fe_t, self.cp_ta, self.tray, initialize=44.0)
def _l_init(m, i, j, t):
if 2 <= t <= 21:
return 83.
elif 22 <= t <= 42:
return 23
elif t == 1:
return 40
# Liquid mole flowrate
self.L = Var(self.fe_t, self.cp_ta, self.tray, initialize=_l_init)
# Vapor mole frac & diff var
self.y = Var(self.fe_t, self.cp_ta, self.tray,
initialize=lambda m, i, j, t: ((0.99 - 0.005) / m.Ntray) * t + 0.005)
# Liquid enthalpy # enthalpy
self.hl = Var(self.fe_t, self.cp_ta, self.tray, initialize=10000.)
# Liquid enthalpy # enthalpy
self.hv = Var(self.fe_t, self.cp_ta, self.tray, initialize=5e+04)
# Re-boiler & condenser heat
self.Qc = Var(self.fe_t, self.cp_ta, initialize=1.6e06)
self.D = Var(self.fe_t, self.cp_ta, initialize=18.33)
# vol holdups
self.Vm = Var(self.fe_t, self.cp_ta, self.tray, initialize=6e-05)
self.Mv = Var(self.fe_t, self.cp_ta, self.tray,
initialize=lambda m, i, j, t: 0.23 if 1 < t < m.Ntray else 0.0)
self.Mv1 = Var(self.fe_t, self.cp_ta, initialize=8.57)
self.Mvn = Var(self.fe_t, self.cp_ta, initialize=0.203)
hi_t = dict.fromkeys(self.fe_t)
for key in hi_t.keys():
hi_t[key] = 1.0 if steady else _t/self.nfe_t
self.hi_t = hi_t if steady else Param(self.fe_t, initialize=hi_t)
# --------------------------------------------------------------------------------------------------------------
#: Controls
self.u1 = Param(self.fe_t, initialize=7.72700925775773761472464684629813E-01, mutable=True) #: Dummy
self.u2 = Param(self.fe_t, initialize=1.78604740940007800236344337463379E+06, mutable=True) #: Dummy
self.Rec = Var(self.fe_t, initialize=7.72700925775773761472464684629813E-01)
self.Qr = Var(self.fe_t, initialize=1.78604740940007800236344337463379E+06)
# --------------------------------------------------------------------------------------------------------------
#: Constraints for the differential states
#: Then the ode-Con:de_x, collocation-Con:dvar_t_x, noisy-Expr: noisy_x, cp-Constraint: cp_x, initial-Con: x_icc
#: Differential equations
self.de_M = Constraint(self.fe_t, self.cp_ta, self.tray, rule=m_ode)
self.de_x = Constraint(self.fe_t, self.cp_ta, self.tray, rule=x_ode)
#: Collocation equations
self.dvar_t_M = None if steady else Constraint(self.fe_t, self.cp_ta, self.tray, rule=M_COLL)
self.dvar_t_x = None if steady else Constraint(self.fe_t, self.cp_ta, self.tray, rule=x_coll)
#: Continuation equations (redundancy here)
if self.nfe_t > 1:
#: Noisy expressions
self.noisy_M = None if steady else Expression(self.fe_t, self.tray, rule=M_CONT)
self.noisy_x = None if steady else Expression(self.fe_t, self.tray, rule=x_cont)
#: Continuation equations
self.cp_M = None if steady else \
Constraint(self.fe_t, self.tray,
rule=lambda m, i, t: self.noisy_M[i, t] == 0.0 if i < self.nfe_t else Constraint.Skip)
self.cp_x = None if steady else \
Constraint(self.fe_t, self.tray,
rule=lambda m, i, t: self.noisy_x[i, t] == 0.0 if i < self.nfe_t else Constraint.Skip)
#: Initial condition-Constraints
self.M_icc = None if steady else Constraint(self.tray, rule=acm)
self.x_icc = None if steady else Constraint(self.tray, rule=acx)
# --------------------------------------------------------------------------------------------------------------
#: Constraint section (algebraic equations)
self.hrc = Constraint(self.fe_t, self.cp_ta, rule=hrc)
self.gh = Constraint(self.fe_t, self.cp_ta, self.tray, rule=gh)
self.ghb = Constraint(self.fe_t, self.cp_ta, rule=ghb)
self.ghc = Constraint(self.fe_t, self.cp_ta, rule=ghc)
self.hkl = Constraint(self.fe_t, self.cp_ta, self.tray, rule=hkl)
self.hkv = Constraint(self.fe_t, self.cp_ta, self.tray, rule=hkv)
self.lpself = Constraint(self.fe_t, self.cp_ta, self.tray, rule=lpm)
self.lpn = Constraint(self.fe_t, self.cp_ta, self.tray, rule=lpn)
self.dp = Constraint(self.fe_t, self.cp_ta, self.tray, rule=dp)
self.lTdot = Constraint(self.fe_t, self.cp_ta, self.tray, rule=lTdot)
self.gy0 = Constraint(self.fe_t, self.cp_ta, rule=gy0)
self.gy = Constraint(self.fe_t, self.cp_ta, self.tray, rule=gy)
self.dMV = Constraint(self.fe_t, self.cp_ta, self.tray, rule=dMV)
self.dMv1 = Constraint(self.fe_t, self.cp_ta, rule=dMv1)
self.dMvn = Constraint(self.fe_t, self.cp_ta, rule=dMvn)
self.hyd = Constraint(self.fe_t, self.cp_ta, self.tray, rule=hyd)
self.hyd1 = Constraint(self.fe_t, self.cp_ta, rule=hyd1)
self.hydN = Constraint(self.fe_t, self.cp_ta, rule=hydN)
self.dvself = Constraint(self.fe_t, self.cp_ta, self.tray, rule=dvm)
# --------------------------------------------------------------------------------------------------------------
#: Control constraint
self.u1_e = Expression(self.fe_t, rule=lambda m, i: self.Rec[i])
self.u2_e = Expression(self.fe_t, rule=lambda m, i: self.Qr[i])
self.u1_c = Constraint(self.fe_t, rule=lambda m, i: self.u1[i] == self.u1_e[i])
self.u2_c = Constraint(self.fe_t, rule=lambda m, i: self.u2[i] == self.u2_e[i])
# --------------------------------------------------------------------------------------------------------------
#: Suffixes
self.dual = Suffix(direction=Suffix.IMPORT_EXPORT)
self.ipopt_zL_out = Suffix(direction=Suffix.IMPORT)
self.ipopt_zU_out = Suffix(direction=Suffix.IMPORT)
self.ipopt_zL_in = Suffix(direction=Suffix.EXPORT)
self.ipopt_zU_in = Suffix(direction=Suffix.EXPORT)
actual_key.append(int(k))
actual_key.append(actual_key.pop(0))
actual_key = tuple(actual_key)
value = kk[8]
value = float(value)
dict[var, actual_key] = value
except IndexError:
continue
file_i.close()
return dict
file_tst = open("iv_ss.txt", "r")
somedict = parse_ig_ampl(file_tst)
somemodel.ipopt_zL_out = Suffix(direction=Suffix.IMPORT)
somemodel.ipopt_zU_out = Suffix(direction=Suffix.IMPORT)
somemodel.display(filename="somefile0.txt")
for var in somemodel.component_objects(Var, active=True):
vx = getattr(somemodel, str(var))
for v, k in var.iteritems():
# print(str(var), v)
try:
vx[v] = somedict[str(var), v]
except KeyError:
continue
someresults = solver.solve(somemodel, tee=True)
# somemodel.pprint(filename="pprint.txt")
# f.close()
e.find_target_ss() #: Compute target-steady state (beforehand)
# For ideal nmpc
for i in range(1, 2):
print(str(i) + "--" * 20, file=sys.stderr)
print("*" * 100)
e.solve_d(e.d1)
e.update_state_real() # update the current state
e.cycle_ics(plant_step=True)
e.plant_input_gen(e.d1, "mod", src=e.ss2)
# e.plant_input_gen(e.d1, src_kind="dict")
e.d1.dcdp = Suffix(direction=Suffix.EXPORT)
e.d1.var_order = Suffix(direction=Suffix.EXPORT)
e.d1.sens_init_constr = Suffix(direction=Suffix.EXPORT)
small_value = 1e-06
ii = 1
for x in e.states:
con = getattr(e.d1, x + '_icc')
con.set_suffix_value(e.d1.sens_init_constr, 1)
var = getattr(e.d1, x)
for key in var.keys():
if key[1] == 0:
if var[key].stale:
continue
setattr(e.d1, "sens_state_" + str(ii),
Suffix(direction=Suffix.EXPORT))
def GradientsTool(self):
self.journalizer("E", self._c_it, "GradientsTool", "Begin")
src = self.d1
src.dum_objfun = Objective(expr=1, sense=minimize)
self.d1.var_order = Suffix(direction=Suffix.EXPORT)
self.d1.con_order = Suffix(direction=Suffix.EXPORT)
src.pprint(filename="first.txt")
#: Fix/Deactivate irrelevant stuff
for var in src.component_objects(Var, active=True):
if not var.is_indexed():
var.fix()
for index in var.keys():
if type(index) != tuple:
var.fix()
continue
try:
if index[1] == self.ncp_t:
continue
var[index].fix()
except IndexError:
var.fix()
print("Variable not indexed by time",
var.name,
file=sys.stderr)
for con in src.component_objects(Constraint, active=True):
if not con.is_indexed():
con.deactivate()
for index in con.keys():
if type(index) != tuple:
con.deactivate()
continue
try:
if index[1] == self.ncp_t:
continue
con[index].deactivate()
except IndexError:
con.deactivate()
print("Constraint not indexed by time",
con.name,
file=sys.stderr)
for i in self.states: #: deactivate collocation related equations
# con = getattr(src, "cp_" + i) #: continuation
# con.deactivate()
con = getattr(src, "dvar_t_" + i) #: derivative vars
con.deactivate()
con = getattr(src, i + "_icc") #: initial-conditions
con.deactivate()
var = getattr(src, "d" + i + "_dt")
var.fix()
var = getattr(src, i)
var.fix() #: left with the av
con = getattr(src, "de_" + i) #: initial-conditions
con.deactivate()
# colcount = 0
# for i in src.component_data_objects(Var, active=True):
# if i.is_fixed():
# continue
# print(i)
# colcount += 1
# i.set_suffix_value(src.var_order, colcount)
# print(colcount)
self.d1.write_nl(name="dgy.nl")
sfxdict = dict()
self.parse_rc("dgy.row", sfxdict)
colcount = 1
for ob in sfxdict.keys():
con = getattr(src, sfxdict[ob][0])
con[sfxdict[ob][1]].set_suffix_value(src.con_order, colcount)
colcount += 1
sfxdict = dict()
self.parse_rc("dgy.col", sfxdict)
colcount = 1
for ob in sfxdict.keys():
var = getattr(src, sfxdict[ob][0])
var[sfxdict[ob][1]].set_suffix_value(src.var_order, colcount)
colcount += 1
print("Colcount\t", str(colcount), file=sys.stderr)
src.write_nl(name="dgy.nl")
#: Now dgx
for var in src.component_objects(Var):
var.fix() #: Fix everything
for i in self.states:
var = getattr(src, i)
for index in var.keys():
try:
if index[1] == self.ncp_t:
var[index].unfix()
except IndexError:
print("Something whent wrong :(\t",
var.name,
file=sys.stderr)
self.d1.write_nl(name="dgx.nl")
sfxdict = dict()
self.parse_rc("dgx.col", sfxdict)
colcount = 1
for ob in sfxdict.keys():
var = getattr(src, sfxdict[ob][0])
var[sfxdict[ob][1]].set_suffix_value(src.var_order, colcount)
colcount += 1
src.write_nl(name="dgx.nl")
#: Now dfy
for var in src.component_objects(Var):
var.unfix()
for var in src.component_objects(Var):
if not var.is_indexed():
var.fix()
for index in var.keys():
if type(index) != tuple:
var.fix()
continue
try:
if index[1] == self.ncp_t:
continue
var[index].fix()
except IndexError:
var.fix()
print("Variable not indexed by time",
var.name,
file=sys.stderr)
for con in src.component_objects(Constraint):
con.deactivate() #: deactivate everything
for i in self.states: #: deactivate collocation related terms
var = getattr(src, "d" + i + "_dt")
var.fix()
var = getattr(src, i)
var.fix() #: left with the av
con = getattr(src, "de_" + i)
for index in con.keys():
if index[1] == self.ncp_t:
con[index].activate()
self.d1.reconstruct()
# self.d1.write_nl(name="dfy.nl")
sfxdict = dict()
self.parse_rc("dgx.col", sfxdict)
colcount = 1
for ob in sfxdict.keys():
col = getattr(src, "de_" + sfxdict[ob][0])
col[sfxdict[ob][1]].set_suffix_value(src.con_order, colcount)
colcount += 1
src.write_nl(name="dfy.nl")
#: Now dfx
for var in src.component_objects(Var):
var.fix() #: Fix everything
for i in self.states:
var = getattr(src, i)
for index in var.keys():
try:
if index[1] == self.ncp_t:
var[index].unfix()
except IndexError:
print("Something whent wrong :(\t",
var.name,
file=sys.stderr)
# var.pprint()
self.d1.reconstruct()
src.pprint(filename="second.txt")
self.d1.write_nl(name="dfx.nl")
def __init__(self, nfe_t, ncp_t, **kwargs):
#: type: (int, int, dict)
#: if steady == True fallback to steady-state computation
self.nfe_t = nfe_t #:
self.ncp_t = ncp_t
self.scheme = kwargs.pop('scheme', 'LAGRANGE-RADAU')
self.steady = kwargs.pop('steady', False)
self._t = kwargs.pop('_t', 1.0)
ncstr = kwargs.pop('n_cstr', 1)
ConcreteModel.__init__(self)
self.ncstr = Set(initialize=[i for i in range(0, ncstr)])
if self.steady:
self.t = Set(initialize=[1])
else:
self.t = ContinuousSet(bounds=(0, self._t))
self.Cainb = Param(default=1.0)
self.Tinb = Param(default=275.0)
self.Tjinb = Param(default=250.0)
self.V = Param(initialize=100)
self.UA = Param(initialize=20000 * 60)
self.rho = Param(initialize=1000)
self.Cp = Param(initialize=4.2)
self.Vw = Param(initialize=10)
self.rhow = Param(initialize=1000)
self.Cpw = Param(initialize=4.2)
self.k0 = Param(initialize=4.11e13)
self.E = Param(initialize=76534.704)
self.R = Param(initialize=8.314472)
self.Er = Param(initialize=lambda m: (value(self.E) / value(self.R)))
self.dH = Param(initialize=596619.)
self.F = Param(self.t, mutable=True, default=1.2000000000000000E+02)
self.Fw = Param(self.t, mutable=True, default=3.0000000000000000E+01)
# States
self.Ca = Var(self.t, self.ncstr, initialize=1.60659680385930765667001907104350E-02)
self.T = Var(self.t, self.ncstr, initialize=3.92336059452774350120307644829154E+02)
self.Tj = Var(self.t, self.ncstr, initialize=3.77995395658401662331016268581152E+02)
self.k = Var(self.t, self.ncstr, initialize=4.70706140E+02)
self.kdef = Constraint(self.t, self.ncstr)
#: These guys have to be zero at the steady-state (steady).
zero0 = dict.fromkeys(self.t * self.ncstr)
for key in zero0.keys():
zero0[key] = 0.0
if self.steady:
self.Cadot = zero0
self.Tdot = zero0
self.Tjdot = zero0
else:
self.Cadot = DerivativeVar(self.Ca, initialize=-3.58709135E+01)
self.Tdot = DerivativeVar(self.T, initialize=5.19191848E+03)
self.Tjdot = DerivativeVar(self.Tj, initialize=-9.70467399E+02)
#: These guys as well (steady).
self.Ca_ic = Param(self.ncstr, default=1.9193793974995963E-02)
self.T_ic = Param(self.ncstr, default=3.8400724261199036E+02)
self.Tj_ic = Param(self.ncstr, default=3.7127352272578315E+02)
# m.Ca_ic = Param(m.ncstr, default=1.9193793974995963E-02)
# m.T_ic = Param(m.ncstr, default=3.8400724261199036E+02)
# m.Tj_ic = Param(m.ncstr, default=3.7127352272578315E+02)
self.ODE_ca = Constraint(self.t, self.ncstr)
self.ODE_T = Constraint(self.t, self.ncstr)
self.ODE_Tj = Constraint(self.t, self.ncstr)
#: No need of these guys at steady.
if self.steady:
self.Ca_icc = None
self.T_icc = None
self.Tj_icc = None
else:
self.Ca_icc = Constraint(self.ncstr)
self.T_icc = Constraint(self.ncstr)
self.Tj_icc = Constraint(self.ncstr)
def _rule_k(m, i, n):
if i == 0:
return Constraint.Skip
else:
return m.k[i, n] == m.k0 * exp(-m.Er / m.T[i, n])
def _rule_ca(m, i, n):
if i == 0:
return Constraint.Skip
else:
rule = m.Cadot[i, n] == (m.F[i] / m.V) * (m.Cainb - m.Ca[i, n]) - 2 * m.k[i, n] * m.Ca[i, n] ** 2
return rule
def _rule_t(m, i, n):
if i == 0:
return Constraint.Skip
else:
return m.Tdot[i, n] == (m.F[i] / m.V) * (m.Tinb - m.T[i, n]) + \
2.0 * m.dH / (m.rho * m.Cp) * m.k[i, n] * m.Ca[i, n] ** 2 -\
m.UA / (m.V * m.rho * m.Cp) * (m.T[i, n] - m.Tj[i, n])
def _rule_tj(m, i, n):
if i == 0:
return Constraint.Skip
else:
return m.Tjdot[i, n] == \
(m.Fw[i] / m.Vw) * (m.Tjinb - m.Tj[i, n]) + m.UA / (m.Vw * m.rhow * m.Cpw) * (m.T[i, n] - m.Tj[i, n])
def _rule_ca0(m, n):
return m.Ca[0, n] == m.Ca_ic[n]
def _rule_t0(m, n):
return m.T[0, n] == m.T_ic[n]
def _rule_tj0(m, n):
return m.Tj[0, n] == m.Tj_ic[n]
# let Ca0 := 1.9193793974995963E-02 ;
# let T0 := 3.8400724261199036E+02 ;
# let Tj0 := 3.7127352272578315E+02 ;
self.kdef.rule = lambda m, i, n: _rule_k(m, i, n)
self.ODE_ca.rule = lambda m, i, n: _rule_ca(m, i, n)
self.ODE_T.rule = lambda m, i, n: _rule_t(m, i, n)
self.ODE_Tj.rule = lambda m, i, n: _rule_tj(m, i, n)
if self.steady:
pass
else:
self.Ca_icc.rule = lambda m, n: _rule_ca0(m, n)
self.T_icc.rule = lambda m, n: _rule_t0(m, n)
self.Tj_icc.rule = lambda m, n: _rule_tj0(m, n)
self.Ca_icc.reconstruct()
self.T_icc.reconstruct()
self.Tj_icc.reconstruct()
self.kdef.reconstruct()
self.ODE_ca.reconstruct()
self.ODE_T.reconstruct()
self.ODE_Tj.reconstruct()
# Declare at framework level
self.dual = Suffix(direction=Suffix.IMPORT_EXPORT)
self.ipopt_zL_out = Suffix(direction=Suffix.IMPORT)
self.ipopt_zU_out = Suffix(direction=Suffix.IMPORT)
self.ipopt_zL_in = Suffix(direction=Suffix.EXPORT)
self.ipopt_zU_in = Suffix(direction=Suffix.EXPORT)
self.discretizer = TransformationFactory('dae.collocation')
