Remove uneeded methods

Author: ptiede

ext/VLBISkyModelsReactantExt.jl

@@ -183,125 +183,5 @@ function NFFT.nfft(k::AbstractMatrix, f::Reactant.AnyTracedRArray, args...; kwar
     return p * f
 end
 
-function NFFT.initParams(
-        k::AbstractMatrix{T},
-        N::NTuple{D, Int},
-        dims::Union{Integer, UnitRange{Int64}} = 1:D;
-        kargs...,
-    ) where {D, T}
-    # convert dims to a unit range
-    dims_ = (typeof(dims) <: Integer) ? (dims:dims) : dims
-
-    params = NFFTParams{T, D}(; kargs...)
-    m, σ, reltol = accuracyParams(; kargs...)
-    params.m = m
-    params.σ = σ
-    params.reltol = reltol
-
-    # Taken from NFFT3
-    m2K = [1, 3, 7, 9, 14, 17, 20, 23, 24]
-    K = m2K[min(m + 1, length(m2K))]
-    params.LUTSize = 2^(K) * (m) # ensure that LUTSize is dividable by (m)
-
-    if length(dims_) != size(k, 1)
-        throw(ArgumentError("Nodes x have dimension $(size(k, 1)) != $(length(dims_))"))
-    end
-
-    doTrafo = ntuple(d -> d ∈ dims_, Val(D))
-
-    Ñ = ntuple(
-        d ->
-        doTrafo[d] ? (ceil(Int, params.σ * N[d]) ÷ 2) * 2 : # ensure that n is an even integer
-            N[d], Val(D)
-    )
-
-    params.σ = Ñ[dims_[1]] / N[dims_[1]]
-
-    #params.blockSize = ntuple(d-> Ñ[d] , D) # just one block
-    if haskey(kargs, :blockSize)
-        params.blockSize = kargs[:blockSize]
-    else
-        params.blockSize = ntuple(d -> NFFT._blockSize(Ñ, d), Val(D))
-    end
-
-    J = size(k, 2)
-
-    # calculate output size
-    NOut = Int[]
-    Mtaken = false
-    ntuple(Val(D)) do d
-        if !doTrafo[d]
-            return N[d]
-        elseif !Mtaken
-            return J
-            Mtaken = true
-        end
-    end
-    for d in 1:D
-        if !doTrafo[d]
-            push!(NOut, N[d])
-        elseif !Mtaken
-            push!(NOut, J)
-            Mtaken = true
-        end
-    end
-    # Sort nodes in lexicographic way
-    if params.sortNodes
-        k .= sortslices(k; dims = 2)
-    end
-    return params, N, Tuple(NOut), J, Ñ, dims_
-end
-
-function NFFT.precomputation(k::AbstractVecOrMat, N::NTuple{D, Int}, Ñ, params) where {D}
-    m = params.m
-    σ = params.σ
-    window = params.window
-    LUTSize = params.LUTSize
-    precompute = params.precompute
-
-    win, win_hat = getWindow(window) # highly type instable. But what should be do
-    J = size(k, 2)
-
-    windowHatInvLUT_ = Vector{Vector{T}}(undef, D)
-    precomputeWindowHatInvLUT(windowHatInvLUT_, win_hat, N, Ñ, m, σ, T)
-
-    if params.storeDeconvolutionIdx
-        windowHatInvLUT = Vector{Vector{T}}(undef, 1)
-        windowHatInvLUT[1], deconvolveIdx = precompWindowHatInvLUT(
-            params, N, Ñ, windowHatInvLUT_
-        )
-    else
-        windowHatInvLUT = windowHatInvLUT_
-        deconvolveIdx = Array{Int64, 1}(undef, 0)
-    end
-
-    if precompute == LINEAR
-        windowLinInterp = precomputeLinInterp(win, m, σ, LUTSize, T)
-        windowPolyInterp = Matrix{T}(undef, 0, 0)
-        B = sparse([], [], T[])
-    elseif precompute == POLYNOMIAL
-        windowLinInterp = Vector{T}(undef, 0)
-        windowPolyInterp = precomputePolyInterp(win, m, σ, T)
-        B = sparse([], [], T[])
-    elseif precompute == FULL
-        windowLinInterp = Vector{T}(undef, 0)
-        windowPolyInterp = Matrix{T}(undef, 0, 0)
-        B = precomputeB(win, k, N, Ñ, m, J, σ, LUTSize, T)
-        #windowLinInterp = precomputeLinInterp(win, windowLinInterp, Ñ, m, σ, LUTSize, T) # These versions are for debugging
-        #B = precomputeB(windowLinInterp, k, N, Ñ, m, J, σ, LUTSize, T)
-    elseif precompute == TENSOR
-        windowLinInterp = Vector{T}(undef, 0)
-        windowPolyInterp = Matrix{T}(undef, 0, 0)
-        B = sparse([], [], T[])
-    else
-        windowLinInterp = Vector{T}(undef, 0)
-        windowPolyInterp = Matrix{T}(undef, 0, 0)
-        B = sparse([], [], T[])
-        error("precompute = $precompute not supported by NFFT.jl!")
-    end
-
-    return (windowLinInterp, windowPolyInterp, windowHatInvLUT, deconvolveIdx, B)
-end
-
 
 end