Don't use these...

bilinear_interp(
    f::AbstractMatrix{Float64},
    grd::EikonalSolvers.AbstractGridEik2D,
    xyzpt::AbstractVector{Float64};
    outputcoeff
) -> Any

Bilinear interpolation.

calc2diagDttD(
    vecD::EikonalSolvers.VecSPDerivMat,
    tt::Vector{Float64},
    onsrccols::Vector{Bool}
) -> Tuple{EikonalSolvers.VecSPDerivMat, SparseArrays.SparseMatrixCSC{Float64, Int64}}

Calculates the following maintaining the sparse structure: 2 * diag(D * tt) * Dr

calc_dus_dsr(
    lambda_coarse::AbstractArray{Float64},
    velcart_coarse::Array{Float64, N},
    ∂ψ_∂u_s::AbstractVector{Float64},
    srcboxpar_coarse,
    grd::EikonalSolvers.AbstractGridEik,
    xyzsrc::Vector{Float64}
) -> Any

Calculates the derivative of the misfit function with respect to the traveltime at the initial points around the source ("onsrc").

calcgradsomesrc(
    vel::Array{Float64, N},
    xyzsrc::AbstractMatrix{Float64},
    coordrec::AbstractVector{Matrix{Float64}},
    grd::EikonalSolvers.AbstractGridEik,
    stdobs::AbstractVector{Vector{Float64}},
    pickobs1::AbstractVector{Vector{Float64}},
    whichgrad::Symbol,
    extrapars::ExtraParams
) -> Tuple{Any, Any, Float64}

Calculate the gradient for some requested sources

calcprojttfmmord(
    ttime::AbstractArray{Float64, N},
    grd::EikonalSolvers.AbstractGridEik,
    idxconv::EikonalSolvers.MapOrderGridFMM,
    coordrec::AbstractArray{Float64}
) -> Any

Projection operator P containing interpolation coefficients, ordered according to FMM order.

calcttpt_2ndord!(
    fmmvars::EikonalSolvers.FMMVars2D,
    vel::Matrix{Float64},
    grd::EikonalSolvers.AbstractGridEik2D,
    ij::StaticArraysCore.MVector{2, Int64},
    codeD::StaticArraysCore.MVector{2, <:Integer}
) -> Any

Compute the traveltime at a given node using 2nd order stencil where possible, otherwise revert to 1st order. Two-dimensional Cartesian or spherical grid.

calcttpt_2ndord!(
    fmmvars::EikonalSolvers.FMMVars3D,
    vel::Array{Float64, 3},
    grd::EikonalSolvers.AbstractGridEik3D,
    ijk::StaticArraysCore.MVector{3, Int64},
    codeD::StaticArraysCore.MVector{3, <:Integer}
) -> Any

Compute the traveltime at a given node using 2nd order stencil where possible, otherwise revert to 1st order. Three-dimensional Cartesian or spherical grid.

distribsrcs(nsrc::Integer, nw::Integer) -> Any

Calculate how to subdivide the sources among workers for parallel jobs.

findclosestnode_sph(
    r::Float64,
    θ::Float64,
    rinit::Float64,
    θinit::Float64,
    Δr::Float64,
    Δθ::Float64
) -> Tuple{Int64, Int64}

Find closest node on a 2D grid to a given point in spherical/polar coordinates.

findclosestnode_sph(
    r::Float64,
    θ::Float64,
    φ::Float64,
    rinit::Float64,
    θinit::Float64,
    φinit::Float64,
    Δr::Float64,
    Δθ::Float64,
    Δφ::Float64
) -> Tuple{Int64, Int64, Int64}

Find closest node on a 3D grid to a given point in spherical coordinates.

findenclosingbox(
    grd::EikonalSolvers.AbstractGridEik,
    xyzsrc::AbstractVector
) -> AbstractMatrix{<:Int64}

Find closest node on a grid to a given point.

Gaussian kernel for smoothing

isonbord(
    ib::Int64,
    jb::Int64,
    n1::Int64,
    n2::Int64
) -> Tuple{Bool, Bool}

Test if point is on borders of 2D domain.

isonbord(
    ib::Int64,
    jb::Int64,
    kb::Int64,
    nx::Int64,
    ny::Int64,
    nz::Int64
) -> Tuple{Bool, Bool}

Test if point is on borders of a 3D domain.

setcoeffderiv!(
    D::EikonalSolvers.VecSPDerivMat,
    status::Array,
    irow::Integer,
    idxconv::EikonalSolvers.MapOrderGridFMM,
    codeDeriv_orig::Matrix{Int64},
    allcoeff::EikonalSolvers.CoeffDerivatives,
    ijkpt::AbstractVector,
    colinds::AbstractVector{Int64},
    colvals::AbstractVector{Float64},
    idxperm::AbstractVector{Int64},
    nptsfixedtt::Integer;
    axis,
    simtype
)

Set the coefficients (elements) of the derivative matrices in the x and y directions.

Smooth gradient for arrays of any dimensions.

Smooth an array of any dimension

sourceboxloctt!(
    fmmvars::EikonalSolvers.AbstractFMMVars,
    vel::Array{Float64, N},
    srcpos::AbstractVector,
    grd::EikonalSolvers.AbstractGridEik
)

Define the "box" of nodes around/including the source.

tracerays_singlesrc(
    grd::EikonalSolvers.AbstractGridEik,
    ttime::Array{Float64, N},
    srccoo::AbstractVector,
    coordrec::Matrix{Float64};
    steplen
)

Ray tracing utility. Given a traveltime grid and source and receiver positions, trace the rays.

trilinear_interp(
    f::AbstractArray{Float64, 3},
    grd::EikonalSolvers.AbstractGridEik3D,
    xyzpt::AbstractVector{Float64};
    outputcoeff
) -> Any

Trinilear interpolation.

ttFMM_core!(
    fmmvars::EikonalSolvers.AbstractFMMVars,
    vel::Array{Float64, N},
    grd::EikonalSolvers.AbstractGridEik,
    adjvars::Union{Nothing, EikonalSolvers.AbstractAdjointVars};
    fmmvars_coarse,
    adjvars_coarse,
    srcrefvars
)

Higher order (2nd) fast marching method in 2D using traditional stencils on regular grid.

ttforwsomesrc(
    vel::Array{Float64, N},
    coordsrc::Matrix{Float64},
    coordrec::Vector{Matrix{Float64}},
    grd::EikonalSolvers.AbstractGridEik,
    extrapars::ExtraParams;
    returntt
) -> Union{Tuple{Vector{Array{Float64}}, Vector{Vector{Float64}}}, Vector{Vector{Float64}}}

Compute the forward problem for a group of sources.

Uniform kernel for smoothing

Binary heaps (min/max)

 IMPORTANT: make sure the handle is unique!
  Check is commented out because it slows things down...

Exports

• BinHeapMax
• BinHeapMin
• build_maxheap!
• build_minheap!
• init_maxheap
• init_minheap
• insert_maxheap!
• insert_minheap!
• pop_maxheap!
• pop_minheap!
• topval_heap
• update_node_maxheap!
• update_node_minheap!

struct BinHeapMax

Fields

• Nmax::Int64

• Nh::Base.RefValue{Int64}

• nodes::Vector{Float64}

• handles::Vector{Int64}

• idxhan::Vector{Int64}

struct BinHeapMin

Fields

• Nmax::Int64

• Nh::Base.RefValue{Int64}

• nodes::Vector{Float64}

• handles::Vector{Int64}

• idxhan::Vector{Int64}

build_maxheap!(
    values::Vector{Float64},
    Nmax::Integer,
    handles::Vector{Int64}
) -> EikonalSolvers.BinHeaps.BinHeapMax

build_minheap!(
    values::Vector{Float64},
    Nmax::Integer,
    handles::Vector{Int64}
) -> EikonalSolvers.BinHeaps.BinHeapMin

index_leftchild(i::Integer) -> Any

index_parent(i::Integer) -> Any

index_rightchild(i::Integer) -> Any

init_maxheap(
    Nmax::Integer
) -> EikonalSolvers.BinHeaps.BinHeapMax

init_minheap(
    Nmax::Integer
) -> EikonalSolvers.BinHeaps.BinHeapMin

insert_maxheap!(
    h::EikonalSolvers.BinHeaps.BinHeapMax,
    val::Float64,
    handle::Int64
)

insert_minheap!(
    h::EikonalSolvers.BinHeaps.BinHeapMin,
    val::Float64,
    handle::Int64
)

max_heapify!(
    h::EikonalSolvers.BinHeaps.BinHeapMax,
    i::Int64
)

pop_maxheap!(
    h::EikonalSolvers.BinHeaps.BinHeapMax
) -> Tuple{Int64, Float64}

pop_minheap!(
    h::EikonalSolvers.BinHeaps.BinHeapMin
) -> Tuple{Int64, Float64}

swap_nodes_heap!(
    h::Union{EikonalSolvers.BinHeaps.BinHeapMax, EikonalSolvers.BinHeaps.BinHeapMin},
    p::Integer,
    q::Integer
)

topval_heap(
    h::Union{EikonalSolvers.BinHeaps.BinHeapMax, EikonalSolvers.BinHeaps.BinHeapMin}
) -> Tuple{Float64, Int64}

update_node_maxheap!(
    h::EikonalSolvers.BinHeaps.BinHeapMax,
    val::Float64,
    handle::Int64
)

update_node_minheap!(
    h::EikonalSolvers.BinHeaps.BinHeapMin,
    val::Float64,
    handle::Int64
)