directsolvers.cc

Flens库-一个在C++的矩阵运算库

#include <poisson_solver/flens_impl/directsolvers.h>

#include <poisson_solver/flens_impl/gridvector.h>
#include <poisson_solver/flens_impl/poissonmatrix.h>
#include <poisson_solver/kernel_impl.h>


namespace flens {

//== fast poisson solver =======================================================

//-- dirichlet poisson 1d ------------------------------------------------------

template <>
FastPoissonSolver<DirichletPoisson1D, GridVector1D>::FastPoissonSolver(
                                                    const DirichletPoisson1D &A,
                                                    const GridVector1D &_f,
                                                    GridVector1D &_u)
    : f(_f), u(_u)
{
    plan = dp1d_fastpoissonsolver_init(f.rh, u.grid);
}

template <>
void
FastPoissonSolver<DirichletPoisson1D, GridVector1D>::solve()
{
    dp1d_fastpoissonsolver(u.rh, plan, f.grid, u.grid);
}

//-- dirichlet poisson 2d ------------------------------------------------------

template <>
FastPoissonSolver<DirichletPoisson2D, GridVector2D>::FastPoissonSolver(
                                                    const DirichletPoisson2D &A,
                                                    const GridVector2D &_f,
                                                    GridVector2D &_u)
    : f(_f), u(_u)
{
    plan = dp2d_fastpoissonsolver_init(f.rh, u.grid);

}

template <>
void
FastPoissonSolver<DirichletPoisson2D, GridVector2D>::solve()
{
    dp2d_fastpoissonsolver(u.rh, plan, f.grid, u.grid);
}

//== cholesky factorization ====================================================

//-- dirichlet poisson 1d ------------------------------------------------------

template <>
Cholesky<DirichletPoisson1D,GridVector1D>::Cholesky(const DirichletPoisson1D &A,
                                                    const GridVector1D &_f,
                                                    GridVector1D &_u)
    : f(_f), u(_u)
{
}

template <>
void
Cholesky<DirichletPoisson1D, GridVector1D>::solve()
{
    dp1d_cholesky(f.rh, f.grid, u.grid);
}

} // namespace flens