Ejemplo n.º 1
0
        def unify(self, other, expr=None):
            """Return a type that can represent both *self* and *other*.
            If impossible, raise :exc:`TypeError`. Subtypes should override
            :meth:`unify_inner`.
            """
            # shortcut
            if self == other:
                return self

            u_s_o = self.unify_inner(other)
            u_o_s = other.unify_inner(self)

            if u_s_o is NotImplemented:
                if u_o_s is NotImplemented:
                    if expr is not None:
                        from hedge.optemplate.tools import pretty_print_optemplate

                        raise TypeError(
                            "types '%s' and '%s' for '%s' "
                            "cannot be unified" % (self, other, pretty_print_optemplate(expr))
                        )
                    else:
                        raise TypeError("types '%s' and '%s' cannot be unified" % (self, other))
                else:
                    return u_o_s
            elif u_o_s is NotImplemented:
                return u_s_o

            if u_s_o != u_o_s:
                raise RuntimeError("types '%s' and '%s' don't agree about their unifier" % (self, other))
            return u_s_o
Ejemplo n.º 2
0
    def map_operator_binding(self, expr):
        if isinstance(expr.op, hedge.optemplate.DiffOperatorBase):
            from hedge.optemplate import (
                    WeakFormDiffOperatorBase,
                    StrongFormDiffOperatorBase,
                    QuadratureGridUpsampler)

            if isinstance(expr.op, WeakFormDiffOperatorBase):
                factor = -1
            elif isinstance(expr.op, StrongFormDiffOperatorBase):
                factor = 1
            else:
                raise RuntimeError("unknown type of differentiation "
                        "operator encountered by stab term generator")

            from hedge.optemplate import DifferentiationOperator
            return factor*DifferentiationOperator(expr.op.xyz_axis)(expr.field)

        elif isinstance(expr.op, hedge.optemplate.FluxOperatorBase):
            return 0
        elif isinstance(expr.op, hedge.optemplate.InverseMassOperator):
            return self.rec(expr.field)
        elif isinstance(expr.op, 
                hedge.optemplate.QuadratureInteriorFacesGridUpsampler):
            return hedge.optemplate.IdentityMapper.map_operator_binding(
                    self, expr)
        else:
            from hedge.optemplate.tools import pretty_print_optemplate
            raise ValueError("IPDG derivative generator doesn't know "
                    "what to do with '%s'" % pretty_print_optemplate(expr))
Ejemplo n.º 3
0
    def map_operator_binding(self, expr, quad_above=[]):
        from hedge.optemplate.operators import (
                DiffOperatorBase, FluxOperatorBase,
                InverseMassOperator,
                QuadratureInteriorFacesGridUpsampler)

        if isinstance(expr.op, DiffOperatorBase):
            flux_arg_idx = self.get_flux_arg_idx(expr.field, quad_above=quad_above)

            from hedge.optemplate import \
                    WeakFormDiffOperatorBase, \
                    StrongFormDiffOperatorBase
            if isinstance(expr.op, WeakFormDiffOperatorBase):
                factor = -1
            elif isinstance(expr.op, StrongFormDiffOperatorBase):
                factor = 1
            else:
                raise RuntimeError("unknown type of differentiation "
                        "operator encountered by stab term generator")

            from hedge.flux import Normal, FluxScalarPlaceholder
            sph = FluxScalarPlaceholder(flux_arg_idx)
            return (factor
                    * Normal(expr.op.xyz_axis)
                    * (sph.int - sph.ext))

        elif isinstance(expr.op, FluxOperatorBase):
            return 0
        elif isinstance(expr.op, InverseMassOperator):
            return self.rec(expr.field, quad_above)
        elif isinstance(expr.op, QuadratureInteriorFacesGridUpsampler):
            if quad_above:
                raise RuntimeError("double quadrature upsampler found "
                        "when generating stabilization term")
            return self.rec(expr.field, [expr.op])
        else:
            from hedge.optemplate.tools import pretty_print_optemplate
            raise ValueError("stabilization term generator doesn't know "
                    "what to do with '%s'" % pretty_print_optemplate(expr))