Gridap.Fields

Exported names

AffineField, ArrayBlock, ArrayBlockView, BlockMap, ConstantField, DIV, DensifyInnerMostBlockLevelMap, Field, FieldGradient, FieldGradientArray, GenericField, IntegrationMap, MatrixBlock, MatrixBlockView, MockField, MockFieldArray, Point, VectorBlock, VectorBlockView, VoidBasis, VoidBasisMap, VoidField, VoidFieldMap, ZeroField, affine_map, constant_field, curl, divergence, evaluate, evaluate!, grad2curl, gradient, gradient_type, integrate, inverse_map, laplacian, linear_combination, pinvJt, push_∇, push_∇∇, return_cache, return_type, symmetric_gradient, test_field, test_field_array, Δ, ε, ∇, ∇∇,

struct AffineField{D1,D2,T,L} <: Field

A Field with the form:

y = x⋅G + y0

with G::TensorValue{D1,D2,T,L} and y0::Point{D2,T}.

struct AffineMap <: Map

Type that represents a broadcast operation over a set of AbstractArray{<:Field}. The result is a sub-type of AbstractArray{<:Field}

struct ConstantField{T<:Number} <: Field

Constant field with value of type T.

struct DensifyInnerMostBlockLevelMap <: Map

abstract type Field <: Map

Abstract type representing a physical (scalar, vector, or tensor) field. The domain is a Point and the range a scalar (i.e., a sub-type of Julia Number), a VectorValue, or a TensorValue.

These different cases are distinguished by the return value obtained when evaluating them. E.g., a physical field returns a vector of values when evaluated at a vector of points, and a basis of nf fields returns a 2d matrix (np x nf) when evaluated at a vector of np points.

The following functions (i.e., the Map API) need to be overloaded:

• evaluate!(cache,f,x)
• return_cache(f,x)

and optionally

• return_type(f,x)

A Field can also provide its gradient if the following function is implemented

• gradient(f)

Higher derivatives can be obtained if the resulting object also implements this method.

The interface can be tested with

• test_field

For performance, the user can also consider a vectorised version of the Field API that evaluates the field in a vector of points (instead of only one point). E.g., the evaluate! function for a vector of points returns a vector of scalar, vector or tensor values.

struct FieldGradient{N,F} <: Field

Type that represents the gradient of a field F. The wrapped field must implement evaluate_gradient! and return_gradient_cache for this gradient to work.

N is how many times the gradient is applied.

A wrapper that represents the broadcast of gradient over an array of fields. Ng is the number of times the gradient is applied

struct GenericField{T} <: Field

A wrapper for objects that can act as fields, e.g., functions which implement the Field API.

struct IntegrationMap <: Map

Map for low level integrate, that is computation of vectorized discrete quadratures.

struct MockField{T<:Number} <: Field

For tests.

struct MockFieldArray{N,A} <: AbstractArray{GenericField{Nothing},N}

For tests.

struct OperationField{O,F} <: Field

A Field that is obtained as a given operation op::O over a tuple of fields fields::F.

const Point{D,T} = VectorValue{D,T}

Type representing a point of D dimensions with coordinates of type T. Fields are evaluated at vectors of Point objects.

Given a matrix np x nf1 x nf2 result of the evaluation of a field vector on a vector of points, it returns an array in which the field axes (second and third axes) are permuted. It is equivalent as Base.permutedims(A,(1,3,2)) but more performant, since it does not involve allocations.

struct VoidBasis{T,N,A} <: AbstractArray{T,N}

struct VoidBasisMap <: Map

struct VoidField{F} <: Field

struct VoidFieldMap <: Map

struct ZeroField{F} <: Field

It represents 0.0*f for a field f::F.

f∘g

It returns the composition of two fields, which is just Operation(f)(g)

Implementation of return_cache for a array of Field.

If the field vector has length nf and it is evaluated in one point, it returns an nf vector with the result. If the same array is applied to a vector of np points, it returns a matrix np x nf.

DIV(f)

Reference space divergence.

affine_map(gradient, origin) = AffineField(gradient, origin)

See AffineField.

constant_field(value) = ConstantField(value)

See ConstantField.

curl(f)

Abstract curl operator, formally equivalent to

• f -> ∂₁f₂ - ∂₂f₁ for 2D vector functions, or
• f -> ∇×f for 3D vector functions.

divergence(f)

Abstract divergence operator, formally equivalent to f -> ∇⋅f.

grad2curl(∇f)

Return

• ∇f[1,2] - ∇f[2,1] for 2×2 input tensor, or
• VectorValue(∇f[2,3] - ∇f[3,2], ∇f[3,1] - ∇f[1,3], ∇f[1,2] - ∇f[2,1]) for 3×3 input tensor.

function gradient end

Abstract gradient operator, see Field.

gradient_type(::Type{T}, x::Point) where T

Tensor type of the gradient of a T valued function.

integrate(a::AbstractArray{<:Field},q::AbstractVector{<:Point},w::AbstractVector{<:Real},j::Field)

Integration of a given array of fields in the "reference" space

integrate(a::AbstractArray{<:Field},x::AbstractVector{<:Point},w::AbstractVector{<:Real})

Integration of a given array of fields in the "physical" space

integrate(a::Field,q::AbstractVector{<:Point},w::AbstractVector{<:Real},j::Field)

Numerical integration of a given field in the "reference" space. j is the Jacobian field of the geometrical mapping .

integrate(a::Field,x::AbstractVector{<:Point},w::AbstractVector{<:Real})

Numerical integration of a given field in the "physical" space. a is the field, x the quadrature points and w the quadrature weights.

laplacian(f)

Abstract laplacian operator, equivalent to tr(∇∇(f)).

linear_combination(a::AbstractVector{<:Number}, b::AbstractVector{<:Field})
linear_combination(a::AbstractMatrix{<:Number}, b::AbstractVector{<:Field})

function pinvJt(Jt::MultiValue{Tuple{D,D}}) = inv(Jt)
function pinvJt(Jt::MultiValue{Tuple{D1,D2}}) = transpose(inv(Jt⋅transpose(J))⋅Jt)

push_∇(∇a::Field, ϕ::Field) = pinvJt(∇(ϕ))⋅∇a

Pushforward of ∇a by the mapping ϕ, or covariant Piola transform.

skew_symmetric_gradient(f)

Abstract skew symmetric gradient operator, formally equivalent to f -> ½(∇f - (∇f)ᵀ).

symmetric_gradient(f)

Abstract symmetric gradient operator, formally equivalent to f -> ½(∇f + (∇f)ᵀ).

test_field(
  f::Union{Field,AbstractArray{<:Field}},
  x,
  v,
  cmp=(==);
  grad=nothing,
  gradgrad=nothing)

Function used to test the field interface. v is an array containing the expected result of evaluating the field f at the point or vector of points x. The comparison is performed using the cmp function. For fields objects that support the gradient function, the keyword argument grad can be used. It should contain the result of evaluating gradient(f) at x. Idem for gradgrad. The checks are performed with the @test macro.

test_field_array(f::AbstractArray{<:Field}, x, v, cmp=(==); grad=nothing, gradgrad=nothing)

For tests.

const Δ = laplacian

Alias for laplacian.

const ε = symmetric_gradient

Alias for the symmetric_gradient.

∇∇(f) = gradient(gradient(f))

Abstract hessian operator.

outer(f,∇)
f⊗∇

Equivalent to transpose(gradient(f)).

outer(∇,f)
∇⊗f

Equivalent to gradient(f).

cross(∇,f)
∇×f

Equivalent to curl(f).

∇⋅f

Equivalent to divergence(f).