def test_print_node(self):
checks = [
'a', 'a+b', 'a-b', 'a*b', 'a/b', 'a-(b-c)', 'a+b*c', 'a[0]',
'a[0::]', 'a[:0:]', 'a[::0]', 'a[(0,0)]', 'a[::,0]', 'a[0,::]'
]
for check in checks:
node = ast.parse(check, mode='eval')
self.assertEqual(check, print_node(node))
def test_print_node(self):
checks = [
'a',
'a+b',
'a-b',
'a*b',
'a/b',
'a-(b-c)',
'a+b*c',
]
for check in checks:
node = ast.parse(check, mode='eval')
self.assertEqual(check, print_node(node))
def test_print_node(self):
checks = [
'a',
'a+b',
'a-b',
'a*b',
'a/b',
'a-(b-c)',
'a+b*c',
]
for check in checks:
node = ast.parse(check, mode='eval')
self.assertEqual(check, print_node(node))
def test_print_node(self):
checks = [
'a',
'a+b',
'a-b',
'a*b',
'a/b',
'a-(b-c)',
'a+b*c',
'a[0]',
'a[0::]',
'a[:0:]',
'a[::0]',
'a[(0,0)]',
'a[::,0]',
'a[0,::]'
]
for check in checks:
node = ast.parse(check, mode='eval')
self.assertEqual(check, print_node(node))
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 test_scaler_adder_conversion(self):
node = ast.parse('a')
cnv = unit_xform(node, 'degC', 'degF')
newexpr = print_node(cnv)
self.assertEqual(newexpr, '(a+17.7777777778)*1.8')
def test_simple_conversion(self):
node = ast.parse('a')
cnv = unit_xform(node, 'ft', 'inch')
newexpr = print_node(cnv)
self.assertEqual(newexpr, 'a*12.0')
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
def test_scaler_adder_conversion(self):
node = ast.parse('a')
cnv = unit_xform(node, 'degC', 'degF')
newexpr = print_node(cnv)
self.assertEqual(newexpr, '(a+17.7777777778)*1.8')
def test_simple_conversion(self):
node = ast.parse('a')
cnv = unit_xform(node, 'ft', 'inch')
newexpr = print_node(cnv)
self.assertEqual(newexpr, 'a*12.0')
