SULU_ENV Derived Type

type, public :: SULU_ENV

Global type for SuperLU which covers all the stuff needed


Inherits

type~~sulu_env~~InheritsGraph type~sulu_env SULU_ENV C_PTR C_PTR type~sulu_env->C_PTR work type~globallu_t GLOBALLU_T type~sulu_env->type~globallu_t Glu type~mem_usage_t MEM_USAGE_T type~sulu_env->type~mem_usage_t mem_usage type~superlu_options_t SUPERLU_OPTIONS_T type~sulu_env->type~superlu_options_t options type~superlustat_t SUPERLUSTAT_T type~sulu_env->type~superlustat_t stat type~supermatrix SUPERMATRIX type~sulu_env->type~supermatrix sma, smb, smx, sml, smu type~globallu_t->C_PTR lusup, ucol type~expheader EXPHEADER type~globallu_t->type~expheader expanders type~lu_stack_t LU_STACK_T type~globallu_t->type~lu_stack_t stack type~superlustat_t->C_PTR panel_histo, utime, ops type~supermatrix->C_PTR Store type~expheader->C_PTR mem type~lu_stack_t->C_PTR array

Components

Type Visibility Attributes Name Initial
real(kind=C_DOUBLE), public, allocatable, dimension(:) :: CC

column scale factors for A
type(GLOBALLU_T), public :: Glu

first, an output with the whole stuff LU; next, an input for other resolutions with same sparsity
real(kind=C_DOUBLE), public, allocatable, dimension(:) :: RR

*row scale factors for A *
real(kind=R8), public, dimension(:), pointer :: a_elt

CC system matrix: points to a_elt
real(kind=R8), public, dimension(:), pointer :: b

right hand side: points to b
real(kind=C_DOUBLE), public, allocatable, dimension(:) :: berr

componentwise relative backward error of each solution
character(kind=C_CHAR, len=1), public :: equed

form of equilibration
integer(kind=C_INT), public, allocatable, dimension(:) :: etree

Elimination tree
real(kind=C_DOUBLE), public, allocatable, dimension(:) :: ferr

estimated forward error bound for each solution vector
logical(kind=I4), public :: first

if false the system has been factorized at least once
integer(kind=C_INT), public :: info

info returned by dgssvx
integer(kind=I4), public, dimension(:), pointer :: irow

matrix line of an a_elt element: points to irow
integer(kind=I4), public, dimension(:), pointer :: jptr

matrix column pointers: points to jptr
integer(kind=C_INT), public :: lwork

size of workspace, not used here
type(MEM_USAGE_T), public :: mem_usage

memory usage statistics
integer(kind=C_INT), public :: n

system size
integer(kind=C_INT), public :: nrhs

number of right hand sides
integer(kind=C_INT), public :: nz

number on non-zero entries
type(SUPERLU_OPTIONS_T), public :: options

LU controls
integer(kind=C_INT), public, allocatable, dimension(:) :: perm_c

If A->Stype = SLU_NC, Column permutation vector of size A->ncol
integer(kind=C_INT), public, allocatable, dimension(:) :: perm_r

If A->Stype = SLU_NC, row permutation vector of size A->nrow
real(kind=C_DOUBLE), public, allocatable, dimension(:) :: rcond

estimate of the reciprocal condition number of the matrix A
real(kind=C_DOUBLE), public, allocatable, dimension(:) :: rpg

reciprocal pivot growth factor
type(SUPERMATRIX), public :: sma

Matrix A in AX=B*
type(SUPERMATRIX), public :: smb

On entry, the right hand side matrix
type(SUPERMATRIX), public :: sml

factor L from the factorization
type(SUPERMATRIX), public :: smu

factor U from the factorization
type(SUPERMATRIX), public :: smx

olution matrix to the original system
type(SUPERLUSTAT_T), public :: stat

statistics on runtime and floating-point operation count
type(C_PTR), public :: work

User supplied workspace
real(kind=R8), public, allocatable, dimension(:) :: x

solution

Source Code

type SULU_ENV
!! <span style="color:green">Global type for *SuperLU* which covers all the stuff needed</span>
   integer(kind=C_INT) :: n      !! *system size*
   integer(kind=C_INT) :: nrhs   !! *number of right hand sides*
   integer(kind=C_INT) :: nz     !! *number on non-zero entries*
   integer(kind=C_INT) :: info   !! *info returned by [[dgssvx]]*
   integer(kind=C_INT) :: lwork  !! *size of workspace, not used here*

   logical(kind=I4)    :: first  !! *if ```false``` the system has been factorized at least once*

   real(kind=R8), dimension(:), pointer     :: b   !! *right hand side: points to [[MAT_SOLV:b]]*
   real(kind=R8), allocatable, dimension(:) :: x   !! *solution*

   real(kind=R8),    dimension(:), pointer :: a_elt   !! *CC system matrix: points to [[MAT_SOLV:a_elt]]*
   integer(kind=I4), dimension(:), pointer :: irow    !! *matrix line of an a_elt element: points to [[MAT_SOLV:irow]]*
   integer(kind=I4), dimension(:), pointer :: jptr    !! *matrix column pointers: points to [[MAT_SOLV:jptr]]*

   real(kind=C_DOUBLE), allocatable, dimension(:) :: ferr   !! *estimated forward error bound for each solution vector*
   real(kind=C_DOUBLE), allocatable, dimension(:) :: berr   !! *componentwise relative backward error of each solution*
   real(kind=C_DOUBLE), allocatable, dimension(:) :: RR     !! *row scale factors for A *
   real(kind=C_DOUBLE), allocatable, dimension(:) :: CC     !!*column scale factors for A*
   real(kind=C_DOUBLE), allocatable, dimension(:) :: rpg    !! *reciprocal pivot growth factor*
   real(kind=C_DOUBLE), allocatable, dimension(:) :: rcond  !!*estimate of the reciprocal condition number of the matrix A*

   integer(kind=C_INT), allocatable, dimension(:) :: perm_c !!*If A->Stype = ```SLU_NC```, Column permutation vector of size A->ncol*
   integer(kind=C_INT), allocatable, dimension(:) :: perm_r !!*If A->Stype = ```SLU_NC```, row permutation vector of size A->nrow*
   integer(kind=C_INT), allocatable, dimension(:) :: etree  !! *Elimination tree*

   character(len=1, kind=C_CHAR) :: equed !! *form of equilibration*

   type(C_PTR) :: work                    !! *User supplied workspace*

   type(SUPERLU_OPTIONS_T) :: options     !! *LU controls*

   type(SUPERMATRIX) :: sma !! *Matrix A in A*X=B*
   type(SUPERMATRIX) :: smb !! *On entry, the right hand side matrix*
   type(SUPERMATRIX) :: smx !! *olution matrix to the original system*
   type(SUPERMATRIX) :: sml !! *factor L from the factorization*
   type(SUPERMATRIX) :: smu !! *factor U from the factorization*

   type(SUPERLUSTAT_T) :: stat !! *statistics on runtime and floating-point operation count*

   type(GLOBALLU_T)    :: Glu  !! *first, an output with the whole stuff LU; next, an input for other resolutions with same sparsity*

   type(MEM_USAGE_T)   :: mem_usage !! *memory usage statistics*
endtype SULU_ENV