api.fem#

Functions#

`collect_spaces`(space, *args)	This function collect the arguments used in the assembly function
`compute_diag_len`(p, md, mc)
`construct_quad_grids_arguments`(grid[, ...])
`construct_test_space_arguments`(basis_values)
`construct_trial_space_arguments`(basis_values)
`do_nothing`(*args)
`extract_stencil_mats`(mats)
`reset_arrays`(*args)

Classes#

`DiscreteBilinearForm`(expr, kernel_expr, ...)	Discrete bilinear form ready to be assembled into a matrix.
`DiscreteFunctional`(expr, kernel_expr, ...[, ...])	Discrete functional ready to be assembled into a scalar (real or complex).
`DiscreteLinearForm`(expr, kernel_expr, ...[, ...])	Discrete linear form ready to be assembled into a vector.
`DiscreteSesquilinearForm`(expr, kernel_expr, ...)	Class that represents the concept of a discrete sesqui-linear form with the antilinearity on the first variable.
`DiscreteSumForm`(a, kernel_expr, args, *kwargs)

Details#

collect_spaces(space, *args)[source]#

This function collect the arguments used in the assembly function

Parameters:

space: <FunctionSpace>: the symbolic space
args<list>: list of discrete space components like basis values, spans, …

Returns:

args<list>: list of discrete space components elements used in the asembly

compute_diag_len(p, md, mc)[source]#

construct_test_space_arguments(basis_values)[source]#

construct_trial_space_arguments(basis_values)[source]#

construct_quad_grids_arguments(grid, use_weights=True)[source]#

reset_arrays(*args)[source]#

do_nothing(*args)[source]#

extract_stencil_mats(mats)[source]#

class DiscreteBilinearForm(expr, kernel_expr, domain_h, spaces, *, nquads, matrix=None, update_ghost_regions=True, backend=None, linalg_backend=None, assembly_backend=None, symbolic_mapping=None)[source]#

Bases: BasicDiscrete

Discrete bilinear form ready to be assembled into a matrix.

This class represents the concept of a discrete bilinear form in Psydac. Instances of this class generate an appropriate matrix assembly kernel, allocate the matrix if not provided, and prepare a list of arguments for the kernel.

Parameters:

exprsympde.expr.expr.BilinearForm: The symbolic bilinear form.
kernel_exprsympde.expr.evaluation.KernelExpression: The atomic representation of the bilinear form.
domain_hGeometry: The discretized domain.
spaceslist of FemSpace: The discrete trial and test spaces.
nquadslist or tuple of int: The number of quadrature points used in the assembly kernel along each direction.
matrixStencilMatrix or BlockLinearOperator, optional: The matrix that we assemble into. If not provided, a new matrix is created with the appropriate domain and codomain (default: None).
update_ghost_regionsbool, default=True: Accumulate the contributions of the neighbouring processes.
backenddict, optional: The backend used to accelerate the computing kernels. The backend dictionaries are defined in the file psydac/api/settings.py
assembly_backenddict, optional: The backend used to accelerate the assembly kernel. The backend dictionaries are defined in the file psydac/api/settings.py
linalg_backenddict, optional: The backend used to accelerate the computing kernels of the linear operator. The backend dictionaries are defined in the file psydac/api/settings.py
symbolic_mappingSympde.topology.Mapping, optional: The symbolic mapping which defines the physical domain of the bilinear form.

See also

DiscreteBilinearForm
DiscreteLinearForm
DiscreteSumForm

property domain#

property target#

property space#

property grid#

property nquads#

property test_basis#

get_space_indices_from_target(domain, target)[source]#

construct_arguments()[source]#

Collect the arguments used in the assembly method.

Returns:

args: tuple: The arguments passed to the assembly method.

assemble(**kwargs)[source]#

This method assembles the square of the functional expression with the given arguments and then compute the square root of the absolute value of the result.

Examples

>>> n = SemiNorm(1.0j*v, domain, kind='l2')
>>> nh = discretize(n, domain_h,      Vh , **kwargs)
>>> fh = FemField(Vh)
>>> fh.coeffs[:] = 1
>>> n_value = nh.assemble(v=fh)

In n_value we have the value of np.sqrt(abs(sum((1.0jv)**2)))

class DiscreteLinearForm(expr, kernel_expr, domain_h, space, *, nquads, vector=None, update_ghost_regions=True, backend=None, symbolic_mapping=None)[source]#

Bases: BasicDiscrete

Discrete linear form ready to be assembled into a vector.

This class represents the concept of a discrete linear form in Psydac. Instances of this class generate an appropriate vector assembly kernel, allocate the vector if not provided, and prepare a list of arguments for the kernel.

Parameters:

exprsympde.expr.expr.LinearForm: The symbolic linear form.
kernel_exprsympde.expr.evaluation.KernelExpression: The atomic representation of the linear form.
domain_hGeometry: The discretized domain.
spaceFemSpace: The discrete test space.
nquadslist or tuple of int: The number of quadrature points used in the assembly kernel along each direction.
vectorStencilVector or BlockVector, optional: The vector that we assemble into. If not provided, a new vector of the appropriate space is created.
update_ghost_regionsbool, default=False: Accumulate the contributions of the neighbouring processes.
backenddict, optional: The backend used to accelerate the computing kernels. The backend dictionaries are defined in the file psydac/api/settings.py
symbolic_mappingSympde.topology.Mapping, optional: The symbolic mapping which defines the physical domain of the linear form.