Example #1
0
    def get_valid(self, names):
        """Returns a list of boolean values indicating whether the named
        variables are valid (True) or invalid (False). Entries in names may
        specify either direct traits of self or those of children.
        """

        ret = [None] * len(names)
        posdict = dict([(name, i) for i, name in enumerate(names)])

        for compname, varnames in partition_names_by_comp(names).items():
            if compname is None:
                vals = super(Assembly, self).get_valid(varnames)
                for i, val in enumerate(vals):
                    ret[posdict[varnames[i]]] = val
            else:
                comp = getattr(self, compname)
                if isinstance(comp, Component):
                    vals = comp.get_valid(varnames)
                else:
                    vals = [
                        self._valid_dict['.'.join([compname, vname])]
                        for vname in varnames
                    ]
                for i, val in enumerate(vals):
                    full = '.'.join([compname, varnames[i]])
                    ret[posdict[full]] = val
        return ret
Example #2
0
 def update_inputs(self, compname, exprs):
     """Transfer input data to input expressions on the specified component.
     The exprs iterator is assumed to contain expression strings that reference
     component variables relative to the component, e.g., 'abc[3][1]' rather
     than 'comp1.abc[3][1]'.
     """
     parent = self.parent
     expr_info = []
     invalids = []
     
     if compname is not None:
         exprs = ['.'.join([compname, n]) for n in exprs]
     for expr in exprs:
         srctxt = self._exprmapper.get_source(expr)
         if srctxt:
             srcexpr = self._exprmapper.get_expr(srctxt)
             invalids.extend(srcexpr.invalid_refs())
             expr_info.append((srcexpr, self._exprmapper.get_expr(expr)))
         
     # if source exprs reference invalid vars, request an update
     if invalids:
         for cname, vnames in partition_names_by_comp(invalids).items():
             if cname is None:
                 if self.parent:
                     self.parent.update_inputs(self.name, vnames)
             else:
                 getattr(self, cname).update_outputs(vnames)
                 #self.set_valid(vnames, True)
         
     for srcexpr, destexpr in expr_info:
         try:
             destexpr.set(srcexpr.evaluate(), src=srcexpr.text)
         except Exception as err:
             self.raise_exception("cannot set '%s' from '%s': %s" % 
                                  (destexpr.text, srcexpr.text, str(err)), type(err))
Example #3
0
 def update_outputs(self, outnames):
     """Execute any necessary internal or predecessor components in order
     to make the specified output variables valid.
     """
     for cname, vnames in partition_names_by_comp(outnames).items():
         if cname is None:  #boundary outputs
             self.update_inputs(None, vnames)
         else:
             getattr(self, cname).update_outputs(vnames)
             self.set_valid(vnames, True)
Example #4
0
 def update_outputs(self, outnames):
     """Execute any necessary internal or predecessor components in order
     to make the specified output variables valid.
     """
     for cname, vnames in partition_names_by_comp(outnames).items():
         if cname is None:  # boundary outputs
             self.update_inputs(None, vnames)
         else:
             getattr(self, cname).update_outputs(vnames)
             self.set_valid(vnames, True)
Example #5
0
    def update_inputs(self, compname, exprs):
        """Transfer input data to input expressions on the specified component.
        The exprs iterator is assumed to contain expression strings that reference
        component variables relative to the component, e.g., 'abc[3][1]' rather
        than 'comp1.abc[3][1]'.
        """
        parent = self.parent
        expr_info = []
        invalids = []

        if compname is not None:
            pred = self._exprmapper._exprgraph.pred
            if exprs:
                ex = ['.'.join([compname, n]) for n in exprs]
                exprs = []
                for e in ex:
                    exprs.extend([
                        expr
                        for expr in self._exprmapper.find_referring_exprs(e)
                        if expr in pred
                    ])
            else:
                exprs = [
                    expr
                    for expr in self._exprmapper.find_referring_exprs(compname)
                    if expr in pred
                ]
        for expr in exprs:
            srctxt = self._exprmapper.get_source(expr)
            if srctxt:
                srcexpr = self._exprmapper.get_expr(srctxt)
                invalids.extend(srcexpr.invalid_refs())
                expr_info.append((srcexpr, self._exprmapper.get_expr(expr)))

        # if source exprs reference invalid vars, request an update
        if invalids:
            for cname, vnames in partition_names_by_comp(invalids).items():
                if cname is None:
                    if self.parent:
                        self.parent.update_inputs(self.name, vnames)
                else:
                    getattr(self, cname).update_outputs(vnames)
                    #self.set_valid(vnames, True)

        for srcexpr, destexpr in expr_info:
            try:
                destexpr.set(srcexpr.evaluate(), src=srcexpr.text)
            except Exception as err:
                self.raise_exception(
                    "cannot set '%s' from '%s': %s" %
                    (destexpr.text, srcexpr.text, str(err)), type(err))
Example #6
0
    def get_valid(self, names):
        """Returns a list of boolean values indicating whether the named
        variables are valid (True) or invalid (False). Entries in names may
        specify either direct traits of self or those of children.
        """

        ret = [None]*len(names)
        posdict = dict([(name,i) for i,name in enumerate(names)])
        
        for compname, varnames in partition_names_by_comp(names).items():
            if compname is None:
                vals = super(Assembly, self).get_valid(varnames)
                for i,val in enumerate(vals):
                    ret[posdict[varnames[i]]] = val
            else:
                vals = getattr(self, compname).get_valid(varnames)
                for i,val in enumerate(vals):
                    full = '.'.join([compname,varnames[i]])
                    ret[posdict[full]] = val
        return ret