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_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 })