moving things around

Author: vpuri3

Project.toml

@@ -9,7 +9,6 @@ IterativeSolvers = "42fd0dbc-a981-5370-80f2-aaf504508153"
 Krylov = "ba0b0d4f-ebba-5204-a429-3ac8c609bfb7"
 KrylovKit = "0b1a1467-8014-51b9-945f-bf0ae24f4b77"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
-Pardiso = "46dd5b70-b6fb-5a00-ae2d-e8fea33afaf2"
 RecursiveFactorization = "f2c3362d-daeb-58d1-803e-2bc74f2840b4"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"

src/LinearSolve.jl

@@ -16,7 +16,6 @@ using Requires
 import Krylov
 import KrylovKit # TODO
 import IterativeSolvers
-import Pardiso
 
 using Reexport
 @reexport using SciMLBase
@@ -48,8 +47,7 @@ export LUFactorization, SVDFactorization, QRFactorization, GenericFactorization,
        RFLUFactorizaation
 export KrylovJL, KrylovJL_CG, KrylovJL_GMRES, KrylovJL_BICGSTAB, KrylovJL_MINRES,
        IterativeSolversJL, IterativeSolversJL_CG, IterativeSolversJL_GMRES,
-       IterativeSolversJL_BICGSTAB, IterativeSolversJL_MINRES,
-       PardisoJL
+       IterativeSolversJL_BICGSTAB, IterativeSolversJL_MINRES
 export DefaultLinSolve
 
 end

src/pardiso.jl

@@ -0,0 +1,72 @@
+
+## Paradiso
+
+import Pardiso
+
+export PardisoJL
+
+struct PardisoJL{A} <: SciMLLinearSolveAlgorithm
+    nthreads::Union{Int, Nothing}
+    solver_type::Union{Int, Pardiso.Solver, Nothing}
+    matrix_type::Union{Int, Pardiso.MatrixType, Nothing}
+    solve_phase::Union{Int, Pardiso.Phase, Nothing}
+    release_phase::Union{Int, Nothing}
+    iparm::Union{A, Nothing}
+    dparm::Union{A, Nothing}
+end
+
+function PardisoJL(solver_type=Pardiso.nothing,)
+
+    return PardisoJL(nthreads, solver_type, matrix_type, solve_phase,
+                     release_phase, iparm, dparm)
+end
+
+function init_cacheval(alg::PardisoJL, cache::LinearCache)
+    @unpack nthreads, solver_type, matrix_type, iparm, dparm = alg
+
+    solver = Pardiso.PARDISO_LOADED[] ? PardisoSolver() : MKLPardisoSolver()
+
+    Pardiso.pardisoinit(solver) # default initialization
+
+    nthreads    !== nothing && Pardiso.set_nprocs!(ps, nthreads)
+    solver_type !== nothing && Pardiso.set_solver!(solver, key)
+    matrix_type !== nothing && Pardiso.set_matrixtype!(solver, matrix_type)
+    cache.verbose && Pardiso.set_msglvl!(solver, Pardiso.MESSAGE_LEVEL_ON)
+
+    iparm !== nothing && begin # pass in vector of tuples like [(iparm, key)]
+        for i in length(iparm)
+            Pardiso.set_iparm!(solver, iparm[i]...)
+        end
+    end
+
+    dparm !== nothing && begin
+        for i in length(dparm)
+            Pardiso.set_dparm!(solver, dparm[i]...)
+        end
+    end
+
+    return solver
+end
+
+function SciMLBase.solve(cache::LinearCache, alg::PardisoJL; kwargs...)
+    @unpack A, b, u, cacheval = cache
+
+    if cache.isfresh
+        solver = init_cacheval(alg, cache)
+        cache = set_cacheval(cache, solver)
+    end
+
+    abstol = cache.abstol
+    reltol = cache.reltol
+    kwargs = (abstol=abstol, reltol=reltol, alg.kwargs...)
+
+    """
+    figure out whatever phase is. should set_phase call be in init_cacheval?
+    can we use phase to store factorization in cache?
+    """
+    Pardiso.set_phase!(cacheval, alg.solve_phase)
+    Pardiso.solve!(cacheval, u, A, b)
+    Pardiso.set_phase!(cacheval, alg.release_phase) # is this necessary?
+
+    return cache.u
+end

src/wrappers.jl

@@ -298,70 +298,3 @@ function SciMLBase.solve(cache::LinearCache, alg::IterativeSolversJL; kwargs...)
     return cache.u
 end
 
-## Paradiso
-
-struct PardisoJL{A} <: SciMLLinearSolveAlgorithm
-    nthreads::Union{Int, Nothing}
-    solver_type::Union{Int, Pardiso.Solver, Nothing}
-    matrix_type::Union{Int, Pardiso.MatrixType, Nothing}
-    solve_phase::Union{Int, Pardiso.Phase, Nothing}
-    release_phase::Union{Int, Nothing}
-    iparm::Union{A, Nothing}
-    dparm::Union{A, Nothing}
-end
-
-function PardisoJL(solver_type=Pardiso.nothing,)
-
-    return PardisoJL(nthreads, solver_type, matrix_type, solve_phase,
-                     release_phase, iparm, dparm)
-end
-
-function init_cacheval(alg::PardisoJL, cache::LinearCache)
-    @unpack nthreads, solver_type, matrix_type, iparm, dparm = alg
-
-    solver = Pardiso.PARDISO_LOADED[] ? PardisoSolver() : MKLPardisoSolver()
-
-    Pardiso.pardisoinit(solver) # default initialization
-
-    nthreads    !== nothing && Pardiso.set_nprocs!(ps, nthreads)
-    solver_type !== nothing && Pardiso.set_solver!(solver, key)
-    matrix_type !== nothing && Pardiso.set_matrixtype!(solver, matrix_type)
-    cache.verbose && Pardiso.set_msglvl!(solver, Pardiso.MESSAGE_LEVEL_ON)
-
-    iparm !== nothing && begin # pass in vector of tuples like [(iparm, key)]
-        for i in length(iparm)
-            Pardiso.set_iparm!(solver, iparm[i]...)
-        end
-    end
-
-    dparm !== nothing && begin
-        for i in length(dparm)
-            Pardiso.set_dparm!(solver, dparm[i]...)
-        end
-    end
-
-    return solver
-end
-
-function SciMLBase.solve(cache::LinearCache, alg::PardisoJL; kwargs...)
-    @unpack A, b, u, cacheval = cache
-
-    if cache.isfresh
-        solver = init_cacheval(alg, cache)
-        cache = set_cacheval(cache, solver)
-    end
-
-    abstol = cache.abstol
-    reltol = cache.reltol
-    kwargs = (abstol=abstol, reltol=reltol, alg.kwargs...)
-
-    """
-    figure out whatever phase is. should set_phase call be in init_cacheval?
-    can we use phase to store factorization in cache?
-    """
-    Pardiso.set_phase!(cacheval, alg.solve_phase)
-    Pardiso.solve!(cacheval, u, A, b)
-    Pardiso.set_phase!(cacheval, alg.release_phase) # is this necessary?
-
-    return cache.u
-end