escript Revision_
paso Namespace Reference

Namespaces

namespace  util
 

Classes

struct  Connector
 
struct  Coupler
 
struct  DegreeAndIdx
 
struct  FCT_FluxLimiter
 
struct  FCT_Solver
 
struct  Function
 
struct  LinearSystem
 
struct  MUMPS_Handler
 
struct  MUMPS_Handler< cplx_t >
 
struct  MUMPS_Handler< double >
 
struct  MUMPS_Handler_t
 
struct  Options
 
class  PasoException
 PasoException exception class. More...
 
struct  Pattern
 
struct  Performance
 
struct  Preconditioner
 
struct  Preconditioner_LocalSmoother
 
struct  Preconditioner_Smoother
 
struct  ReactiveSolver
 
struct  SharedComponents
 
struct  Solver_ILU
 ILU preconditioner. More...
 
struct  Solver_RILU
 RILU preconditioner. More...
 
struct  SparseMatrix
 
class  SystemMatrix
 this class holds a (distributed) stiffness matrix More...
 
struct  SystemMatrixPattern
 
class  TransportProblem
 
struct  UMFPACK_Handler
 

Typedefs

typedef boost::shared_ptr< ConnectorConnector_ptr
 
typedef boost::shared_ptr< const Connectorconst_Connector_ptr
 
template<typename T >
using Coupler_ptr = boost::shared_ptr<Coupler<T> >
 
template<typename T >
using const_Coupler_ptr = boost::shared_ptr<const Coupler<T> >
 
typedef boost::shared_ptr< PatternPattern_ptr
 
typedef boost::shared_ptr< const Patternconst_Pattern_ptr
 
typedef boost::shared_ptr< PreconditionerPreconditioner_ptr
 
typedef boost::shared_ptr< const Preconditionerconst_Preconditioner_ptr
 
typedef boost::shared_ptr< SharedComponentsSharedComponents_ptr
 
typedef boost::shared_ptr< const SharedComponentsconst_SharedComponents_ptr
 
template<typename T >
using SparseMatrix_ptr = boost::shared_ptr<SparseMatrix<T> >
 
template<typename T >
using const_SparseMatrix_ptr = boost::shared_ptr<const SparseMatrix<T> >
 
typedef int SparseMatrixType
 
template<typename T >
using SystemMatrix_ptr = boost::shared_ptr<SystemMatrix<T> >
 
template<typename T >
using const_SystemMatrix_ptr = boost::shared_ptr<const SystemMatrix<T> >
 
typedef int SystemMatrixType
 
typedef boost::shared_ptr< SystemMatrixPatternSystemMatrixPattern_ptr
 
typedef boost::shared_ptr< const SystemMatrixPatternconst_SystemMatrixPattern_ptr
 
typedef boost::shared_ptr< TransportProblemTransportProblem_ptr
 
typedef boost::shared_ptr< const TransportProblemconst_TransportProblem_ptr
 

Enumerations

enum  SolverResult {
  NoError = 0 , MaxIterReached , InputError , MemoryError ,
  Breakdown , NegativeNormError , Divergence
}
 

Functions

SolverResult Solver_BiCGStab (SystemMatrix_ptr< double > A, double *r, double *x, dim_t *iter, double *tolerance, Performance *pp)
 
void BlockOps_Cpy_N (dim_t N, double *R, const double *V)
 
void BlockOps_SMV_2 (double *R, const double *mat, const double *V)
 performs operation R=R-mat*V (V and R are not overlapping) - 2x2
 
void BlockOps_SMV_3 (double *R, const double *mat, const double *V)
 performs operation R=R-mat*V (V and R are not overlapping) - 3x3
 
void BlockOps_SMV_N (dim_t N, double *R, const double *mat, const double *V)
 performs operation R=R-mat*V (V and R are not overlapping) - NxN
 
void BlockOps_MV_N (dim_t N, double *R, const double *mat, const double *V)
 
void BlockOps_invM_2 (double *invA, const double *A, int *failed)
 
void BlockOps_invM_3 (double *invA, const double *A, int *failed)
 
void BlockOps_invM_N (dim_t N, double *mat, index_t *pivot, int *failed)
 LU factorization of NxN matrix mat with partial pivoting.
 
void BlockOps_solve_N (dim_t N, double *X, double *mat, index_t *pivot, int *failed)
 solves system of linear equations A*X=B
 
void BlockOps_MViP_2 (const double *mat, double *V)
 inplace matrix vector product - order 2
 
void BlockOps_MViP_3 (const double *mat, double *V)
 inplace matrix vector product - order 3
 
void BlockOps_solveAll (dim_t n_block, dim_t n, double *D, index_t *pivot, double *x)
 
SolverResult Solver_GMRES (SystemMatrix_ptr< double > A, double *r, double *x, dim_t *iter, double *tolerance, dim_t Length_of_recursion, dim_t restart, Performance *pp)
 
SolverResult Solver_GMRES2 (Function *F, const double *f0, const double *x0, double *dx, dim_t *iter, double *tolerance, Performance *pp)
 
void Solver_ILU_free (Solver_ILU *in)
 
Solver_ILUSolver_getILU (SparseMatrix_ptr< double > A, bool verbose)
 constructs the incomplete block factorization
 
void Solver_solveILU (SparseMatrix_ptr< double > A, Solver_ILU *ilu, double *x, const double *b)
 
SolverResult Solver_MINRES (SystemMatrix_ptr< double > A, double *R, double *X, dim_t *iter, double *tolerance, Performance *pp)
 
void MKL_free (SparseMatrix< double > *A)
 
void MKL_solve (SparseMatrix_ptr< double > A, double *out, double *in, index_t reordering, dim_t numRefinements, bool verbose)
 
void MKL_free (SparseMatrix< cplx_t > *A)
 
void MKL_solve (SparseMatrix_ptr< cplx_t > A, cplx_t *out, cplx_t *in, index_t reordering, dim_t numRefinements, bool verbose)
 
std::ostream & operator<< (std::ostream &os, const cplx_t &c)
 
template<typename T >
void MUMPS_free (SparseMatrix< T > *A)
 frees any MUMPS related data from the matrix
 
template<typename T >
void MUMPS_solve (SparseMatrix_ptr< T > A, T *out, T *in, dim_t numRefinements, bool verbose)
 calls the solver
 
template<typename T >
void MUMPS_print_list (const char *name, const T *vals, const int n, const int max_n=100)
 
SolverResult Solver_NewtonGMRES (Function *F, double *x, Options *options, Performance *pp)
 
void checkPasoError ()
 
int comparDegreeAndIdx (const void *arg1, const void *arg2)
 
bool dropTree (index_t root, const Pattern *pattern, index_t *AssignedLevel, index_t *VerticesInTree, dim_t *numLevels, index_t *firstVertexInLevel, dim_t max_LevelWidth_abort, dim_t N)
 
SolverResult Solver_PCG (SystemMatrix_ptr< double > A, double *r, double *x, dim_t *iter, double *tolerance, Performance *pp)
 
void Performance_open (Performance *pp, int verbose)
 sets up the monitoring process
 
int Performance_getEventIndex (Performance *pp, int event_id)
 find the index of an event in the list of monitored events
 
void Performance_close (Performance *pp, int verbose)
 shuts down the monitoring process
 
void Performance_startMonitor (Performance *pp, int monitor)
 switches on a monitor
 
void Performance_stopMonitor (Performance *pp, int monitor)
 switches off a monitor
 
void Preconditioner_free (Preconditioner *in)
 
PreconditionerPreconditioner_alloc (SystemMatrix_ptr< double > A, Options *options)
 
void Preconditioner_solve (Preconditioner *prec, SystemMatrix_ptr< double > A, double *x, double *b)
 
void Preconditioner_Smoother_free (Preconditioner_Smoother *in)
 
void Preconditioner_LocalSmoother_free (Preconditioner_LocalSmoother *in)
 
Preconditioner_SmootherPreconditioner_Smoother_alloc (SystemMatrix_ptr< double > A, bool jacobi, bool is_local, bool verbose)
 constructs the symmetric Gauss-Seidel preconditioner
 
Preconditioner_LocalSmootherPreconditioner_LocalSmoother_alloc (SparseMatrix_ptr< double > A, bool jacobi, bool verbose)
 
void Preconditioner_Smoother_solve (SystemMatrix_ptr< double > A, Preconditioner_Smoother *gs, double *x, const double *b, dim_t sweeps, bool x_is_initial)
 
void Preconditioner_LocalSmoother_solve (SparseMatrix_ptr< double > A, Preconditioner_LocalSmoother *gs, double *x, const double *b, dim_t sweeps, bool x_is_initial)
 
SolverResult Preconditioner_Smoother_solve_byTolerance (SystemMatrix_ptr< double > A, Preconditioner_Smoother *gs, double *x, const double *b, double atol, dim_t *sweeps, bool x_is_initial)
 
void Preconditioner_LocalSmoother_Sweep (SparseMatrix_ptr< double > A, Preconditioner_LocalSmoother *gs, double *x)
 
void Preconditioner_LocalSmoother_Sweep_sequential (SparseMatrix_ptr< double > A, Preconditioner_LocalSmoother *smoother, double *x)
 inplace Gauss-Seidel sweep in sequential mode
 
void Preconditioner_LocalSmoother_Sweep_tiled (SparseMatrix_ptr< double > A, Preconditioner_LocalSmoother *gs, double *x)
 
void Preconditioner_LocalSmoother_Sweep_colored (SparseMatrix_ptr< double > A, Preconditioner_LocalSmoother *gs, double *x)
 
void Solver_RILU_free (Solver_RILU *in)
 
Solver_RILUSolver_getRILU (SparseMatrix_ptr< double > A, bool verbose)
 
void Solver_solveRILU (Solver_RILU *rilu, double *x, double *b)
 
void Solver_updateIncompleteSchurComplement (SparseMatrix_ptr< double > A_CC, SparseMatrix_ptr< double > A_CF, double *invA_FF, index_t *A_FF_pivot, SparseMatrix_ptr< double > A_FC)
 
void Solver_free (SystemMatrix< double > *A)
 
SolverResult Solver (SystemMatrix_ptr< double > A, double *x, double *b, Options *options, Performance *pp)
 calls the iterative solver
 
SolverResult Solver (SystemMatrix_ptr< cplx_t > A, cplx_t *x, cplx_t *b, Options *options, Performance *pp)
 
void Solver_free (SystemMatrix< cplx_t > *A)
 
template<typename T >
void solve_free (SystemMatrix< T > *A)
 
SolverResult Solver_TFQMR (SystemMatrix_ptr< double > A, double *B, double *X, dim_t *iter, double *tolerance, Performance *pp)
 
void swap (index_t *r, index_t *c, double *v, int left, int right)
 
void q_sort (index_t *row, index_t *col, double *val, int begin, int end, int N)
 
void SparseMatrix_MatrixVector_CSC_OFFSET0 (const double alpha, const_SparseMatrix_ptr< double > A, const double *in, const double beta, double *out)
 
void SparseMatrix_MatrixVector_CSC_OFFSET1 (const double alpha, const_SparseMatrix_ptr< double > A, const double *in, const double beta, double *out)
 
void SparseMatrix_MatrixVector_CSR_OFFSET0 (const double alpha, const_SparseMatrix_ptr< double > A, const double *in, const double beta, double *out)
 
template<typename T >
void SparseMatrix_MatrixVector_CSR_OFFSET1 (const double alpha, const_SparseMatrix_ptr< T > A, const T *in, const double beta, T *out)
 
void SparseMatrix_MatrixVector_CSR_OFFSET0_DIAG (const double alpha, const_SparseMatrix_ptr< double > A, const double *in, const double beta, double *out)
 
SparseMatrix_ptr< double > SparseMatrix_MatrixMatrix (const_SparseMatrix_ptr< double > A, const_SparseMatrix_ptr< double > B)
 
SparseMatrix_ptr< double > SparseMatrix_MatrixMatrixTranspose (const_SparseMatrix_ptr< double > A, const_SparseMatrix_ptr< double > B, const_SparseMatrix_ptr< double > T)
 
void SparseMatrix_MatrixMatrix_DD (SparseMatrix_ptr< double > C, const_SparseMatrix_ptr< double > A, const_SparseMatrix_ptr< double > B)
 
void SparseMatrix_MatrixMatrix_DB (SparseMatrix_ptr< double > C, const_SparseMatrix_ptr< double > A, const_SparseMatrix_ptr< double > B)
 
void SparseMatrix_MatrixMatrix_BD (SparseMatrix_ptr< double > C, const_SparseMatrix_ptr< double > A, const_SparseMatrix_ptr< double > B)
 
void SparseMatrix_MatrixMatrix_BB (SparseMatrix_ptr< double > C, const_SparseMatrix_ptr< double > A, const_SparseMatrix_ptr< double > B)
 
void SparseMatrix_MatrixMatrixTranspose_DD (SparseMatrix_ptr< double > C, const_SparseMatrix_ptr< double > A, const_SparseMatrix_ptr< double > B, const_SparseMatrix_ptr< double > T)
 
void SparseMatrix_MatrixMatrixTranspose_DB (SparseMatrix_ptr< double > C, const_SparseMatrix_ptr< double > A, const_SparseMatrix_ptr< double > B, const_SparseMatrix_ptr< double > T)
 
void SparseMatrix_MatrixMatrixTranspose_BD (SparseMatrix_ptr< double > C, const_SparseMatrix_ptr< double > A, const_SparseMatrix_ptr< double > B, const_SparseMatrix_ptr< double > T)
 
void SparseMatrix_MatrixMatrixTranspose_BB (SparseMatrix_ptr< double > C, const_SparseMatrix_ptr< double > A, const_SparseMatrix_ptr< double > B, const_SparseMatrix_ptr< double > T)
 
void SparseMatrix_MatrixVector_CSR_OFFSET0_stripe (double alpha, dim_t nRows, dim_t row_block_size, dim_t col_block_size, const index_t *ptr, const index_t *index, const double *val, const double *in, double beta, double *out)
 
static int calc_digits (int)
 
static void fmt_str (int, int, int *, int *, int *, char *, char *)
 
static void print_data (std::ofstream &, int, int, int, char *, const void *, int, int)
 
static void generate_HB (std::ofstream &, dim_t *, dim_t *, const double *)
 
void RHS_loadMM_toCSR (const char *filename, double *b, dim_t size)
 
static void q_sort (index_t *, index_t *, double *, int, int)
 
void UMFPACK_free (SparseMatrix< double > *A)
 frees any UMFPACK related data from the matrix
 
void UMFPACK_solve (SparseMatrix_ptr< double > A, double *out, double *in, dim_t numRefinements, bool verbose)
 calls the solver
 
void UMFPACK_free (SparseMatrix< cplx_t > *A)
 frees any UMFPACK related data from the matrix
 
void UMFPACK_solve (SparseMatrix_ptr< cplx_t > A, cplx_t *out, cplx_t *in, dim_t numRefinements, bool verbose)
 calls the solver
 

Variables

static const real_t LARGE_POSITIVE_FLOAT = escript::DataTypes::real_t_max()
 
static double Pattern_mis_seed =.4142135623730951
 
static const real_t EPSILON = escript::DataTypes::real_t_eps()
 
static const real_t PASO_RT_EXP_LIM_MIN = sqrt(EPSILON)
 
static const real_t PASO_RT_EXP_LIM_MAX = log(1./sqrt(EPSILON))
 
static dim_t M
 
static dim_t N
 
static dim_t nz
 
static int M
 
static int N
 
static int nz
 
static const real_t LARGE_POSITIVE_FLOAT = escript::DataTypes::real_t_max()
 

Typedef Documentation

◆ Connector_ptr

typedef boost::shared_ptr<Connector> paso::Connector_ptr

◆ const_Connector_ptr

typedef boost::shared_ptr<const Connector> paso::const_Connector_ptr

◆ const_Coupler_ptr

template<typename T >
using paso::const_Coupler_ptr = boost::shared_ptr<const Coupler<T> >

◆ const_Pattern_ptr

typedef boost::shared_ptr<const Pattern> paso::const_Pattern_ptr

◆ const_Preconditioner_ptr

typedef boost::shared_ptr<const Preconditioner> paso::const_Preconditioner_ptr

◆ const_SharedComponents_ptr

typedef boost::shared_ptr<const SharedComponents> paso::const_SharedComponents_ptr

◆ const_SparseMatrix_ptr

template<typename T >
using paso::const_SparseMatrix_ptr = boost::shared_ptr<const SparseMatrix<T> >

◆ const_SystemMatrix_ptr

template<typename T >
using paso::const_SystemMatrix_ptr = boost::shared_ptr<const SystemMatrix<T> >

◆ const_SystemMatrixPattern_ptr

typedef boost::shared_ptr<const SystemMatrixPattern> paso::const_SystemMatrixPattern_ptr

◆ const_TransportProblem_ptr

typedef boost::shared_ptr<const TransportProblem> paso::const_TransportProblem_ptr

◆ Coupler_ptr

template<typename T >
using paso::Coupler_ptr = boost::shared_ptr<Coupler<T> >

◆ Pattern_ptr

typedef boost::shared_ptr<Pattern> paso::Pattern_ptr

◆ Preconditioner_ptr

typedef boost::shared_ptr<Preconditioner> paso::Preconditioner_ptr

◆ SharedComponents_ptr

typedef boost::shared_ptr<SharedComponents> paso::SharedComponents_ptr

◆ SparseMatrix_ptr

template<typename T >
using paso::SparseMatrix_ptr = boost::shared_ptr<SparseMatrix<T> >

◆ SparseMatrixType

◆ SystemMatrix_ptr

template<typename T >
using paso::SystemMatrix_ptr = boost::shared_ptr<SystemMatrix<T> >

◆ SystemMatrixPattern_ptr

◆ SystemMatrixType

◆ TransportProblem_ptr

typedef boost::shared_ptr<TransportProblem> paso::TransportProblem_ptr

Enumeration Type Documentation

◆ SolverResult

Enumerator
NoError 
MaxIterReached 
InputError 
MemoryError 
Breakdown 
NegativeNormError 
Divergence 

Function Documentation

◆ BlockOps_Cpy_N()

void paso::BlockOps_Cpy_N ( dim_t N,
double * R,
const double * V )
inline

◆ BlockOps_invM_2()

void paso::BlockOps_invM_2 ( double * invA,
const double * A,
int * failed )
inline

◆ BlockOps_invM_3()

void paso::BlockOps_invM_3 ( double * invA,
const double * A,
int * failed )
inline

◆ BlockOps_invM_N()

void paso::BlockOps_invM_N ( dim_t N,
double * mat,
index_t * pivot,
int * failed )
inline

LU factorization of NxN matrix mat with partial pivoting.

References N, and PASO_MISSING_CLAPACK.

Referenced by paso::SparseMatrix< T >::invMain().

◆ BlockOps_MV_N()

void paso::BlockOps_MV_N ( dim_t N,
double * R,
const double * mat,
const double * V )
inline

◆ BlockOps_MViP_2()

void paso::BlockOps_MViP_2 ( const double * mat,
double * V )
inline

inplace matrix vector product - order 2

References V.

Referenced by BlockOps_solveAll(), Preconditioner_LocalSmoother_Sweep_colored(), and Preconditioner_LocalSmoother_Sweep_sequential().

◆ BlockOps_MViP_3()

void paso::BlockOps_MViP_3 ( const double * mat,
double * V )
inline

inplace matrix vector product - order 3

References V.

Referenced by BlockOps_solveAll(), Preconditioner_LocalSmoother_Sweep_colored(), and Preconditioner_LocalSmoother_Sweep_sequential().

◆ BlockOps_SMV_2()

void paso::BlockOps_SMV_2 ( double * R,
const double * mat,
const double * V )
inline

performs operation R=R-mat*V (V and R are not overlapping) - 2x2

References V.

Referenced by Preconditioner_LocalSmoother_Sweep_colored(), and Preconditioner_LocalSmoother_Sweep_sequential().

◆ BlockOps_SMV_3()

void paso::BlockOps_SMV_3 ( double * R,
const double * mat,
const double * V )
inline

performs operation R=R-mat*V (V and R are not overlapping) - 3x3

References V.

Referenced by Preconditioner_LocalSmoother_Sweep_colored(), and Preconditioner_LocalSmoother_Sweep_sequential().

◆ BlockOps_SMV_N()

void paso::BlockOps_SMV_N ( dim_t N,
double * R,
const double * mat,
const double * V )
inline

performs operation R=R-mat*V (V and R are not overlapping) - NxN

References N, PASO_MISSING_CLAPACK, and V.

Referenced by Preconditioner_LocalSmoother_Sweep_colored(), and Preconditioner_LocalSmoother_Sweep_sequential().

◆ BlockOps_solve_N()

void paso::BlockOps_solve_N ( dim_t N,
double * X,
double * mat,
index_t * pivot,
int * failed )
inline

◆ BlockOps_solveAll()

void paso::BlockOps_solveAll ( dim_t n_block,
dim_t n,
double * D,
index_t * pivot,
double * x )
inline

◆ calc_digits()

int paso::calc_digits ( int var)
static

Referenced by generate_HB().

◆ checkPasoError()

void paso::checkPasoError ( )

◆ comparDegreeAndIdx()

int paso::comparDegreeAndIdx ( const void * arg1,
const void * arg2 )

◆ dropTree()

bool paso::dropTree ( index_t root,
const Pattern * pattern,
index_t * AssignedLevel,
index_t * VerticesInTree,
dim_t * numLevels,
index_t * firstVertexInLevel,
dim_t max_LevelWidth_abort,
dim_t N )

◆ fmt_str()

void paso::fmt_str ( int nvalues,
int integer,
int * width,
int * nlines,
int * nperline,
char * pfmt,
char * fmt )
static

Referenced by generate_HB().

◆ generate_HB()

void paso::generate_HB ( std::ofstream & fp,
dim_t * col_ptr,
dim_t * row_ind,
const double * val )
static

◆ MKL_free() [1/2]

void paso::MKL_free ( SparseMatrix< cplx_t > * A)

◆ MKL_free() [2/2]

◆ MKL_solve() [1/2]

void paso::MKL_solve ( SparseMatrix_ptr< cplx_t > A,
cplx_t * out,
cplx_t * in,
index_t reordering,
dim_t numRefinements,
bool verbose )

◆ MKL_solve() [2/2]

◆ MUMPS_free()

template<typename T >
void paso::MUMPS_free ( SparseMatrix< T > * A)

frees any MUMPS related data from the matrix

References paso::MUMPS_Handler< T >::rhs, and paso::SparseMatrix< T >::solver_p.

Referenced by solve_free(), and paso::SparseMatrix< T >::~SparseMatrix().

◆ MUMPS_print_list()

template<typename T >
void paso::MUMPS_print_list ( const char * name,
const T * vals,
const int n,
const int max_n = 100 )

Referenced by MUMPS_solve().

◆ MUMPS_solve()

template<typename T >
void paso::MUMPS_solve ( SparseMatrix_ptr< T > A,
T * out,
T * in,
dim_t numRefinements,
bool verbose )

◆ operator<<()

std::ostream & paso::operator<< ( std::ostream & os,
const cplx_t & c )

◆ Performance_close()

◆ Performance_getEventIndex()

int paso::Performance_getEventIndex ( Performance * pp,
int event_id )

find the index of an event in the list of monitored events

References PERFORMANCE_UNMONITORED_EVENT.

Referenced by Performance_close().

◆ Performance_open()

void paso::Performance_open ( Performance * pp,
int verbose )

◆ Performance_startMonitor()

void paso::Performance_startMonitor ( Performance * pp,
int monitor )

◆ Performance_stopMonitor()

void paso::Performance_stopMonitor ( Performance * pp,
int monitor )

◆ Preconditioner_alloc()

◆ Preconditioner_free()

◆ Preconditioner_LocalSmoother_alloc()

◆ Preconditioner_LocalSmoother_free()

◆ Preconditioner_LocalSmoother_solve()

void paso::Preconditioner_LocalSmoother_solve ( SparseMatrix_ptr< double > A,
Preconditioner_LocalSmoother * gs,
double * x,
const double * b,
dim_t sweeps,
bool x_is_initial )

◆ Preconditioner_LocalSmoother_Sweep()

◆ Preconditioner_LocalSmoother_Sweep_colored()

◆ Preconditioner_LocalSmoother_Sweep_sequential()

◆ Preconditioner_LocalSmoother_Sweep_tiled()

void paso::Preconditioner_LocalSmoother_Sweep_tiled ( SparseMatrix_ptr< double > A,
Preconditioner_LocalSmoother * gs,
double * x )

◆ Preconditioner_Smoother_alloc()

Preconditioner_Smoother * paso::Preconditioner_Smoother_alloc ( SystemMatrix_ptr< double > A,
bool jacobi,
bool is_local,
bool verbose )

◆ Preconditioner_Smoother_free()

void paso::Preconditioner_Smoother_free ( Preconditioner_Smoother * in)

◆ Preconditioner_Smoother_solve()

◆ Preconditioner_Smoother_solve_byTolerance()

◆ Preconditioner_solve()

◆ print_data()

void paso::print_data ( std::ofstream & fp,
int n_perline,
int width,
int nval,
char * fmt,
const void * ptr,
int integer,
int adjust )
static

Referenced by generate_HB().

◆ q_sort() [1/2]

void paso::q_sort ( index_t * row,
index_t * col,
double * val,
int begin,
int end )
static

References N, q_sort(), and swap().

◆ q_sort() [2/2]

void paso::q_sort ( index_t * row,
index_t * col,
double * val,
int begin,
int end,
int N )

◆ RHS_loadMM_toCSR()

void paso::RHS_loadMM_toCSR ( const char * filename,
double * b,
dim_t size )

◆ solve_free()

◆ Solver() [1/2]

SolverResult paso::Solver ( SystemMatrix_ptr< cplx_t > A,
cplx_t * x,
cplx_t * b,
Options * options,
Performance * pp )

◆ Solver() [2/2]

◆ Solver_BiCGStab()

SolverResult paso::Solver_BiCGStab ( SystemMatrix_ptr< double > A,
double * r,
double * x,
dim_t * iter,
double * tolerance,
Performance * pp )

◆ Solver_free() [1/2]

void paso::Solver_free ( SystemMatrix< cplx_t > * A)

◆ Solver_free() [2/2]

void paso::Solver_free ( SystemMatrix< double > * A)

◆ Solver_getILU()

Solver_ILU * paso::Solver_getILU ( SparseMatrix_ptr< double > A,
bool verbose )

constructs the incomplete block factorization

References paso::Solver_ILU::factors, and escript::gettime().

Referenced by Preconditioner_alloc().

◆ Solver_getRILU()

◆ Solver_GMRES()

SolverResult paso::Solver_GMRES ( SystemMatrix_ptr< double > A,
double * r,
double * x,
dim_t * iter,
double * tolerance,
dim_t Length_of_recursion,
dim_t restart,
Performance * pp )

◆ Solver_GMRES2()

◆ Solver_ILU_free()

void paso::Solver_ILU_free ( Solver_ILU * in)

◆ Solver_MINRES()

SolverResult paso::Solver_MINRES ( SystemMatrix_ptr< double > A,
double * R,
double * X,
dim_t * iter,
double * tolerance,
Performance * pp )

◆ Solver_NewtonGMRES()

◆ Solver_PCG()

◆ Solver_RILU_free()

◆ Solver_solveILU()

void paso::Solver_solveILU ( SparseMatrix_ptr< double > A,
Solver_ILU * ilu,
double * x,
const double * b )

◆ Solver_solveRILU()

◆ Solver_TFQMR()

◆ Solver_updateIncompleteSchurComplement()

void paso::Solver_updateIncompleteSchurComplement ( SparseMatrix_ptr< double > A_CC,
SparseMatrix_ptr< double > A_CF,
double * invA_FF,
index_t * A_FF_pivot,
SparseMatrix_ptr< double > A_FC )

References paso::util::comparIndex().

Referenced by Solver_getRILU().

◆ SparseMatrix_MatrixMatrix()

◆ SparseMatrix_MatrixMatrix_BB()

void paso::SparseMatrix_MatrixMatrix_BB ( SparseMatrix_ptr< double > C,
const_SparseMatrix_ptr< double > A,
const_SparseMatrix_ptr< double > B )

◆ SparseMatrix_MatrixMatrix_BD()

void paso::SparseMatrix_MatrixMatrix_BD ( SparseMatrix_ptr< double > C,
const_SparseMatrix_ptr< double > A,
const_SparseMatrix_ptr< double > B )

◆ SparseMatrix_MatrixMatrix_DB()

void paso::SparseMatrix_MatrixMatrix_DB ( SparseMatrix_ptr< double > C,
const_SparseMatrix_ptr< double > A,
const_SparseMatrix_ptr< double > B )

◆ SparseMatrix_MatrixMatrix_DD()

void paso::SparseMatrix_MatrixMatrix_DD ( SparseMatrix_ptr< double > C,
const_SparseMatrix_ptr< double > A,
const_SparseMatrix_ptr< double > B )

◆ SparseMatrix_MatrixMatrixTranspose()

◆ SparseMatrix_MatrixMatrixTranspose_BB()

void paso::SparseMatrix_MatrixMatrixTranspose_BB ( SparseMatrix_ptr< double > C,
const_SparseMatrix_ptr< double > A,
const_SparseMatrix_ptr< double > B,
const_SparseMatrix_ptr< double > T )

◆ SparseMatrix_MatrixMatrixTranspose_BD()

void paso::SparseMatrix_MatrixMatrixTranspose_BD ( SparseMatrix_ptr< double > C,
const_SparseMatrix_ptr< double > A,
const_SparseMatrix_ptr< double > B,
const_SparseMatrix_ptr< double > T )

◆ SparseMatrix_MatrixMatrixTranspose_DB()

void paso::SparseMatrix_MatrixMatrixTranspose_DB ( SparseMatrix_ptr< double > C,
const_SparseMatrix_ptr< double > A,
const_SparseMatrix_ptr< double > B,
const_SparseMatrix_ptr< double > T )

◆ SparseMatrix_MatrixMatrixTranspose_DD()

void paso::SparseMatrix_MatrixMatrixTranspose_DD ( SparseMatrix_ptr< double > C,
const_SparseMatrix_ptr< double > A,
const_SparseMatrix_ptr< double > B,
const_SparseMatrix_ptr< double > T )

◆ SparseMatrix_MatrixVector_CSC_OFFSET0()

void paso::SparseMatrix_MatrixVector_CSC_OFFSET0 ( const double alpha,
const_SparseMatrix_ptr< double > A,
const double * in,
const double beta,
double * out )

◆ SparseMatrix_MatrixVector_CSC_OFFSET1()

void paso::SparseMatrix_MatrixVector_CSC_OFFSET1 ( const double alpha,
const_SparseMatrix_ptr< double > A,
const double * in,
const double beta,
double * out )

◆ SparseMatrix_MatrixVector_CSR_OFFSET0()

void paso::SparseMatrix_MatrixVector_CSR_OFFSET0 ( const double alpha,
const_SparseMatrix_ptr< double > A,
const double * in,
const double beta,
double * out )

◆ SparseMatrix_MatrixVector_CSR_OFFSET0_DIAG()

void paso::SparseMatrix_MatrixVector_CSR_OFFSET0_DIAG ( const double alpha,
const_SparseMatrix_ptr< double > A,
const double * in,
const double beta,
double * out )

◆ SparseMatrix_MatrixVector_CSR_OFFSET0_stripe()

void paso::SparseMatrix_MatrixVector_CSR_OFFSET0_stripe ( double alpha,
dim_t nRows,
dim_t row_block_size,
dim_t col_block_size,
const index_t * ptr,
const index_t * index,
const double * val,
const double * in,
double beta,
double * out )

◆ SparseMatrix_MatrixVector_CSR_OFFSET1()

template<typename T >
void paso::SparseMatrix_MatrixVector_CSR_OFFSET1 ( const double alpha,
const_SparseMatrix_ptr< T > A,
const T * in,
const double beta,
T * out )

◆ swap()

void paso::swap ( index_t * r,
index_t * c,
double * v,
int left,
int right )

Referenced by q_sort(), and q_sort().

◆ UMFPACK_free() [1/2]

void paso::UMFPACK_free ( SparseMatrix< cplx_t > * A)

frees any UMFPACK related data from the matrix

◆ UMFPACK_free() [2/2]

void paso::UMFPACK_free ( SparseMatrix< double > * A)

◆ UMFPACK_solve() [1/2]

void paso::UMFPACK_solve ( SparseMatrix_ptr< cplx_t > A,
cplx_t * out,
cplx_t * in,
dim_t numRefinements,
bool verbose )

calls the solver

◆ UMFPACK_solve() [2/2]

void paso::UMFPACK_solve ( SparseMatrix_ptr< double > A,
double * out,
double * in,
dim_t numRefinements,
bool verbose )

Variable Documentation

◆ EPSILON

◆ LARGE_POSITIVE_FLOAT [1/2]

◆ LARGE_POSITIVE_FLOAT [2/2]

const real_t paso::LARGE_POSITIVE_FLOAT = escript::DataTypes::real_t_max()
static

◆ M [1/2]

◆ M [2/2]

int paso::M
static

◆ N [1/2]

◆ N [2/2]

int paso::N
static

◆ nz [1/2]

◆ nz [2/2]

int paso::nz
static

◆ PASO_RT_EXP_LIM_MAX

const real_t paso::PASO_RT_EXP_LIM_MAX = log(1./sqrt(EPSILON))
static

◆ PASO_RT_EXP_LIM_MIN

const real_t paso::PASO_RT_EXP_LIM_MIN = sqrt(EPSILON)
static

◆ Pattern_mis_seed

double paso::Pattern_mis_seed =.4142135623730951
static

Referenced by paso::Pattern::mis().