def _cvt_names_to_graph(srcpath, destpath):
"""Translates model pathnames into pathnames in term of
our 'fake' graph nodes @xin, @bin, @bout, and @xout.
"""
srcvar, _ = _split_expr(srcpath)
srccompname, _, srcvarname = srcvar.partition('.')
destcompname, _, destvarname = destpath.partition('.')
if srccompname == 'parent': # external input
srccompname = '@xin'
srcvarname = srcpath
if not destvarname:
destcompname = '@bin' # ext input to boundary var
destvarname = destpath
elif destcompname == 'parent': # external output
destcompname = '@xout'
destvarname = destpath
if not srcvarname:
srccompname = '@bout' # ext output from boundary var
srcvarname = srcpath
elif not srcvarname: # internal connection from a boundary var
srcvarname = srcpath
srccompname = '@bin'
elif not destvarname: # internal connection to a boundary var
destvarname = destpath
destcompname = '@bout'
elif srcvar != srcpath:
srcvarname = transform_expression(srcpath,
{ '.'.join([srccompname, srcvarname]): srcvarname })
return (srccompname, srcvarname, destcompname, destvarname)
def _translate_up(self, text, node):
if is_legal_name(text):
return '.'.join([node, text])
expr = ExprEvaluator(text)
varpath = expr.get_referenced_varpaths().pop()
return transform_expression(text, { varpath: '.'.join([node, varpath]) })
def _translate_up(self, text, node):
"""Upscoping"""
if is_legal_name(text):
return '.'.join([node, text])
expr = ExprEvaluator(text)
varpath = expr.get_referenced_varpaths().pop()
return transform_expression(text, { varpath: '.'.join([node, varpath]) })
def test_xforms(self):
tests = [
('abc.de.g.abc', {'abc':'ABC'}, 'ABC.de.g.abc'),
]
for orig, mapping, expected in tests:
xformed = transform_expression(orig, mapping)
self.assertEqual(expected, xformed)
def test_xforms(self):
tests = [
('abc.de.g.abc', {
'abc': 'ABC'
}, 'ABC.de.g.abc'),
]
for orig, mapping, expected in tests:
xformed = transform_expression(orig, mapping)
self.assertEqual(expected, xformed)
def SymGrad(ex, vars):
"""Symbolic gradient."""
s=[]
var_map = {}
for i,var in enumerate(vars):
s_var = Symbol(var)
s.append(s_var)
var_map[var] = "s[%d]"%i
newex=ex
newex = transform_expression(ex, var_map)
exec "newex="+newex.replace('math.', '')
grad=[]
for i,var in enumerate(vars):
d = diff(newex, Symbol(var)).evalf()
diff_str=d.__str__()
if isinstance(d, Derivative) or 'Derivative' in diff_str \
or 'im(' in diff_str:
raise SymbolicDerivativeError('Could not symbolically differentiate expression')
grad.append(diff_str)
return grad
def __init__(self,
parent,
srcexpr,
destexpr=None,
translate=True,
pseudo_type=None):
if destexpr is None:
destexpr = DummyExpr()
self.name = _get_new_name()
self._inmap = {} # mapping of component vars to our inputs
self._meta = {}
self._valid = False
self._parent = parent
self._inputs = []
self.force_fd = False
self._provideJ_bounds = None
self._pseudo_type = pseudo_type # a string indicating the type of pseudocomp
# this is, e.g., 'units', 'constraint', 'objective',
# or 'multi_var_expr'
self._orig_src = srcexpr.text
self._orig_dest = destexpr.text
self.Jsize = None
varmap = {}
rvarmap = {}
for i, ref in enumerate(srcexpr.refs()):
in_name = 'in%d' % i
self._inputs.append(in_name)
self._inmap[ref] = in_name
varmap[ref] = in_name
rvarmap.setdefault(_get_varname(ref), set()).add(ref)
setattr(self, in_name, None)
refs = list(destexpr.refs())
if refs:
if len(refs) == 1:
setattr(self, 'out0', None)
else:
raise RuntimeError(
"output of PseudoComponent must reference only one variable"
)
varmap[refs[0]] = 'out0'
rvarmap.setdefault(_get_varname(refs[0]), set()).add(refs[0])
for name, meta in srcexpr.get_metadata():
for rname in rvarmap[name]:
self._meta[varmap[rname]] = meta
for name, meta in destexpr.get_metadata():
for rname in rvarmap[name]:
self._meta[varmap[rname]] = meta
if translate:
xformed_src = transform_expression(srcexpr.text, self._inmap)
else:
xformed_src = srcexpr.text
out_units = self._meta['out0'].get('units')
pq = None
if out_units is not None:
# evaluate the src expression using UnitsOnlyPQ objects
tmpdict = {}
# First, replace values with UnitsOnlyPQ objects
for inp in self._inputs:
units = self._meta[inp].get('units')
if units:
tmpdict[inp] = UnitsOnlyPQ(0., units)
else:
tmpdict[inp] = 0.
pq = eval(xformed_src, _expr_dict, tmpdict)
self._srcunits = pq.unit
unitnode = ast.parse(xformed_src)
try:
unitxform = unit_xform(unitnode, self._srcunits, out_units)
except Exception as err:
raise TypeError("Incompatible units for '%s' and '%s': %s" %
(srcexpr.text, destexpr.text, err))
unit_src = print_node(unitxform)
xformed_src = unit_src
else:
self._srcunits = None
self._srcexpr = ConnectedExprEvaluator(xformed_src, scope=self)
# this is just the equation string (for debugging)
if self._orig_dest:
self._outdests = [self._orig_dest]
if pq is None:
sunit = dunit = ''
else:
sunit = "'%s'" % pq.get_unit_name()
dunit = "'%s'" % out_units
self._orig_expr = "%s %s -> %s %s" % (self._orig_src, sunit,
self._orig_dest, dunit)
else:
self._outdests = []
self._orig_expr = self._orig_src
#if destexpr and destexpr.text:
#out = destexpr.text
#else:
#out = 'out0'
#if translate:
#src = transform_expression(self._srcexpr.text,
#_invert_dict(self._inmap))
#else:
#src = self._srcexpr.text
#self._expr_conn = (src, out) # the actual expression connection
self.missing_deriv_policy = 'error'
def __init__(self, parent, srcexpr, destexpr=None, translate=True, pseudo_type=None):
if destexpr is None:
destexpr = DummyExpr()
self.name = _get_new_name()
self._inmap = {} # mapping of component vars to our inputs
self._meta = {}
self._valid = False
self._parent = parent
self._inputs = []
self.force_fd = False
self._provideJ_bounds = None
self._pseudo_type = pseudo_type # a string indicating the type of pseudocomp
# this is, e.g., 'units', 'constraint', 'objective',
# or 'multi_var_expr'
self._orig_src = srcexpr.text
self._orig_dest = destexpr.text
self.Jsize = None
if destexpr.text:
self._outdests = [destexpr.text]
else:
self._outdests = []
varmap = {}
rvarmap = {}
for i,ref in enumerate(srcexpr.refs()):
in_name = 'in%d' % i
self._inputs.append(in_name)
self._inmap[ref] = in_name
varmap[ref] = in_name
rvarmap.setdefault(_get_varname(ref), set()).add(ref)
setattr(self, in_name, None)
refs = list(destexpr.refs())
if refs:
if len(refs) == 1:
setattr(self, 'out0', None)
else:
raise RuntimeError("output of PseudoComponent must reference only one variable")
varmap[refs[0]] = 'out0'
rvarmap.setdefault(_get_varname(refs[0]), set()).add(refs[0])
for name, meta in srcexpr.get_metadata():
for rname in rvarmap[name]:
self._meta[varmap[rname]] = meta
for name, meta in destexpr.get_metadata():
for rname in rvarmap[name]:
self._meta[varmap[rname]] = meta
if translate:
xformed_src = transform_expression(srcexpr.text, self._inmap)
else:
xformed_src = srcexpr.text
out_units = self._meta['out0'].get('units')
if out_units is not None:
# evaluate the src expression using UnitsOnlyPQ objects
tmpdict = {}
# First, replace values with UnitsOnlyPQ objects
for inp in self._inputs:
units = self._meta[inp].get('units')
if units:
tmpdict[inp] = UnitsOnlyPQ(0., units)
else:
tmpdict[inp] = 0.
pq = eval(xformed_src, _expr_dict, tmpdict)
self._srcunits = pq.unit
unitnode = ast.parse(xformed_src)
try:
unitxform = unit_xform(unitnode, self._srcunits, out_units)
except Exception as err:
raise TypeError("Incompatible units for '%s' and '%s': %s" % (srcexpr.text,
destexpr.text, err))
unit_src = print_node(unitxform)
xformed_src = unit_src
else:
self._srcunits = None
self._srcexpr = ConnectedExprEvaluator(xformed_src, scope=self)
# this is just the equation string (for debugging)
if destexpr and destexpr.text:
out = destexpr.text
else:
out = 'out0'
if translate:
src = transform_expression(self._srcexpr.text,
_invert_dict(self._inmap))
else:
src = self._srcexpr.text
self._expr_conn = (src, out) # the actual expression connection
self.missing_deriv_policy = 'error'
def __init__(self, parent, srcexpr, destexpr=None,
translate=True, pseudo_type=None, subtype=None,
exprobject=None):
if destexpr is None:
destexpr = DummyExpr()
self._parent = None
self.parent = parent
self.name = _get_new_name(parent)
self._inmap = {} # mapping of component vars to our inputs
self._meta = {}
self._inputs = []
# Flags and caching used by the derivatives calculation
self.force_fd = False
self._provideJ_bounds = None
self._pseudo_type = pseudo_type # a string indicating the type of pseudocomp
# this is, e.g., 'units', 'constraint', 'objective',
# or 'multi_var_expr'
self._subtype = subtype # for constraints, 'equality' or 'inequality'
self._exprobj = exprobject # object responsible for creation of this pcomp, e.g. a Constraint
self._orig_src = srcexpr.text
self._orig_dest = destexpr.text
self.Jsize = None
self.mpi = MPI_info()
varmap = {}
rvarmap = {}
for i, ref in enumerate(srcexpr.ordered_refs()):
in_name = 'in%d' % i
self._inputs.append(in_name)
self._inmap[ref] = in_name
varmap[ref] = in_name
rvarmap.setdefault(_get_varname(ref), set()).add(ref)
setattr(self, in_name, 0.)
refs = list(destexpr.refs())
if refs:
if len(refs) == 1:
setattr(self, 'out0', None)
else:
raise RuntimeError("output of PseudoComponent must reference"
" only one variable")
varmap[refs[0]] = 'out0'
rvarmap.setdefault(_get_varname(refs[0]), set()).add(refs[0])
noflat = False
for name, meta in srcexpr.get_metadata():
# If any input is noflat, then the output must be too.
if 'noflat' in meta:
noflat = True
for rname in rvarmap[name]:
self._meta[varmap[rname]] = meta
for name, meta in destexpr.get_metadata():
if noflat and 'noflat' not in meta:
meta['noflat'] = True
for rname in rvarmap[name]:
self._meta[varmap[rname]] = meta
if translate:
xformed_src = transform_expression(srcexpr.text, self._inmap)
else:
xformed_src = srcexpr.text
out_units = self._meta['out0'].get('units')
pq = None
if out_units is not None:
# evaluate the src expression using UnitsOnlyPQ objects
tmpdict = {}
# First, replace values with UnitsOnlyPQ objects
for inp in self._inputs:
units = self._meta[inp].get('units')
if units:
tmpdict[inp] = UnitsOnlyPQ(0., units)
else:
tmpdict[inp] = 0.
pq = eval(xformed_src, _expr_dict, tmpdict)
self._srcunits = pq.unit
unitnode = ast.parse(xformed_src)
try:
unitxform = unit_xform(unitnode, self._srcunits, out_units)
except Exception as err:
raise TypeError("Incompatible units for '%s' and '%s': %s"
% (srcexpr.text, destexpr.text, err))
unit_src = print_node(unitxform)
xformed_src = unit_src
else:
self._srcunits = None
self._srcexpr = ConnectedExprEvaluator(xformed_src,
scope=self)
# this is just the equation string (for debugging)
if self._orig_dest:
self._outdests = [self._orig_dest]
if pq is None:
sunit = dunit = ''
else:
sunit = "'%s'" % pq.get_unit_name()
dunit = "'%s'" % out_units
self._orig_expr = "%s %s -> %s %s" % (self._orig_src, sunit,
self._orig_dest, dunit)
else:
self._outdests = []
self._orig_expr = self._orig_src
self.missing_deriv_policy = 'error'
self._negate = False
