Пример #1
0
    def setup_terms(self, regions, variables, materials, caches=None, user=None):
        """Parse equations and create term instances.

        Grabs references to materials and variables."""
        if caches is None:
            self.caches = DataCaches()
        else:
            self.caches = caches

        self.materials = materials
        self.variables = variables

        for eq in self:
            eq.setup_terms(regions, variables, materials, self.caches, user)
Пример #2
0
    def assign_caches(self, caches=None):
        from sfepy.terms import cache_table, DataCaches

        if not hasattr(self, "use_caches"):
            return

        if caches is None:
            caches = DataCaches()

        ## print self.name
        for name, arg_lists in self.use_caches.iteritems():
            ## print self.arg_names
            ## print name, arg_lists
            for args in arg_lists:
                ## Order should be handled in terms...
                args = copy(args)

                if len(args) and (type(args[-1]) == dict):
                    history_sizes = args.pop()

                else:
                    history_sizes = None

                ans = [self.get_arg_name(arg, full=True) for arg in args]
                cname = "_".join([name] + ans)

                ## print self.name, name, arg_lists, args, cname
                ## print history_sizes

                if caches.has_key(cname):
                    caches[cname].merge_history_sizes(history_sizes)

                else:
                    ## print 'new'
                    try:
                        constructor = cache_table[name]
                    except:
                        raise RuntimeError, "cache not found! %s in %s" % (name, sorted(cache_table.keys()))
                    cache = constructor(cname, ans, history_sizes)
                    caches.insert_cache(cache)
            caches.insert_term(cname, self.name, ans)
        self.caches = caches
Пример #3
0
class Equations(Container):

    ##
    # c: 18.04.2006, r: 20.02.2008
    def from_conf(conf):
        objs = OneTypeList(Equation)

        conf = copy(conf)
        tps = conf.pop("namespaces", {})
        itps = invert_dict(tps, True)

        ii = 0
        for name, desc in conf.iteritems():
            output('equation "%s":' % name)
            output(desc)
            eq = Equation(name=name, desc=desc, itps=itps)
            objs.append(eq)
            ii += 1

        obj = Equations(objs, itps=itps)

        return obj

    from_conf = staticmethod(from_conf)

    def setup_terms(self, regions, variables, materials, caches=None, user=None):
        """Parse equations and create term instances.

        Grabs references to materials and variables."""
        if caches is None:
            self.caches = DataCaches()
        else:
            self.caches = caches

        self.materials = materials
        self.variables = variables

        for eq in self:
            eq.setup_terms(regions, variables, materials, self.caches, user)

    ##
    # c: ??, r: 26.02.2008
    def describe_geometry(self, geometries, variables, integrals):
        output("describing geometries...")
        tt = time.clock()
        for eq in self:
            eq.describe_geometry(geometries, variables, integrals)
        output("...done in %.2f s" % (time.clock() - tt))

    ##
    # 24.08.2006, c
    # 24.04.2007
    def get_term_geometries(self):
        tgs = set()
        for eq in self:
            tgs.update(eq.get_term_geometries())
        return tgs

    ##
    # 16.11.2007, c
    def get_term_integral_names(self):
        i_names = set()
        for eq in self:
            i_names.update(eq.get_term_integral_names())
        return i_names

    def get_variable_names(self):
        """Return the list of names of all variables used in equations."""
        vns = set()
        for eq in self:
            for term in eq.terms:
                vns.update(term.get_variable_names())
        return list(vns)

    ##
    # 27.02.2007, c
    def invalidate_term_caches(self):
        for cache in self.caches.itervalues():
            cache.clear()

    ##
    # c: 07.05.2008, r: 07.05.2008
    def reset_term_caches(self):
        for cache in self.caches.itervalues():
            cache.reset()

    ##
    # 02.03.2007, c
    def set_cache_mode(self, cache_override):
        for cache in self.caches.itervalues():
            cache.set_mode(cache_override)

    def time_update(self, ts):
        for eq in self:
            for term in eq.terms:
                term.time_update(ts)

    ##
    # c: 02.04.2008, r: 02.04.2008
    def init_time(self, ts):
        for cache in self.caches.itervalues():
            cache.init_time(ts)

    ##
    # 08.06.2007, c
    def advance(self, ts):
        for cache in self.caches.itervalues():
            cache.advance(ts.step + 1)
Пример #4
0
def eval_term(
    state,
    term_desc,
    conf,
    domain,
    variables,
    materials,
    ts,
    funmod=None,
    chunk_size=1000,
    term_prefixes=None,
    caches=None,
    ret_caches=False,
    override=True,
    new_geometries=True,
    dw_mode="vector",
    tangent_matrix=None,
    **kwargs
):
    """Evaluate a term. May not succeed!"""
    if term_prefixes is None:
        term_prefixes = {}
    if caches is None:
        caches = DataCaches()

    equation = Equation.from_desc("tmp", term_desc, term_prefixes)
    equation.setup_terms(domain.regions, variables, materials, caches, kwargs)

    for cache in caches.itervalues():
        cache.set_mode(override=override)

    if new_geometries:
        i_names = equation.get_term_integral_names()
        integrals = Integrals.from_conf(conf.integrals, i_names)
        integrals.set_quadratures(quadratures)

        geometries = {}
        equation.describe_geometry(geometries, variables, integrals)

    variables.data_from_state(state)
    if "call_mode" in kwargs:
        itype = kwargs["call_mode"].split("_")[0]
    else:
        # itype according to the first term in term_desc!
        itype = equation.terms[0].itype

    if itype == "dw":
        variables.setup_dof_conns()
        if not variables.has_eq_map:
            variables.equation_mapping(conf.ebcs, conf.epbcs, domain.regions, ts, funmod)
            variables.setup_lcbc_operators(conf.lcbcs, domain.regions)
            variables.setup_a_dof_conns()

        if dw_mode == "vector":
            residual = variables.create_stripped_state_vector()
            assemble_vector(residual, equation, variables, materials, chunk_size, group_can_fail=False, **kwargs)
            if variables.has_lcbc:
                op_lcbc = variables.op_lcbc
                residual = op_lcbc.T * residual
            ret_val = residual

        elif dw_mode == "matrix":
            if tangent_matrix is None:
                tangent_matrix = variables.create_matrix_graph()

            tangent_matrix.data[:] = 0.0
            assemble_matrix(tangent_matrix, equation, variables, materials, chunk_size, group_can_fail=False, **kwargs)
            if variables.has_lcbc:
                op_lcbc = variables.op_lcbc
                tangent_matrix = op_lcbc.T * tangent_matrix * op_lcbc
                tangent_matrix = tangent_matrix.tocsr()
                tangent_matrix.sort_indices()
            ret_val = tangent_matrix

        else:
            print dw_mode
            raise ValueError

    elif itype == "d":
        kwargs.setdefault("call_mode", "d_eval")

        val = 0.0
        for term in equation.terms:
            args = build_args(term, variables, materials, **kwargs)
            for ig in term.iter_groups():
                for aux, iels, status in term(chunk_size=chunk_size, **args):
                    val += term.sign * aux
            ret_val = val

    elif itype == "di":

        val = None
        for term in equation.terms:
            args = build_args(term, variables, materials, **kwargs)
            for ig in term.iter_groups():
                for aux, iels, status in term(chunk_size=chunk_size, **args):
                    if val is None:
                        val = term.sign * aux
                    else:
                        val += term.sign * aux
            ret_val = val

    elif (itype == "de") or (itype == "dq"):

        val = None
        for term in equation.terms:
            args = build_args(term, variables, materials, **kwargs)
            for ig in term.iter_groups():
                for aux, iels, status in term(chunk_size=chunk_size, **args):
                    if val is None:
                        val = term.sign * aux
                    else:
                        val = nm.concatenate((val, term.sign * aux), axis=0)
        ret_val = val

    else:
        raise NotImplementedError, "unknown term integration type: %s" % itype

    if ret_caches:
        return ret_val, caches
    else:
        return ret_val