FEI Version of the Day
Public Member Functions
FEI Class Reference

#include <FEI.hpp>

Inheritance diagram for FEI:
Inheritance graph
[legend]

List of all members.

Public Member Functions

virtual ~FEI ()
virtual int parameters (int numParams, const char *const *paramStrings)=0
virtual int setIDLists (int numMatrices, const int *matrixIDs, int numRHSs, const int *rhsIDs)=0
virtual int setSolveType (int solveType)=0
virtual int initFields (int numFields, const int *fieldSizes, const int *fieldIDs, const int *fieldTypes=NULL)=0
virtual int initElemBlock (GlobalID elemBlockID, int numElements, int numNodesPerElement, const int *numFieldsPerNode, const int *const *nodalFieldIDs, int numElemDofFieldsPerElement, const int *elemDOFFieldIDs, int interleaveStrategy)=0
virtual int initElem (GlobalID elemBlockID, GlobalID elemID, const GlobalID *elemConn)=0
virtual int initSharedNodes (int numSharedNodes, const GlobalID *sharedNodeIDs, const int *numProcsPerNode, const int *const *sharingProcIDs)=0
virtual int initCRMult (int numCRNodes, const GlobalID *CRNodeIDs, const int *CRFieldIDs, int &CRID)=0
virtual int initCRPen (int numCRNodes, const GlobalID *CRNodeIDs, const int *CRFieldIDs, int &CRID)=0
virtual int initSlaveVariable (GlobalID slaveNodeID, int slaveFieldID, int offsetIntoSlaveField, int numMasterNodes, const GlobalID *masterNodeIDs, const int *masterFieldIDs, const double *weights, double rhsValue)=0
virtual int initComplete ()=0
virtual int setCurrentMatrix (int matrixID)=0
virtual int setCurrentRHS (int rhsID)=0
virtual int resetSystem (double s=0.0)=0
virtual int resetMatrix (double s=0.0)=0
virtual int resetRHSVector (double s=0.0)=0
virtual int resetInitialGuess (double s)=0
virtual int deleteMultCRs ()=0
virtual int loadNodeBCs (int numNodes, const GlobalID *nodeIDs, int fieldID, const int *offsetsIntoField, const double *prescribedValues)=0
virtual int loadElemBCs (int numElems, const GlobalID *elemIDs, int fieldID, const double *const *alpha, const double *const *beta, const double *const *gamma)=0
virtual int sumInElem (GlobalID elemBlockID, GlobalID elemID, const GlobalID *elemConn, const double *const *elemStiffness, const double *elemLoad, int elemFormat)=0
virtual int sumInElemMatrix (GlobalID elemBlockID, GlobalID elemID, const GlobalID *elemConn, const double *const *elemStiffness, int elemFormat)=0
virtual int sumInElemRHS (GlobalID elemBlockID, GlobalID elemID, const GlobalID *elemConn, const double *elemLoad)=0
virtual int loadCRMult (int CRMultID, int numCRNodes, const GlobalID *CRNodeIDs, const int *CRFieldIDs, const double *CRWeights, double CRValue)=0
virtual int loadCRPen (int CRPenID, int numCRNodes, const GlobalID *CRNodeIDs, const int *CRFieldIDs, const double *CRWeights, double CRValue, double penValue)=0
virtual int putIntoRHS (int IDType, int fieldID, int numIDs, const GlobalID *IDs, const double *coefficients)=0
virtual int sumIntoRHS (int IDType, int fieldID, int numIDs, const GlobalID *IDs, const double *coefficients)=0
virtual int setMatScalars (int numScalars, const int *IDs, const double *scalars)=0
virtual int setRHSScalars (int numScalars, const int *IDs, const double *scalars)=0
virtual int loadComplete (bool applyBCs=true, bool globalAssemble=true)=0
virtual int residualNorm (int whichNorm, int numFields, int *fieldIDs, double *norms)=0
virtual int solve (int &status)=0
virtual int iterations (int &itersTaken) const =0
virtual int getFieldSize (int fieldID, int &numScalars)=0
virtual int getEqnNumbers (GlobalID ID, int idType, int fieldID, int &numEqns, int *eqnNumbers)=0
virtual int getNodalFieldSolution (int fieldID, int numNodes, const GlobalID *nodeIDs, double *results)=0
virtual int getNumLocalNodes (int &numNodes)=0
virtual int getLocalNodeIDList (int &numNodes, GlobalID *nodeIDs, int lenNodeIDs)=0
virtual int putNodalFieldData (int fieldID, int numNodes, const GlobalID *nodeIDs, const double *data)=0
virtual int getBlockNodeSolution (GlobalID elemBlockID, int numNodes, const GlobalID *nodeIDs, int *offsets, double *results)=0
virtual int getNodalSolution (int numNodes, const GlobalID *nodeIDs, int *offsets, double *results)=0
virtual int getBlockFieldNodeSolution (GlobalID elemBlockID, int fieldID, int numNodes, const GlobalID *nodeIDs, double *results)=0
virtual int getBlockElemSolution (GlobalID elemBlockID, int numElems, const GlobalID *elemIDs, int &numElemDOFPerElement, double *results)=0
virtual int getNumCRMultipliers (int &numMultCRs)=0
virtual int getCRMultIDList (int numMultCRs, int *multIDs)=0
virtual int getCRMultipliers (int numCRs, const int *CRIDs, double *results)=0
virtual int putBlockNodeSolution (GlobalID elemBlockID, int numNodes, const GlobalID *nodeIDs, const int *offsets, const double *estimates)=0
virtual int putBlockFieldNodeSolution (GlobalID elemBlockID, int fieldID, int numNodes, const GlobalID *nodeIDs, const double *estimates)=0
virtual int putBlockElemSolution (GlobalID elemBlockID, int numElems, const GlobalID *elemIDs, int dofPerElem, const double *estimates)=0
virtual int putCRMultipliers (int numMultCRs, const int *CRMultIDs, const double *multEstimates)=0
virtual int getBlockNodeIDList (GlobalID elemBlockID, int numNodes, GlobalID *nodeIDs)=0
virtual int getBlockElemIDList (GlobalID elemBlockID, int numElems, GlobalID *elemIDs)=0
virtual int version (const char *&versionString)=0
virtual int cumulative_cpu_times (double &initPhase, double &loadPhase, double &solve, double &solnReturn)=0
virtual int getNumSolnParams (GlobalID globalNodeID, int &numSolnParams) const =0
virtual int getNumElemBlocks (int &numElemBlocks) const =0
virtual int getNumBlockActNodes (GlobalID elemBlockID, int &numNodes) const =0
virtual int getNumBlockActEqns (GlobalID elemBlockID, int &numEqns) const =0
virtual int getNumNodesPerElement (GlobalID elemBlockID, int &nodesPerElem) const =0
virtual int getNumEqnsPerElement (GlobalID elemBlockID, int &eqnsPerElem) const =0
virtual int getNumBlockElements (GlobalID blockID, int &numElems) const =0
virtual int getNumBlockElemDOF (GlobalID blockID, int &DOFPerElem) const =0

Detailed Description

public Finite Element Interface specification, version 2.1, in C++.

Abstract base class.

Note: all FEI functions return an int error code. A value of 0 indicates that there was no error. Errors are usually indicated by -1, except where noted in the documentation for a particular function.

Definition at line 179 of file FEI.hpp.


Constructor & Destructor Documentation

virtual FEI::~FEI ( ) [inline, virtual]

Destructor.

Definition at line 185 of file FEI.hpp.


Member Function Documentation

virtual int FEI::parameters ( int  numParams,
const char *const *  paramStrings 
) [pure virtual]

Set parameters associated with solver choice, etc. This function may be called at any time after the FEI object is instantiated. This function may be called repeatedly with different parameters, which will accumulate those parameters into an internal 'master'-list of parameters.

Parameters:
numParamsNumber of parameters being supplied.
paramStringsList of 'numParams' strings. Each string usually contains a key-value pair, separated by a space.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::setIDLists ( int  numMatrices,
const int *  matrixIDs,
int  numRHSs,
const int *  rhsIDs 
) [pure virtual]

Specify matrixIDs and rhsIDs to be used in cases where multiple matrices and/or rhs vectors are being assembled. This function does not need to be called if only one matrix and rhs are being assembled. Note: the values of the matrix and rhs identifiers must be non-negative. Important Note: If this function is called, it must be called BEFORE setSolveType is called. setSolveType must then be called with the parameter FEI_AGGREGATE_SUM (eigen-solves and product-solves aren't supported yet).

Parameters:
numMatriceslength of matrixIDs parameter
matrixIDslist of user-defined identifiers for separate matrices to be assembled
numRHSslength of rhsIDs parameter
rhsIDslist of user-defined identifiers for separate rhs vectors to be assembled

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::setSolveType ( int  solveType) [pure virtual]

Set the type of solve to be performed. This distinguishes between a 'standard' single solve of Ax=b, an eigen-solve (not yet supported), an 'aggregate-sum' solve (a linear-combination of several separate A's and b's), and an 'aggregate-product' solve (not supported).

Parameters:
solveTypecurrently supported values for this are: FEI_SINGLE_SOLVE, FEI_AGGREGATE_SUM

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::initFields ( int  numFields,
const int *  fieldSizes,
const int *  fieldIDs,
const int *  fieldTypes = NULL 
) [pure virtual]

Identify all the fields present in the analysis. A field may be a scalar such as temperature or pressure, or a 3-vector for velocity, etc. Non-solution fields may be denoted by a negative fieldID. This allows for situations where the application wants to pass data that the FEI doesn't need, (such as geometric coordinates) through to the underlying linear algebra library. This may be done via the various put*Solution functions.

Parameters:
numFieldsGlobal number of fields in the entire problem, on all processors. (This is the length of the fieldSizes and fieldIDs lists.)
fieldSizesNumber of scalars contained in each field.
fieldIDsUser-supplied identifiers for each field.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::initElemBlock ( GlobalID  elemBlockID,
int  numElements,
int  numNodesPerElement,
const int *  numFieldsPerNode,
const int *const *  nodalFieldIDs,
int  numElemDofFieldsPerElement,
const int *  elemDOFFieldIDs,
int  interleaveStrategy 
) [pure virtual]

Initialize the description of an element-block. This function informs the fei implementation of the defining characteristics for a block of elements. An element-block must be homogeneous -- all elements in the block must have the same number of nodes, same number of solution fields per node, etc.

Parameters:
elemBlockIDThe user-defined identifier for this element-block.
numElementsThe number of elements in this block.
numNodesPerElementLength of the numFieldsPerNode list.
numFieldsPerNodeLengths of the rows of the nodalFieldIDs table.
nodalFieldIDsTable where row 'i' is the list of field ids for the ith node on every element in this element-block.
numElemDofFieldsPerElementLength of the elemDOFFieldIDs list.
elemDOFFieldIDslist of field identifiers for the element- centered degrees-of-freedom in the elements in this block.
interleaveStrategyIndicates the ordering of solution-components in the element-wise (e.g., stiffness) contribution arrays. Valid values are FEI_NODE_MAJOR (all field-components for first node are followed by all field-components for second node, ...) or FEI_FIELD_MAJOR (first-field for all nodes, then second-field for all nodes, ...)

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::initElem ( GlobalID  elemBlockID,
GlobalID  elemID,
const GlobalID *  elemConn 
) [pure virtual]

Initialize an element's connectivity. Provide a nodal connectivity list for inclusion in the sparse matrix structure being constructed.

Parameters:
elemBlockIDWhich element-block this element belongs to.
elemIDA user-provided identifier for this element.
elemConnList of nodeIDs connected to this element. Length of this list must be 'numNodesPerElement' provided to the function 'initElemBlock' for this elemBlockID.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::initSharedNodes ( int  numSharedNodes,
const GlobalID *  sharedNodeIDs,
const int *  numProcsPerNode,
const int *const *  sharingProcIDs 
) [pure virtual]

Identify a list of nodes that are shared by processors other than the local processor. This function must be called symmetrically on sharing processors -- if a node is identified to processor 0 as being shared with processor 1, then that node must also be identified to processor 1 as being shared with processor 0. This function may be called repeatedly, and shared nodes may appear in multiple calls to this function.

Parameters:
numSharedNodesLength of the sharedNodeIDs and numProcsPerNode lists, and the number of rows in the sharingProcIDs table.
sharedNodeIDsList of nodes that are shared by this processor and one or more other processors.
numProcsPerNodeLengths of the rows of the sharingProcIDs table.
sharingProcIDsList, for each sharedNode, of processors which share that node.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::initCRMult ( int  numCRNodes,
const GlobalID *  CRNodeIDs,
const int *  CRFieldIDs,
int &  CRID 
) [pure virtual]

Constraint relation initialization, Lagrange Multiplier formulation.

Parameters:
numCRNodesLength of the CRNodeIDs and CRFieldIDs lists.
CRNodeIDsNodes involved in this constraint relation.
CRFieldIDsList of the the field being constrained at each node.
CRIDOutput. An identifier by which this constraint relation may be referred to later, when loading its weight data and recovering its Lagrange Multiplier after the solve.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::initCRPen ( int  numCRNodes,
const GlobalID *  CRNodeIDs,
const int *  CRFieldIDs,
int &  CRID 
) [pure virtual]

Constraint relation initialization, Penalty function formulation .

Parameters:
numCRNodesLength of the CRNodeIDs and CRFieldIDs lists.
CRNodeIDsNodes involved in this constraint relation.
CRFieldIDsList of the the field being constrained at each node.
CRIDOutput. An identifier by which this constraint relation may be referred to later, when loading its weight data and penalty value.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::initSlaveVariable ( GlobalID  slaveNodeID,
int  slaveFieldID,
int  offsetIntoSlaveField,
int  numMasterNodes,
const GlobalID *  masterNodeIDs,
const int *  masterFieldIDs,
const double *  weights,
double  rhsValue 
) [pure virtual]

Advise the FEI that a nodal variable is slaved to a linear combination of other variables, plus a right-hand-side value (note that the rhsValue will often be zero). Since a field may contain more than one scalar component, the particular scalar equation that's being slaved must be specified by not only a nodeID and fieldID, but also an offset into the slave field.

The general form of the dependency being specified is: seqn = sum ( weight_i * meqn_i ) + rhsValue where 'seqn' means slave-equation and 'meqn' means master equation.

Example: to specify that a slave-equation is the average of two master- equations: seqn = 0.5*meqn_1 + 0.5*meqn_2 + 0.0 (Where 0.0 is the rhsValue in this case.)

The list of weights supplied will be assumed to be of length sum(masterFieldSizes). i.e., the slave equation may be dependent on more than one component of the specified master field. In cases where a master field contains more than one scalar component, but only one of those components is relevant to the dependency being specified, then positions in the weights list corresponding to the non-relevant field-components should contain zeros.

This mechanism can also be used as an alternative way to specify essential boundary conditions, where the rhsValue will be the boundary condition value, with no master nodes or weights.

Note: This is a new and experimental capability, and is not compatible with all other FEI capabilities. In particular, the following precaution should be taken: Don't identify both slave variables and constraint-relations for the same degree of freedom. They are mutually exclusive.

Parameters:
slaveNodeIDNode identifier of the node containing the slave eqn.
slaveFieldIDField identifier corresponding to the slave eqn.
offsetIntoSlaveFieldDenotes location, within the field, of the slave eqn.
numMasterNodesNumber of nodes containing variables on which the slave depends.
masterNodeIDsNode identifiers of the master nodes.
masterFieldIDsList, length numMasterNodes, of the field at each master-node which contains the scalar variable(s) on which the slave depends.
weightsList, length sum-of-master-field-sizes, containing the weighting coefficients described above.
rhsValue

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::initComplete ( ) [pure virtual]

Indicate that initialization phase is complete. This function will internally finish calculating the structure of the sparse matrix, and provide that structure to the underlying linear algebra library. At that point the linear algebra library may or may not go ahead and allocate the matrix and vectors for the linear system(s).

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::setCurrentMatrix ( int  matrixID) [pure virtual]

Set current matrix data 'context'. When assembling multiple matrices, this allows the application to specify which matrix should receive data provided by any subsequent data-loading function calls.

Parameters:
matrixIDOne of the identifiers provided earlier via the function 'setIDLists'.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::setCurrentRHS ( int  rhsID) [pure virtual]

Set current rhs data 'context'. When assembling multiple rhs vectors, this allows the application to specify which rhs should receive data provided by any subsequent data-loading function calls.

Parameters:
rhsIDOne of the identifiers provided earlier via the function 'setIDLists'.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::resetSystem ( double  s = 0.0) [pure virtual]

Set a value (usually zero) througout the linear system.

Parameters:
sThe value to be written into the linear system.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::resetMatrix ( double  s = 0.0) [pure virtual]

Set a value (usually zero) througout the matrix.

Parameters:
sThe value to be written into the matrix.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::resetRHSVector ( double  s = 0.0) [pure virtual]

Set a value (usually zero) througout the rhs vector.

Parameters:
sThe value to be written into the rhs vector.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::resetInitialGuess ( double  s) [pure virtual]

Set a value (usually, if not always, 0.0) throughout the initial guess (solution) vector.

Parameters:
sInput. Scalar value to use in filling the solution vector.
Returns:
error-code 0 if successful

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::deleteMultCRs ( ) [pure virtual]

Request that any existing Lagrange-Multiplier constraints be deleted. (Intended to be called in preparation for loading new/different constraints.)

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::loadNodeBCs ( int  numNodes,
const GlobalID *  nodeIDs,
int  fieldID,
const int *  offsetsIntoField,
const double *  prescribedValues 
) [pure virtual]

Load nodal boundary condition data. This allows the application to specify a boundary condition (dirichlet) on a list of nodes.

The boundary condition specified via this function applies to the same solution field on all nodes in the nodeIDs list.

The i-th entry in the offsetsIntoField array specifies which component of the specified field will be prescribed by the i-th entry in the prescribedValues array.

Parameters:
numNodesLength of the nodeIDs list.
nodeIDsList of nodes upon which a boundary condition is to be imposed.
fieldIDThe solution field that will receive the boundary condition.
offsetsIntoFieldArray, length numNodes.
prescribedValuesArray, length numNodes.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::loadElemBCs ( int  numElems,
const GlobalID *  elemIDs,
int  fieldID,
const double *const *  alpha,
const double *const *  beta,
const double *const *  gamma 
) [pure virtual]

Load boundary condition data for element-dof. The form of these boundary conditions is as follows for a given field upon which the condition is to be imposed (description courtesy of Kim Mish). If the primary field solution unknown is denoted by u, and the dual of the solution (e.g., force as opposed to displacement) is denoted by q, then a generic boundary condition can be specified by alpha*u + beta*q = gamma. A dirichlet boundary condition is given when alpha is non-zero but beta is zero. A neumann boundary condition is given when alpha is zero but beta is non-zero. A mixed boundary condition is given when alpha and beta are both non-zero.

Parameters:
numElemsLength of the elemIDs list.
elemIDsList of elements for which a boundary condition is to be specified.
fieldIDThe solution field for which to apply the boundary condition.
alphaTable, as in 'loadNodeBCs', but with 'numElems' number-of- rows.
betaTable, same dimensions as alpha.
gammaTable, same dimensions as alpha.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::sumInElem ( GlobalID  elemBlockID,
GlobalID  elemID,
const GlobalID *  elemConn,
const double *const *  elemStiffness,
const double *  elemLoad,
int  elemFormat 
) [pure virtual]

Element-stiffness/load data loading. This function accumulates element stiffness and load data into the underlying matrix and rhs vector.

Parameters:
elemBlockIDWhich element-block this element belongs to.
elemIDUser-supplied identifier for this element.
elemConnConnectivity list of nodes that are connected to this element.
elemStiffnessTable of element-stiffness data. Dimensions of this table defined by the sum of the sizes of the fields associated with this element. (This information supplied earlier via 'initElemBlock'.)
elemLoadElement-load vector.
elemFormatDesignates the way in which the 'elemStiffness' stiffness-matrix data is laid out. Valid values for this parameter can be found in the file fei_defs.h.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::sumInElemMatrix ( GlobalID  elemBlockID,
GlobalID  elemID,
const GlobalID *  elemConn,
const double *const *  elemStiffness,
int  elemFormat 
) [pure virtual]

Element-stiffness data loading. This function is the same as 'sumInElem' but only accepts stiffness data, not the load data for the rhs.

Parameters:
elemBlockIDWhich element-block this element belongs to.
elemIDUser-supplied identifier for this element.
elemConnConnectivity list of nodes that are connected to this element.
elemStiffnessTable of element-stiffness data. Dimensions of this table defined by the sum of the sizes of the fields associated with this element. (This information supplied earlier via 'initElemBlock'.)
elemFormatDesignates the way in which the 'elemStiffness' stiffness-matrix data is laid out. Valid values for this parameter can be found in the file fei_defs.h.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::sumInElemRHS ( GlobalID  elemBlockID,
GlobalID  elemID,
const GlobalID *  elemConn,
const double *  elemLoad 
) [pure virtual]

Element-load data loading. This function is the same as 'sumInElem', but only accepts the load for the rhs, not the stiffness matrix.

Parameters:
elemBlockIDWhich element-block this element belongs to.
elemIDUser-supplied identifier for this element.
elemConnConnectivity list of nodes that are connected to this element.
elemLoadElement-load vector.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::loadCRMult ( int  CRMultID,
int  numCRNodes,
const GlobalID *  CRNodeIDs,
const int *  CRFieldIDs,
const double *  CRWeights,
double  CRValue 
) [pure virtual]

Load weight/value data for a Lagrange Multiplier constraint relation.

Parameters:
CRMultIDIdentifier returned from an earlier call to 'initCRMult'.
numCRNodesLength of CRNodeIDs and CRFieldIDs lists.
CRNodeIDsList of nodes in this constraint relation.
CRFieldIDsList of fields, one per node, to be constrained.
CRWeightsWeighting coefficients. This length of this list is the sum of the sizes associated with the fields identified in CRFieldIDs.
CRValueThe constraint's rhs value. Often (always?) zero.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::loadCRPen ( int  CRPenID,
int  numCRNodes,
const GlobalID *  CRNodeIDs,
const int *  CRFieldIDs,
const double *  CRWeights,
double  CRValue,
double  penValue 
) [pure virtual]

Load weight/value data for a Penalty constraint relation.

Parameters:
CRPenIDIdentifier returned from an earlier call to 'initCRPen'.
numCRNodesLength of CRNodeIDs and CRFieldIDs lists.
CRNodeIDsList of nodes in this constraint relation.
CRFieldIDsList of fields, one per node, to be constrained.
CRWeightsWeighting coefficients. This length of this list is the sum of the sizes associated with the fields identified in CRFieldIDs.
CRValueThe constraint's rhs value. Often (always?) zero.
penValueThe penalty value.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::putIntoRHS ( int  IDType,
int  fieldID,
int  numIDs,
const GlobalID *  IDs,
const double *  coefficients 
) [pure virtual]

Put a copy of coefficient data into the rhs vector.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::sumIntoRHS ( int  IDType,
int  fieldID,
int  numIDs,
const GlobalID *  IDs,
const double *  coefficients 
) [pure virtual]

Sum a copy of coefficient data into the rhs vector.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::setMatScalars ( int  numScalars,
const int *  IDs,
const double *  scalars 
) [pure virtual]

Set scalars by which to multiply matrices, in cases where a linear- combination of several matrices is to be solved.

Parameters:
numScalarsLength of the IDs and scalars lists.
IDsMatrix identifiers which must be a subset of those supplied via an earlier call to 'setIDLists'.
scalarsThe coefficients by which to multiply the matrices.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::setRHSScalars ( int  numScalars,
const int *  IDs,
const double *  scalars 
) [pure virtual]

Set scalars by which to multiply rhs vectors, in cases where a linear- combination of several rhs vectors is to be solved.

Parameters:
numScalarsLength of the IDs and scalars lists.
IDsRHS-vector identifiers which must be a subset of those supplied via an earlier call to 'setIDLists'.
scalarsThe coefficients by which to multiply the rhs vectors.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::loadComplete ( bool  applyBCs = true,
bool  globalAssemble = true 
) [pure virtual]

Indicate that all data loading is complete, and that the underlying linear system can now be "finalized". e.g., boundary conditions enforced, shared contributions exchanged among processors, etc.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::residualNorm ( int  whichNorm,
int  numFields,
int *  fieldIDs,
double *  norms 
) [pure virtual]

Request residual norms of the underlying linear-system, broken down by solution field. This function should obviously not be called until after the matrix and vector data has been fully assembled. Calculates the residual vector r = b - Ax, then takes a norm of r, separating out the components corresponding to the various fields in 'fieldIDs'. If the solution vector x contains zeros, then r == b.

Parameters:
whichNormDetermines which norm is calculated. 1 -> 1-norm, 2 -> 2-norm, 0 -> infinity-norm.
numFieldsLength of the fieldIDs and norms lists.
fieldIDsThe fields for which residual norms are to be returned.
normsA norm corresponding to each field in fieldIDs.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::solve ( int &  status) [pure virtual]

Launch the solver to solve the assembled linear system.

Parameters:
statusIndicates the status of the solve. Varies depending on the specific underlying solver library.
Returns:
err is 0 if the solve was acheived according to any specified parameters (i.e., reached specified tolerance within any specified iteration-limit). Non-zero error return might not indicate a fatal error, but rather might indicate that the iteration-limit was reached before convergence, etc. A non-zero error return basically indicates that the status parameter should be checked and interpreted.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::iterations ( int &  itersTaken) const [pure virtual]

Query number of iterations taken for last solve.

Parameters:
itersTakenIterations performed during any previous solve.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getFieldSize ( int  fieldID,
int &  numScalars 
) [pure virtual]

Query the size of a field. This info is supplied to the FEI (initFields) by the application, but may not be readily available on the app side at all times. Thus, it would be nice if the FEI could answer this query.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getEqnNumbers ( GlobalID  ID,
int  idType,
int  fieldID,
int &  numEqns,
int *  eqnNumbers 
) [pure virtual]

Since the ultimate intent for matrix-access is to bypass the FEI and go straight to the underlying data objects, we need a translation function to map between the IDs that the FEI deals in, and equation numbers that linear algebra objects deal in.

Parameters:
IDIdentifier of either a node or an element.
idTypeCan take either of the values FEI_NODE or FEI_ELEMENT.
fieldIDIdentifies a particular field at this [node||element].
numEqnsOutput. Number of equations associated with this node/field (or element/field) pair.
eqnNumbersCaller-allocated array. On exit, this is filled with the above-described equation-numbers. They are global 0-based numbers.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getNodalFieldSolution ( int  fieldID,
int  numNodes,
const GlobalID *  nodeIDs,
double *  results 
) [pure virtual]

Get the solution data for a particular field, on an arbitrary set of nodes.

Parameters:
fieldIDInput. field identifier for which solution data is being requested.
numNodesInput. Length of the nodeIDs list.
nodeIDsInput. List specifying the nodes on which solution data is being requested.
resultsAllocated by caller, but contents are output. Solution data for the i-th node/element starts in position i*fieldSize, where fieldSize is the number of scalar components that make up 'fieldID'.
Returns:
error-code 0 if successful

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getNumLocalNodes ( int &  numNodes) [pure virtual]

Get the number of nodes that are local to this processor (includes nodes that are shared by other processors).

Parameters:
numNodesOutput. Number of local nodes.
Returns:
error-code 0 if successful

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getLocalNodeIDList ( int &  numNodes,
GlobalID *  nodeIDs,
int  lenNodeIDs 
) [pure virtual]

Get a list of the nodeIDs that are local to this processor (includes nodes that are shared by other processors).

Parameters:
numNodesOutput. Same as the value output by 'getNumLocalNodes'.
nodeIDsCaller-allocated array, contents to be filled by this function.
lenNodeIDsInput. Length of the caller-allocated nodeIDs array. If lenNodeIDs is less than numNodes, then only 'lenNodeIDs' nodeIDs are provided, of course. If lenNodeIDs is greater than numNodes, then only 'numNodes' positions of the nodeIDs array are referenced.
Returns:
error-code 0 if successful

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::putNodalFieldData ( int  fieldID,
int  numNodes,
const GlobalID *  nodeIDs,
const double *  data 
) [pure virtual]

Input data associated with the specified field on a specified list of nodes.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getBlockNodeSolution ( GlobalID  elemBlockID,
int  numNodes,
const GlobalID *  nodeIDs,
int *  offsets,
double *  results 
) [pure virtual]

Return nodal solutions for an element-block. The user supplies the list of nodes for which solutions are required. This list may be a subset of the nodes in the element-block.

Parameters:
elemBlockIDElement-block for which the nodal solutions are desired.
numNodesLength of the nodeIDs list.
nodeIDsUser-supplied list of nodes in this element-block. The list of all nodes in an element-block may be obtained from the FEI via the function 'getBlockNodeIDList'.
offsetsList of offsets into the results list. The first solution value for node i is results[offsets[i]]. The number of solution values for node i is offsets[i+1]-offsets[i]. The offsets list is of length numNodes+1.
resultsList of the nodal solution values. The results list should be allocated with length 'getNumBlockActEqns', if 'nodeIDs' contains all nodes in the element-block.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getNodalSolution ( int  numNodes,
const GlobalID *  nodeIDs,
int *  offsets,
double *  results 
) [pure virtual]

Return nodal solutions for an arbitrary list of nodes. The user supplies the list of node-identifiers for which solutions are required. This list may be any subset of the nodes that reside on the local processor.

Parameters:
numNodesNumber of nodes
nodeIDsNode-identifiers, list of length numNodes
offsetsList of length numNodes+1, allocated by caller. On exit, this list will contain offsets into the results array at which nodal solutions are located. The solution values for the nodeIDs[i] will begin at position offsets[i]. The last solution value for nodeIDs[i] will be located at position offsets[i+1]-1.
resultsList, allocated by caller, of length sum-of-num-dof-per-node.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getBlockFieldNodeSolution ( GlobalID  elemBlockID,
int  fieldID,
int  numNodes,
const GlobalID *  nodeIDs,
double *  results 
) [pure virtual]

Return nodal solutions for one field.

Parameters:
elemBlockIDElement-block identifier.
fieldIDThe field for which solution values are desired.
numNodesLength of the nodeIDs list.
nodeIDsUser-supplied list of nodes for which solution values are desired. The list of all nodes in an element-block may be obtained from the FEI via the function 'getBlockNodeIDList'.
resultsList of solution values. The solution values for node i start at results[i*fieldSize] where fieldSize is the size of fieldID.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getBlockElemSolution ( GlobalID  elemBlockID,
int  numElems,
const GlobalID *  elemIDs,
int &  numElemDOFPerElement,
double *  results 
) [pure virtual]

Return elem-dof solution params.

Parameters:
elemBlockIDElement-block identifier.
numElemsLength of the elemIDs list.
elemIDsUser-supplied list of elements for which solution values are desired.
numElemDOFPerElementOutput. Number of elem-dof per element.
resultsList of solution values. The solution values for element i start at results[i*numElemDOFPerElement]

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getNumCRMultipliers ( int &  numMultCRs) [pure virtual]

Number of constraint relation multipliers. The number of Lagrange Multiplier constraint relations in the problem.

Parameters:
numMultCRsOutput

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getCRMultIDList ( int  numMultCRs,
int *  multIDs 
) [pure virtual]

List of identifiers for Lagrange Multipliers.

Parameters:
numMultCRsInput. Value obtained from 'getNumCRMultipliers'.
multIDsOutput. User-allocated list, to be filled, on exit, with the identifiers for the first 'numMultCRs' multiplier constraints in the problem.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getCRMultipliers ( int  numCRs,
const int *  CRIDs,
double *  results 
) [pure virtual]

Return Lagrange Multiplier solutions.

Parameters:
numCRsnumber of constraint relations for which multipliers are being requested.
CRIDsIdentifiers of constraint-relations for which multipliers are being requested.
resultsList of Lagrange Multipliers, one per constraint relation.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::putBlockNodeSolution ( GlobalID  elemBlockID,
int  numNodes,
const GlobalID *  nodeIDs,
const int *  offsets,
const double *  estimates 
) [pure virtual]

Put nodal-based solution estimates for an element-block.

Parameters:
elemBlockIDElement-block identifier.
numNodesLength of nodeIDs list.
nodeIDsThose nodes for which solutions are being supplied.
offsetsList, length numNodes+1, of offsets into the estimates list.
estimatesList of solution estimates. The solution estimates for node i will be assumed to start in estimates[offsets[i]]. The length of the estimates list should be offsets[numNodes].

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::putBlockFieldNodeSolution ( GlobalID  elemBlockID,
int  fieldID,
int  numNodes,
const GlobalID *  nodeIDs,
const double *  estimates 
) [pure virtual]

Put nodal-based solution estimates for one field for an element-block.

Parameters:
elemBlockIDElement-block identifier.
fieldIDThe field for which estimates are being supplied.
numNodesLength of the nodeIDs list.
nodeIDsThe nodes for which solution estimates are being supplied.
estimatesList of initial guesses. Should be of length numNodes * fieldSize, where fieldSize is the size of field 'fieldID'.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::putBlockElemSolution ( GlobalID  elemBlockID,
int  numElems,
const GlobalID *  elemIDs,
int  dofPerElem,
const double *  estimates 
) [pure virtual]

Put element-dof solution guesses for an element-block.

Parameters:
elemBlockIDElement-block identifier.
numElemsLength of the elemIDs list.
elemIDsThose elements for which elem-dof initial guesses are being supplied.
dofPerElemNumber of degrees-of-freedom per element.
estimatesList of length numElems*dofPerElem. The estimates for element i should start in estimates[i*dofPerElem].

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::putCRMultipliers ( int  numMultCRs,
const int *  CRMultIDs,
const double *  multEstimates 
) [pure virtual]

Put Lagrange Multiplier solution guesses.

Parameters:
numMultCRsLength of the CRMultIDs and multEstimates lists.
CRMultIDsIdentifiers obtained from earlier calls to 'initCRMult'.
multEstimatesInitial guesses for the Lagrange Multipliers.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getBlockNodeIDList ( GlobalID  elemBlockID,
int  numNodes,
GlobalID *  nodeIDs 
) [pure virtual]

Return list of nodes associated with an element-block.

Parameters:
elemBlockIDElement-block identifier.
numNodesAllocated length of the nodeIDs list. If this is less than the value obtained via 'getNumBlockActNodes', then the first numNodes node id's will be placed in the nodeIDs list, ordered in ascending value.
nodeIDsOutput. All nodes associated with this element-block.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getBlockElemIDList ( GlobalID  elemBlockID,
int  numElems,
GlobalID *  elemIDs 
) [pure virtual]

Return llist of all elements associated with an element-block.

Parameters:
elemBlockIDElement-block identifier.
numElemsLength of the elemIDs list.
elemIDsOutput. All elements associated with this element-block.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::version ( const char *&  versionString) [pure virtual]

Return a version string. This string is owned by the FEI implementation, the calling application should not delete/free it. This string will contain the FEI implementation's version number, and if possible, a build time/date.

Parameters:
versionStringOutput reference to a char*. The C interface will have a char** here. This function is simply setting versionString to point to the internal version string.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::cumulative_cpu_times ( double &  initPhase,
double &  loadPhase,
double &  solve,
double &  solnReturn 
) [pure virtual]

Return cumulative cpu-time spent in each of 4 major FEI phases.

Parameters:
initPhaseTime in seconds, spent in the initialization phase.
loadPhaseTime in seconds, spent loading data, up until the solver was launched.
solveTime in seconds, spent in the call to the underlying solver.
solnReturnTime in seconds, spent in the solution-return functions.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getNumSolnParams ( GlobalID  globalNodeID,
int &  numSolnParams 
) const [pure virtual]

Return the number of scalar degrees of freedom associated with a node.

Parameters:
globalNodeIDGlobally unique node identifier
numSolnParamsSum of the sizes of the solution fields associated with the node. This will be the union of the set of fields defined on this node over all element-blocks it is associated with.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getNumElemBlocks ( int &  numElemBlocks) const [pure virtual]

Return the number of element-blocks.

Parameters:
numElemBlocks

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getNumBlockActNodes ( GlobalID  elemBlockID,
int &  numNodes 
) const [pure virtual]

Return the number of active nodes in an element-block.

Parameters:
elemBlockIDInput.
numNodesOutput.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getNumBlockActEqns ( GlobalID  elemBlockID,
int &  numEqns 
) const [pure virtual]

Return the number of active equations in an element block.

Parameters:
elemBlockIDInput.
numEqnsOutput. Includes both nodal equations and elem-dof equations.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getNumNodesPerElement ( GlobalID  elemBlockID,
int &  nodesPerElem 
) const [pure virtual]

Return the number of nodes associated with elements of an element-block.

Parameters:
elemBlockIDInput.
nodesPerElemOutput.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getNumEqnsPerElement ( GlobalID  elemBlockID,
int &  eqnsPerElem 
) const [pure virtual]

Return the number of equations at each element in an element-block. Includes elem-dof equations.

Parameters:
elemBlockIDInput.
eqnsPerElemOutput.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getNumBlockElements ( GlobalID  blockID,
int &  numElems 
) const [pure virtual]

Return the number of elements in an element-block.

Parameters:
blockIDInput.
numElemsOutput.

Implemented in fei::FEI_Impl, and FEI_Implementation.

virtual int FEI::getNumBlockElemDOF ( GlobalID  blockID,
int &  DOFPerElem 
) const [pure virtual]

Return the number of element-dof at elements in this element-block.

Parameters:
blockIDInput.
DOFPerElemOutput.

Implemented in fei::FEI_Impl, and FEI_Implementation.


The documentation for this class was generated from the following file:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Friends