def compute_form_action(form, coefficient): """Compute the action of a form on a Coefficient. This works simply by replacing the last Argument with a Coefficient on the same function space (element). The form returned will thus have one Argument less and one additional Coefficient at the end if no Coefficient has been provided. """ # TODO: Check whatever makes sense for coefficient # Extract all arguments arguments = form.arguments() parts = [arg.part() for arg in arguments] if set(parts) - {None}: error("compute_form_action cannot handle parts.") # Pick last argument (will be replaced) u = arguments[-1] fs = u.ufl_function_space() if coefficient is None: coefficient = Coefficient(fs) elif coefficient.ufl_function_space() != fs: debug("Computing action of form on a coefficient in a different function space.") return replace(form, {u: coefficient})
def compute_energy_norm(form, coefficient): """Compute the a-norm of a Coefficient given a form a. This works simply by replacing the two Arguments with a Coefficient on the same function space (element). The Form returned will thus be a functional with no Arguments, and one additional Coefficient at the end if no coefficient has been provided. """ arguments = form.arguments() parts = [arg.part() for arg in arguments] if set(parts) - {None}: error("compute_energy_norm cannot handle parts.") if len(arguments) != 2: error("Expecting bilinear form.") v, u = arguments U = u.ufl_function_space() V = v.ufl_function_space() if U != V: error("Expecting equal finite elements for test and trial functions, got '%s' and '%s'." % (U, V)) if coefficient is None: coefficient = Coefficient(V) else: if coefficient.ufl_function_space() != U: error("Trying to compute action of form on a " "coefficient in an incompatible element space.") return replace(form, {u: coefficient, v: coefficient})
def compute_energy_norm(form, coefficient): """Compute the a-norm of a Coefficient given a form a. This works simply by replacing the two Arguments with a Coefficient on the same function space (element). The Form returned will thus be a functional with no Arguments, and one additional Coefficient at the end if no coefficient has been provided. """ arguments = extract_arguments(form) ufl_assert(len(arguments) == 2, "Expecting bilinear form.") v, u = arguments e = u.element() e2 = v.element() ufl_assert( e == e2, "Expecting equal finite elements for test and trial functions, got '%s' and '%s'." % (str(e), str(e2))) if coefficient is None: coefficient = Coefficient(e) else: ufl_assert(coefficient.element() == e, \ "Trying to compute action of form on a "\ "coefficient in an incompatible element space.") return replace(form, {u: coefficient, v: coefficient})
def compute_form_action(form, coefficient): """Compute the action of a form on a Coefficient. This works simply by replacing the last Argument with a Coefficient on the same function space (element). The form returned will thus have one Argument less and one additional Coefficient at the end if no Coefficient has been provided. """ # TODO: Check whatever makes sense for coefficient # Extract all arguments arguments = extract_arguments(form) # Pick last argument (will be replaced) u = arguments[-1] e = u.element() if coefficient is None: coefficient = Coefficient(e) else: #ufl_assert(coefficient.element() == e, \ if coefficient.element() != e: debug( "Computing action of form on a coefficient in a different element space." ) return replace(form, {u: coefficient})
def compute_form_action(form, coefficient): """Compute the action of a form on a Coefficient. This works simply by replacing the last Argument with a Coefficient on the same function space (element). The form returned will thus have one Argument less and one additional Coefficient at the end if no Coefficient has been provided. """ # TODO: Check whatever makes sense for coefficient # Extract all arguments arguments = extract_arguments(form) # Pick last argument (will be replaced) u = arguments[-1] e = u.element() if coefficient is None: coefficient = Coefficient(e) else: #ufl_assert(coefficient.element() == e, \ if coefficient.element() != e: debug("Computing action of form on a coefficient in a different element space.") return replace(form, { u: coefficient })
def __call__(self,M,b): # FIXME we currently lose the variable names of the forms (this can be # looked up in the uflObjects) # b as the rhs should always only have a single argument # Extract its element element = extract_arguments(b)[0].element() coeff = Coefficient(element) self._solves[coeff.count()] = (M,b) return coeff
def compute_energy_norm(form, coefficient): """Compute the a-norm of a Coefficient given a form a. This works simply by replacing the two Arguments with a Coefficient on the same function space (element). The Form returned will thus be a functional with no Arguments, and one additional Coefficient at the end if no coefficient has been provided. """ arguments = extract_arguments(form) ufl_assert(len(arguments) == 2, "Expecting bilinear form.") v, u = arguments e = u.element() e2 = v.element() ufl_assert(e == e2, "Expecting equal finite elements for test and trial functions, got '%s' and '%s'." % (str(e), str(e2))) if coefficient is None: coefficient = Coefficient(e) else: ufl_assert(coefficient.element() == e, \ "Trying to compute action of form on a "\ "coefficient in an incompatible element space.") return replace(form, { u: coefficient, v: coefficient })