DOF (Degree-of-Freedom) Arrays

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

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__()[source]

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

shape
size
copy()[source]
fill(value)[source]
conj()[source]
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)[source]

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)[source]
meshmode.dof_array.rec_multimap_dof_array_container(f: Callable[[Any], Any], *args)[source]

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)[source]
meshmode.dof_array.flatten(ary: arraycontext.container.ArrayContainer, *, strict: bool = True) arraycontext.container.ArrayContainer[source]

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[source]

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[source]

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[source]

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[source]

Takes “flat” arrays returned by flatten_to_numpy() and reconstructs the corresponding DOFArrays using unflatten().

meshmode.dof_array.flat_norm(ary, ord=None) Any[source]

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)[source]

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.

exception meshmode.dof_array.InconsistentDOFArray[source]
meshmode.dof_array.check_dofarray_against_discr(discr, dof_ary: meshmode.dof_array.DOFArray)[source]

Verify that the DOFArray dof_ary is consistent with the discretization discr, in terms of things like group count, number of elements, and number of DOFs per element. If a discrepancy is detected, InconsistentDOFArray is raised.

Parameters

discr – a Discretization against which dof_ary is to be checked.

Array Contexts

class meshmode.array_context.PyOpenCLArrayContext(queue: pyopencl.CommandQueue, allocator: Optional[pyopencl.tools.AllocatorInterface] = None, wait_event_queue_length: Optional[int] = None, force_device_scalars: bool = False)[source]

Extends arraycontext.PyOpenCLArrayContext with knowledge about program transformation for finite element programs.

See meshmode.transform_metadata for relevant metadata.

class meshmode.array_context.PytatoPyOpenCLArrayContext(queue, allocator=None)[source]

Metadata for Program Transformation

class meshmode.transform_metadata.FirstAxisIsElementsTag[source]

A tag that is applicable to array outputs indicating that the first index corresponds to element indices. This suggests that the implementation should set element indices as the outermost loop extent.

For convenience, this tag may also be applied to a kernel if that kernel contains exactly one assignment, in which case the tag is considered equivalent to being applied to the (single) output array argument.

class meshmode.transform_metadata.ConcurrentElementInameTag[source]

A tag applicable to an iname indicating that this iname is used to iterate over elements in a discretization. States that no dependencies exist between elements, i.e. that computations for all elements may be performed concurrently.

class meshmode.transform_metadata.ConcurrentDOFInameTag[source]

A tag applicable to an iname indicating that this iname is used to iterate over degrees of freedom (DOFs) within an element in a discretization. States that no dependencies exist between output DOFs, i.e. that computations for all DOFs within each element may be performed concurrently.