DOF (Degree-of-Freedom) Arrays¶

class meshmode.dof_array.DOFArray(actx: Optional[arraycontext.context.ArrayContext], data: Tuple[Any])¶

This array type holds degree-of-freedom arrays for use with Discretization, with one entry in the DOFArray for each ElementGroupBase. The arrays contained within a DOFArray are expected to be logically two-dimensional, with shape (nelements, ndofs_per_element), where nelements is the same as nelements of the associated group. ndofs_per_element is typically, but not necessarily, the same as nunit_dofs of the associated group. The entries in this array are further arrays managed by array_context.

One main purpose of this class is to describe the data structure, i.e. when a DOFArray occurs inside of further numpy object array, the level representing the array of element groups can be recognized (by people and programs).

array_context¶: An ArrayContext.

entry_dtype¶: The (assumed uniform) numpy.dtype of the group arrays contained in this instance.

__len__()¶

The following methods and attributes are implemented to mimic the functionality of ndarrays. They require the DOFArray to be thaw()ed.

shape¶

size¶

copy()¶

fill(value)¶

conj()¶

real¶

imag¶

Implements the usual set of arithmetic operations, including broadcasting of numbers and over numpy object arrays.

Note

DOFArray instances can be pickled and unpickled while the context manager array_context_for_pickling is active. If, for an array to be pickled, the ArrayContext given to array_context_for_pickling() does not agree with array_context, the array is frozen and rethawed. If array_context is None, the DOFArray is thaw()ed into the array context given to array_context_for_pickling().

meshmode.dof_array.rec_map_dof_array_container(f: Callable[[Any], Any], ary)¶

Applies f recursively to an ArrayContainer.

Similar to map_array_container(), but does not further recurse on DOFArrays.

meshmode.dof_array.mapped_over_dof_arrays(f)¶

meshmode.dof_array.rec_multimap_dof_array_container(f: Callable[[Any], Any], *args)¶

Applies f recursively to multiple ArrayContainers.

Similar to multimap_array_container(), but does not further recurse on DOFArrays.

meshmode.dof_array.multimapped_over_dof_arrays(f)¶

meshmode.dof_array.flatten(ary: arraycontext.container.ArrayContainer, *, strict: bool = True) → arraycontext.container.ArrayContainer ¶

Convert all DOFArrays into a “flat” array of degrees of freedom, where the resulting type of the array is given by the DOFArray.array_context.

Array elements are laid out contiguously, with the element group index varying slowest, element index next, and intra-element DOF index fastest.

Recurses into the ArrayContainer for all DOFArrays.

Parameters: strict – if True, only DOFArrays are allowed as leaves in the container ary. If False, any non-DOFArray are left as is.

meshmode.dof_array.unflatten(actx: arraycontext.context.ArrayContext, discr, ary: arraycontext.container.ArrayContainer, ndofs_per_element_per_group: Optional[Iterable[int]] = None, *, strict: bool = True) → arraycontext.container.ArrayContainer ¶

Convert all “flat” arrays returned by flatten() back to DOFArrays.

This function recurses into the ArrayContainer for all DOFArrays. All class:DOFArrays inside the container ary must agree on the mapping from element group number to number of degrees of freedom, as given by ndofs_per_element_per_group (or via discr).

Parameters

ndofs_per_element – if given, an iterable of numbers representing the number of degrees of freedom per element, overriding the numbers provided by the element groups in discr. May be used (for example) to handle DOFArrays that have only one DOF per element, representing some per-element quantity.
strict – if True, only DOFArrays are allowed as leaves in the container ary. If False, any non-DOFArray are left as is.

meshmode.dof_array.unflatten_like(actx: arraycontext.context.ArrayContext, ary: arraycontext.container.ArrayContainer, prototype: arraycontext.container.ArrayContainer, *, strict: bool = True) → arraycontext.container.ArrayContainer ¶

Convert all “flat” arrays returned by flatten() back to DOFArrays based on a prototype container.

This function allows doing a roundtrip with flatten() for containers which have DOFArrays with different numbers of degrees of freedom. This is unlike unflatten(), where all the DOFArrays must agree on the number of degrees of freedom per element group. For example, this enables “unflattening” of arrays associated with different Discretizations within the same container.

Parameters

prototype – an array container with the same structure as ary, whose DOFArray leaves are used to get the sizes to unflatten ary.
strict – if True, only DOFArrays are allowed as leaves in the container ary. If False, any non-DOFArray are left as is.

meshmode.dof_array.flatten_to_numpy(actx: arraycontext.context.ArrayContext, ary: arraycontext.container.ArrayContainer, *, strict: bool = True) → arraycontext.container.ArrayContainer ¶: Converts all DOFArrays into “flat” numpy.ndarrays using flatten().

meshmode.dof_array.unflatten_from_numpy(actx: arraycontext.context.ArrayContext, discr, ary: arraycontext.container.ArrayContainer, ndofs_per_element_per_group: Optional[Iterable[int]] = None, *, strict: bool = True) → arraycontext.container.ArrayContainer ¶: Takes “flat” arrays returned by flatten_to_numpy() and reconstructs the corresponding DOFArrays using unflatten().

meshmode.dof_array.flat_norm(ary, ord=None) → float ¶

Return an element-wise \(\ell^{\text{ord}}\) norm of ary.

Parameters: ary – may be a DOFArray or a ArrayContainer containing them.

meshmode.dof_array.array_context_for_pickling(actx: arraycontext.context.ArrayContext)¶: A context manager that, for the current thread, sets the array context to be used for pickling and unpickling DOFArrays to actx.

New in version 2021.1.

DOF (Degree-of-Freedom) Arrays¶

Array Contexts¶