PaddedArrays

PaddedArrays

Module defining the PaddedArray type for dealing with arrays padded by ghost cells.

Among other things, this type allows to efficiently work with periodic boundary conditions in one and more spatial dimensions.

PaddedArray{M, T, N} <: AbstractArray{T, N}

Pads a vector with M "ghost" entries on each side, along each direction.

Can be useful for dealing with periodic boundary conditions. In that use case, one can call pad_periodic! once the non-ghost entries have been filled to conveniently impose those kind of conditions.

See also PaddedVector.

PaddedArray{M}(data::AbstractArray)

Interpret input array as a padded array.

Note that the input array is not modified. Instead, its M first and M last entries along each direction are considered as "ghost" entries.

In other words, the "logical" dimensions of the resulting PaddedArray are size(v) = size(data) .- 2M. Along a given direction of size N, indexing functions like axes return the range 1:N (or an equivalent). However, the array can in reality be indexed (and modified) over the range (1 - M):(N + M).

See PaddedVector for some one-dimensional examples.

PaddedVector{M, T} <: AbstractVector{T}

Alias for PaddedArray{M, T, 1} which can be used to work with one-dimensional data.

PaddedVector{M}(data::AbstractVector)

Interpret input vector as a padded vector.

See PaddedArray for details.

Examples

julia> v = PaddedVector{2}(collect(1:10))
6-element PaddedVector{2, Int64, Vector{Int64}}:
 3
 4
 5
 6
 7
 8

julia> eachindex(v)
Base.OneTo(6)

julia> v[begin]
3

julia> v[begin - 2]
1

julia> v[end]
8

julia> v[end + 2]
10

julia> v[end - 1] = 42; println(v)
[3, 4, 5, 6, 42, 8]

pad_periodic!(v::PaddedArray{M, T, N}, [L = zero(T)])

Fill ghost cells in a periodic manner.

In the simplest case of a 1D PaddedArray (N = 1), this function will copy:

• v[begin:(begin + M - 1)] → v[(end + 1):(end + M)], and

• v[(end - M + 1):end] → v[(begin - M):(begin - 1)].

Something equivalent (but more complicated) is done in multiple dimensions.

If L ≠ 0, it is interpreted as an unfolding period (or as an end-to-end distance after a single period), such that v[N + i] - v[i] = L, where N = length(v).