Python ExprEvaluator.get_referenced_varpaths方法代码示例

# 需要导入模块: from openmdao.main.expreval import ExprEvaluator [as 别名]
# 或者: from openmdao.main.expreval.ExprEvaluator import get_referenced_varpaths [as 别名]
 def test_get_referenced_varpaths(self):
     ex = ExprEvaluator('comp.x[0] = 10*(3.2+ a.a1d[3]* 1.1*a.a1d[2 ])', self.top.a)
     self.assertEqual(ex.get_referenced_varpaths(), set(['comp.x','a.a1d']))
     ex.text = 'comp.contlist[1].a2d[2][1]'
     self.assertEqual(ex.get_referenced_varpaths(), set(['comp.contlist']))
     ex.scope = self.top.comp
     ex.text = 'comp.contlist[1]'
     self.assertEqual(ex.get_referenced_varpaths(), set(['comp.contlist']))

# 需要导入模块: from openmdao.main.expreval import ExprEvaluator [as 别名]
# 或者: from openmdao.main.expreval.ExprEvaluator import get_referenced_varpaths [as 别名]
 def __init__(self, exprs=(), derivatives=(), sleep=0, dsleep=0):
     super(ExecCompWithDerivatives, self).__init__()
     
     ins = set()
     outs = set()
     allvars = set()
     self.exprs = exprs
     self.codes = [compile(expr,'<string>','exec') for expr in exprs]
     self.sleep = sleep
     self.dsleep = dsleep
     
     for expr in exprs:
         lhs,rhs = expr.split('=')
         lhs = lhs.strip()
         lhs = lhs.split(',')
         outs.update(lhs)
         expreval = ExprEvaluator(expr, scope=self)
         allvars.update(expreval.get_referenced_varpaths(copy=False))
     ins = allvars - outs
     
     for var in allvars:
         if '.' not in var:  # if a varname has dots, it's outside of our scope,
                             # so don't add a trait for it
             if var in outs:
                 iotype = 'out'
             else:
                 iotype = 'in'
             self.add(var, Float(0.0, iotype=iotype))
 
     self.deriv_exprs = derivatives
     self.derivative_codes = \
         [compile(expr,'<string>','exec') for expr in derivatives]
     
     self.derivative_names = []
     regex = re.compile('d(.*)_d(.*)')
     for expr in derivatives:
         expreval = ExprEvaluator(expr, scope=self)
         exvars = expreval.get_referenced_varpaths(copy=False)
         
         lhs, _ = expr.split('=')
         lhs = lhs.strip()
         allvars.add(lhs)
         
         # Check for undefined vars the cool way with sets
         if len(exvars-allvars) > 0:
             self.raise_exception('derivative references a variable '
                                  'that is not defined in exprs',
                                  ValueError)
                 
         names = regex.findall(lhs)
         num = names[0][0]
         wrt = names[0][1]
         self.derivatives.declare_first_derivative(num, wrt)
         
         self.derivative_names.append( (lhs, num, wrt) )

# 需要导入模块: from openmdao.main.expreval import ExprEvaluator [as 别名]
# 或者: from openmdao.main.expreval.ExprEvaluator import get_referenced_varpaths [as 别名]
def _split_expr(text):
    """Take an expression string and return varpath, expr"""
    if text.startswith('@') or is_legal_name(text):
        return text, text
    
    expr = ExprEvaluator(text)
    return expr.get_referenced_varpaths().pop(), text

# 需要导入模块: from openmdao.main.expreval import ExprEvaluator [as 别名]
# 或者: from openmdao.main.expreval.ExprEvaluator import get_referenced_varpaths [as 别名]
    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]) })

# 需要导入模块: from openmdao.main.expreval import ExprEvaluator [as 别名]
# 或者: from openmdao.main.expreval.ExprEvaluator import get_referenced_varpaths [as 别名]
 def __init__(self, exprs=()):
     super(ExecComp, self).__init__()
     ins = set()
     outs = set()
     allvars = set()
     self.codes = [compile(expr,'<string>','exec') for expr in exprs]
     for expr in exprs:
         lhs,rhs = expr.split('=')
         lhs = lhs.strip()
         lhs = lhs.split(',')
         outs.update(lhs)
         expreval = ExprEvaluator(expr, scope=self)
         allvars.update(expreval.get_referenced_varpaths(copy=False))
     ins = allvars - outs
     for var in allvars:
         if '.' not in var:  # if a varname has dots, it's outside of our scope,
                             # so don't add a trait for it
             if var in outs:
                 iotype = 'out'
             else:
                 iotype = 'in'
             self.add(var, Float(iotype=iotype))

# 需要导入模块: from openmdao.main.expreval import ExprEvaluator [as 别名]
# 或者: from openmdao.main.expreval.ExprEvaluator import get_referenced_varpaths [as 别名]
 def __init__(self, exprs=(), sleep=0):
     super(ExecComp, self).__init__()
     ins = set()
     outs = set()
     allvars = set()
     self.exprs = exprs
     self.codes = [compile(expr, "<string>", "exec") for expr in exprs]
     self.sleep = sleep
     for expr in exprs:
         lhs, rhs = expr.split("=")
         lhs = lhs.strip()
         lhs = lhs.split(",")
         outs.update(lhs)
         expreval = ExprEvaluator(expr, scope=self)
         allvars.update(expreval.get_referenced_varpaths(copy=False))
     ins = allvars - outs
     for var in allvars:
         if "." not in var:  # if a varname has dots, it's outside of our scope,
             # so don't add a trait for it
             if var in outs:
                 iotype = "out"
             else:
                 iotype = "in"
             self.add(var, Float(0.0, iotype=iotype))

# 需要导入模块: from openmdao.main.expreval import ExprEvaluator [as 别名]
# 或者: from openmdao.main.expreval.ExprEvaluator import get_referenced_varpaths [as 别名]

#.........这里部分代码省略.........
        else:
            first = self.lhs.text
            second = self.rhs.text

        first_zero = False
        try:
            f = float(first)
        except Exception:
            pass
        else:
            if f == 0:
                first_zero = True

        second_zero = False
        try:
            f = float(second)
        except Exception:
            pass
        else:
            if f == 0:
                second_zero = True

        if first_zero:
            newexpr = "-(%s)" % second
        elif second_zero:
            newexpr = first
        else:
            newexpr = '%s-(%s)' % (first, second)

        return ExprEvaluator(newexpr, scope)

    def copy(self):
        """ Returns a copy of our self. """
        return Constraint(str(self.lhs), self.comparator, str(self.rhs),
                          scope=self.lhs.scope, jacs=self.jacs)

    def evaluate(self, scope):
        """Returns the value of the constraint as a sequence."""
        vname = self.pcomp_name + '.out0'
        try:
            system = getattr(scope,self.pcomp_name)._system
            info = system.vec['u']._info[scope.name2collapsed[vname]]
            # if a pseudocomp output is marked as hidden, that means that
            # it's really a residual, but it's mapped in the vector to
            # the corresponding state, so don't pull that value because
            # we want the actual residual value
            if info.hide: # it's a residual so pull from f vector
                return -system.vec['f'][scope.name2collapsed[vname]]
            else:
                return info.view
        except (KeyError, AttributeError):
            pass

        val = getattr(scope, self.pcomp_name).out0

        if isinstance(val, ndarray):
            return val.flatten()
        else:
            return [val]

    def get_referenced_compnames(self):
        """Returns a set of names of each component referenced by this
        constraint.
        """
        if isinstance(self.rhs, float):
            return self.lhs.get_referenced_compnames()
        else:
            return self.lhs.get_referenced_compnames().union(
                                            self.rhs.get_referenced_compnames())

    def get_referenced_varpaths(self, copy=True, refs=False):
        """Returns a set of names of each component referenced by this
        constraint.
        """
        if isinstance(self.rhs, float):
            return self.lhs.get_referenced_varpaths(copy=copy, refs=refs)
        else:
            return self.lhs.get_referenced_varpaths(copy=copy, refs=refs).union(
                    self.rhs.get_referenced_varpaths(copy=copy, refs=refs))

    def check_resolve(self):
        """Returns True if this constraint has no unresolved references."""
        return self.lhs.check_resolve() and self.rhs.check_resolve()

    def get_unresolved(self):
        return list(set(self.lhs.get_unresolved()).union(self.rhs.get_unresolved()))

    def name_changed(self, old, new):
        """Update expressions if necessary when an object is renamed."""
        self.rhs.name_changed(old, new)
        self.lhs.name_changed(old, new)

    def __str__(self):
        return ' '.join((str(self.lhs), self.comparator, str(self.rhs)))

    def __eq__(self, other):
        if not isinstance(other, Constraint):
            return False
        return (self.lhs, self.comparator, self.rhs) == \
               (other.lhs, other.comparator, other.rhs)

# 需要导入模块: from openmdao.main.expreval import ExprEvaluator [as 别名]
# 或者: from openmdao.main.expreval.ExprEvaluator import get_referenced_varpaths [as 别名]
class Constraint2Sided(Constraint):
    """ Object that stores info for a double-sided constraint. """

    def __init__(self, lhs, center, rhs, comparator, scope, jacs=None):
        self.lhs = ExprEvaluator(lhs, scope=scope)
        unresolved_vars = self.lhs.get_unresolved()

        self._pseudo = None
        self.pcomp_name = None

        if unresolved_vars:
            msg = "Left hand side of constraint '{0}' has invalid variables {1}"
            expression = ' '.join((lhs, comparator, center, comparator,
                                   rhs))

            raise ExprEvaluator._invalid_expression_error(unresolved_vars,
                                                          expr=expression,
                                                          msg=msg)
        self.center = ExprEvaluator(center, scope=scope)
        unresolved_vars = self.center.get_unresolved()

        if unresolved_vars:
            msg = "Center of constraint '{0}' has invalid variables {1}"
            expression = ' '.join((lhs, comparator, center, comparator,
                                   rhs))

            raise ExprEvaluator._invalid_expression_error(unresolved_vars,
                                                          expr=expression,
                                                          msg=msg)
        self.rhs = ExprEvaluator(rhs, scope=scope)
        unresolved_vars = self.rhs.get_unresolved()

        if unresolved_vars:
            msg = "Right hand side of constraint '{0}' has invalid variables {1}"
            expression = ' '.join((lhs, comparator, center, comparator,
                                   rhs))

            raise ExprEvaluator._invalid_expression_error(unresolved_vars,
                                                          expr=expression,
                                                          msg=msg)
        self.comparator = comparator
        self._size = None

        # Linear flag: constraints are nonlinear by default
        self.linear = False

        self.low = self.lhs.evaluate()
        self.high = self.rhs.evaluate()

        # User-defined jacobian function
        self.jacs = jacs

        self._create_pseudo()

    def _create_pseudo(self):
        """Create our pseudo component."""
        scope = self.lhs.scope
        refs = list(self.center.ordered_refs())
        pseudo_class = PseudoComponent

        # look for a<var1<b
        if len(refs) == 1 and self.center.text == refs[0]:
            pseudo_class = SimpleEQ0PComp

        self._pseudo = pseudo_class(scope,
                                    self.center,
                                    pseudo_type='constraint',
                                    subtype='inequality',
                                    exprobject=self)

        self.pcomp_name = self._pseudo.name

    def _combined_expr(self):
        """Only need the center expression
        """
        return self.center

    def copy(self):
        """ Returns a copy of our self. """
        return Constraint2Sided(str(self.lhs), str(self.center), str(self.rhs),
                          self.comparator, scope=self.lhs.scope,
                          jacs=self.jacs)

    def get_referenced_compnames(self):
        """Returns a set of names of each component referenced by this
        constraint.
        """
        return self.center.get_referenced_compnames()

    def get_referenced_varpaths(self, copy=True, refs=False):
        """Returns a set of names of each component referenced by this
        constraint.
        """
        return self.center.get_referenced_varpaths(copy=copy, refs=refs)

    def name_changed(self, old, new):
        """Update expressions if necessary when an object is renamed."""
        self.rhs.name_changed(old, new)
        self.lhs.name_changed(old, new)
        self.center.name_changed(old, new)
#.........这里部分代码省略.........

# 需要导入模块: from openmdao.main.expreval import ExprEvaluator [as 别名]
# 或者: from openmdao.main.expreval.ExprEvaluator import get_referenced_varpaths [as 别名]

#.........这里部分代码省略.........
        rhs and combine them into a single expression by moving rhs
        terms over to the lhs.  For example,
        for the constraint 'C1.x < C2.y + 7', return the expression
        'C1.x - C2.y - 7'.  Depending on the direction of the operator,
        the sign of the expression may be flipped.  The final form of
        the constraint, when evaluated, will be considered to be satisfied
        if it evaluates to a value <= 0.
        """
        scope = self.lhs.scope

        if self.comparator.startswith('>'):
            first = self.rhs.text
            second = self.lhs.text
        else:
            first = self.lhs.text
            second = self.rhs.text

        first_zero = False
        try:
            f = float(first)
        except Exception:
            pass
        else:
            if f == 0:
                first_zero = True

        second_zero = False
        try:
            f = float(second)
        except Exception:
            pass
        else:
            if f == 0:
                second_zero = True

        if first_zero:
            newexpr = "-(%s)" % second
        elif second_zero:
            newexpr = "%s" % first
        else:
            newexpr = '%s-(%s)' % (first, second)

        return ExprEvaluator(newexpr, scope)

    def copy(self):
        return Constraint(str(self.lhs), self.comparator, str(self.rhs),
                          scope=self.lhs.scope)

    def evaluate(self, scope):
        """Returns the value of the constraint as a sequence."""
        pcomp = getattr(scope, self.pcomp_name)
        if not pcomp.is_valid():
            pcomp.update_outputs(['out0'])
        val = pcomp.out0

        if isinstance(val, ndarray):
            return val.flatten()
        else:
            return [val]

    def evaluate_gradient(self, scope, stepsize=1.0e-6, wrt=None):
        """Returns the gradient of the constraint eq/ineq as a tuple of the
        form (lhs, rhs, comparator, is_violated)."""

        lhs = self.lhs.evaluate_gradient(scope=scope, stepsize=stepsize, wrt=wrt)
        if isinstance(self.rhs, float):
            rhs = 0.
        else:
            rhs = self.rhs.evaluate_gradient(scope=scope, stepsize=stepsize, wrt=wrt)

        return (lhs, rhs, self.comparator, not _ops[self.comparator](lhs, rhs))

    def get_referenced_compnames(self):
        """Returns a set of names of each component referenced by this
        constraint.
        """
        if isinstance(self.rhs, float):
            return self.lhs.get_referenced_compnames()
        else:
            return self.lhs.get_referenced_compnames().union(
                                            self.rhs.get_referenced_compnames())

    def get_referenced_varpaths(self, copy=True):
        """Returns a set of names of each component referenced by this
        constraint.
        """
        if isinstance(self.rhs, float):
            return self.lhs.get_referenced_varpaths(copy=copy)
        else:
            return self.lhs.get_referenced_varpaths(copy=copy).union(
                                    self.rhs.get_referenced_varpaths(copy=copy))

    def __str__(self):
        return ' '.join([str(self.lhs), self.comparator, str(self.rhs)])

    def __eq__(self, other):
        if not isinstance(other, Constraint):
            return False
        return (self.lhs, self.comparator, self.rhs) == \
               (other.lhs, other.comparator, other.rhs)