def set_bc_nest(b: PETSc.Vec,
bcs: typing.List[typing.List[DirichletBCMetaClass]],
x0: typing.Optional[PETSc.Vec] = None,
scale: float = 1.0) -> None:
"""Apply the function :func:`dolfinx.fem.set_bc` to each sub-vector of a nested PETSc Vector."""
_b = b.getNestSubVecs()
x0 = len(_b) * [None] if x0 is None else x0.getNestSubVecs()
for b_sub, bc, x_sub in zip(_b, bcs, x0):
set_bc(b_sub, bc, x_sub, scale)
def _(b: PETSc.Vec, L: typing.List[typing.Union[Form, cpp.fem.Form]]) -> PETSc.Vec:
"""Assemble linear forms into a nested PETSc (VecNest) vector. The vector is not
zeroed before assembly and it is not finalised, qi.e. ghost values
are not accumulated on the owning processes.
"""
for b_sub, L_sub in zip(b.getNestSubVecs(), _create_cpp_form(L)):
cpp.fem.assemble_vector(b_sub, L_sub)
return b
def set_bc_nest(b: PETSc.Vec,
bcs: typing.List[typing.List[DirichletBC]],
x0: typing.Optional[PETSc.Vec] = None,
scale: float = 1.0) -> None:
"""Insert boundary condition values into nested vector. Only local (owned)
entries are set, hence communication after calling this function is
not required unless the ghost entries need to be updated to the
boundary condition value.
"""
_b = b.getNestSubVecs()
x0 = len(_b) * [None] if x0 is None else x0.getNestSubVecs()
for b_sub, bc, x_sub in zip(_b, bcs, x0):
set_bc(b_sub, bc, x_sub, scale)
def apply_lifting_nest(b: PETSc.Vec,
a: typing.List[typing.List[typing.Union[Form, cpp.fem.Form]]],
bcs: typing.List[DirichletBC],
x0: typing.Optional[PETSc.Vec] = None,
scale: float = 1.0) -> PETSc.Vec:
"""Modify nested vector for lifting of Dirichlet boundary conditions.
"""
x0 = [] if x0 is None else x0.getNestSubVecs()
_a = _create_cpp_form(a)
bcs1 = cpp.fem.bcs_cols(_a, bcs)
for b_sub, a_sub, bc1 in zip(b.getNestSubVecs(), _a, bcs1):
apply_lifting(b_sub, a_sub, bc1, x0, scale)
return b
def _(
b: PETSc.Vec,
L: typing.List[FormMetaClass],
coeffs=Coefficients(None, None)) -> PETSc.Vec:
"""Assemble linear forms into a nested PETSc (VecNest) vector. The
vector is not zeroed before assembly and it is not finalised, i.e.
ghost values are not accumulated on the owning processes.
"""
c = (coeffs[0] if coeffs[0] is not None else pack_constants(L),
coeffs[1] if coeffs[1] is not None else pack_coefficients(L))
for b_sub, L_sub, constant, coeff in zip(b.getNestSubVecs(), L, c[0],
c[1]):
with b_sub.localForm() as b_local:
_cpp.fem.assemble_vector(b_local.array_w, L_sub, constant, coeff)
return b
def _(b: PETSc.Vec,
L: typing.List[FormMetaClass],
constants=None,
coeffs=None) -> PETSc.Vec:
"""Assemble linear forms into a nested PETSc (VecNest) vector. The
vector is not zeroed before assembly and it is not finalised, i.e.
ghost values are not accumulated on the owning processes.
"""
constants = [None] * len(L) if constants is None else constants
coeffs = [None] * len(L) if coeffs is None else coeffs
for b_sub, L_sub, const, coeff in zip(b.getNestSubVecs(), L, constants,
coeffs):
with b_sub.localForm() as b_local:
assemble.assemble_vector(b_local.array_w, L_sub, const, coeff)
return b
def apply_lifting_nest(
b: PETSc.Vec,
a: typing.List[typing.List[FormMetaClass]],
bcs: typing.List[DirichletBCMetaClass],
x0: typing.Optional[PETSc.Vec] = None,
scale: float = 1.0,
coeffs=Coefficients(None, None)) -> PETSc.Vec:
"""Modify nested vector for lifting of Dirichlet boundary conditions.
"""
x0 = [] if x0 is None else x0.getNestSubVecs()
c = (coeffs[0] if coeffs[0] is not None else pack_constants(a),
coeffs[1] if coeffs[1] is not None else pack_coefficients(a))
bcs1 = bcs_by_block(extract_function_spaces(a, 1), bcs)
for b_sub, a_sub, constants, coeffs in zip(b.getNestSubVecs(), a, c[0],
c[1]):
apply_lifting(b_sub, a_sub, bcs1, x0, scale, (constants, coeffs))
return b
def assemble_vector_nest(b: _PETSc.Vec, L: Sequence[_fem.FormMetaClass],
constraints: Sequence[MultiPointConstraint]):
"""
Assemble a linear form into a PETSc vector of type "nest"
Parameters
----------
b
A PETSc vector of type "nest"
L
A sequence of linear forms
constraints
An ordered list of multi point constraints
"""
assert len(constraints) == len(L)
assert b.getType() == "nest"
b_sub_vecs = b.getNestSubVecs()
for i, L_row in enumerate(L):
assemble_vector(L_row, constraints[i], b=b_sub_vecs[i])
def apply_lifting_nest(b: PETSc.Vec,
a: typing.List[typing.List[FormMetaClass]],
bcs: typing.List[DirichletBCMetaClass],
x0: typing.Optional[PETSc.Vec] = None,
scale: float = 1.0,
constants=None,
coeffs=None) -> PETSc.Vec:
"""Apply the function :func:`dolfinx.fem.apply_lifting` to each sub-vector in a nested PETSc Vector."""
x0 = [] if x0 is None else x0.getNestSubVecs()
bcs1 = _bcs_by_block(_extract_spaces(a, 1), bcs)
constants = [[form and _pack_constants(form) for form in forms]
for forms in a] if constants is None else constants
coeffs = [[{} if form is None else _pack_coefficients(form)
for form in forms] for forms in a] if coeffs is None else coeffs
for b_sub, a_sub, const, coeff in zip(b.getNestSubVecs(), a, constants,
coeffs):
apply_lifting(b_sub, a_sub, bcs1, x0, scale, const, coeff)
return b