Amesos2_Superludist_FunctionMap.hpp

Go to the documentation of this file.

// @HEADER
//
// ***********************************************************************
//
//           Amesos2: Templated Direct Sparse Solver Package 
//                  Copyright 2011 Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
//
// ***********************************************************************
//
// @HEADER

#ifndef AMESOS2_SUPERLUDIST_FUNCTIONMAP_HPP
#define AMESOS2_SUPERLUDIST_FUNCTIONMAP_HPP

#ifdef HAVE_TEUCHOS_COMPLEX
#include <complex>
#endif

#include "Amesos2_FunctionMap.hpp"
#include "Amesos2_MatrixAdapter.hpp"
#include "Amesos2_Superludist_TypeMap.hpp"


// Declarations of SuperLU_DIST types and namespace are found in
// Superludist_TypeMap.hpp

#define AMESOS2_SLUD_GET_DIAG_SCALE(eq) (((eq)=='N') ? SLUD::NOEQUIL : ((eq)=='R') ? SLUD::ROW : ((eq)=='C') ? SLUD::COL : SLUD::BOTH)

#define AMESOS2_SLUD_GET_EQUED(ds) (((ds)==SLUD::NOEQUIL) ? 'N' : ((ds)==SLUD::ROW) ? 'R' : ((ds)=='C') ? SLUD::COL : SLUD::BOTH)

namespace Amesos2 {

  template <class Matrix, class Vector> class Superludist;

  SLUD::DiagScale_t get_diag_scale(char eq);
  char get_equed(SLUD::DiagScale_t ds);


  /* ==================== Specializations ====================
   *
   * \cond SuperLU_DIST_function_specializations 
   */

  template <>
  struct FunctionMap<Superludist,double>
  {
    typedef TypeMap<Superludist,double> type_map;
  
    static void gstrf(SLUD::superlu_options_t* options, int m, int n, double anorm, 
          type_map::LUstruct_t* LU, SLUD::gridinfo_t* grid, SLUD::SuperLUStat_t* stat, 
          int* info)
    {
      SLUD::D::pdgstrf(options, m, n, anorm, LU, grid, stat, info);
    }

    static void gstrs(SLUD::int_t n, type_map::LUstruct_t* lu_struct, 
          SLUD::ScalePermstruct_t* scale_perm_struct, SLUD::gridinfo_t* grid,
          type_map::type* B, SLUD::int_t l_numrows, SLUD::int_t fst_global_row, 
          SLUD::int_t ldb, int nrhs, type_map::SOLVEstruct_t* solve_struct, 
          SLUD::SuperLUStat_t* stat, int* info)
    {
      SLUD::D::pdgstrs(n, lu_struct, scale_perm_struct, grid, B, l_numrows,
           fst_global_row, ldb, nrhs, solve_struct, stat, info);
    }

    static void gstrs_Bglobal(SLUD::int_t n, type_map::LUstruct_t* lu_struct,
            SLUD::gridinfo_t* grid, type_map::type* B,
            SLUD::int_t ldb, int nrhs,
            SLUD::SuperLUStat_t* stat, int* info)
    {
      SLUD::D::pdgstrs_Bglobal(n, lu_struct, grid, B, ldb, nrhs, stat, info);
    }

    static void gsrfs(SLUD::int_t n, SLUD::SuperMatrix* A, double anorm, 
          type_map::LUstruct_t* lu_struct,
          SLUD::ScalePermstruct_t* scale_perm, 
          SLUD::gridinfo_t* grid, type_map::type* B, SLUD::int_t ldb, 
          type_map::type* X, SLUD::int_t ldx, int nrhs, 
          type_map::SOLVEstruct_t* solve_struct, double* berr, 
          SLUD::SuperLUStat_t* stat, int* info)
    {
      SLUD::D::pdgsrfs(n, A, anorm, lu_struct, scale_perm, grid, B, ldb, 
           X, ldx, nrhs, solve_struct, berr, stat, info);
    }

    static void gsrfs_ABXglobal(SLUD::int_t n, SLUD::SuperMatrix* A, double anorm,
        type_map::LUstruct_t* lu_struct, SLUD::gridinfo_t* grid,
        type_map::type* B, SLUD::int_t ldb, type_map::type* X,
        SLUD::int_t ldx, int nrhs, double* berr,
        SLUD::SuperLUStat_t* stat, int* info)
    {
      SLUD::D::pdgsrfs_ABXglobal(n, A, anorm, lu_struct, grid, B, ldb, 
         X, ldx, nrhs, berr, stat, info);
    }
  
    static void create_CompRowLoc_Matrix(SLUD::SuperMatrix* A, SLUD::int_t g_numrows,
           SLUD::int_t g_numcols, SLUD::int_t l_nnz,
           SLUD::int_t l_numrows, SLUD::int_t fst_global_row,
           type_map::type* nzval, SLUD::int_t* colind,
           SLUD::int_t* rowptr, SLUD::Stype_t storage_t,
           SLUD::Dtype_t data_t, SLUD::Mtype_t mat_t)
    {
      SLUD::D::dCreate_CompRowLoc_Matrix_dist(A, g_numrows, g_numcols, l_nnz, 
                l_numrows, fst_global_row,
                nzval, colind, rowptr,
                storage_t, data_t, mat_t);
    }

    static void create_CompCol_Matrix(SLUD::SuperMatrix* A, SLUD::int_t numrows,
              SLUD::int_t numcols, SLUD::int_t nnz,
              type_map::type* nzval, SLUD::int_t* rowind,
              SLUD::int_t* colptr, SLUD::Stype_t storage_t,
              SLUD::Dtype_t data_t, SLUD::Mtype_t mat_t)
    {
      SLUD::D::dCreate_CompCol_Matrix_dist(A, numrows, numcols, nnz, 
             nzval, rowind, colptr,
             storage_t, data_t, mat_t);
    }

    static void create_Dense_Matrix(SLUD::SuperMatrix* X, int m, int n,
            type_map::type* x, int ldx, SLUD::Stype_t stype,
            SLUD::Dtype_t dtype, SLUD::Mtype_t mtype)
    {
      SLUD::D::dCreate_Dense_Matrix_dist(X, m, n, x, ldx, stype, dtype, mtype);
    }

    static void permute_Dense_Matrix(SLUD::int_t fst_row, SLUD::int_t m_loc,
             SLUD::int_t* row_to_proc, SLUD::int_t* perm,
             type_map::type* X, int ldx, type_map::type* B,
             int ldb, int nrhs, SLUD::gridinfo_t* grid)
    {
      SLUD::D::pdPermute_Dense_Matrix(fst_row, m_loc, row_to_proc, perm,
              X, ldx, B, ldb, nrhs, grid);
    }
  
    static void gsequ_loc(SLUD::SuperMatrix* A, double* r, double* c, 
        double* rowcnd, double* colcnd, double* amax, int* info, 
        SLUD::gridinfo_t* grid)
    {
      SLUD::D::pdgsequ(A, r, c, rowcnd, colcnd, amax, info, grid);
    }

    static void gsequ(SLUD::SuperMatrix* A, double* r, double* c, 
          double* rowcnd, double* colcnd, double* amax, int* info)
    {
      SLUD::D::dgsequ_dist(A, r, c, rowcnd, colcnd, amax, info);
    }

    static void laqgs_loc(SLUD::SuperMatrix* A, double* r, double* c, 
        double rowcnd, double colcnd, double amax,
        SLUD::DiagScale_t* equed)
    {
      char eq = AMESOS2_SLUD_GET_EQUED(*equed);
      SLUD::D::pdlaqgs(A, r, c, rowcnd, colcnd, amax, &eq);
      *equed = AMESOS2_SLUD_GET_DIAG_SCALE(eq);
    }

    static void laqgs(SLUD::SuperMatrix* A, double* r, double* c, 
          double rowcnd, double colcnd, double amax, SLUD::DiagScale_t* equed)
    {
      char eq = AMESOS2_SLUD_GET_EQUED(*equed);
      SLUD::D::dlaqgs_dist(A, r, c, rowcnd, colcnd, amax, &eq);
      *equed = AMESOS2_SLUD_GET_DIAG_SCALE(eq);
    }

    /*
     * This version suitable for A in NCPformat
     */
    static void distribute(SLUD::fact_t fact, SLUD::int_t n,
         SLUD::SuperMatrix* A, SLUD::Glu_freeable_t* glu_freeable,
         type_map::LUstruct_t* lu, SLUD::gridinfo_t* grid)
    {
      SLUD::D::ddistribute(fact, n, A, glu_freeable, lu, grid);
    }

    /*
     * This version suitable for A in NR_loc format.
     *
     * This routine should be used in the case where fact ==
     * SamePattern_SameRowPerm, otherwise dist_psymbtonum should be
     * called.o
     */
    static void pdistribute(SLUD::fact_t fact, SLUD::int_t n, 
          SLUD::SuperMatrix* A, SLUD::ScalePermstruct_t* scale_perm, 
          SLUD::Glu_freeable_t* glu_freeable, type_map::LUstruct_t* lu,
          SLUD::gridinfo_t* grid)
    {
      SLUD::D::pddistribute(fact, n, A, scale_perm, glu_freeable, lu, grid);
    }

    /*
     * Distributes the input matrix A onto the 2D process grid based on
     * the L/U graph data in pslu_freeable.  On exit the struct lu
     * contains the information necessary to perform a numeric
     * factorization using gstrf.
     *
     * This routine should always be called with fact == DOFACT
     */
    static void dist_psymbtonum(SLUD::fact_t fact, SLUD::int_t n, SLUD::SuperMatrix* A,
        SLUD::ScalePermstruct_t* scale_perm,
        SLUD::Pslu_freeable_t* pslu_freeable,
        type_map::LUstruct_t* lu, SLUD::gridinfo_t* grid)
    {
      SLUD::D::ddist_psymbtonum(fact, n, A, scale_perm, pslu_freeable, lu, grid);
    }

    /*
     * The parameter norm may be one of:
     *  - 'M' for the max absolute matrix entry value
     *  - '1' for the norm1(A)
     *  - 'I' for the normI(A)
     *  - 'F' for the Frobenius norm of A
     */
    static double plangs(char* norm, SLUD::SuperMatrix* A, SLUD::gridinfo_t* grid)
    {
      return SLUD::D::pdlangs(norm, A, grid);
    }

    static void SolveInit(SLUD::superlu_options_t* options, SLUD::SuperMatrix* A, 
        SLUD::int_t* perm_r, SLUD::int_t* perm_c, SLUD::int_t nrhs, 
        type_map::LUstruct_t* lu, SLUD::gridinfo_t* grid, 
        type_map::SOLVEstruct_t* solve_struct)
    {
      SLUD::D::dSolveInit(options, A, perm_r, perm_c, nrhs, lu, grid, solve_struct);
    }

    static void LUstructInit(SLUD::int_t m, SLUD::int_t n,
           type_map::LUstruct_t* lu)
    {
      SLUD::D::LUstructInit(m, n, lu);
    }

    static void Destroy_LU(SLUD::int_t m, SLUD::gridinfo_t* grid,
         type_map::LUstruct_t* lu)
    {
      SLUD::D::Destroy_LU(m, grid, lu);
    }

    static void LUstructFree(type_map::LUstruct_t* lu)
    {
      SLUD::D::LUstructFree(lu);
    }

    static void SolveFinalize(SLUD::superlu_options_t* options,
            type_map::SOLVEstruct_t* solve_struct)
    {
      SLUD::D::dSolveFinalize(options, solve_struct);
    }
  };


#ifdef HAVE_TEUCHOS_COMPLEX
  /* The specializations for Teuchos::as<> for SLUD::complex and
   * SLUD::doublecomplex are provided in Amesos2_Superlu_Type.hpp
   */
  template <>
  struct FunctionMap<Superludist,SLUD::Z::doublecomplex>
  {
    typedef TypeMap<Superludist,std::complex<double> > type_map;

    static void gstrf(SLUD::superlu_options_t* options, int m, int n, double anorm, 
          type_map::LUstruct_t* LU, SLUD::gridinfo_t* grid,
          SLUD::SuperLUStat_t* stat, int* info)
    {
      SLUD::Z::pzgstrf(options, m, n, anorm, LU, grid, stat, info);
    }

    static void gstrs(SLUD::int_t n, type_map::LUstruct_t* lu_struct,
          SLUD::ScalePermstruct_t* scale_perm_struct,
          SLUD::gridinfo_t* grid, type_map::type* B,
          SLUD::int_t l_numrows, SLUD::int_t fst_global_row,
          SLUD::int_t ldb, int nrhs,
          type_map::SOLVEstruct_t* solve_struct,
          SLUD::SuperLUStat_t* stat, int* info)
    {
      SLUD::Z::pzgstrs(n, lu_struct, scale_perm_struct, grid, B, l_numrows,
           fst_global_row, ldb, nrhs, solve_struct, stat, info);
    }

    static void gstrs_Bglobal(SLUD::int_t n, type_map::LUstruct_t* lu_struct, 
            SLUD::gridinfo_t* grid, type_map::type* B, 
            SLUD::int_t ldb, int nrhs, SLUD::SuperLUStat_t* stat, int* info)
    {
      SLUD::Z::pzgstrs_Bglobal(n, lu_struct, grid, B, ldb, nrhs, stat, info);
    }
  
    static void create_CompRowLoc_Matrix(SLUD::SuperMatrix* A, SLUD::int_t g_numrows,
           SLUD::int_t g_numcols, SLUD::int_t l_nnz,
           SLUD::int_t l_numrows, SLUD::int_t fst_global_row,
           type_map::type* nzval, SLUD::int_t* colind,
           SLUD::int_t* rowptr, SLUD::Stype_t storage_t,
           SLUD::Dtype_t data_t, SLUD::Mtype_t mat_t)
    {
      SLUD::Z::zCreate_CompRowLoc_Matrix_dist(A, g_numrows, g_numcols, l_nnz, 
                l_numrows, fst_global_row,
                nzval, colind, rowptr,
                storage_t, data_t, mat_t);
    }

    static void create_CompCol_Matrix(SLUD::SuperMatrix* A, SLUD::int_t numrows,
              SLUD::int_t numcols, SLUD::int_t nnz,
              type_map::type* nzval, SLUD::int_t* rowind,
              SLUD::int_t* colptr, SLUD::Stype_t storage_t,
              SLUD::Dtype_t data_t, SLUD::Mtype_t mat_t)
    {
      SLUD::Z::zCreate_CompCol_Matrix_dist(A, numrows, numcols, nnz, 
             nzval, rowind, colptr,
             storage_t, data_t, mat_t);
    }

    static void create_Dense_Matrix(SLUD::SuperMatrix* X, int m, int n,
            TypeMap<Superludist,std::complex<double> >::type* x, int ldx, 
            SLUD::Stype_t stype, SLUD::Dtype_t dtype, SLUD::Mtype_t mtype)
    {
      SLUD::Z::zCreate_Dense_Matrix_dist(X, m, n, x, ldx, stype, dtype, mtype);
    }

    static void permute_Dense_Matrix(SLUD::int_t fst_row, SLUD::int_t m_loc,
             SLUD::int_t* row_to_proc, SLUD::int_t* perm,
             type_map::type* X, int ldx,
             type_map::type* B, int ldb,
             int nrhs, SLUD::gridinfo_t* grid)
    {
      SLUD::Z::pzPermute_Dense_Matrix(fst_row, m_loc, row_to_proc, perm,
              X, ldx, B, ldb, nrhs, grid);
    }
  
    static void gsequ_loc(SLUD::SuperMatrix* A, double* r, double* c, 
        double* rowcnd, double* colcnd, double* amax, int* info, 
        SLUD::gridinfo_t* grid)
    {
      SLUD::Z::pzgsequ(A, r, c, rowcnd, colcnd, amax, info, grid);
    }

    static void gsequ(SLUD::SuperMatrix* A, double* r, double* c, 
          double* rowcnd, double* colcnd, double* amax, int* info)
    {
      SLUD::Z::zgsequ_dist(A, r, c, rowcnd, colcnd, amax, info);
    }

    static void laqgs_loc(SLUD::SuperMatrix* A, double* r, double* c, 
        double rowcnd, double colcnd, double amax, SLUD::DiagScale_t* equed)
    {
      char eq = AMESOS2_SLUD_GET_EQUED(*equed);
      SLUD::Z::pzlaqgs(A, r, c, rowcnd, colcnd, amax, &eq);
      *equed = AMESOS2_SLUD_GET_DIAG_SCALE(eq);
    }

    static void laqgs(SLUD::SuperMatrix* A, double* r, double* c, 
          double rowcnd, double colcnd, double amax, SLUD::DiagScale_t* equed)
    {
      char eq = AMESOS2_SLUD_GET_EQUED(*equed);
      SLUD::Z::zlaqgs_dist(A, r, c, rowcnd, colcnd, amax, &eq);
      *equed = AMESOS2_SLUD_GET_DIAG_SCALE(eq);
    }

    static void distribute(SLUD::fact_t fact, SLUD::int_t n,
         SLUD::SuperMatrix* A, SLUD::Glu_freeable_t* glu_freeable,
         type_map::LUstruct_t* lu, SLUD::gridinfo_t* grid)
    {
      SLUD::Z::zdistribute(fact, n, A, glu_freeable, lu, grid);
    }

    static void pdistribute(SLUD::fact_t fact, SLUD::int_t n, 
          SLUD::SuperMatrix* A, SLUD::ScalePermstruct_t* scale_perm, 
          SLUD::Glu_freeable_t* glu_freeable, type_map::LUstruct_t* lu,
          SLUD::gridinfo_t* grid)
    {
      SLUD::Z::pzdistribute(fact, n, A, scale_perm, glu_freeable, lu, grid);
    }

    static void dist_psymbtonum(SLUD::fact_t fact, SLUD::int_t n,
        SLUD::SuperMatrix* A, SLUD::ScalePermstruct_t* scale_perm, 
        SLUD::Pslu_freeable_t* pslu_freeable, type_map::LUstruct_t* lu,
        SLUD::gridinfo_t* grid)
    {
      SLUD::Z::zdist_psymbtonum(fact, n, A, scale_perm, pslu_freeable, lu, grid);
    }

    static double plangs(char* norm, SLUD::SuperMatrix* A, SLUD::gridinfo_t* grid)
    {
      return SLUD::Z::pzlangs(norm, A, grid);
    }

    static void SolveInit(SLUD::superlu_options_t* options, SLUD::SuperMatrix* A,
        SLUD::int_t* perm_r, SLUD::int_t* perm_c, SLUD::int_t nrhs,
        type_map::LUstruct_t* lu, SLUD::gridinfo_t* grid, 
        type_map::SOLVEstruct_t* solve_struct)
    {
      SLUD::Z::zSolveInit(options, A, perm_r, perm_c, nrhs, lu, grid, solve_struct);
    }

    static void LUstructInit(SLUD::int_t m, SLUD::int_t n, type_map::LUstruct_t* lu)
    {
      SLUD::Z::LUstructInit(m, n, lu);
    }

    static void Destroy_LU(SLUD::int_t m, SLUD::gridinfo_t* grid, type_map::LUstruct_t* lu)
    {
      SLUD::Z::Destroy_LU(m, grid, lu);
    }

    static void LUstructFree(type_map::LUstruct_t* lu)
    {
      SLUD::Z::LUstructFree(lu);
    }

    static void SolveFinalize(SLUD::superlu_options_t* options,
            type_map::SOLVEstruct_t* solve_struct)
    {
      SLUD::Z::zSolveFinalize(options, solve_struct);
    }
  };
#endif  // HAVE_TEUCHOS_COMPLEX

} // end namespace Amesos2


#endif  // AMESOS2_SUPERLUDIST_FUNCTIONMAP_HPP