GitHub

Interpolation

Tesserae.update! — Method
update!(weights, particles, mesh)

Updates each element in weights using particle data and the background mesh. Automatically dispatches to CPU or GPU backend with appropriate parallelization.

This is functionally equivalent to:

for p in eachindex(particles)
    update!(weights[p], LazyRow(particles, p), mesh)
end

where LaxyRow is provided in StructArrays.jl.

source

Interpolation types

Tesserae.BSpline — Type
BSpline(degree)

B-spline kernel. degree is one of Linear(), Quadratic() or Cubic().

Warning

BSpline(Quadratic()) and BSpline(Cubic()) cannot handle boundaries correctly because the kernel values are merely truncated, which leads to unstable behavior. Therefore, it is recommended to use either SteffenBSpline or KernelCorrection in cases where proper handling of boundaries is necessary.

source
Tesserae.uGIMP — Type
uGIMP()

A kernel for the unchanged generalized interpolation material point (uGIMP) [GIMP]. uGIMP requires the initial particle length l in the particle property as follows:

ParticleProp = @NamedTuple begin
    < variables... >
    l :: Float64
end
source
Tesserae.CPDI — Type
CPDI()

A kernel for convected particle domain interpolation (CPDI) [CPDI]. CPDI requires the initial particle length l and the deformation gradient F in the particle property. For example, in two dimensions, the property is likely to be as follows:

ParticleProp = @NamedTuple begin
    < variables... >
    l :: Float64
    F :: Mat{2, 2, Float64, 4}
end
source
Tesserae.WLS — Type
WLS(kernel)

WLS performs a local weighted least squares fit for the kernel. This results in the same kernel used in moving least squares MPM[MLSMPM]. kernel is one of BSpline and uGIMP.

source
Tesserae.KernelCorrection — Type
KernelCorrection(kernel)

KernelCorrection[KC] modifies kernel to achieve stable simulations near boundaries. The corrected kernel satisfies not only the partition of unity, $\sum_i w_{ip} = 1$, but also the linear field reproduction, $\sum_i w_{ip} \bm{x}_i = \bm{x}_p$, near boundaries. In the implementation, this simply applies WLS near boundaries. kernel is one of BSpline and uGIMP. See also SteffenBSpline.

source

Interpolation weight

Tesserae.InterpolationWeight — Type
InterpolationWeight([T,] interpolation, mesh)

InterpolationWeight stores interpolation data, such as basis function values and their spatial derivatives.

julia> mesh = CartesianMesh(1.0, (0,5), (0,5));

julia> xₚ = Vec(2.2, 3.4); # particle position

julia> iw = InterpolationWeight(BSpline(Quadratic()), mesh);

julia> update!(iw, xₚ, mesh) # update `iw` at position `xₚ` in `mesh`
InterpolationWeight:
  Interpolation: BSpline(Quadratic())
  Property names: w::Matrix{Float64}, ∇w::Matrix{Vec{2, Float64}}
  Neighboring nodes: CartesianIndices((2:4, 3:5))

julia> sum(iw.w) ≈ 1 # partition of unity
true

julia> nodeindices = neighboringnodes(iw) # grid indices within a particles' local domain
CartesianIndices((2:4, 3:5))

julia> sum(eachindex(nodeindices)) do ip # linear field reproduction
           i = nodeindices[ip]
           iw.w[ip] * mesh[i]
       end ≈ xₚ
true
source