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_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_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 beforeChild(self, node, child, child_idx):
"""Replace a node if it's a _GetItemExpression."""
if type(child) is EXPR.GetItemExpression:
_id = _GetItemIndexer(child)
if _id not in self.templatemap:
name = "%s[%s]" % (_id.base.name, ','.join(
str(x) for x in _id.args))
self.templatemap[_id] = casadi.SX.sym(name)
return False, self.templatemap[_id]
elif type(child) is IndexTemplate:
return False, child
return super().beforeChild(node, child, child_idx)
def beforeChild(self, node, child, child_idx):
if type(child) is IndexTemplate:
return False, child
if type(child) is EXPR.GetItemExpression:
_id = _GetItemIndexer(child)
if _id not in self.templatemap:
self.templatemap[_id] = Param(mutable=True)
self.templatemap[_id].construct()
self.templatemap[_id]._name = "%s[%s]" % (
_id.base.name, ','.join(str(x) for x in _id.args))
return False, self.templatemap[_id]
return super().beforeChild(node, child, child_idx)
def visiting_potential_leaf(self, node):
if type(node) is IndexTemplate:
return True, node
if type(node) is EXPR.GetItemExpression:
_id = _GetItemIndexer(node)
if _id not in self.templatemap:
self.templatemap[_id] = Param(mutable=True)
self.templatemap[_id].construct()
self.templatemap[_id]._name = "%s[%s]" % (
_id.base.name, ','.join(str(x) for x in _id.args))
return True, self.templatemap[_id]
return super(Pyomo2Scipy_Visitor, self).visiting_potential_leaf(node)
def visiting_potential_leaf(self, node):
"""Replace a node if it's a _GetItemExpression."""
if type(node) is EXPR.GetItemExpression:
_id = _GetItemIndexer(node)
if _id not in self.templatemap:
name = "%s[%s]" % (
_id.base.name, ','.join(str(x) for x in _id.args))
self.templatemap[_id] = casadi.SX.sym(name)
return True, self.templatemap[_id]
if type(node) in native_numeric_types or \
not node.is_expression_type() or \
type(node) is IndexTemplate:
return True, node
return False, None
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 __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_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_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))