SRC/pzgstrs.c File Reference

Solves a system of distributed linear equations A*X = B with a general N-by-N matrix A using the LU factors computed previously. More...

#include "superlu_zdefs.h"

Include dependency graph for pzgstrs.c:


Defines

#define ISEND_IRECV

Functions

int_t pzReDistribute_B_to_X (doublecomplex *B, int_t m_loc, int nrhs, int_t ldb, int_t fst_row, int_t *ilsum, doublecomplex *x, ScalePermstruct_t *ScalePermstruct, Glu_persist_t *Glu_persist, gridinfo_t *grid, SOLVEstruct_t *SOLVEstruct)
int_t pzReDistribute_X_to_B (int_t n, doublecomplex *B, int_t m_loc, int_t ldb, int_t fst_row, int_t nrhs, doublecomplex *x, int_t *ilsum, ScalePermstruct_t *ScalePermstruct, Glu_persist_t *Glu_persist, gridinfo_t *grid, SOLVEstruct_t *SOLVEstruct)
void pzgstrs (int_t n, LUstruct_t *LUstruct, ScalePermstruct_t *ScalePermstruct, gridinfo_t *grid, doublecomplex *B, int_t m_loc, int_t fst_row, int_t ldb, int nrhs, SOLVEstruct_t *SOLVEstruct, SuperLUStat_t *stat, int *info)

Detailed Description

 -- Distributed SuperLU routine (version 2.3) --
 Lawrence Berkeley National Lab, Univ. of California Berkeley.
 October 15, 2008
 

Define Documentation

#define ISEND_IRECV


Function Documentation

void pzgstrs ( int_t  n,
LUstruct_t LUstruct,
ScalePermstruct_t ScalePermstruct,
gridinfo_t grid,
doublecomplex B,
int_t  m_loc,
int_t  fst_row,
int_t  ldb,
int  nrhs,
SOLVEstruct_t SOLVEstruct,
SuperLUStat_t stat,
int *  info 
)

 Purpose
 =======

 PZGSTRS solves a system of distributed linear equations
 A*X = B with a general N-by-N matrix A using the LU factorization
 computed by PZGSTRF.
 If the equilibration, and row and column permutations were performed,
 the LU factorization was performed for A1 where
     A1 = Pc*Pr*diag(R)*A*diag(C)*Pc^T = L*U
 and the linear system solved is
     A1 * Y = Pc*Pr*B1, where B was overwritten by B1 = diag(R)*B, and
 the permutation to B1 by Pc*Pr is applied internally in this routine.

 Arguments
 =========

 n      (input) int (global)
        The order of the system of linear equations.

 LUstruct (input) LUstruct_t*
        The distributed data structures storing L and U factors.
        The L and U factors are obtained from PZGSTRF for
        the possibly scaled and permuted matrix A.
        See superlu_zdefs.h for the definition of 'LUstruct_t'.
        A may be scaled and permuted into A1, so that
        A1 = Pc*Pr*diag(R)*A*diag(C)*Pc^T = L*U

 grid   (input) gridinfo_t*
        The 2D process mesh. It contains the MPI communicator, the number
        of process rows (NPROW), the number of process columns (NPCOL),
        and my process rank. It is an input argument to all the
        parallel routines.
        Grid can be initialized by subroutine SUPERLU_GRIDINIT.
        See superlu_defs.h for the definition of 'gridinfo_t'.

 B      (input/output) doublecomplex*
        On entry, the distributed right-hand side matrix of the possibly
        equilibrated system. That is, B may be overwritten by diag(R)*B.
        On exit, the distributed solution matrix Y of the possibly
        equilibrated system if info = 0, where Y = Pc*diag(C)^(-1)*X,
        and X is the solution of the original system.

 m_loc  (input) int (local)
        The local row dimension of matrix B.

 fst_row (input) int (global)
        The row number of B's first row in the global matrix.

 ldb    (input) int (local)
        The leading dimension of matrix B.

 nrhs   (input) int (global)
        Number of right-hand sides.

 SOLVEstruct (output) SOLVEstruct_t* (global)
        Contains the information for the communication during the
        solution phase.

 stat   (output) SuperLUStat_t*
        Record the statistics about the triangular solves.
        See util.h for the definition of 'SuperLUStat_t'.

 info   (output) int*
 	   = 0: successful exit
	   < 0: if info = -i, the i-th argument had an illegal value
 

int_t pzReDistribute_B_to_X ( doublecomplex B,
int_t  m_loc,
int  nrhs,
int_t  ldb,
int_t  fst_row,
int_t ilsum,
doublecomplex x,
ScalePermstruct_t ScalePermstruct,
Glu_persist_t Glu_persist,
gridinfo_t grid,
SOLVEstruct_t SOLVEstruct 
)

 Purpose
 =======
   Re-distribute B on the diagonal processes of the 2D process mesh.

 Note
 ====
   This routine can only be called after the routine pxgstrs_init(),
   in which the structures of the send and receive buffers are set up.

 Arguments
 =========

 B      (input) doublecomplex*
        The distributed right-hand side matrix of the possibly
        equilibrated system.

 m_loc  (input) int (local)
        The local row dimension of matrix B.

 nrhs   (input) int (global)
        Number of right-hand sides.

 ldb    (input) int (local)
        Leading dimension of matrix B.

 fst_row (input) int (global)
        The row number of B's first row in the global matrix.

 ilsum  (input) int* (global)
        Starting position of each supernode in a full array.

 x      (output) doublecomplex*
        The solution vector. It is valid only on the diagonal processes.

 ScalePermstruct (input) ScalePermstruct_t*
        The data structure to store the scaling and permutation vectors
        describing the transformations performed to the original matrix A.

 grid   (input) gridinfo_t*
        The 2D process mesh.

 SOLVEstruct (input) SOLVEstruct_t*
        Contains the information for the communication during the
        solution phase.

 Return value
 ============
 

int_t pzReDistribute_X_to_B ( int_t  n,
doublecomplex B,
int_t  m_loc,
int_t  ldb,
int_t  fst_row,
int_t  nrhs,
doublecomplex x,
int_t ilsum,
ScalePermstruct_t ScalePermstruct,
Glu_persist_t Glu_persist,
gridinfo_t grid,
SOLVEstruct_t SOLVEstruct 
)

 Purpose
 =======
   Re-distribute X on the diagonal processes to B distributed on all
   the processes.

 Note
 ====
   This routine can only be called after the routine pxgstrs_init(),
   in which the structures of the send and receive buffers are set up.
 


Generated on Sat Aug 29 04:22:03 2009 for SuperLUDistributed by  doxygen 1.5.9