FEI Version of the Day

#include <fei_LinearSystemCore.hpp>
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 
This is the original internal FEI interface to solverlibraries  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:
An implementation of LinearSystemCore holds and manipulates all solverlibraryspecific 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 finiteelement 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:
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 elementdofs to equation numbers.
Partitioning and communication: Decide which processor shared equations belong to. Move elementcontributions 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:
1. The LinearSystemCore object is given a 'Lookup' interface, from which it can obtain information about the structure of the finiteelement problem. e.g., it can look up the number of fields, the fields' sizes, the number of elementblocks, etc., etc. For details on the Lookup interface, see the file Lookup.h.
2. 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.
3. Nodenumbers that are given to LinearSystemCore (through setConnectivities, etc.,) are 0based and contiguous. Each processor owns a contiguous block of nodenumbers. However, nonlocal nodenumbers may of course appear in connectivity lists. These nodenumbers 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 0based or contiguous. They are arbitrary node identifiers which need only be globally unique. nodeIDs never appear in LinearSystemCore functions.
4. 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.
5. 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 finiteelement nodes is moved onto the 'owning' processor before being passed to LinearSystemCore::sumIntoSystemMatrix. The finiteelement 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 unmodified stiffness data supplied by the application, including any sharednonlocal portions.
Similarly for setLoadVectors and sumIntoRHSVector. sumIntoRHSVector only provides local data, while setLoadVectors supplies the unmodified element load vectors from the application, including any shared portions.
Definition at line 124 of file fei_LinearSystemCore.hpp.
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  (  )  [inline, virtual] 
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.
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.
numParams  Number of strings in the params argument 
params  A list of strings which will usually contain spaceseparated keyvalue 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 finiteelement nodes, etc. For details, see the documentation for the Lookup interface.
lookup  Input. Reference to an implementation of the Lookup interface 
virtual int LinearSystemCore::getProperty  (  const char *  , 
double &  
)  [inline, virtual] 
Query a named property (such as timing statistics, etc.) from the solver library.
name  Input. Name of the property for which a value is being requested. value Output. Requested property's value. 
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.
len  Length of the following list arguments. This will be numProcs+1 
nodeOffsets  The FEI implementation assigns a global 0based numbering to the finiteelement nodes in the problem. Each processor is given ownership of a contiguous subset of these nodenumbers. nodeOffsets[i] gives the first local nodenumber for processor i. nodeOffsets[len1] gives the total number of nodes. 
eqnOffsets  eqnOffsets[i] gives the first local equation number for processor i, eqnOffsets[len1] gives the global number of equations. 
blkEqnOffsets  Contains the same kind of information as eqnOffsets, but for 'blockequations'. A blockequation contains all of the pointequations present at a finiteelement 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 blockequation. 
virtual int LinearSystemCore::setConnectivities  (  GlobalID  elemBlock, 
int  numElements,  
int  numNodesPerElem,  
const GlobalID *  elemIDs,  
const int *const *  connNodes  
)  [pure virtual] 
For passing elementconnectivity arrays.
elemBlock  Identifier for the elementblock 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 elementstiffness arrays.
elemBlock  Identifier for the elementblock 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 (0based 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 elementload vectors.
elemBlock  Identifier for the elementblock 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 (0based 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 numberoflocalequations can be trivially calculated. After setMatrixStructure has been called, there should be enough information to instantiate internal linearalgebra entities, such as vectors, matrix, etc.
ptColIndices  Table, with numlocaleqns rows, and the ith row is of length ptRowLengths[i]. 
ptRowLengths  
blkColIndices  Table, with numlocalblkEqns rows, and the ith row is of length blkRowLengths[i]. 
blkRowLengths  
ptRowsPerBlkRow  The ith local blockequation corresponds to ptRowsPerBlkRow[i] pointequations. 
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.
numCRs  number of constraint relations 
numNodesPerCR  number of constrained node in each constraint relation 
nodeNumbers  Table of constrained nodes. 'numCRs' rows, with the ith row being of length numNodesPerCR[i]. 
eqnNumbers  Table, same dimensions as 'nodeNumbers'. These are the global 0based 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 pointentry data, as well as blockentry 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 pointentry version for accumulating coefficient data into the matrix. This will be called when a matrix contribution fills only part of a blockequation. e.g., when a penalty constraint is being applied to a single solution field on a node that has several solution fields. (A blockequation 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] 
Pointentry 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.
row  Global 0based equation number 
length  Output. Length of the row. 
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.
row  Global 0based equation number 
coefs  Callerallocated array, length 'len', to be filled with coefficients 
indices  Callerallocated array, length 'len', to be filled with indices. (These indices will be global 0based equation numbers.) 
len  Length of the callerallocated coefs and indices arrays 
rowLength  Output. Actual length of this row. Not referenced if row is not in the local portion of the matrix. 
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 dataloading 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.
fieldID  Identifier for the field that describes this data. Lists of field identifiers and field sizes defined for the finiteelement 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 columnmodification 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.)
globalEqn  List, of length 'len', of global 0based 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 columnmodifications made due to essential boundaryconditions 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..numEqns1] 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.)
numEqns  Length of 'globalEqns' 
globalEqns  Equations that are local to this processor. 
colIndices  Table, with 'numEqns' rows, and the ith row is of length colIndLen[i]. The ith 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] 
virtual int LinearSystemCore::copyInMatrix  (  double  scalar, 
const Data &  data  
)  [pure virtual] 
LinearSystemCore's internal 'Amatrix' should be replaced with a scaled copy of the incoming data.
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 'Amatrix' 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.
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 'Amatrix'.
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'.
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'.
data  See documentation for Data class. 
virtual int LinearSystemCore::setNumRHSVectors  (  int  numRHSs, 
const int *  rhsIDs  
)  [pure virtual] 
Indicate the number of rhsvectors 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 .. numRHSs1]. If there is only one rhsvector, then 'objName' will be simply "b_Vector".
numRHSs  Length of the rhsIDs list. 
rhsIDs  Callersupplied integer identifiers for the rhs vectors. This argument will probably be removed, as it is obsolete (a carryover from LinearSystemCore). 
virtual int LinearSystemCore::setRHSID  (  int  rhsID  )  [pure virtual] 
Set the 'current context' to the rhsvector corresponding to rhsID. Subsequent data received via 'sumIntoRHSVector' should be directed into this rhsvector. Any other functioncalls having to do with the rhsvector should also effect this rhsvector.
rhsID 
virtual int LinearSystemCore::putInitialGuess  (  const int *  eqnNumbers, 
const double *  values,  
int  len  
)  [pure virtual] 
The FEI implementation will call this function to supply initialguess data that should be used as the starting 'xvector' if an iterative solution is to be performed.
eqnNumbers  Global 0based 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.
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.
eqnNumber  Global 0based 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.
values  
len  This should equal numlocaleqns. 
virtual int LinearSystemCore::launchSolver  (  int &  solveStatus, 
int &  iterations  
)  [pure virtual] 
Function called to request the launching of the linear solver.
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. 
virtual int LinearSystemCore::writeSystem  (  const char *  name  )  [pure virtual] 
This function's intent is to provide a filename 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 illdefined, obsolete, and will probably never be called by the FEI implementation.