GitHub

DataLayouts

ClimaCore.DataLayouts — Module
ClimaCore.DataLayouts

Defines the following DataLayouts (see individual docs for more info):

TODO: Add links to these datalayouts

  • IJKFVH
  • IJFH
  • IJHF
  • IFH
  • IHF
  • DataF
  • IJF
  • IF
  • VF
  • VIJFH
  • VIJHF
  • VIFH
  • VIHF
  • IH1JH2
  • IV1JH2

Notation:

  • i,j are horizontal node indices within an element
  • k is the vertical node index within an element
  • f is the field index (1 if field is scalar, >1 if it is a vector field)
  • v is the vertical element index in a stack
  • h is the element stack index

Data layout is specified by the order in which they appear, e.g. IJKFVH indexes the underlying array as [i,j,k,f,v,h]

Datalayouts that end with the field index

One of the fundamental features of datalayouts is to be able to store multiple variables in the same array, and then access those variables by name. As such, we occasionally must index into multiple variables when performing operations with a datalayout.

We can efficiently support linear indexing with datalayouts whose field index (f) is first or last. This is for the same reason as https://docs.julialang.org/en/v1/devdocs/subarrays/#Linear-indexing:

Linear indexing can be implemented efficiently when the entire array
has a single stride that separates successive elements, starting from
some offset.

Therefore, we provide special handling for these datalayouts where possible to leverage efficient linear indexing.

Here are some references containing relevant discussions and efforts to leverage efficient linear indexing:

  • https://github.com/CliMA/ClimaCore.jl/issues/1889
  • https://github.com/JuliaLang/julia/issues/28126
  • https://github.com/JuliaLang/julia/issues/32051
  • https://github.com/maleadt/StaticCartesian.jl
  • https://github.com/JuliaGPU/GPUArrays.jl/pull/454#issuecomment-1431575721
  • https://github.com/JuliaGPU/GPUArrays.jl/pull/520
  • https://github.com/JuliaGPU/GPUArrays.jl/pull/464
source
ClimaCore.DataLayouts.DataF — Type
DataF{S, A} <: Data0D{S}

Backing DataLayout for 0D point data.

DataF{S}(ArrayType[, ones | zeros | rand])

The ArrayType constructor returns a DataF given the ArrayType and (optionally) an initialization method (one of Base.ones, Base.zeros, Random.rand).

source
ClimaCore.DataLayouts.IF — Type
IF{S, Ni, A} <: DataSlab1D{S, Ni}

Backing DataLayout for 1D spectral element slab data.

Nodal element data (I) are contiguous for each S datatype struct field (F) for a single element slab.

A DataSlab1D view can be returned from other Data1D objects by calling slab(data, idx...).

IF{S}(ArrayType[, ones | zeros | rand]; Ni)

The keyword constructor returns a IF given the ArrayType and (optionally) an initialization method (one of Base.ones, Base.zeros, Random.rand) and the keywords:

  • Ni quadrature degrees of freedom in the horizontal direction
Note

Objects made with the keyword constructor accept integer keyword inputs, so they are dynamically created. You may want to use a different constructor if you're making the object in a performance-critical section, and if you know the type parameters at compile time.

source
ClimaCore.DataLayouts.IJF — Type
IJF{S, Nij, A} <: DataSlab2D{S, Nij}

Backing DataLayout for 2D spectral element slab data.

Nodal element data (I,J) are contiguous for each S datatype struct field (F) for a single element slab.

A DataSlab2D view can be returned from other Data2D objects by calling slab(data, idx...).

IJF{S}(ArrayType[, ones | zeros | rand]; Nij)

The keyword constructor returns a IJF given the ArrayType and (optionally) an initialization method (one of Base.ones, Base.zeros, Random.rand) and the keywords:

  • Nij quadrature degrees of freedom per horizontal direction
Note

Objects made with the keyword constructor accept integer keyword inputs, so they are dynamically created. You may want to use a different constructor if you're making the object in a performance-critical section, and if you know the type parameters at compile time.

source
ClimaCore.DataLayouts.VF — Type
VF{S, A} <: DataColumn{S, Nv}

Backing DataLayout for 1D FV column data.

Column level data (V) are contiguous for each S datatype struct field (F).

A DataColumn view can be returned from other Data1DX, Data2DX objects by calling column(data, idx...).

VF{S}(ArrayType[, ones | zeros | rand]; Nv)

The keyword constructor returns a VF given the ArrayType and (optionally) an initialization method (one of Base.ones, Base.zeros, Random.rand) and the keywords:

  • Nv number of vertical degrees of freedom
Note

Objects made with the keyword constructor accept integer keyword inputs, so they are dynamically created. You may want to use a different constructor if you're making the object in a performance-critical section, and if you know the type parameters at compile time.

source
ClimaCore.DataLayouts.IFH — Type
IFH{S,Ni,Nh,A} <: Data1D{S, Ni}
IFH{S,Ni,Nh}(ArrayType)

Backing DataLayout for 1D spectral element slabs.

Element nodal point (I) data is contiguous for each datatype S struct field (F), for each 1D mesh element (H).

The ArrayType-constructor makes a IFH 1D Spectral DataLayout given the backing ArrayType, quadrature degrees of freedom Ni, and the number of mesh elements Nh.

IFH{S}(ArrayType[, ones | zeros | rand]; Ni, Nh)

The keyword constructor returns a IFH given the ArrayType and (optionally) an initialization method (one of Base.ones, Base.zeros, Random.rand) and the keywords:

  • Ni quadrature degrees of freedom in the horizontal direction
  • Nh number of mesh elements
Note

Objects made with the keyword constructor accept integer keyword inputs, so they are dynamically created. You may want to use a different constructor if you're making the object in a performance-critical section, and if you know the type parameters at compile time.

source
ClimaCore.DataLayouts.IJFH — Type
IJFH{S, Nij, A} <: Data2D{S, Nij}
IJFH{S,Nij}(ArrayType, nelements)

Backing DataLayout for 2D spectral element slabs.

Element nodal point (I,J) data is contiguous for each datatype S struct field (F), for each 2D mesh element slab (H).

The ArrayType-constructor constructs a IJFH 2D Spectral DataLayout given the backing ArrayType, quadrature degrees of freedom Nij × Nij, and the number of mesh elements nelements.

IJFH{S}(ArrayType[, Base.ones | zeros | rand]; Nij, Nh)

The keyword constructor returns a IJFH given the ArrayType and (optionally) an initialization method (one of Base.ones, Base.zeros, Random.rand) and the keywords:

  • Nij quadrature degrees of freedom per horizontal direction
  • Nh number of mesh elements
Note

Objects made with the keyword constructor accept integer keyword inputs, so they are dynamically created. You may want to use a different constructor if you're making the object in a performance-critical section, and if you know the type parameters at compile time.

source
ClimaCore.DataLayouts.VIFH — Type
VIFH{S, Nv, Ni, A} <: Data1DX{S, Nv, Ni}

Backing DataLayout for 1D spectral element slab + extruded 1D FV column data.

Column levels (V) are contiguous for every element nodal point (I) for each datatype S struct field (F), for each 1D mesh element slab (H).

VIFH{S}(ArrayType[, ones | zeros | rand]; Nv, Ni, Nh)

The keyword constructor returns a VIFH given the ArrayType and (optionally) an initialization method (one of Base.ones, Base.zeros, Random.rand) and the keywords:

  • Nv number of vertical degrees of freedom
  • Ni quadrature degrees of freedom in the horizontal direction
  • Nh number of horizontal elements
Note

Objects made with the keyword constructor accept integer keyword inputs, so they are dynamically created. You may want to use a different constructor if you're making the object in a performance-critical section, and if you know the type parameters at compile time.

source
ClimaCore.DataLayouts.VIJFH — Type
VIJFH{S, Nij, A} <: Data2DX{S, Nij}

Backing DataLayout for 2D spectral element slab + extruded 1D FV column data.

Column levels (V) are contiguous for every element nodal point (I, J) for each S datatype struct field (F), for each 2D mesh element slab (H).

VIJFH{S}(ArrayType[, ones | zeros | rand]; Nv, Nij, Nh)

The keyword constructor returns a VIJFH given the ArrayType and (optionally) an initialization method (one of Base.ones, Base.zeros, Random.rand) and the keywords:

  • Nv number of vertical degrees of freedom
  • Nij quadrature degrees of freedom per horizontal direction
  • Nh number of horizontal elements
Note

Objects made with the keyword constructor accept integer keyword inputs, so they are dynamically created. You may want to use a different constructor if you're making the object in a performance-critical section, and if you know the type parameters at compile time.

source
ClimaCore.DataLayouts.IHF — Type
IHF{S,Ni,Nh,A} <: Data1D{S, Ni}
IHF{S,Ni,Nh}(ArrayType)

Backing DataLayout for 1D spectral element slabs.

Element nodal point (I) data is contiguous for each datatype S struct field (F), for each 1D mesh element (H).

The ArrayType-constructor makes a IHF 1D Spectral DataLayout given the backing ArrayType, quadrature degrees of freedom Ni, and the number of mesh elements Nh.

IHF{S}(ArrayType[, ones | zeros | rand]; Ni, Nh)

The keyword constructor returns a IHF given the ArrayType and (optionally) an initialization method (one of Base.ones, Base.zeros, Random.rand) and the keywords:

  • Ni quadrature degrees of freedom in the horizontal direction
  • Nh number of mesh elements
Note

Objects made with the keyword constructor accept integer keyword inputs, so they are dynamically created. You may want to use a different constructor if you're making the object in a performance-critical section, and if you know the type parameters at compile time.

source
ClimaCore.DataLayouts.IJHF — Type
IJHF{S, Nij, A} <: Data2D{S, Nij}
IJHF{S,Nij}(ArrayType, nelements)

Backing DataLayout for 2D spectral element slabs.

Element nodal point (I,J) data is contiguous for each datatype S struct field (F), for each 2D mesh element slab (H).

The ArrayType-constructor constructs a IJHF 2D Spectral DataLayout given the backing ArrayType, quadrature degrees of freedom Nij × Nij, and the number of mesh elements nelements.

IJHF{S}(ArrayType[, Base.ones | zeros | rand]; Nij, Nh)

The keyword constructor returns a IJHF given the ArrayType and (optionally) an initialization method (one of Base.ones, Base.zeros, Random.rand) and the keywords:

  • Nij quadrature degrees of freedom per horizontal direction
  • Nh number of mesh elements
Note

Objects made with the keyword constructor accept integer keyword inputs, so they are dynamically created. You may want to use a different constructor if you're making the object in a performance-critical section, and if you know the type parameters at compile time.

source
ClimaCore.DataLayouts.VIHF — Type
VIHF{S, Nv, Ni, A} <: Data1DX{S, Nv, Ni}

Backing DataLayout for 1D spectral element slab + extruded 1D FV column data.

Column levels (V) are contiguous for every element nodal point (I) for each datatype S struct field (F), for each 1D mesh element slab (H).

VIHF{S}(ArrayType[, ones | zeros | rand]; Nv, Ni, Nh)

The keyword constructor returns a VIHF given the ArrayType and (optionally) an initialization method (one of Base.ones, Base.zeros, Random.rand) and the keywords:

  • Nv number of vertical degrees of freedom
  • Ni quadrature degrees of freedom in the horizontal direction
  • Nh number of horizontal elements
Note

Objects made with the keyword constructor accept integer keyword inputs, so they are dynamically created. You may want to use a different constructor if you're making the object in a performance-critical section, and if you know the type parameters at compile time.

source
ClimaCore.DataLayouts.VIJHF — Type
VIJHF{S, Nij, A} <: Data2DX{S, Nij}

Backing DataLayout for 2D spectral element slab + extruded 1D FV column data.

Column levels (V) are contiguous for every element nodal point (I, J) for each S datatype struct field (F), for each 2D mesh element slab (H).

VIJHF{S}(ArrayType[, ones | zeros | rand]; Nv, Nij, Nh)

The keyword constructor returns a VIJHF given the ArrayType and (optionally) an initialization method (one of Base.ones, Base.zeros, Random.rand) and the keywords:

  • Nv number of vertical degrees of freedom
  • Nij quadrature degrees of freedom per horizontal direction
  • Nh number of horizontal elements
Note

Objects made with the keyword constructor accept integer keyword inputs, so they are dynamically created. You may want to use a different constructor if you're making the object in a performance-critical section, and if you know the type parameters at compile time.

source