def test_IndexTemplate(self):
m = self.m
i = IndexTemplate(m.I)
with self.assertRaisesRegex(TemplateExpressionError,
"Evaluating uninitialized IndexTemplate"):
value(i)
self.assertEqual(str(i), "{I}")
i.set_value(5)
self.assertEqual(value(i), 5)
self.assertIs(resolve_template(i), 5)
def test_simple_substitute_index(self):
def diffeq(m, t, i):
return m.dxdt[t, i] == t * m.x[t, i]**2 + m.y**2
m = self.m
t = IndexTemplate(m.TIME)
e = diffeq(m, t, 2)
t.set_value(5)
self.assertTrue(isinstance(e, EXPR.ExpressionBase))
self.assertEqual((e.arg(0)(), e.arg(1)()), (10, 126))
E = substitute_template_expression(e, substitute_template_with_value)
self.assertIsNot(e, E)
self.assertEqual(str(E), 'dxdt[5,2] == 5.0*x[5,2]**2 + y**2')
def test_time_multi_indexed_algebraic(self):
m = self.m
m.v2 = Var(m.t, m.s)
m.v3 = Var(m.s, m.t)
m.dv2 = DerivativeVar(m.v2)
m.dv3 = DerivativeVar(m.v3)
m.a2 = Var(m.t, m.s)
def _diffeq(m, t, s):
return m.dv2[t, s] == m.v2[t, s]**2 + m.a2[t, s]
m.con = Constraint(m.t, m.s, rule=_diffeq)
m.a3 = Var(m.s, m.t)
def _diffeq2(m, s, t):
return m.dv3[s, t] == m.v3[s, t]**2 + m.a3[s, t]
m.con2 = Constraint(m.s, m.t, rule=_diffeq2)
mysim = Simulator(m)
t = IndexTemplate(m.t)
self.assertEqual(len(mysim._algvars), 6)
self.assertTrue(_GetItemIndexer(m.a2[t, 1]) in mysim._algvars)
self.assertTrue(_GetItemIndexer(m.a2[t, 3]) in mysim._algvars)
self.assertTrue(_GetItemIndexer(m.a3[1, t]) in mysim._algvars)
self.assertTrue(_GetItemIndexer(m.a3[3, t]) in mysim._algvars)
m.del_component('con')
m.del_component('con_index')
m.del_component('con2')
m.del_component('con2_index')
def test_check_getitemexpression(self):
m = self.m
t = IndexTemplate(m.t)
e = m.dv[t] == m.v[t]
temp = _check_getitemexpression(e, 0)
self.assertIs(e.arg(0), temp[0])
self.assertIs(e.arg(1), temp[1])
self.assertIs(m.dv, temp[0].arg(0))
self.assertIs(m.v, temp[1].arg(0))
temp = _check_getitemexpression(e, 1)
self.assertIsNone(temp)
e = m.v[t] == m.dv[t]
temp = _check_getitemexpression(e, 1)
self.assertIs(e.arg(0), temp[1])
self.assertIs(e.arg(1), temp[0])
self.assertIs(m.dv, temp[0].arg(0))
self.assertIs(m.v, temp[1].arg(0))
temp = _check_getitemexpression(e, 0)
self.assertIsNone(temp)
e = m.v[t] == m.v[t]
temp = _check_getitemexpression(e, 0)
self.assertIsNone(temp)
temp = _check_getitemexpression(e, 1)
self.assertIsNone(temp)
def test_separable_diffeq_case2(self):
m = self.m
m.w = Var(m.t, m.s)
m.dw = DerivativeVar(m.w)
t = IndexTemplate(m.t)
def _deqv(m, i):
return m.v[i]**2 + m.v[i] == m.dv[i]
m.deqv = Constraint(m.t, rule=_deqv)
def _deqw(m, i, j):
return m.w[i, j]**2 + m.w[i, j] == m.dw[i, j]
m.deqw = Constraint(m.t, m.s, rule=_deqw)
mysim = Simulator(m)
self.assertEqual(len(mysim._diffvars), 4)
self.assertEqual(mysim._diffvars[0], _GetItemIndexer(m.v[t]))
self.assertEqual(mysim._diffvars[1], _GetItemIndexer(m.w[t, 1]))
self.assertEqual(mysim._diffvars[2], _GetItemIndexer(m.w[t, 2]))
self.assertEqual(len(mysim._derivlist), 4)
self.assertEqual(mysim._derivlist[0], _GetItemIndexer(m.dv[t]))
self.assertEqual(mysim._derivlist[1], _GetItemIndexer(m.dw[t, 1]))
self.assertEqual(mysim._derivlist[2], _GetItemIndexer(m.dw[t, 2]))
self.assertEqual(len(mysim._rhsdict), 4)
m.del_component('deqv')
m.del_component('deqw')
m.del_component('deqv_index')
m.del_component('deqw_index')
m.del_component('w')
m.del_component('dw')
def test_template_name(self):
m = self.m
t = IndexTemplate(m.I)
E = m.x[t + m.P[1 + t]] + m.P[1]
self.assertEqual(str(E), "x[{I} + P[1 + {I}]] + P[1]")
E = m.x[t + m.P[1 + t]**2.]**2. + m.P[1]
self.assertEqual(str(E), "x[{I} + P[1 + {I}]**2.0]**2.0 + P[1]")
def test_template_expr(self):
m = ConcreteModel()
m.I = RangeSet(1,9)
m.x = Var(m.I, initialize=lambda m,i: i+1)
m.P = Param(m.I, initialize=lambda m,i: 10-i, mutable=True)
t = IndexTemplate(m.I)
e = m.x[t+m.P[t+1]] + 3
self.assertRaises(TemplateExpressionError, evaluate_expression, e)
self.assertRaises(TemplateExpressionError, evaluate_expression, e, constant=True)
def test_template_operation(self):
m = self.m
t = IndexTemplate(m.I)
e = m.x[t + m.P[5]]
self.assertIs(type(e), EXPR.GetItemExpression)
self.assertEqual(e.nargs(), 2)
self.assertIs(e.arg(0), m.x)
self.assertIsInstance(e.arg(1), EXPR.SumExpressionBase)
self.assertIs(e.arg(1).arg(0), t)
self.assertIs(e.arg(1).arg(1), m.P[5])
self.assertEqual(str(e), "x[{I} + P[5]]")
def test_substitute_casadi_intrinsic1(self):
m = self.m
m.y = Var()
t = IndexTemplate(m.t)
e = m.v[t]
templatemap = {}
e3 = substitute_pyomo2casadi(e, templatemap)
self.assertIs(type(e3), casadi.SX)
m.del_component('y')
def test_template_in_expression(self):
m = self.m
t = IndexTemplate(m.I)
E = m.x[t + m.P[t + 1]] + m.P[1]
self.assertIsInstance(E, EXPR.SumExpressionBase)
e = E.arg(0)
self.assertIs(type(e), EXPR.GetItemExpression)
self.assertEqual(e.nargs(), 2)
self.assertIs(e.arg(0), m.x)
self.assertIsInstance(e.arg(1), EXPR.SumExpressionBase)
self.assertIs(e.arg(1).arg(0), t)
self.assertIs(type(e.arg(1).arg(1)), EXPR.GetItemExpression)
self.assertIsInstance(e.arg(1).arg(1).arg(1), EXPR.SumExpressionBase)
self.assertIs(e.arg(1).arg(1).arg(1).arg(0), t)
E = m.P[1] + m.x[t + m.P[t + 1]]
self.assertIsInstance(E, EXPR.SumExpressionBase)
e = E.arg(1)
self.assertIs(type(e), EXPR.GetItemExpression)
self.assertEqual(e.nargs(), 2)
self.assertIs(e.arg(0), m.x)
self.assertIsInstance(e.arg(1), EXPR.SumExpressionBase)
self.assertIs(e.arg(1).arg(0), t)
self.assertIs(type(e.arg(1).arg(1)), EXPR.GetItemExpression)
self.assertIsInstance(e.arg(1).arg(1).arg(1), EXPR.SumExpressionBase)
self.assertIs(e.arg(1).arg(1).arg(1).arg(0), t)
E = m.x[t + m.P[t + 1]] + 1
self.assertIsInstance(E, EXPR.SumExpressionBase)
e = E.arg(0)
self.assertIs(type(e), EXPR.GetItemExpression)
self.assertEqual(e.nargs(), 2)
self.assertIs(e.arg(0), m.x)
self.assertIsInstance(e.arg(1), EXPR.SumExpressionBase)
self.assertIs(e.arg(1).arg(0), t)
self.assertIs(type(e.arg(1).arg(1)), EXPR.GetItemExpression)
self.assertIsInstance(e.arg(1).arg(1).arg(1), EXPR.SumExpressionBase)
self.assertIs(e.arg(1).arg(1).arg(1).arg(0), t)
E = 1 + m.x[t + m.P[t + 1]]
self.assertIsInstance(E, EXPR.SumExpressionBase)
e = E.arg(E.nargs() - 1)
self.assertIs(type(e), EXPR.GetItemExpression)
self.assertEqual(e.nargs(), 2)
self.assertIs(e.arg(0), m.x)
self.assertIsInstance(e.arg(1), EXPR.SumExpressionBase)
self.assertIs(e.arg(1).arg(0), t)
self.assertIs(type(e.arg(1).arg(1)), EXPR.GetItemExpression)
self.assertIsInstance(e.arg(1).arg(1).arg(1), EXPR.SumExpressionBase)
self.assertIs(e.arg(1).arg(1).arg(1).arg(0), t)
def test_substitute_casadi_intrinsic3(self):
m = self.m
m.y = Var()
t = IndexTemplate(m.t)
e = sin(m.dv[t] + m.v[t]) + log(m.v[t] * m.y + m.dv[t]**2)
templatemap = {}
e3 = substitute_pyomo2casadi(e, templatemap)
self.assertIs(e3.arg(0)._fcn, casadi.sin)
self.assertIs(e3.arg(1)._fcn, casadi.log)
m.del_component('y')
def test_substitute_casadi_intrinsic4(self):
m = self.m
m.y = Var()
t = IndexTemplate(m.t)
e = m.v[t] * sin(m.dv[t] + m.v[t]) * t
templatemap = {}
e3 = substitute_pyomo2casadi(e, templatemap)
self.assertIs(type(e3.arg(0).arg(0)), casadi.SX)
self.assertIs(e3.arg(0).arg(1)._fcn, casadi.sin)
self.assertIs(type(e3.arg(1)), IndexTemplate)
m.del_component('y')
def test_nonRHS_vars(self):
m = self.m
m.v2 = Var(m.t)
m.dv2 = DerivativeVar(m.v2)
m.p = Param(initialize=5)
t = IndexTemplate(m.t)
def _con(m, t):
return m.dv2[t] == 10 + m.p
m.con = Constraint(m.t, rule=_con)
mysim = Simulator(m,package='casadi')
self.assertEqual(len(mysim._templatemap), 1)
self.assertEqual(mysim._diffvars[0], _GetItemIndexer(m.v2[t]))
m.del_component('con')
def test_time_indexed_algebraic(self):
m = self.m
m.a = Var(m.t)
def _diffeq(m, t):
return m.dv[t] == m.v[t]**2 + m.a[t]
m.con = Constraint(m.t, rule=_diffeq)
mysim = Simulator(m)
t = IndexTemplate(m.t)
self.assertEqual(len(mysim._algvars), 1)
self.assertTrue(_GetItemIndexer(m.a[t]) in mysim._algvars)
self.assertEqual(len(mysim._alglist), 0)
m.del_component('con')
def test_sim_initialization_single_index(self):
m = self.m
m.w = Var(m.t)
m.dw = DerivativeVar(m.w)
t = IndexTemplate(m.t)
def _deq1(m, i):
return m.dv[i] == m.v[i]
m.deq1 = Constraint(m.t, rule=_deq1)
def _deq2(m, i):
return m.dw[i] == m.v[i]
m.deq2 = Constraint(m.t, rule=_deq2)
mysim = Simulator(m)
self.assertIs(mysim._contset, m.t)
self.assertEqual(len(mysim._diffvars), 2)
self.assertEqual(mysim._diffvars[0], _GetItemIndexer(m.v[t]))
self.assertEqual(mysim._diffvars[1], _GetItemIndexer(m.w[t]))
self.assertEqual(len(mysim._derivlist), 2)
self.assertEqual(mysim._derivlist[0], _GetItemIndexer(m.dv[t]))
self.assertEqual(mysim._derivlist[1], _GetItemIndexer(m.dw[t]))
self.assertEqual(len(mysim._templatemap), 1)
self.assertTrue(_GetItemIndexer(m.v[t]) in mysim._templatemap)
self.assertFalse(_GetItemIndexer(m.w[t]) in mysim._templatemap)
self.assertEqual(len(mysim._rhsdict), 2)
self.assertTrue(
isinstance(mysim._rhsdict[_GetItemIndexer(m.dv[t])], Param))
self.assertEqual(mysim._rhsdict[_GetItemIndexer(m.dv[t])].name,
'v[{t}]')
self.assertTrue(
isinstance(mysim._rhsdict[_GetItemIndexer(m.dw[t])], Param))
self.assertEqual(mysim._rhsdict[_GetItemIndexer(m.dw[t])].name,
'v[{t}]')
self.assertEqual(len(mysim._rhsfun(0, [0, 0])), 2)
self.assertIsNone(mysim._tsim)
self.assertIsNone(mysim._simsolution)
m.del_component('deq1')
m.del_component('deq2')
m.del_component('dw')
m.del_component('w')
def test_substitute_casadi_sym(self):
m = self.m
m.y = Var()
t = IndexTemplate(m.t)
e = m.dv[t] + m.v[t] + m.y + t
templatemap = {}
e2 = substitute_pyomo2casadi(e, templatemap)
self.assertEqual(len(templatemap), 2)
self.assertIs(type(e2.arg(0)), casadi.SX)
self.assertIs(type(e2.arg(1)), casadi.SX)
self.assertIsNot(type(e2.arg(2)), casadi.SX)
self.assertIs(type(e2.arg(3)), IndexTemplate)
m.del_component('y')
def test_check_viewsumexpression(self):
m = self.m
m.p = Param(initialize=5)
m.mp = Param(initialize=5, mutable=True)
m.y = Var()
m.z = Var()
t = IndexTemplate(m.t)
e = m.dv[t] + m.y + m.z == m.v[t]
temp = _check_viewsumexpression(e, 0)
self.assertIs(m.dv, temp[0].arg(0))
self.assertIs(type(temp[1]), EXPR.SumExpression)
self.assertIs(type(temp[1].arg(0)), EXPR.GetItemExpression)
self.assertIs(type(temp[1].arg(1)), EXPR.MonomialTermExpression)
self.assertEqual(-1, temp[1].arg(1).arg(0))
self.assertIs(m.y, temp[1].arg(1).arg(1))
self.assertIs(type(temp[1].arg(2)), EXPR.MonomialTermExpression)
self.assertEqual(-1, temp[1].arg(2).arg(0))
self.assertIs(m.z, temp[1].arg(2).arg(1))
e = m.v[t] == m.y + m.dv[t] + m.z
temp = _check_viewsumexpression(e, 1)
self.assertIs(m.dv, temp[0].arg(0))
self.assertIs(type(temp[1]), EXPR.SumExpression)
self.assertIs(type(temp[1].arg(0)), EXPR.GetItemExpression)
self.assertIs(type(temp[1].arg(1)), EXPR.MonomialTermExpression)
self.assertIs(m.y, temp[1].arg(1).arg(1))
self.assertIs(type(temp[1].arg(2)), EXPR.MonomialTermExpression)
self.assertIs(m.z, temp[1].arg(2).arg(1))
e = 5 * m.dv[t] + 5 * m.y - m.z == m.v[t]
temp = _check_viewsumexpression(e, 0)
self.assertIs(m.dv, temp[0].arg(0))
self.assertIs(type(temp[1]), EXPR.DivisionExpression)
self.assertIs(type(temp[1].arg(0).arg(0)), EXPR.GetItemExpression)
self.assertIs(m.y, temp[1].arg(0).arg(1).arg(1))
self.assertIs(m.z, temp[1].arg(0).arg(2).arg(1))
e = 2 + 5 * m.y - m.z == m.v[t]
temp = _check_viewsumexpression(e, 0)
self.assertIs(temp, None)
def test_template_scalar_with_set(self):
m = self.m
t = IndexTemplate(m.I)
e = m.s[t]
self.assertIs(type(e), EXPR.GetItemExpression)
self.assertEqual(e.args, (m.s, t))
self.assertFalse(e.is_constant())
self.assertTrue(e.is_fixed())
self.assertEqual(e.polynomial_degree(), 0)
self.assertEqual(str(e), "s[{I}]")
t.set_value(5)
v = e()
self.assertIs(v, m.s[5])
self.assertIs(resolve_template(e), m.s[5])
t.set_value()
def test_block_templates(self):
m = ConcreteModel()
m.T = RangeSet(3)
@m.Block(m.T)
def b(b, i):
b.x = Var(initialize=i)
@b.Block(m.T)
def bb(bb, j):
bb.I = RangeSet(i * j)
bb.y = Var(bb.I, initialize=lambda m, i: i)
t = IndexTemplate(m.T)
e = m.b[t].x
self.assertIs(type(e), EXPR.GetAttrExpression)
self.assertEqual(e.nargs(), 2)
self.assertIs(type(e.arg(0)), EXPR.GetItemExpression)
self.assertIs(e.arg(0).arg(0), m.b)
self.assertEqual(e.arg(0).nargs(), 2)
self.assertIs(e.arg(0).arg(1), t)
self.assertEqual(str(e), "b[{T}].x")
t.set_value(2)
v = e()
self.assertIn(type(v), (int, float))
self.assertEqual(v, 2)
self.assertIs(resolve_template(e), m.b[2].x)
t.set_value()
e = m.b[t].bb[t].y[1]
self.assertIs(type(e), EXPR.GetItemExpression)
self.assertEqual(e.nargs(), 2)
self.assertEqual(str(e), "b[{T}].bb[{T}].y[1]")
t.set_value(2)
v = e()
self.assertIn(type(v), (int, float))
self.assertEqual(v, 1)
self.assertIs(resolve_template(e), m.b[2].bb[2].y[1])
def __init__(self, m, package='scipy'):
self._intpackage = package
if self._intpackage not in ['scipy', 'casadi']:
raise DAE_Error(
"Unrecognized simulator package %s. Please select from "
"%s" % (self._intpackage, ['scipy', 'casadi']))
if self._intpackage == 'scipy':
if not scipy_available:
# Converting this to a warning so that Simulator initialization
# can be tested even when scipy is unavailable
logger.warning(
"The scipy module is not available. "
"You may build the Simulator object but you will not "
"be able to run the simulation.")
elif is_pypy:
logger.warning(
"The scipy ODE integrators do not work in pypy. "
"You may build the Simulator object but you will not "
"be able to run the simulation.")
else:
if not casadi_available:
# Initializing the simulator for use with casadi requires
# access to casadi objects. Therefore, we must throw an error
# here instead of a warning.
raise ValueError("The casadi module is not available. "
"Cannot simulate model.")
# Check for active Blocks and throw error if any are found
if len(list(m.component_data_objects(Block, active=True,
descend_into=False))):
raise DAE_Error("The Simulator cannot handle hierarchical models "
"at the moment.")
temp = m.component_map(ContinuousSet)
if len(temp) != 1:
raise DAE_Error(
"Currently the simulator may only be applied to "
"Pyomo models with a single ContinuousSet")
# Get the ContinuousSet in the model
contset = list(temp.values())[0]
# Create a index template for the continuous set
cstemplate = IndexTemplate(contset)
# Ensure that there is at least one derivative in the model
derivs = m.component_map(DerivativeVar)
derivs = list(derivs.keys())
if hasattr(m, '_pyomo_dae_reclassified_derivativevars'):
for d in m._pyomo_dae_reclassified_derivativevars:
derivs.append(d.name)
if len(derivs) == 0:
raise DAE_Error("Cannot simulate a model with no derivatives")
templatemap = {} # Map for template substituter
rhsdict = {} # Map of derivative to its RHS templated expr
derivlist = [] # Ordered list of derivatives
alglist = [] # list of templated algebraic equations
# Loop over constraints to find differential equations with separable
# RHS. Must find a RHS for every derivative var otherwise ERROR. Build
# dictionary of DerivativeVar:RHS equation.
for con in m.component_objects(Constraint, active=True):
# Skip the discretization equations if model is discretized
if '_disc_eq' in con.name:
continue
# Check dimension of the Constraint. Check if the
# Constraint is indexed by the continuous set and
# determine its order in the indexing sets
if con.dim() == 0:
continue
conindex = con.index_set()
if not hasattr(conindex, 'set_tuple'):
# Check if the continuous set is the indexing set
if conindex is not contset:
continue
else:
csidx = 0
noncsidx = (None,)
else:
temp = conindex.set_tuple
dimsum = 0
csidx = -1
noncsidx = None
for s in temp:
if s is contset:
if csidx != -1:
raise DAE_Error(
"Cannot simulate the constraint %s because "
"it is indexed by duplicate ContinuousSets"
% con.name)
csidx = dimsum
elif noncsidx is None:
noncsidx = s
else:
noncsidx = noncsidx.cross(s)
dimsum += s.dimen
if csidx == -1:
continue
# Get the rule used to construct the constraint
conrule = con.rule
for i in noncsidx:
# Insert the index template and call the rule to
# create a templated expression
if i is None:
tempexp = conrule(m, cstemplate)
else:
if not isinstance(i, tuple):
i = (i,)
tempidx = i[0:csidx] + (cstemplate,) + i[csidx:]
tempexp = conrule(m, *tempidx)
# Check to make sure it's an EqualityExpression
if not type(tempexp) is EXPR.EqualityExpression:
continue
# Check to make sure it's a differential equation with
# separable RHS
args = None
# Case 1: m.dxdt[t] = RHS
if type(tempexp.arg(0)) is EXPR.GetItemExpression:
args = _check_getitemexpression(tempexp, 0)
# Case 2: RHS = m.dxdt[t]
if args is None:
if type(tempexp.arg(1)) is EXPR.GetItemExpression:
args = _check_getitemexpression(tempexp, 1)
# Case 3: m.p*m.dxdt[t] = RHS
if args is None:
if type(tempexp.arg(0)) is EXPR.ProductExpression or \
type(tempexp.arg(0)) is EXPR.ReciprocalExpression or \
type(tempexp.arg(0)) is EXPR.DivisionExpression:
args = _check_productexpression(tempexp, 0)
# Case 4: RHS = m.p*m.dxdt[t]
if args is None:
if type(tempexp.arg(1)) is EXPR.ProductExpression or \
type(tempexp.arg(1)) is EXPR.ReciprocalExpression or \
type(tempexp.arg(1)) is EXPR.DivisionExpression:
args = _check_productexpression(tempexp, 1)
# Case 5: m.dxdt[t] + sum(ELSE) = RHS
# or CONSTANT + m.dxdt[t] = RHS
if args is None:
if type(tempexp.arg(0)) is EXPR.SumExpression:
args = _check_viewsumexpression(tempexp, 0)
# Case 6: RHS = m.dxdt[t] + sum(ELSE)
if args is None:
if type(tempexp.arg(1)) is EXPR.SumExpression:
args = _check_viewsumexpression(tempexp, 1)
# Case 7: RHS = m.p*m.dxdt[t] + CONSTANT
# This case will be caught by Case 6 if p is immutable. If
# p is mutable then this case will not be detected as a
# separable differential equation
# Case 8: - dxdt[t] = RHS
if args is None:
if type(tempexp.arg(0)) is EXPR.NegationExpression:
args = _check_negationexpression(tempexp, 0)
# Case 9: RHS = - dxdt[t]
if args is None:
if type(tempexp.arg(1)) is EXPR.NegationExpression:
args = _check_negationexpression(tempexp, 1)
# At this point if args is not None then args[0] contains
# the _GetItemExpression for the DerivativeVar and args[1]
# contains the RHS expression. If args is None then the
# constraint is considered an algebraic equation
if args is None:
# Constraint is an algebraic equation or unsupported
# differential equation
if self._intpackage == 'scipy':
raise DAE_Error(
"Model contains an algebraic equation or "
"unrecognized differential equation. Constraint "
"'%s' cannot be simulated using Scipy. If you are "
"trying to simulate a DAE model you must use "
"CasADi as the integration package."
% str(con.name))
tempexp = tempexp.arg(0) - tempexp.arg(1)
algexp = substitute_pyomo2casadi(tempexp, templatemap)
alglist.append(algexp)
continue
# Add the differential equation to rhsdict and derivlist
dv = args[0]
RHS = args[1]
dvkey = _GetItemIndexer(dv)
if dvkey in rhsdict.keys():
raise DAE_Error(
"Found multiple RHS expressions for the "
"DerivativeVar %s" % str(dvkey))
derivlist.append(dvkey)
if self._intpackage == 'casadi':
rhsdict[dvkey] = substitute_pyomo2casadi(RHS, templatemap)
else:
rhsdict[dvkey] = convert_pyomo2scipy(RHS, templatemap)
# Check to see if we found a RHS for every DerivativeVar in
# the model
# FIXME: Not sure how to rework this for multi-index case
# allderivs = derivs.keys()
# if set(allderivs) != set(derivlist):
# missing = list(set(allderivs)-set(derivlist))
# print("WARNING: Could not find a RHS expression for the "
# "following DerivativeVar components "+str(missing))
# Create ordered list of differential variables corresponding
# to the list of derivatives.
diffvars = []
for deriv in derivlist:
sv = deriv.base.get_state_var()
diffvars.append(_GetItemIndexer(sv[deriv._args]))
# Create ordered list of algebraic variables and time-varying
# parameters
algvars = []
for item in iterkeys(templatemap):
if item.base.name in derivs:
# Make sure there are no DerivativeVars in the
# template map
raise DAE_Error(
"Cannot simulate a differential equation with "
"multiple DerivativeVars")
if item not in diffvars:
# Finds time varying parameters and algebraic vars
algvars.append(item)
if self._intpackage == 'scipy':
# Function sent to scipy integrator
def _rhsfun(t, x):
residual = []
cstemplate.set_value(t)
for idx, v in enumerate(diffvars):
if v in templatemap:
templatemap[v].set_value(x[idx])
for d in derivlist:
residual.append(rhsdict[d]())
return residual
self._rhsfun = _rhsfun
# Add any diffvars not added by expression walker to self._templatemap
if self._intpackage == 'casadi':
for _id in diffvars:
if _id not in templatemap:
name = "%s[%s]" % (
_id.base.name, ','.join(str(x) for x in _id.args))
templatemap[_id] = casadi.SX.sym(name)
self._contset = contset
self._cstemplate = cstemplate
self._diffvars = diffvars
self._derivlist = derivlist
self._templatemap = templatemap
self._rhsdict = rhsdict
self._alglist = alglist
self._algvars = algvars
self._model = m
self._tsim = None
self._simsolution = None
# The algebraic vars in the most recent simulation
self._simalgvars = None
# The time-varying inputs in the most recent simulation
self._siminputvars = None
def test_check_productexpression(self):
m = self.m
m.p = Param(initialize=5)
m.mp = Param(initialize=5, mutable=True)
m.y = Var()
m.z = Var()
t = IndexTemplate(m.t)
# Check multiplication by constant
e = 5 * m.dv[t] == m.v[t]
temp = _check_productexpression(e, 0)
self.assertIs(m.dv, temp[0].arg(0))
self.assertIs(type(temp[1]), EXPR.DivisionExpression)
e = m.v[t] == 5 * m.dv[t]
temp = _check_productexpression(e, 1)
self.assertIs(m.dv, temp[0].arg(0))
self.assertIs(type(temp[1]), EXPR.DivisionExpression)
# Check multiplication by fixed param
e = m.p * m.dv[t] == m.v[t]
temp = _check_productexpression(e, 0)
self.assertIs(m.dv, temp[0].arg(0))
self.assertIs(type(temp[1]), EXPR.DivisionExpression)
e = m.v[t] == m.p * m.dv[t]
temp = _check_productexpression(e, 1)
self.assertIs(m.dv, temp[0].arg(0))
self.assertIs(type(temp[1]), EXPR.DivisionExpression)
# Check multiplication by mutable param
e = m.mp * m.dv[t] == m.v[t]
temp = _check_productexpression(e, 0)
self.assertIs(m.dv, temp[0].arg(0))
self.assertIs(type(temp[1]), EXPR.DivisionExpression)
self.assertIs(m.mp, temp[1].arg(1)) # Reciprocal
self.assertIs(e.arg(1), temp[1].arg(0))
e = m.v[t] == m.mp * m.dv[t]
temp = _check_productexpression(e, 1)
self.assertIs(m.dv, temp[0].arg(0))
self.assertIs(type(temp[1]), EXPR.DivisionExpression)
self.assertIs(m.mp, temp[1].arg(1)) # Reciprocal
self.assertIs(e.arg(0), temp[1].arg(0))
# Check multiplication by var
e = m.y * m.dv[t] / m.z == m.v[t]
temp = _check_productexpression(e, 0)
self.assertIs(m.dv, temp[0].arg(0))
self.assertIs(type(temp[1]), EXPR.DivisionExpression)
self.assertIs(e.arg(1), temp[1].arg(0).arg(0))
self.assertIs(m.z, temp[1].arg(0).arg(1))
e = m.v[t] == m.y * m.dv[t] / m.z
temp = _check_productexpression(e, 1)
self.assertIs(m.dv, temp[0].arg(0))
self.assertIs(type(temp[1]), EXPR.DivisionExpression)
self.assertIs(e.arg(0), temp[1].arg(0).arg(0))
self.assertIs(m.z, temp[1].arg(0).arg(1))
# Check having the DerivativeVar in the denominator
e = m.y / (m.dv[t] * m.z) == m.mp
temp = _check_productexpression(e, 0)
self.assertIs(m.dv, temp[0].arg(0))
self.assertIs(type(temp[1]), EXPR.DivisionExpression)
self.assertIs(m.y, temp[1].arg(0))
self.assertIs(e.arg(1), temp[1].arg(1).arg(0))
e = m.mp == m.y / (m.dv[t] * m.z)
temp = _check_productexpression(e, 1)
self.assertIs(m.dv, temp[0].arg(0))
self.assertIs(type(temp[1]), EXPR.DivisionExpression)
self.assertIs(m.y, temp[1].arg(0))
self.assertIs(e.arg(0), temp[1].arg(1).arg(0))
# Check expression with no DerivativeVar
e = m.v[t] * m.y / m.z == m.v[t] * m.y / m.z
temp = _check_productexpression(e, 0)
self.assertIsNone(temp)
temp = _check_productexpression(e, 1)
self.assertIsNone(temp)
def test_sim_initialization_multi_index2(self):
m = self.m
m.s2 = Set(initialize=[(1, 1), (2, 2)])
m.w1 = Var(m.t, m.s2)
m.dw1 = DerivativeVar(m.w1)
m.w2 = Var(m.s2, m.t)
m.dw2 = DerivativeVar(m.w2)
m.w3 = Var([0, 1], m.t, m.s2)
m.dw3 = DerivativeVar(m.w3)
t = IndexTemplate(m.t)
def _deq1(m, t, i, j):
return m.dw1[t, i, j] == m.w1[t, i, j]
m.deq1 = Constraint(m.t, m.s2, rule=_deq1)
def _deq2(m, *idx):
return m.dw2[idx] == m.w2[idx]
m.deq2 = Constraint(m.s2, m.t, rule=_deq2)
def _deq3(m, i, t, j, k):
return m.dw3[i, t, j, k] == m.w1[t, j, k] + m.w2[j, k, t]
m.deq3 = Constraint([0, 1], m.t, m.s2, rule=_deq3)
mysim = Simulator(m)
self.assertIs(mysim._contset, m.t)
self.assertEqual(len(mysim._diffvars), 8)
self.assertTrue(_GetItemIndexer(m.w1[t, 1, 1]) in mysim._diffvars)
self.assertTrue(_GetItemIndexer(m.w1[t, 2, 2]) in mysim._diffvars)
self.assertTrue(_GetItemIndexer(m.w2[1, 1, t]) in mysim._diffvars)
self.assertTrue(_GetItemIndexer(m.w2[2, 2, t]) in mysim._diffvars)
self.assertTrue(_GetItemIndexer(m.w3[0, t, 1, 1]) in mysim._diffvars)
self.assertTrue(_GetItemIndexer(m.w3[1, t, 2, 2]) in mysim._diffvars)
self.assertEqual(len(mysim._derivlist), 8)
self.assertTrue(_GetItemIndexer(m.dw1[t, 1, 1]) in mysim._derivlist)
self.assertTrue(_GetItemIndexer(m.dw1[t, 2, 2]) in mysim._derivlist)
self.assertTrue(_GetItemIndexer(m.dw2[1, 1, t]) in mysim._derivlist)
self.assertTrue(_GetItemIndexer(m.dw2[2, 2, t]) in mysim._derivlist)
self.assertTrue(_GetItemIndexer(m.dw3[0, t, 1, 1]) in mysim._derivlist)
self.assertTrue(_GetItemIndexer(m.dw3[1, t, 2, 2]) in mysim._derivlist)
self.assertEqual(len(mysim._templatemap), 4)
self.assertTrue(_GetItemIndexer(m.w1[t, 1, 1]) in mysim._templatemap)
self.assertTrue(_GetItemIndexer(m.w1[t, 2, 2]) in mysim._templatemap)
self.assertTrue(_GetItemIndexer(m.w2[1, 1, t]) in mysim._templatemap)
self.assertTrue(_GetItemIndexer(m.w2[2, 2, t]) in mysim._templatemap)
self.assertFalse(
_GetItemIndexer(m.w3[0, t, 1, 1]) in mysim._templatemap)
self.assertFalse(
_GetItemIndexer(m.w3[1, t, 2, 2]) in mysim._templatemap)
self.assertEqual(len(mysim._rhsdict), 8)
self.assertTrue(
isinstance(mysim._rhsdict[_GetItemIndexer(m.dw1[t, 1, 1])], Param))
self.assertTrue(
isinstance(mysim._rhsdict[_GetItemIndexer(m.dw1[t, 2, 2])], Param))
self.assertTrue(
isinstance(mysim._rhsdict[_GetItemIndexer(m.dw2[1, 1, t])], Param))
self.assertTrue(
isinstance(mysim._rhsdict[_GetItemIndexer(m.dw2[2, 2, t])], Param))
self.assertTrue(
isinstance(mysim._rhsdict[_GetItemIndexer(m.dw3[0, t, 1, 1])],
EXPR.SumExpression))
self.assertTrue(
isinstance(mysim._rhsdict[_GetItemIndexer(m.dw3[1, t, 2, 2])],
EXPR.SumExpression))
self.assertEqual(mysim._rhsdict[_GetItemIndexer(m.dw1[t, 1, 1])].name,
'w1[{t},1,1]')
self.assertEqual(mysim._rhsdict[_GetItemIndexer(m.dw1[t, 2, 2])].name,
'w1[{t},2,2]')
self.assertEqual(mysim._rhsdict[_GetItemIndexer(m.dw2[1, 1, t])].name,
'w2[1,1,{t}]')
self.assertEqual(mysim._rhsdict[_GetItemIndexer(m.dw2[2, 2, t])].name,
'w2[2,2,{t}]')
self.assertEqual(len(mysim._rhsfun(0, [0] * 8)), 8)
self.assertIsNone(mysim._tsim)
self.assertIsNone(mysim._simsolution)
m.del_component('deq1')
m.del_component('deq1_index')
m.del_component('deq2')
m.del_component('deq2_index')
m.del_component('deq3')
m.del_component('deq3_index')
def test_sim_initialization_multi_index(self):
m = self.m
m.w1 = Var(m.t, m.s)
m.dw1 = DerivativeVar(m.w1)
m.w2 = Var(m.s, m.t)
m.dw2 = DerivativeVar(m.w2)
m.w3 = Var([0, 1], m.t, m.s)
m.dw3 = DerivativeVar(m.w3)
t = IndexTemplate(m.t)
def _deq1(m, t, s):
return m.dw1[t, s] == m.w1[t, s]
m.deq1 = Constraint(m.t, m.s, rule=_deq1)
def _deq2(m, s, t):
return m.dw2[s, t] == m.w2[s, t]
m.deq2 = Constraint(m.s, m.t, rule=_deq2)
def _deq3(m, i, t, s):
return m.dw3[i, t, s] == m.w1[t, s] + m.w2[i + 1, t]
m.deq3 = Constraint([0, 1], m.t, m.s, rule=_deq3)
mysim = Simulator(m)
self.assertIs(mysim._contset, m.t)
self.assertEqual(len(mysim._diffvars), 12)
self.assertTrue(_GetItemIndexer(m.w1[t, 1]) in mysim._diffvars)
self.assertTrue(_GetItemIndexer(m.w1[t, 3]) in mysim._diffvars)
self.assertTrue(_GetItemIndexer(m.w2[1, t]) in mysim._diffvars)
self.assertTrue(_GetItemIndexer(m.w2[3, t]) in mysim._diffvars)
self.assertTrue(_GetItemIndexer(m.w3[0, t, 1]) in mysim._diffvars)
self.assertTrue(_GetItemIndexer(m.w3[1, t, 3]) in mysim._diffvars)
self.assertEqual(len(mysim._derivlist), 12)
self.assertTrue(_GetItemIndexer(m.dw1[t, 1]) in mysim._derivlist)
self.assertTrue(_GetItemIndexer(m.dw1[t, 3]) in mysim._derivlist)
self.assertTrue(_GetItemIndexer(m.dw2[1, t]) in mysim._derivlist)
self.assertTrue(_GetItemIndexer(m.dw2[3, t]) in mysim._derivlist)
self.assertTrue(_GetItemIndexer(m.dw3[0, t, 1]) in mysim._derivlist)
self.assertTrue(_GetItemIndexer(m.dw3[1, t, 3]) in mysim._derivlist)
self.assertEqual(len(mysim._templatemap), 6)
self.assertTrue(_GetItemIndexer(m.w1[t, 1]) in mysim._templatemap)
self.assertTrue(_GetItemIndexer(m.w1[t, 3]) in mysim._templatemap)
self.assertTrue(_GetItemIndexer(m.w2[1, t]) in mysim._templatemap)
self.assertTrue(_GetItemIndexer(m.w2[3, t]) in mysim._templatemap)
self.assertFalse(_GetItemIndexer(m.w3[0, t, 1]) in mysim._templatemap)
self.assertFalse(_GetItemIndexer(m.w3[1, t, 3]) in mysim._templatemap)
self.assertEqual(len(mysim._rhsdict), 12)
self.assertTrue(
isinstance(mysim._rhsdict[_GetItemIndexer(m.dw1[t, 1])], Param))
self.assertTrue(
isinstance(mysim._rhsdict[_GetItemIndexer(m.dw1[t, 3])], Param))
self.assertTrue(
isinstance(mysim._rhsdict[_GetItemIndexer(m.dw2[1, t])], Param))
self.assertTrue(
isinstance(mysim._rhsdict[_GetItemIndexer(m.dw2[3, t])], Param))
self.assertTrue(
isinstance(mysim._rhsdict[_GetItemIndexer(m.dw3[0, t, 1])],
EXPR.SumExpression))
self.assertTrue(
isinstance(mysim._rhsdict[_GetItemIndexer(m.dw3[1, t, 3])],
EXPR.SumExpression))
self.assertEqual(mysim._rhsdict[_GetItemIndexer(m.dw1[t, 1])].name,
'w1[{t},1]')
self.assertEqual(mysim._rhsdict[_GetItemIndexer(m.dw1[t, 3])].name,
'w1[{t},3]')
self.assertEqual(mysim._rhsdict[_GetItemIndexer(m.dw2[1, t])].name,
'w2[1,{t}]')
self.assertEqual(mysim._rhsdict[_GetItemIndexer(m.dw2[3, t])].name,
'w2[3,{t}]')
self.assertEqual(len(mysim._rhsfun(0, [0] * 12)), 12)
self.assertIsNone(mysim._tsim)
self.assertIsNone(mysim._simsolution)
m.del_component('deq1')
m.del_component('deq1_index')
m.del_component('deq2')
m.del_component('deq2_index')
m.del_component('deq3')
m.del_component('deq3_index')
def test_clone(self):
m = self.m
t = IndexTemplate(m.I)
E_base = m.x[t + m.P[t + 1]] + m.P[1]
E = E_base.clone()
self.assertIsInstance(E, EXPR.SumExpressionBase)
e = E.arg(0)
self.assertIs(type(e), EXPR.GetItemExpression)
self.assertIsNot(e, E_base.arg(0))
self.assertEqual(e.nargs(), 2)
self.assertIs(e.arg(0), m.x)
self.assertIsInstance(e.arg(1), EXPR.SumExpressionBase)
self.assertIs(e.arg(1).arg(0), t)
self.assertIs(type(e.arg(1).arg(1)), EXPR.GetItemExpression)
self.assertIs(type(e.arg(1).arg(1)), type(E_base.arg(0).arg(1).arg(1)))
self.assertIsNot(e.arg(1).arg(1), E_base.arg(0).arg(1).arg(1))
self.assertIsInstance(e.arg(1).arg(1).arg(1), EXPR.SumExpressionBase)
self.assertIs(e.arg(1).arg(1).arg(1).arg(0), t)
E_base = m.P[1] + m.x[t + m.P[t + 1]]
E = E_base.clone()
self.assertTrue(isinstance(E, EXPR.SumExpressionBase))
e = E.arg(1)
self.assertIs(type(e), EXPR.GetItemExpression)
self.assertIsNot(e, E_base.arg(0))
self.assertEqual(e.nargs(), 2)
self.assertIs(e.arg(0), m.x)
self.assertIsInstance(e.arg(1), EXPR.SumExpressionBase)
self.assertIs(e.arg(1).arg(0), t)
self.assertIs(type(e.arg(1).arg(1)), EXPR.GetItemExpression)
self.assertIs(type(e.arg(1).arg(1)), type(E_base.arg(1).arg(1).arg(1)))
self.assertIsNot(e.arg(1).arg(1), E_base.arg(1).arg(1).arg(1))
self.assertIsInstance(e.arg(1).arg(1).arg(1), EXPR.SumExpressionBase)
self.assertIs(e.arg(1).arg(1).arg(1).arg(0), t)
E_base = m.x[t + m.P[t + 1]] + 1
E = E_base.clone()
self.assertIsInstance(E, EXPR.SumExpressionBase)
e = E.arg(0)
self.assertIs(type(e), EXPR.GetItemExpression)
self.assertIsNot(e, E_base.arg(0))
self.assertEqual(e.nargs(), 2)
self.assertIs(e.arg(0), m.x)
self.assertIsInstance(e.arg(1), EXPR.SumExpressionBase)
self.assertIs(e.arg(1).arg(0), t)
self.assertIs(type(e.arg(1).arg(1)), EXPR.GetItemExpression)
self.assertIs(type(e.arg(1).arg(1)), type(E_base.arg(0).arg(1).arg(1)))
self.assertIsNot(e.arg(1).arg(1), E_base.arg(0).arg(1).arg(1))
self.assertIsInstance(e.arg(1).arg(1).arg(1), EXPR.SumExpressionBase)
self.assertIs(e.arg(1).arg(1).arg(1).arg(0), t)
E_base = 1 + m.x[t + m.P[t + 1]]
E = E_base.clone()
self.assertIsInstance(E, EXPR.SumExpressionBase)
e = E.arg(-1)
self.assertIs(type(e), EXPR.GetItemExpression)
self.assertIsNot(e, E_base.arg(0))
self.assertEqual(e.nargs(), 2)
self.assertIs(e.arg(0), m.x)
self.assertIsInstance(e.arg(1), EXPR.SumExpressionBase)
self.assertIs(e.arg(1).arg(0), t)
self.assertIs(type(e.arg(1).arg(1)), EXPR.GetItemExpression)
self.assertIs(type(e.arg(1).arg(1)),
type(E_base.arg(-1).arg(1).arg(1)))
self.assertIsNot(e.arg(1).arg(1), E_base.arg(-1).arg(1).arg(1))
self.assertIsInstance(e.arg(1).arg(1).arg(1), EXPR.SumExpressionBase)
self.assertIs(e.arg(1).arg(1).arg(1).arg(0), t)
def test_simple_substitute_param(self):
def diffeq(m, t, i):
return m.dxdt[t, i] == t*m.x[t, i-1]**2 + m.y**2 + \
m.x[t, i+1] + m.x[t, i-1]
m = self.m
t = IndexTemplate(m.TIME)
e = diffeq(m, t, 2)
self.assertTrue(isinstance(e, EXPR.ExpressionBase))
_map = {}
E = substitute_template_expression(e, substitute_getitem_with_param,
_map)
self.assertIsNot(e, E)
self.assertEqual(len(_map), 3)
idx1 = _GetItemIndexer(m.x[t, 1])
self.assertEqual(idx1.nargs(), 2)
self.assertIs(idx1.base, m.x)
self.assertIs(idx1.arg(0), t)
self.assertEqual(idx1.arg(1), 1)
self.assertIn(idx1, _map)
idx2 = _GetItemIndexer(m.dxdt[t, 2])
self.assertEqual(idx2.nargs(), 2)
self.assertIs(idx2.base, m.dxdt)
self.assertIs(idx2.arg(0), t)
self.assertEqual(idx2.arg(1), 2)
self.assertIn(idx2, _map)
idx3 = _GetItemIndexer(m.x[t, 3])
self.assertEqual(idx3.nargs(), 2)
self.assertIs(idx3.base, m.x)
self.assertIs(idx3.arg(0), t)
self.assertEqual(idx3.arg(1), 3)
self.assertIn(idx3, _map)
self.assertFalse(idx1 == idx2)
self.assertFalse(idx1 == idx3)
self.assertFalse(idx2 == idx3)
idx4 = _GetItemIndexer(m.x[t, 2])
self.assertNotIn(idx4, _map)
t.set_value(5)
self.assertEqual((e.arg(0)(), e.arg(1)()), (10, 136))
self.assertEqual(
str(E), "'dxdt[{TIME},2]' == "
"{TIME}*'x[{TIME},1]'**2 + y**2 + 'x[{TIME},3]' + 'x[{TIME},1]'")
_map[idx1].set_value(value(m.x[value(t), 1]))
_map[idx2].set_value(value(m.dxdt[value(t), 2]))
_map[idx3].set_value(value(m.x[value(t), 3]))
self.assertEqual((E.arg(0)(), E.arg(1)()), (10, 136))
_map[idx1].set_value(12)
_map[idx2].set_value(34)
self.assertEqual((E.arg(0)(), E.arg(1)()), (34, 738))
def test_template_scalar(self):
m = self.m
t = IndexTemplate(m.I)
e = m.x[t]
self.assertIs(type(e), EXPR.GetItemExpression)
self.assertEqual(e.args, (m.x, t))
self.assertFalse(e.is_constant())
self.assertFalse(e.is_fixed())
self.assertEqual(e.polynomial_degree(), 1)
self.assertEqual(str(e), "x[{I}]")
t.set_value(5)
v = e()
self.assertIn(type(v), (int, float))
self.assertEqual(v, 6)
self.assertIs(resolve_template(e), m.x[5])
t.set_value()
e = m.p[t, 10]
self.assertIs(type(e), EXPR.GetItemExpression)
self.assertEqual(e.args, (m.p, t, 10))
self.assertFalse(e.is_constant())
self.assertTrue(e.is_fixed())
self.assertEqual(e.polynomial_degree(), 0)
self.assertEqual(str(e), "p[{I},10]")
t.set_value(5)
v = e()
self.assertIn(type(v), (int, float))
self.assertEqual(v, 510)
self.assertIs(resolve_template(e), m.p[5, 10])
t.set_value()
e = m.p[5, t]
self.assertIs(type(e), EXPR.GetItemExpression)
self.assertEqual(e.args, (m.p, 5, t))
self.assertFalse(e.is_constant())
self.assertTrue(e.is_fixed())
self.assertEqual(e.polynomial_degree(), 0)
self.assertEqual(str(e), "p[5,{I}]")
t.set_value(10)
v = e()
self.assertIn(type(v), (int, float))
self.assertEqual(v, 510)
self.assertIs(resolve_template(e), m.p[5, 10])
t.set_value()