PaStiX Handbook  6.2.1
simple.c File Reference

A simple example that reads the matrix and then runs pastix in one call. More...

Go to the source code of this file.

Detailed Description

A simple example that reads the matrix and then runs pastix in one call.

Version
6.2.0
Author
Gregoire Pichon
Mathieu Faverge
Matias Hastaran
Pierre Ramet
Theophile Terraz
Tony Delarue
Date
2021-04-07
/
#include <pastix.h>
#include <spm.h>
int main (int argc, char **argv)
{
pastix_data_t *pastix_data = NULL; /*< Pointer to the storage structure required by pastix */
pastix_int_t iparm[IPARM_SIZE]; /*< Integer in/out parameters for pastix */
double dparm[DPARM_SIZE]; /*< Floating in/out parameters for pastix */
spm_driver_t driver;
char *filename;
spmatrix_t *spm, spm2;
void *x, *b, *x0 = NULL;
size_t size;
int check = 1;
int nrhs = 1;
int rc = 0;
/**
* Initialize parameters to default values
*/
pastixInitParam( iparm, dparm );
/**
* Get options from command line
*/
pastixGetOptions( argc, argv,
iparm, dparm,
&check, &driver, &filename );
/**
* Startup PaStiX
*/
pastixInit( &pastix_data, MPI_COMM_WORLD, iparm, dparm );
/**
* Read the sparse matrix with the driver
*/
spm = malloc( sizeof( spmatrix_t ) );
spmReadDriver( driver, filename, spm );
free( filename );
spmPrintInfo( spm, stdout );
rc = spmCheckAndCorrect( spm, &spm2 );
if ( rc != 0 ) {
spmExit( spm );
*spm = spm2;
rc = 0;
}
/**
* Generate a Fake values array if needed for the numerical part
*/
if ( spm->flttype == SpmPattern ) {
spmGenFakeValues( spm );
}
/**
* Perform ordering, symbolic factorization, and analyze steps
*/
pastix_task_analyze( pastix_data, spm );
/**
* Normalize A matrix (optional, but recommended for low-rank functionality)
*/
double normA = spmNorm( SpmFrobeniusNorm, spm );
spmScalMatrix( 1./normA, spm );
/**
* Perform the numerical factorization
*/
pastix_task_numfact( pastix_data, spm );
/**
* Generates the b and x vector such that A * x = b
* Compute the norms of the initial vectors if checking purpose.
*/
size = pastix_size_of( spm->flttype ) * spm->n * nrhs;
x = malloc( size );
b = malloc( size );
if ( check )
{
if ( check > 1 ) {
x0 = malloc( size );
}
spmGenRHS( SpmRhsRndX, nrhs, spm, x0, spm->n, b, spm->n );
memcpy( x, b, size );
}
else {
spmGenRHS( SpmRhsRndB, nrhs, spm, NULL, spm->n, x, spm->n );
/* Apply also normalization to b vectors */
spmScalVector( spm->flttype, 1./normA, spm->n * nrhs, b, 1 );
/* Save b for refinement */
memcpy( b, x, size );
}
/**
* Solve the linear system (and perform the optional refinement)
*/
pastix_task_solve( pastix_data, nrhs, x, spm->n );
pastix_task_refine( pastix_data, spm->n, nrhs, b, spm->n, x, spm->n );
if ( check )
{
rc = spmCheckAxb( dparm[DPARM_EPSILON_REFINEMENT], nrhs, spm, x0, spm->n, b, spm->n, x, spm->n );
if ( x0 ) {
free( x0 );
}
}
spmExit( spm );
free( spm );
free( x );
free( b );
pastixFinalize( &pastix_data );
return rc;
}
/**
*

Definition in file simple.c.

DPARM_EPSILON_REFINEMENT
@ DPARM_EPSILON_REFINEMENT
Definition: api.h:154
pastixGetOptions
void pastixGetOptions(int argc, char **argv, pastix_int_t *iparm, double *dparm, int *check, spm_driver_t *driver, char **filename)
PaStiX helper function to read command line options in examples.
Definition: get_options.c:142
pastix_task_solve
int pastix_task_solve(pastix_data_t *pastix_data, pastix_int_t nrhs, void *b, pastix_int_t ldb)
Solve the given problem.
Definition: pastix_task_solve.c:681
pastix.h
pastixInit
void pastixInit(pastix_data_t **pastix_data, PASTIX_Comm pastix_comm, pastix_int_t *iparm, double *dparm)
Initialize the solver instance.
Definition: api.c:857
main
int main(int argc, char *argv[])
Definition: binding_for_multimpi.c:49
pastixInitParam
void pastixInitParam(pastix_int_t *iparm, double *dparm)
Initialize the iparm and dparm arrays to their default values.
Definition: api.c:401
pastix_task_analyze
int pastix_task_analyze(pastix_data_t *pastix_data, const spmatrix_t *spm)
Perform all the preprocessing steps: ordering, symbolic factorization, reordering,...
Definition: pastix_task_analyze.c:53
pastixFinalize
void pastixFinalize(pastix_data_t **pastix_data)
Finalize the solver instance.
Definition: api.c:880
pastix_task_refine
int pastix_task_refine(pastix_data_t *pastix_data, pastix_int_t n, pastix_int_t nrhs, void *b, pastix_int_t ldb, void *x, pastix_int_t ldx)
Perform iterative refinement.
Definition: pastix_task_refine.c:226
pastix_task_numfact
int pastix_task_numfact(pastix_data_t *pastix_data, spmatrix_t *spm)
Perform all the numerical factorization steps: fill the internal block CSC and the solver matrix stru...
Definition: pastix_task_sopalin.c:587