Gridap.Geometry

Exported names are

• BoundaryTriangulation
• CartesianDescriptor
• CartesianDiscreteModel
• CartesianGrid
• CellField
• CellQuadrature
• DiscreteModel
• DiscreteModelFromFile
• FaceLabeling
• GenericBoundaryTriangulation
• GenericCellField
• Grid
• GridPortion
• GridTopology
• OrientationStyle
• RegularityStyle
• SkeletonCellField
• SkeletonPair
• SkeletonTriangulation
• Triangulation
• TriangulationPortion
• UnstructuredDiscreteModel
• UnstructuredGrid
• UnstructuredGridTopology
• add_tag!
• add_tag_from_tags!
• compute_cell_faces
• compute_cell_permutations
• compute_face_nodes
• compute_face_own_nodes
• compute_face_vertices
• compute_isboundary_face
• compute_linear_grid
• compute_node_face_owner
• compute_reference_grid
• compute_reffaces
• compute_vertex_node
• convert_to_cell_field
• get_cartesian_descriptor
• get_cell_coordinates
• get_cell_faces
• get_cell_id
• get_cell_map
• get_cell_nodes
• get_cell_permutations
• get_cell_reffes
• get_cell_shapefuns
• get_cell_type
• get_cell_vertices
• get_face_entity
• get_face_labeling
• get_face_mask
• get_face_tag
• get_face_tag_index
• get_face_to_cell
• get_face_to_cell_map
• get_grid
• get_grid_topology
• get_isboundary_face
• get_node_face_owner
• get_normal_vector
• get_physical_coordinate
• get_polytopes
• get_reffaces_offsets
• get_reffes
• get_tag_entities
• get_tag_from_name
• get_tag_name
• get_tags_from_names
• get_triangulation
• get_volume_triangulation
• is_oriented
• is_regular
• jump
• mean
• num_cells
• num_entities
• num_tags
• restrict
• similar_object
• test_boundary_triangulation
• test_cell_field
• test_discrete_model
• test_grid
• test_grid_topology
• test_triangulation

abstract type Triangulation{Dc,Dp}

Abstract type representing an arbitrary tiling, tessellation, or triangulation of a domain of parametric dimension Dc and physical dimension Dp.

We define a triangulation from two basic ingredients:

• the cell-wise nodal coordinates of the cells in the triangulation, plus
• an interpolation of this cell-wise coordinates into the cells interior.

Note that this type represents general triangulations (not necessarily conforming), which is the minimum geometrical information needed to perform cell-wise numerical integration.

The Triangulation interface is defined by overloading these methods:

• get_cell_coordinates(trian::Triangulation)
• get_reffes(trian::Triangulation)
• get_cell_type(trian::Triangulation)

Optional interface:

For triangulations living in a space of co-dimension 1, the following method can be defined:

• [get_normal_vector(trian::Triangulation)]

In some cases, concrete implementations want to override the default implementation of the following methods:

• [restrict(f::AbstractArray, trian::Triangulation)]
• [get_cell_id(f::AbstractArray, trian::Triangulation)]

The (mandatory) Triangulation interface can be tested with

• test_triangulation

get_cell_coordinates(trian::Triangulation) -> AbstractArray{Vector{<:Point{Dp}}}

get_reffes(trian::Triangulation) -> Vector{LagrangianRefFE}

get_cell_type(trian::Triangulation) -> AbstractVector{<:Integer}

get_normal_vector(trian::Triangulation)

restrict(f::AbstractArray, trian::Triangulation)

reindex(a::AbstractArray, trian::Triangulation)

test_triangulation(trian::Triangulation)

num_cells(trian::Triangulation) -> Int

num_cell_dims(::GridTopology) -> Int
num_cell_dims(::Type{<:GridTopology}) -> Int

num_cell_dims(::Triangulation) -> Int
num_cell_dims(::Type{<:Triangulation}) -> Int

num_point_dims(::Quadrature{D}) where D
num_point_dims(::Type{<:Quadrature{D}}) where D

num_point_dims(::GridTopology) -> Int
num_point_dims(::Type{<:GridTopology}) -> Int

num_point_dims(::Triangulation) -> Int
num_point_dims(::Type{<:Triangulation}) -> Int

num_dims(::Quadrature{D}) where D where D
num_dims(::Type{<:Quadrature{D}}) where D

num_dims(::GridTopology) -> Int
num_dims(::Type{<:GridTopology}) -> Int

Equivalent to num_cell_dims.

num_dims(::Triangulation) -> Int
num_dims(::Type{<:Triangulation}) -> Int

Equivalent to num_cell_dims.

is_affine(trian::Triangulation) -> Bool

is_first_order(trian::Triangulation) -> Bool

get_cell_reffes(trian::Triangulation) -> Vector{<:NodalReferenceFEs}

It is not desirable to iterate over the resulting array for large number of cells if the underlying reference FEs are of different Julia type.

get_cell_shapefuns(trian::Triangulation) -> Vector{<:Field}

get_cell_map(trian::Triangulation) -> Vector{<:Field}

get_physical_coordinate(trian::Triangulation)

In contrast to getcellmap, the returned object:

• is a CellField
• its gradient is the identity tensor

struct CellQuadrature <: GridapType
  array
end

CellQuadrature(array::AbstractArray{<:Quadrature})

CellQuadrature(trian::Triangulation, degree::Integer)

CellQuadrature(polytopes::Vector{<:Polytope}, cell_types::AbstractVector)

get_coordinates(q::CellQuadrature)

get_weights(q::CellQuadrature)

get_array(quad::CellQuadrature)

integrate(cell_field,trian::Triangulation,quad::CellQuadrature)

The cell_field is aligned with the cells in trian

abstract type BoundaryTriangulation{Dc,Dp} <: Triangulation{Dc,Dp}

BoundaryTriangulation(model::DiscreteModel,face_to_mask::Vector{Bool})
BoundaryTriangulation(model::DiscreteModel)

BoundaryTriangulation(model::DiscreteModel,tags::Vector{Int})
BoundaryTriangulation(model::DiscreteModel,tags::Vector{String})
BoundaryTriangulation(model::DiscreteModel,tag::Int)
BoundaryTriangulation(model::DiscreteModel,tag::String)

get_volume_triangulation(trian::BoundaryTriangulation)

test_boundary_triangulation(trian::BoundaryTriangulation)

struct GenericBoundaryTriangulation{Dc,Dp,Gf,Gc,O} <: BoundaryTriangulation{Dc,Dp}
  face_trian::Gf
  cell_trian::Gc
  # + private fields
end

GenericBoundaryTriangulation(model::DiscreteModel,face_to_mask::Vector{Bool})

struct SkeletonTriangulation{Dc,Dp,B} <: Triangulation{Dc,Dp}
  left::B
  right::B
end

The inner constructor enforces B<:BoundaryTriangulation

SkeletonTriangulation(model::DiscreteModel,face_to_mask::Vector{Bool})
SkeletonTriangulation(model::DiscreteModel)

get_volume_triangulation(trian::SkeletonTriangulation)

get_normal_vector(trian::SkeletonTriangulation)

struct SkeletonPair{L,R} <: GridapType
  left::L
  right::R
end

abstract type Grid{Dc,Dp} <: Triangulation{Dc,Dp}

Abstract type that represents conforming triangulations, whose cell-wise nodal coordinates are defined with a vector of nodal coordinates, plus a cell-wise vector of node ids.

The interface of Grid is defined by overloading the methods in Triangulation plus the following ones:

• get_node_coordinates(trian::Grid)
• get_cell_nodes(trian::Grid)

From these two methods a default implementation of get_cell_coordinates(trian::Triangulation) is available.

The Grid interface has the following traits

• OrientationStyle(::Type{<:Grid})
• RegularityStyle(::Type{<:Grid})

The interface of Grid is tested with

• test_grid

OrientationStyle(::Type{<:Grid}) -> Val{Bool}
OrientationStyle(::Grid) -> Val{Bool}

Val{true}() if has oriented faces, Val{false}() otherwise (default).

RegularityStyle(::Type{<:Grid}) -> Val{Bool}
RegularityStyle(::Grid) -> Val{Bool}

Val{true}() if no hanging-nodes (refault), Val{false}() otherwise.

get_node_coordinates(trian::Grid) -> AbstractArray{<:Point{Dp}}

get_cell_nodes(trian::Grid)

test_grid(trian::Grid)

num_nodes(trian::Grid) -> Int

is_oriented(::Type{<:Grid}) -> Bool
is_oriented(a::Grid) -> Bool

is_regular(::Type{<:Grid}) -> Bool
is_regular(a::Grid) -> Bool

Grid(reffe::LagrangianRefFE)

compute_linear_grid(reffe::LagrangianRefFE)

compute_reference_grid(p::LagrangianRefFE, nelems::Integer)

Grid(::Type{ReferenceFE{d}},p::Polytope) where d

GridTopology(grid::Grid)
GridTopology(grid::Grid, cell_to_vertices::Table, vertex_to_node::Vector)

simplexify(grid::Grid)

struct UnstructuredGrid{Dc,Dp,Tp,Ti,O} <: Grid{Dc,Dp}
  node_coordinates::Vector{Point{Dp,Tp}}
  cell_nodes::Table{Ti,Int32}
  reffes::Vector{<:NodalReferenceFE{Dc}}
  cell_types::Vector{Int8}
end

function UnstructuredGrid(
  node_coordinates::Vector{Point{Dp,Tp}},
  cell_nodes::Table{Ti},
  reffes::Vector{<:NodalReferenceFE{Dc}},
  cell_types::Vector,
  ::Val{B}=Val{false}()) where {Dc,Dp,Tp,Ti,B}
end

Low-level inner constructor.

UnstructuredGrid(trian::Grid)

UnstructuredGrid(reffe::LagrangianRefFE)

Build a grid with a single cell that is the given reference FE itself

UnstructuredGrid(::Type{ReferenceFE{d}},p::Polytope) where d

UnstructuredGrid(x::AbstractArray{<:Point})

UnstructuredGridTopology(grid::UnstructuredGrid)

UnstructuredGridTopology(
  grid::UnstructuredGrid,
  cell_to_vertices::Table,
  vertex_to_node::AbstractVector)

struct CartesianGrid{D,T,F} <: Grid{D,D}
  # private fields
end

CartesianGrid(desc::CartesianDescriptor)

CartesianGrid(domain,partition,map::Function=identity)

get_cartesian_descriptor(grid::CartesianGrid)

Get the descriptor of the Cartesian grid

struct CartesianDescriptor{D,T,F<:Function}
  origin::Point{D,T}
  sizes::Point{D,T}
  partition::Point{D,Int}
  map::F
end

Struct that stores the data defining a Cartesian grid.

CartesianDescriptor(origin,sizes,partition,map::Function=identity)

CartesianDescriptor(domain,partition,map::Function=identity)

struct GridPortion{Dc,Dp,G} <: Grid{Dc,Dp}
  oldgrid::G
  cell_to_oldcell::Vector{Int}
  node_to_oldnode::Vector{Int}
end

GridPortion(oldgrid::Grid{Dc,Dp},cell_to_oldcell::Vector{Int}) where {Dc,Dp}

struct FaceLabeling <: GridapType
  d_to_dface_to_entity::Vector{Vector{Int32}}
  tag_to_entities::Vector{Vector{Int32}}
  tag_to_name::Vector{String}
end

FaceLabeling(d_to_num_dfaces::Vector{Int})
FaceLabeling(topo::GridTopology)

num_dims(lab::FaceLabeling)

num_cell_dims(lab::FaceLabeling)

num_tags(lab::FaceLabeling)

num_entities(lab::FaceLabeling)

num_faces(lab::FaceLabeling,d::Integer)

num_faces(lab::FaceLabeling)

num_vertices(lab::FaceLabeling)

num_edges(lab::FaceLabeling)

num_facets(lab::FaceLabeling)

num_cells(lab::FaceLabeling)

get_face_entity(lab::FaceLabeling,d::Integer)

get_face_entity(lab::FaceLabeling)

get_tag_entities(lab::FaceLabeling,tag::Integer)
get_tag_entities(lab::FaceLabeling,tag::String)

get_tag_entities(lab::FaceLabeling)

get_tag_name(lab::FaceLabeling,tag::Integer)

get_tag_name(lab::FaceLabeling)

get_tag_from_name(lab::FaceLabeling,name::String)

get_tag_from_name(lab::FaceLabeling)

get_tags_from_names(lab::FaceLabeling,names::Vector{String})

get_face_mask(labeling::FaceLabeling,tags::Vector{Int},d::Integer)
get_face_mask(labeling::FaceLabeling,tags::Vector{String},d::Integer)
get_face_mask(labeling::FaceLabeling,tag::Int,d::Integer)
get_face_mask(labeling::FaceLabeling,tag::String,d::Integer)

add_tag!(lab::FaceLabeling,name::String,entities::Vector{<:Integer})

add_tag_from_tags!(lab::FaceLabeling, name::String, tags::Vector{Int})
add_tag_from_tags!(lab::FaceLabeling, name::String, tags::Vector{String})
add_tag_from_tags!(lab::FaceLabeling, name::String, tag::Int)
add_tag_from_tags!(lab::FaceLabeling, name::String, tag::String)

get_face_tag(labeling::FaceLabeling,tags::Vector{Int},d::Integer)
get_face_tag(labeling::FaceLabeling,tags::Vector{String},d::Integer)
get_face_tag(labeling::FaceLabeling,tag::Int,d::Integer)
get_face_tag(labeling::FaceLabeling,tag::String,d::Integer)
get_face_tag(labeling::FaceLabeling,d::Integer)

The first of the given tags appearing in the face is taken. If there is no tag on a face, this face will have a value equal to UNSET. If not tag or tags are provided, all the tags in the model are considered

get_face_tag_index(labeling::FaceLabeling,tags::Vector{Int},d::Integer)
get_face_tag_index(labeling::FaceLabeling,tags::Vector{String},d::Integer)
get_face_tag_index(labeling::FaceLabeling,tag::Int,d::Integer)
get_face_tag_index(labeling::FaceLabeling,tag::String,d::Integer)

Like get_face_tag by provides the index into the array tags instead of the tag stored in tags.

abstract type GridTopology{Dc,Dp}

Abstract type representing the topological information associated with a grid.

The GridTopology interface is defined by overloading the methods:

• get_faces(g::GridTopology,dimfrom::Integer,dimto::Integer)
• get_polytopes(g::GridTopology)
• get_cell_type(g::GridTopology)
• get_vertex_coordinates(g::GridTopology)

The GridTopology interface has the following traits

• OrientationStyle(::Type{<:GridTopology})
• RegularityStyle(::Type{<:GridTopology})

and tested with this function:

• test_grid_topology

OrientationStyle(::Type{<:GridTopology}) -> Val{Bool}
OrientationStyle(::GridTopology) -> Val{Bool}

Val{true}() if has oriented faces, Val{false}() otherwise (default).

RegularityStyle(::Type{<:GridTopology}) -> Val{Bool}
RegularityStyle(::GridTopology) -> Val{Bool}

Val{true}() if no hanging-faces (refault), Val{false}() otherwise.

get_faces(g::GridTopology,dimfrom::Integer,dimto::Integer)

get_polytopes(g::GridTopology)

get_cell_type(g::GridTopology)

get_vertex_coordinates(g::GridTopology)

test_grid_topology(top::GridTopology)

num_cell_dims(::GridTopology) -> Int
num_cell_dims(::Type{<:GridTopology}) -> Int

num_cell_dims(::Triangulation) -> Int
num_cell_dims(::Type{<:Triangulation}) -> Int

num_point_dims(::Quadrature{D}) where D
num_point_dims(::Type{<:Quadrature{D}}) where D

num_point_dims(::GridTopology) -> Int
num_point_dims(::Type{<:GridTopology}) -> Int

num_point_dims(::Triangulation) -> Int
num_point_dims(::Type{<:Triangulation}) -> Int

num_dims(::Quadrature{D}) where D where D
num_dims(::Type{<:Quadrature{D}}) where D

num_dims(::GridTopology) -> Int
num_dims(::Type{<:GridTopology}) -> Int

Equivalent to num_cell_dims.

num_dims(::Triangulation) -> Int
num_dims(::Type{<:Triangulation}) -> Int

Equivalent to num_cell_dims.

num_faces(g::GridTopology,d::Integer)
num_faces(g::GridTopology)

num_cells(g::GridTopology)

num_facets(g::GridTopology)

num_edges(g::GridTopology)

num_vertices(g::GridTopology)

get_dimranges(g::GridTopology)

get_dimrange(g::GridTopology,d::Integer)

get_offsets(g::GridTopology)

get_offset(g::GridTopology,d::Integer)

get_facedims(g::GridTopology)

get_cell_faces(g::GridTopology)

Defaults to

compute_cell_faces(g)

compute_cell_faces(g::GridTopology)

get_face_vertices(g::GridTopology,d::Integer)

get_face_vertices(g::GridTopology)

Defaults to

compute_face_vertices(g)

compute_face_vertices(g::GridTopology)

get_cell_vertices(g::GridTopology)

is_simplex(p::GridTopology) -> Bool

is_n_cube(p::GridTopology) -> Bool

is_oriented(::Type{<:GridTopology}) -> Bool
is_oriented(a::GridTopology) -> Bool

is_regular(::Type{<:GridTopology}) -> Bool
is_regular(a::GridTopology) -> Bool

get_reffaces(::Type{Polytope{d}}, g::GridTopology) where d

By default, it calls to compute_reffaces.

get_face_type(g::GridTopology,d::Integer)

By default, it calls to compute_reffaces.

compute_reffaces(::Type{Polytope{d}}, g::GridTopology) where d

get_reffaces(topo::GridTopology)

get_face_type(topo::GridTopology)

get_reffaces_offsets(topo::GridTopology)

compute_reffaces(g::GridTopology)

get_isboundary_face(g::GridTopology)

get_isboundary_face(g::GridTopology,d::Integer)

compute_isboundary_face(g::GridTopology)

compute_isboundary_face(g::GridTopology,d::Integer)

get_cell_permutations(top::GridTopology)

get_cell_permutations(top::GridTopology,d::Integer)

compute_cell_permutations(top::GridTopology)

compute_cell_permutations(top::GridTopology,d::Integer)

struct UnstructuredGridTopology{Dc,Dp,T,O} <: GridTopology{Dc,Dp}
  # private fields
end

UnstructuredGridTopology(
  vertex_coordinates::Vector{<:Point},
  cell_vertices::Table,
  cell_type::Vector{<:Integer},
  polytopes::Vector{<:Polytope},
  orientation::Val{O}=Val{false}()) where O

UnstructuredGridTopology(
  vertex_coordinates::Vector{<:Point},
  d_to_dface_vertices::Vector{<:Table},
  cell_type::Vector{<:Integer},
  polytopes::Vector{<:Polytope},
  orientation::Val{O}=Val{false}()) where O

abstract type DiscreteModel{Dc,Dp} <: GridapType

Abstract type holding information about a physical grid, the underlying grid topology, and a labeling of the grid faces. This is the information that typically provides a mesh generator, and it is what one needs to perform a simulation.

The DiscreteModel interface is defined by overloading the methods:

• get_grid(model::DiscreteModel)
• get_grid_topology(model::DiscreteModel)
• get_face_labeling(g::DiscreteModel)

The interface is tested with this function:

• test_discrete_model

get_grid(model::DiscreteModel)

get_grid_topology(model::DiscreteModel)

get_face_labeling(g::DiscreteModel)

test_discrete_model(model::DiscreteModel)

num_dims(model::DiscreteModel)

num_cell_dims(model::DiscreteModel)

num_point_dims(model::DiscreteModel)

num_faces(g::DiscreteModel,d::Integer)
num_faces(g::DiscreteModel)

num_cells(g::DiscreteModel)

num_facets(g::DiscreteModel)

num_edges(g::DiscreteModel)

num_vertices(g::DiscreteModel)

num_nodes(g::DiscreteModel)

get_face_nodes(g::DiscreteModel,d::Integer)

get_face_nodes(g::DiscreteModel)

compute_face_nodes(model::DiscreteModel,d::Integer)

compute_face_nodes(model::DiscreteModel)

get_face_own_nodes(g::DiscreteModel,d::Integer)

get_face_own_nodes(g::DiscreteModel)

compute_face_own_nodes(model::DiscreteModel,d::Integer)

compute_face_own_nodes(model::DiscreteModel)

get_vertex_node(g::DiscreteModel)

compute_vertex_node(g::DiscreteModel)

get_node_face_owner(g::DiscreteModel)

compute_node_face_owner(g::DiscreteModel)

get_reffaces(::Type{ReferenceFE{d}},model::DiscreteModel) where d

get_face_type(g::DiscreteModel,d::Integer)

Index to the vector get_reffaces(ReferenceFE{d},g)

compute_reffaces(::Type{ReferenceFE{d}}, g::DiscreteModel) where d

get_reffaces(model::DiscreteModel)

get_face_type(model::DiscreteModel)

get_reffaces_offsets(model::DiscreteModel)

compute_reffaces(g::DiscreteModel)

Grid(::Type{ReferenceFE{d}},model::DiscreteModel) where d

Triangulation(::Type{ReferenceFE{d}},model::DiscreteModel) where d
Triangulation(model::DiscreteModel)

get_triangulation(model::DiscreteModel)

get_polytopes(model::DiscreteModel)

simplexify(model::DiscreteModel)

DiscreteModelFromFile(filename::AbstractString)

struct UnstructuredDiscreteModel{Dc,Dp,Tp,B} <: DiscreteModel{Dc,Dp}
  grid::UnstructuredGrid{Dc,Dp,Tp,B}
  grid_topology::UnstructuredGridTopology{Dc,Dp,Tp,B}
  face_labeling::FaceLabeling
end

UnstructuredDiscreteModel(grid::Grid)

struct CartesianDiscreteModel{D,T,F} <: DiscreteModel{D,D}
  # Private Fields
end

CartesianDiscreteModel(desc::CartesianDescriptor)

Inner constructor

CartesianDiscreteModel(args...)

Same args needed to construct a CartesianDescriptor

get_cartesian_descriptor(model::CartesianDiscreteModel)

abstract type CellFieldLike <: GridapType end

get_array(cf::CellFieldLike)

get_cell_map(cf::CellFieldLike)

similar_object(cf::CellFieldLike,array::AbstractArray)

similar_object(cf1::CellFieldLike,cf2::CellFieldLike,array::AbstractArray)

gradient(cf::CellFieldLike)

grad2curl(cf::CellFieldLike)

test_cell_field_like(
  cf::CellFieldLike,
  x::AbstractArray,
  b::AbstractArray,
  pred=(==);
  grad=nothing)

evaluate(cf::CellFieldLike,x)

length(cf::CellFieldLike)

abstract type CellField <: CellFieldLike end

test_cell_field(cf::CellField,args...;kwargs...)

Same arguments as test_cell_field_like

convert_to_cell_field(object::CellField,cell_map)

restrict(cf::CellField,trian::Triangulation)

struct GenericCellField <: CellField
  array::AbstractArray
  cell_map::AbstractArray
end

struct SkeletonCellField <: GridapType
  left::CellField
  right::CellField
end

Supports the same differential and algebraic operations than CellField

get_cell_map(a::SkeletonCellField)

jump(sf::SkeletonCellField)

mean(sf::SkeletonCellField)