#include <fei_LinearSystemCore.hpp>

Inheritance diagram for LinearSystemCore:

Public Member Functions
	LinearSystemCore ()

virtual	~LinearSystemCore ()

virtual LinearSystemCore *	clone ()=0

virtual int	parameters (int numParams, const char const params)=0

virtual int	setLookup (Lookup &lookup)=0

virtual int	getProperty (const char *, double &)

virtual int	setGlobalOffsets (int len, int nodeOffsets, int eqnOffsets, int *blkEqnOffsets)=0

virtual int	setConnectivities (GlobalID elemBlock, int numElements, int numNodesPerElem, const GlobalID elemIDs, const int const *connNodes)=0

virtual int	setStiffnessMatrices (GlobalID elemBlock, int numElems, const GlobalID elemIDs, const double const const stiff, int numEqnsPerElem, const int const eqnIndices)=0

virtual int	setLoadVectors (GlobalID elemBlock, int numElems, const GlobalID elemIDs, const double const load, int numEqnsPerElem, const int const *eqnIndices)=0

virtual int	setMatrixStructure (int *ptColIndices, int ptRrowLengths, int *blkColIndices, int blkRowLengths, int *ptRowsPerBlkRow)=0

virtual int	setMultCREqns (int multCRSetID, int numCRs, int numNodesPerCR, int nodeNumbers, int eqnNumbers, int fieldIDs, int multiplierEqnNumbers)=0

virtual int	setPenCREqns (int penCRSetID, int numCRs, int numNodesPerCR, int nodeNumbers, int eqnNumbers, int *fieldIDs)=0

virtual int	sumIntoSystemMatrix (int numPtRows, const int ptRows, int numPtCols, const int ptCols, int numBlkRows, const int blkRows, int numBlkCols, const int blkCols, const double const values)=0

virtual int	sumIntoSystemMatrix (int numPtRows, const int ptRows, int numPtCols, const int ptCols, const double const values)=0

virtual int	putIntoSystemMatrix (int numPtRows, const int ptRows, int numPtCols, const int ptCols, const double const values)=0

virtual int	getMatrixRowLength (int row, int &length)=0

virtual int	getMatrixRow (int row, double coefs, int indices, int len, int &rowLength)=0

virtual int	sumIntoRHSVector (int num, const double values, const int indices)=0

virtual int	putIntoRHSVector (int num, const double values, const int indices)=0

virtual int	getFromRHSVector (int num, double values, const int indices)=0

virtual int	matrixLoadComplete ()=0

virtual int	putNodalFieldData (int fieldID, int fieldSize, int nodeNumbers, int numNodes, const double data)=0

virtual int	resetMatrixAndVector (double s)=0

virtual int	resetMatrix (double s)=0

virtual int	resetRHSVector (double s)=0

virtual int	enforceEssentialBC (int globalEqn, double alpha, double *gamma, int len)=0

virtual int	enforceRemoteEssBCs (int numEqns, int globalEqns, int colIndices, int colIndLen, double **coefs)=0

virtual int	getMatrixPtr (Data &data)=0

virtual int	copyInMatrix (double scalar, const Data &data)=0

virtual int	copyOutMatrix (double scalar, Data &data)=0

virtual int	sumInMatrix (double scalar, const Data &data)=0

virtual int	getRHSVectorPtr (Data &data)=0

virtual int	copyInRHSVector (double scalar, const Data &data)=0

virtual int	copyOutRHSVector (double scalar, Data &data)=0

virtual int	sumInRHSVector (double scalar, const Data &data)=0

virtual int	destroyMatrixData (Data &data)=0

virtual int	destroyVectorData (Data &data)=0

virtual int	setNumRHSVectors (int numRHSs, const int *rhsIDs)=0

virtual int	setRHSID (int rhsID)=0

virtual int	putInitialGuess (const int eqnNumbers, const double values, int len)=0

virtual int	getSolution (double *answers, int len)=0

virtual int	getSolnEntry (int eqnNumber, double &answer)=0

virtual int	formResidual (double *values, int len)=0

virtual int	launchSolver (int &solveStatus, int &iterations)=0

virtual int	writeSystem (const char *name)=0

Detailed Description

This is the original internal FEI interface to solver-libraries – the destination for the data being assembled into a linear system by the FEI implementation.

When creating a specific FEI implementation, i.e., a version that supports a specific underlying linear solver library, the main task that must be performed is the implementation of this interface, LinearSystemCore (Note: the LinearSystemCore interface is being replaced by the ESI_Broker interface.).

To date (as of August 2001), implementations of this interface exist for coupling the following solver libraries to the FEI implementation:

Aztec
HYPRE
ISIS++
PETSc
Prometheus
SPOOLES

An implementation of LinearSystemCore holds and manipulates all solver-library-specific stuff, such as matrices/vectors, solvers/preconditioners, etc. An instance of this class is owned and used by the class that implements the public FEI spec. i.e., when element contributions, etc., are received from the finite-element application, the data is ultimately passed to this class for assembly into the sparse matrix and associated vectors. This class will also be asked to launch any underlying solver, and finally to return the solution.

Terminology notes:

I generally refer to connectivities as nodes or nodeIDs, which are finite-element entities. However, the LinearSystemCore interface functions don't receive nodeIDs – instead, nodeNumbers are provided by the FEI implementation code layer. See note 3 below.
I refer to the rows of a matrix or entries in a vector as equations or equation-numbers, which are linear-algebra entities.
An equation can be mapped to a node/field pair. i.e., given a globally unique node number, and a solution field on that node, a global equation number can be obtained, and vice versa.
The term 'block' is used in two different ways here. A block-entry matrix is a matrix made up of dense sub-blocks, with each sub-block containing a number of equations. An element-block is a finite-element term, denoting a group of elements which are homogeneous in topology. i.e., all elements in an element-block have the same number of nodes, and the same numbers of fields per node.

Key services provided by the FEI implementation layer:

Mappings: Map from node/field pairs to equation numbers. Map from lagrange multipliers to equation numbers. Map from element-dofs to equation numbers.

Partitioning and communication: Decide which processor shared equations belong to. Move element-contributions for shared equations from the sharing/contributing processor to the owning processor. i.e., the LinearSystemCore object will only be given local equation data.

NOTES:

The LinearSystemCore object is given a 'Lookup' interface, from which it can obtain information about the structure of the finite-element problem. e.g., it can look up the number of fields, the fields' sizes, the number of element-blocks, etc., etc. For details on the Lookup interface, see the file Lookup.h.
Except for making calls on the Lookup object, LinearSystemCore is reactive. All of the functions below are member functions of LinearSystemCore, which are called by FEI code. 'set' and 'put' functions are for information to be provided TO LinearSystemCore by the FEI implementation layer, while 'get' functions are for information to be requested FROM LinearSystemCore by the FEI implementation layer.
Node-numbers that are given to LinearSystemCore (through setConnectivities, etc.,) are 0-based and contiguous. Each processor owns a contiguous block of node-numbers. However, non-local node-numbers may of course appear in connectivity lists. These node-numbers are not the same as the 'nodeIDs' that appear in the FEI public interface, and throughout the FEI implementation code. nodeIDs are provided by the application, and may not be assumed to be 0-based or contiguous. They are arbitrary node identifiers which need only be globally unique. nodeIDs never appear in LinearSystemCore functions.
Not all LinearSystemCore functions are necessary for assembling a linear system. For instance, many implementations will ignore the data that is passed in by 'setConnectivities', 'setStiffnessMatrices', etc.
Some data is passed into LinearSystemCore redundantly. i.e., matrix coefficient data appears in the 'setStiffnessMatrices' function as well as the 'sumIntoSystemMatrix/sumIntoSystemBlkMatrix' function. The difference is, only local data is supplied through sumIntoSystemMatrix. Additionally, the FEI implementation layer performs the necessary communication to ensure that data from shared finite-element nodes is moved onto the 'owning' processor before being passed to LinearSystemCore::sumIntoSystemMatrix. The finite-element application doesn't have the concept of node ownership, instead processors can equally share nodes. The FEI implementation designates a single processor as the owner of these nodes, and moves any shared stiffness data onto the appropriate owning processor. The data supplied through setStiffnessMatrices is the un-modified stiffness data supplied by the application, including any shared-non-local portions.

Similarly for setLoadVectors and sumIntoRHSVector. sumIntoRHSVector only provides local data, while setLoadVectors supplies the un-modified element- load vectors from the application, including any shared portions.

Definition at line 124 of file fei_LinearSystemCore.hpp.

Constructor & Destructor Documentation

LinearSystemCore::LinearSystemCore ( )

inline

Default constructor, typically overridden by the implementing class, which probably requires an MPI Communicator, and possibly other arguments.

Definition at line 129 of file fei_LinearSystemCore.hpp.

virtual LinearSystemCore::~LinearSystemCore ( )

inlinevirtual

Destructor, should call through to the implementation's destructor and destroy all allocated memory, internal objects, etc. Exceptions: objects created in reponse to calls to the functions 'copyOutMatrix' and 'copyOutRHSVector' are not destroyed here. The caller is assumed to have taken responsibility for those matrix/vector copies.

Definition at line 137 of file fei_LinearSystemCore.hpp.

Member Function Documentation

virtual LinearSystemCore* LinearSystemCore::clone ( )

pure virtual

For cloning a LinearSystemCore instance. Caller recieves a pointer to a new instantiation of the implementing object.

virtual int LinearSystemCore::parameters	(	int	numParams,
		const char const	params
	)

pure virtual

For setting argc/argv style parameters.

Parameters

numParams	Number of strings in the params argument
params	A list of strings which will usually contain space-separated key-value pairs. Example: "debugOutput /usr/users/me/work_dir"

virtual int LinearSystemCore::setLookup ( Lookup & lookup )

pure virtual

Supply the LinearSystemCore implementation with an object (created and owned by the caller) that can be used to obtain various information about problem layout, shared finite-element nodes, etc. For details, see the documentation for the Lookup interface.

Parameters

lookup Input. Reference to an implementation of the Lookup interface

virtual int LinearSystemCore::getProperty	(	const char *	,
		double &
	)

inlinevirtual

Query a named property (such as timing statistics, etc.) from the solver library.

Parameters

name	Input. Name of the property for which a value is being requested. value Output. Requested property's value.

Returns: error-code 0 if successful. -1 probably indicates that the named property is not recognized.

Definition at line 171 of file fei_LinearSystemCore.hpp.

virtual int LinearSystemCore::setGlobalOffsets	(	int	len,
		int *	nodeOffsets,
		int *	eqnOffsets,
		int *	blkEqnOffsets
	)

pure virtual

Supply LinearSystemCore with global offset information for the problem being assembled.

Parameters

len	Length of the following list arguments. This will be numProcs+1
nodeOffsets	The FEI implementation assigns a global 0-based numbering to the finite-element nodes in the problem. Each processor is given ownership of a contiguous subset of these node-numbers. nodeOffsets[i] gives the first local node-number for processor i. nodeOffsets[len-1] gives the total number of nodes.
eqnOffsets	eqnOffsets[i] gives the first local equation number for processor i, eqnOffsets[len-1] gives the global number of equations.
blkEqnOffsets	Contains the same kind of information as eqnOffsets, but for 'block-equations'. A block-equation contains all of the point-equations present at a finite-element node. Special case: if this problem contains Lagrange Multiplier constraints, they will be equations that don't correspond to any node, and there will only be one of these equations mapped to a block-equation.

virtual int LinearSystemCore::setConnectivities	(	GlobalID	elemBlock,
		int	numElements,
		int	numNodesPerElem,
		const GlobalID *	elemIDs,
		const int const	connNodes
	)

pure virtual

For passing element-connectivity arrays.

Parameters

elemBlock	Identifier for the element-block that these elements belong to.
numElements	Length of the elemIDs list.
numNodesPerElem	Length of each row in the connNodes table.
elemIDs	Identifiers for each element for which connectivities are being supplied.
connNodes	Table, with one row for each element. Each row is a list of the nodes that are connected to that element.

virtual int LinearSystemCore::setStiffnessMatrices	(	GlobalID	elemBlock,
		int	numElems,
		const GlobalID *	elemIDs,
		const double const const *	stiff,
		int	numEqnsPerElem,
		const int const	eqnIndices
	)

pure virtual

For passing element-stiffness arrays.

Parameters

elemBlock	Identifier for the element-block that these elements belong to.
numElems	Length of the elemIDs list.
elemIDs	Identifiers for each element for which a stiffness array is being supplied.
stiff	List of 'numElems' tables, each table is of size 'numEqnsPerElem' X 'numEqnsPerElem'.
numEqnsPerElem
eqnIndices	Table, with 'numElems' rows, each row being a list of 'numEqnsPerElem' scatter indices (0-based global matrix row/column indices).

virtual int LinearSystemCore::setLoadVectors	(	GlobalID	elemBlock,
		int	numElems,
		const GlobalID *	elemIDs,
		const double const	load,
		int	numEqnsPerElem,
		const int const	eqnIndices
	)

pure virtual

For passing element-load vectors.

Parameters

elemBlock	Identifier for the element-block that these elements belong to.
numElems	Length of the elemIDs list.
elemIDs	Identifiers for each element for which a load vector is being supplied.
load	Table with 'numElems' rows, each row is of length 'numEqnsPerElem'.
numEqnsPerElem
eqnIndices	Table, with 'numElems' rows, each row being a list of 'numEqnsPerElem' scatter indices (0-based global equation numbers).

virtual int LinearSystemCore::setMatrixStructure	(	int **	ptColIndices,
		int *	ptRrowLengths,
		int **	blkColIndices,
		int *	blkRowLengths,
		int *	ptRowsPerBlkRow
	)

pure virtual

Supply LinearSystemCore with information defining the structure of the sparse matrix to be assembled. Implementers of LinearSystemCore may safely assume that this function will not be called until after the function 'setGlobalOffsets' has been called. Using the information provided via setGlobalOffsets, the number-of-local-equations can be trivially calculated. After setMatrixStructure has been called, there should be enough information to instantiate internal linear-algebra entities, such as vectors, matrix, etc.

Parameters

ptColIndices	Table, with num-local-eqns rows, and the i-th row is of length ptRowLengths[i].
ptRowLengths
blkColIndices	Table, with num-local-blkEqns rows, and the i-th row is of length blkRowLengths[i].
blkRowLengths
ptRowsPerBlkRow	The i-th local block-equation corresponds to ptRowsPerBlkRow[i] point-equations.

virtual int LinearSystemCore::setMultCREqns	(	int	multCRSetID,
		int	numCRs,
		int	numNodesPerCR,
		int **	nodeNumbers,
		int **	eqnNumbers,
		int *	fieldIDs,
		int *	multiplierEqnNumbers
	)

pure virtual

Specify which global equation numbers correspond to Lagrange Multiplier equations. This function won't be called if there are no Lagrange Multiplier constraints in the problem. If this function is called, it is guaranteed to be called after 'setGlobalOffsets' and before 'setMatrixStructure'. The primary purpose of this function is to give LinearSystemCore implementers the opportunity to deal with constraints in a special way, rather than assembling everything into one matrix. If the problem being assembled does have Lagrange constraints, then the FEI implementation will request an ESI_MatrixRowWriteAccess interface for "C_Matrix" from LinearSystemCore. If that is not available, then the FEI implementation will request "A_Matrix" and assemble everything into that.

Parameters

numCRs	number of constraint relations
numNodesPerCR	number of constrained node in each constraint relation
nodeNumbers	Table of constrained nodes. 'numCRs' rows, with the i-th row being of length numNodesPerCR[i].
eqnNumbers	Table, same dimensions as 'nodeNumbers'. These are the global 0-based matrix column indices of the constraint coefficients.
multiplierEqnNumbers	Equation numbers that the Lagrange Multipliers correspond to.

virtual int LinearSystemCore::setPenCREqns	(	int	penCRSetID,
		int	numCRs,
		int	numNodesPerCR,
		int **	nodeNumbers,
		int **	eqnNumbers,
		int *	fieldIDs
	)

pure virtual

Specify which nodes and equation numbers correspond to penalty constraints. This function is included for completeness, but hasn't yet been proven to be useful or necessary, and will probably not be included in the successor to LinearSystemCore (ESI_LSManager).

virtual int LinearSystemCore::sumIntoSystemMatrix	(	int	numPtRows,
		const int *	ptRows,
		int	numPtCols,
		const int *	ptCols,
		int	numBlkRows,
		const int *	blkRows,
		int	numBlkCols,
		const int *	blkCols,
		const double const	values
	)

pure virtual

Provides point-entry data, as well as block-entry data. This is the

primary assembly function, through which the FEI implementation provides the local equation contributions of all element contributions.

virtual int LinearSystemCore::sumIntoSystemMatrix	(	int	numPtRows,
		const int *	ptRows,
		int	numPtCols,
		const int *	ptCols,
		const double const	values
	)

pure virtual

 Purely point-entry version for accumulating coefficient data into the 
matrix. This will be called when a matrix contribution fills only part of
a block-equation. e.g., when a penalty constraint is being applied to a

single solution field on a node that has several solution fields. (A block-equation contains all solution field equations at a node.)

virtual int LinearSystemCore::putIntoSystemMatrix	(	int	numPtRows,
		const int *	ptRows,
		int	numPtCols,
		const int *	ptCols,
		const double const	values
	)

pure virtual

Point-entry matrix data as for 'sumIntoSystemMatrix', but in this case the data should be "put" into the matrix (i.e., overwrite any coefficients already present) rather than being "summed" into the matrix.

virtual int LinearSystemCore::getMatrixRowLength	(	int	row,
		int &	length
	)

pure virtual

Get the length of a row of the matrix.

Parameters

row	Global 0-based equation number
length	Output. Length of the row.

Returns: error-code non-zero if any error occurs, e.g., row is not local.

virtual int LinearSystemCore::getMatrixRow	(	int	row,
		double *	coefs,
		int *	indices,
		int	len,
		int &	rowLength
	)

pure virtual

Obtain the coefficients and indices for a row of the matrix.

Parameters

row	Global 0-based equation number
coefs	Caller-allocated array, length 'len', to be filled with coefficients
indices	Caller-allocated array, length 'len', to be filled with indices. (These indices will be global 0-based equation numbers.)
len	Length of the caller-allocated coefs and indices arrays
rowLength	Output. Actual length of this row. Not referenced if row is not in the local portion of the matrix.

Returns: error-code non-zero if any error occurs, e.g., row is not local.

virtual int LinearSystemCore::sumIntoRHSVector	(	int	num,
		const double *	values,
		const int *	indices
	)

pure virtual

For accumulating coefficients into the rhs vector

virtual int LinearSystemCore::putIntoRHSVector	(	int	num,
		const double *	values,
		const int *	indices
	)

pure virtual

For putting coefficients into the rhs vector

virtual int LinearSystemCore::getFromRHSVector	(	int	num,
		double *	values,
		const int *	indices
	)

pure virtual

For getting coefficients out of the rhs vector

virtual int LinearSystemCore::matrixLoadComplete ( )

pure virtual

The FEI implementation calls this function to signal the linsyscore object that data-loading is finished.

virtual int LinearSystemCore::putNodalFieldData	(	int	fieldID,
		int	fieldSize,
		int *	nodeNumbers,
		int	numNodes,
		const double *	data
	)

pure virtual

Pass nodal data that probably doesn't mean anything to the FEI implementation, but may mean something to the linear solver. Examples: geometric coordinates, nullspace data, etc.

Parameters

fieldID	Identifier for the field that describes this data. Lists of field identifiers and field sizes defined for the finite-element problem may be obtained from the Lookup interface that is supplied to the LinearSystemCore by the FEI implementation.
nodeNumbers	List of nodes for which data is being supplied.
numNodes
data	List of length numNodes * (size of field 'fieldID')

virtual int LinearSystemCore::resetMatrixAndVector ( double s )

pure virtual

For setting the scalar 's' (usually 0.0) throughout the matrix rhs vector.

virtual int LinearSystemCore::resetMatrix ( double s )

pure virtual

For setting the scalar 's' (usually 0.0) throughout the matrix.

virtual int LinearSystemCore::resetRHSVector ( double s )

pure virtual

For setting the scalar 's' (usually 0.0) throughout the rhs vector.

virtual int LinearSystemCore::enforceEssentialBC	(	int *	globalEqn,
		double *	alpha,
		double *	gamma,
		int	len
	)

pure virtual

The FEI implementation calls this function to inform LinearSystemCore of equations that need to have essential (Dirichlet) boundary conditions enforced on them. The intent is that the LinearSystemCore implementation will perform the column-modification b[i] = gamma[i]/alpha[i] if i == globalEqn[i], otherwise b[i] -= gamma[i]/alpha[i] * A(i,globalEqn[i]) if i != globalEqn[i]. After this operation is performed, all of row globalEqn[i] and column globalEqn[i] should be set to 0.0, except for the diagonal position. (Naturally the implementer is free to enforce the boundary condition another way if they wish.)

Parameters

globalEqn	List, of length 'len', of global 0-based equation numbers.
alpha	List, of length 'len', of coefficients. When the solution to the linear system is later requested, the solution value for globalEqn[i] should be gamma[i]/alpha[i].
gamma
len

virtual int LinearSystemCore::enforceRemoteEssBCs	(	int	numEqns,
		int *	globalEqns,
		int **	colIndices,
		int *	colIndLen,
		double **	coefs
	)

pure virtual

The FEI implementation calls this function to inform LinearSystemCore that certain local equations need column-modifications made due to essential boundary-conditions being enforced on other processors. The column modification is roughly this: b(globalEqns[i]) -= A(globalEqns[i], colIndices[i][j]) * coefs[i][j], for i in [0..numEqns-1] and j in [0.. colIndLen[i]-1]. (Note that A(globalEqns[i], colIndices[i][j]) should be set = 0.0 after the appropriate value has been accumulated into b also.)

Parameters

numEqns	Length of 'globalEqns'
globalEqns	Equations that are local to this processor.
colIndices	Table, with 'numEqns' rows, and the i-th row is of length colIndLen[i]. The i-th row contains column indices in equation globalEqns[i]. These column indices correspond to equations (rows) that are owned by other processors, and those other processors are imposing essential boundary conditions on those equations.
colIndLen	List of length 'numEqns'.
coefs	This table holds the gamma/alpha coeficients that are the value of the boundary conditions being enforced on each of the remote equations in the 'colIndices' table.

virtual int LinearSystemCore::getMatrixPtr ( Data & data )

pure virtual

The FEI implementation calls this function to request a pointer to the internal 'A-matrix' data.

Parameters

data	See Data class documentation.

virtual int LinearSystemCore::copyInMatrix	(	double	scalar,
		const Data &	data
	)

pure virtual

LinearSystemCore's internal 'A-matrix' should be replaced with a scaled copy of the incoming data.

Parameters

scalar	coefficient by which to scale the incoming data.
data	See documentation for Data class.

virtual int LinearSystemCore::copyOutMatrix	(	double	scalar,
		Data &	data
	)

pure virtual

The FEI implementation calls this function to request a scaled copy of the internal 'A-matrix' data. The FEI implementation will then be responsible for deciding when this matrix data should be destroyed. The LinearSystemCore implementation should not keep a reference to the pointer that was handed out.

Parameters

scalar
data	See documentation for Data class.

virtual int LinearSystemCore::sumInMatrix	(	double	scalar,
		const Data &	data
	)

pure virtual

A scaled copy of the incoming data should be added to the internal 'A-matrix'.

Parameters

scalar
data	See documentation for Data class.

virtual int LinearSystemCore::getRHSVectorPtr ( Data & data )

pure virtual

Same semantics as getMatrixPtr, but applied to rhs vector.

virtual int LinearSystemCore::copyInRHSVector	(	double	scalar,
		const Data &	data
	)

pure virtual

Same semantics as copyInMatrix, but applied to rhs vector.

virtual int LinearSystemCore::copyOutRHSVector	(	double	scalar,
		Data &	data
	)

pure virtual

Same semantics as copyOutMatrix, but applied to rhs vector.

virtual int LinearSystemCore::sumInRHSVector	(	double	scalar,
		const Data &	data
	)

pure virtual

Same semantics as sumInMatrix, but applied to rhs vector.

virtual int LinearSystemCore::destroyMatrixData ( Data & data )

pure virtual

Utility function for destroying the matrix in a Data container. The caller (owner of 'data') can't destroy the matrix because they don't know what concrete type it is and can't get to its destructor. The contents of 'data' is a matrix previously passed out via 'copyOutMatrix'.

Parameters

data	See documentation for Data class.

virtual int LinearSystemCore::destroyVectorData ( Data & data )

pure virtual

  Utility function for destroying the vector in a Data container. The

caller (owner of 'data') can't destroy the vector because they don't know what concrete type it is and can't get to its destructor. The contents of 'data' is a vector previously passed out via 'copyOutRHSVector'.

Parameters

data	See documentation for Data class.

virtual int LinearSystemCore::setNumRHSVectors	(	int	numRHSs,
		const int *	rhsIDs
	)

pure virtual

Indicate the number of rhs-vectors being assembled/solved for. This function will be called by the FEI implementation at or near the beginning of the problem assembly. If numRHSs is greater than 1, then calls to 'getMemberInterface' requesting an interface to an rhs vector will use the 'objName' argument "b_Vector_n", where n is in [0 .. numRHSs-1]. If there is only one rhs-vector, then 'objName' will be simply "b_Vector".

Parameters

numRHSs	Length of the rhsIDs list.
rhsIDs	Caller-supplied integer identifiers for the rhs vectors. This argument will probably be removed, as it is obsolete (a carry-over from LinearSystemCore).

virtual int LinearSystemCore::setRHSID ( int rhsID )

pure virtual

Set the 'current context' to the rhs-vector corresponding to rhsID. Subsequent data received via 'sumIntoRHSVector' should be directed into this rhs-vector. Any other function-calls having to do with the rhs-vector should also effect this rhs-vector.

Parameters

rhsID

virtual int LinearSystemCore::putInitialGuess	(	const int *	eqnNumbers,
		const double *	values,
		int	len
	)

pure virtual

The FEI implementation will call this function to supply initial-guess data that should be used as the starting 'x-vector' if an iterative solution is to be performed.

Parameters

eqnNumbers	Global 0-based equation numbers for which the initial guess should be set.
values	The initial guess data.
len	Number of equations for which an initial guess is being supplied.

virtual int LinearSystemCore::getSolution	(	double *	answers,
		int	len
	)

pure virtual

The FEI implementation will call this function to request all local solution values.

Parameters

answers	Solution coefficients.
len	This should equal the number of local equations. If it is less, the LinearSystemCore implementation should simply pass out the first 'len' local solution values. If it is more, then just pass out numLocalEqns solution values.

virtual int LinearSystemCore::getSolnEntry	(	int	eqnNumber,
		double &	answer
	)

pure virtual

The FEI implementation will call this function to request a single solution value.

Parameters

eqnNumber	Global 0-based equation number.
answer

virtual int LinearSystemCore::formResidual	(	double *	values,
		int	len
	)

pure virtual

This will be called to request that LinearSystemCore form the residual vector r = b - A*x, and pass the coefficients for r back out in the 'values' list.

Parameters

values
len	This should equal num-local-eqns.

virtual int LinearSystemCore::launchSolver	(	int &	solveStatus,
		int &	iterations
	)

pure virtual

Function called to request the launching of the linear solver.

Parameters

solveStatus	Output, should indicate the status of the solve. A successful solve is usually indicated by a value of 0.
iterations	Output, how many iterations were performed.

Returns: error-code, 0 if convergence tolerance was achieved within the specified maximum number of iterations. If error return is non-zero, the calling application will be expected to check solveStatus, and consult the solver-library's documentation to figure out exactly what happened.

virtual int LinearSystemCore::writeSystem ( const char * name )

pure virtual

This function's intent is to provide a file-name to be used by LinearSystemCore in writing the linear system into disk files. Format is not specified. Implementers may choose to augment this name in the style of writing 3 files: A_name, x_name, b_name, or some other convention. This function is ill-defined, obsolete, and will probably never be called by the FEI implementation.

The documentation for this class was generated from the following file:

fei_LinearSystemCore.hpp

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation