Gridap.CellData

Exported names

CellDatum, CellDof, CellField, CellPoint, CellQuadrature, CellState, DiracDelta, DomainContribution, DomainStyle, GenericCellField, Integrand, Interpolable, KDTreeSearch, Measure, PhysicalDomain, ReferenceDomain, SkeletonCellFieldPair, add_contribution!, attach_constraints_cols, attach_constraints_rows, attach_dirichlet, change_domain, compute_cell_points_from_vector_of_points, cross, det, dot, double_contraction, get_cell_measure, get_cell_points, get_contribution, get_data, get_domains, get_normal_vector, get_physical_coordinate, get_tangent_vector, get_triangulation, gradient, identity_constraints, inner, jump, make_inverse_table, mean, num_domains, outer, symmetric_part, test_cell_datum, tr, update_state!, ×, ∇, ∇∇, ∫, ⊗, ⊙, ⋅, ⋅², ⋅¹,

abstract type CellDatum <: GridapType

Data associated with the cells of a Triangulation. CellDatum objects behave as if they are defined in the physical space of the triangulation. But in some cases they are implemented as reference quantities plus some transformation to the physical domain.

A single point or an array of points on the cells of a Triangulation CellField objects can be evaluated efficiently at CellPoint instances.

This can be used as a CellField as long as one evaluates it on the stored CellPoint.

struct CompositeMeasure <: Measure
  ttrian :: Triangulation
  itrian :: Triangulation
  quad   :: CellQuadrature
end

Measure such that the integration and target triangulations are different.

• ttrian: Target triangulation, where the domain contribution lives.
• itrian: Integration triangulation, where the integration takes place.
• quad : ::CellQuadrature, defined in itrian

const DiracDelta{D} = GenericDiracDelta{D,D,IsGridEntity}

DiracDelta{D}(model::DiscreteModel, degree; tags)
DiracDelta{0}(model::DiscreteModel; tags)
DiracDelta{D}(model::DiscreteModel, labeling::FaceLabeling, degree; tags)
DiracDelta{0}(model::DiscreteModel, labeling::FaceLabeling; tags)
DiracDelta{D}(model::DiscreteModel, face_to_bgface::AbstractVector{<:Integer}, degree)
DiracDelta{D}(model::DiscreteModel, bgface_to_mask::AbstractVector{Bool}, degree)
DiracDelta(   model::DiscreteModel{D}, p::Point{D,T})
DiracDelta(   model::DiscreteModel{D}, pvec::Vector{Point{D,T}})

where degree isa Integer.

struct DomainContribution <: GridapType

Struct to gather contributions from one or several domain(s) (Triangulations).

abstract type DomainStyle

Trait that signals if a <:CellDatum type is implemented in the physical or the reference domain, the possible values are ReferenceDomain() and PhysicalDomain().

DomainStyle(::Type{<:CellDatum})

Tell if the stored array is in the reference or physical domain.

struct Integrand object end
∫(object)

Generic placeholder for a quantity object to be integrated against a CellQuadrature.

struct Interpolable{M,A} <: Function

Interpolable(uh; tol=1e-6, searchmethod=KDTreeSearch(; tol=tol))

abstract type Measure <: GridapType

For measures to integrate against, see integrate.

struct SkeletonCellFieldPair{...}

SkeletonCellFieldPair is a special construct for allowing uh.plus and uh.minus to be two different CellFields. In particular, it is useful when we need one of the CellFields to be the dualized version of the other for performing ForwardDiff AD of a skeleton integration DomainContribution wrt to the degrees of freedom of the CellField, plus and minus sensitivities done separately, so as to restrict the interaction between the dual numbers.

It takes in two CellFields and stores plus version of CellFieldAt of the first CellField and minus version of CellFieldAt of the second the CellField. SkeletonCellFieldPair is associated with same triangulation as that of the CellFields (we check if the triangulations of both CellFields match)

SkeletonCellFieldPair is an internal convenience artifact/construct to aid in dualizing plus and minus side around a skeleton face separately to perform the sensitivity of degrees of freedom of cells sharing the skeleton face, without the interaction dual numbers of the two cells. The user doesn't have to deal with this construct anywhere when performing AD of functionals involving integration over skeleton faces using the public API.

get_array(a::CellDatum)

Get the raw array of a datas defined in the physical space.

add_contribution!(a::DomainContribution, trian::Triangulation, b::AbstractArray, op=+)

attach_constraints_cols(cellmat, cellconstr, cellmask=Fill(true,...))

attach_constraints_rows(cellvec, cellconstr, cellmask=(true,...))

attach_dirichlet(cellmatvec, cellvals, cellmask=(true,...))

change_domain(a::CellDatum, target_domain)
change_domain(a::CellDatum, input_domain, target_domain)

where a isa CellDatum and the domains are DomainStyles. Change the underlying data to the target domain

compute_cell_points_from_vector_of_points(xs::AbstractVector{<:Point},
    trian::Triangulation, domain_style::PhysicalDomain)

distance(poly::ExtrusionPolytope, inv_cmap::Field, x::Point)

Calculate distance from point x to a polytope. The polytope is given by its type poly and by the inverse cell map, i.e. by the map from the physical to the reference space.

Positive distances are outside the polytope, negative distances are inside the polytope.

The distance is measured in an unspecified norm, currently the L∞ norm.

get_cell_measure(trian)
get_cell_measure(strian, ttrian)

where all arguments are Triangulations, returns a vector containing the volume of each cell of [t]trian.

get_contribution(a::DomainContribution, trian::Triangulation)

Returns the array of contributions on trian in a.

get_data(a::CellDatum)

Get the stored array of cell-wise data. It can be defined in the physical or the reference domain.

get_domains(a::DomainContribution)

get_normal_vector(trian::Triangulation)

get_physical_coordinate(trian::Triangulation)

In contrast to getcellmap, the returned object:

• is a CellField
• its gradient is the identity tensor

get_tangent_vector(trian::Triangulation)

identity_constraints(cell_axes)

Dummy constraints for Unconstrained spaces.

jump(a::CellField)
jump(a::SkeletonPair{<:CellField})

Jump operator at interior facets of the supporting Triangulation, defined by jump(a n) = ⟦a n⟧ = a⁺n⁺ + a⁻n⁻, where n is an oriented normal field to the interior facets, n⁺ = -n⁻ are the normal pointing into the element on the + and - side of the facets, and a⁺/a⁻ are the restrictions of a to each element respectively.

make_inverse_table(i2j::AbstractVector{<:Integer}, nj::Int)

num_domains(a::DomainContribution)

update_state!(updater::Function, f::CellField...)

integrate(integrand, dΩ::Measure)
integrate(integrand, dΩ::CellQuadrature)
(integrand::Integrand) * dΩ
∫(quantity) * dΩ
∫(quantity)dΩ

High level integral definition API, the integrand can be created using ∫.

get_triangulation(a::CellDatum)

Return the underlying Triangulation object.

num_cells(a::CellDatum)

Number of cells of a.

mean(a::CellField)

Similar to jump, but for the mean operator a ⟶ (a⁺ + a⁻)/2.