fei Namespace Reference


Classes

class  BlockLinearProblemManager
struct  CommMap
class  MessageHandler
class  ConnectivityBlock
class  CSRMat
class  CSVec
class  ctg_set
class  DirichletBCManager
struct  DirichletBCRecord
class  less_DirichletBCRecord
class  Dof
struct  less_rank_id_field
struct  less_field_rank_id
class  DofMapper
class  EqnComm
struct  EqnRecord
class  Factory
class  FEI_Impl
class  FieldMask
class  FillableMat
class  FillableVec
class  Graph
class  Graph_Impl
class  GraphReducer
class  IndexTable
class  LinearDecomposition
class  LinearProblemManager
class  LinearSystem
class  LogFile
class  Logger
class  LogManager
class  Lookup_Impl
class  Matrix
class  Matrix_core
class  Matrix_Impl
class  Matrix_Local
class  MatrixGraph
class  MatrixGraph_Impl2
class  MatrixReducer
struct  MatrixTraits
struct  MatrixTraits< FiniteElementData >
struct  MatrixTraits< FillableMat >
struct  MatrixTraits< LinearSystemCore >
struct  mpiTraits
struct  mpiTraits< float >
struct  mpiTraits< double >
struct  mpiTraits< int >
struct  mpiTraits< long >
class  Param
class  ParameterSet
class  Pattern
class  Record
class  Record_Operator
class  Reducer
class  ReverseMapper
class  SharedIDs
class  SharedPtr
class  Solver
class  SparseRowGraph
class  Vector
class  Vector_core
class  Vector_Impl
class  Vector_Local
class  VectorReducer
class  VectorSpace
struct  VectorTraits
struct  VectorTraits< FiniteElementData >
struct  VectorTraits< FillableVec >
struct  VectorTraits< LinearSystemCore >
struct  MatrixTraits< fei::LinearProblemManager >
struct  VectorTraits< fei::LinearProblemManager >

Namespaces

namespace  impl_utils
namespace  utils

Typedefs

typedef snl_fei::RaggedTable<
std::map< int, std::set<
int > * >, std::set< int > > 
comm_map
typedef snl_fei::Constraint<
fei::Record< int > * > 
ConstraintType

Enumerations

enum  OutputLevel

Functions

template<typename T>
int binarySearch (const T &item, const T *list, int len)
template<typename T>
void insertion_sort_with_companions (int len, int *array, T *companions)
template<typename T>
int lowerBound (const T &item, const T *list, int len)
template<typename T>
int binarySearch (const T &item, const T *list, int len, int &insertPoint)
template<typename T>
int binarySearch (const T &item, const std::vector< T > &list, int &insertPoint)
template<typename T>
int binarySearch (const T &item, const std::vector< T > &list)
template<typename T>
int binarySearch (const T &item, const T *list, int, int start, int end, int &insertPoint)
template<typename T>
int binarySearch (int numItems, const T *items, int *offsets, const T *list, int listLength)
template<class T>
int sortedListInsert (const T &item, std::vector< T > &list)
template<class T>
int sortedListInsert (const T &item, T *&list, int &len, int &allocLen)
template<class T>
int listInsert (const T &item, int offset, T *&list, int &usedLength, int &allocatedLength, int allocChunkSize=200)
template<class T>
int searchList (const T &item, const T *list, int len)
template<typename T>
void addItemsToCommMap (int proc, size_t numItems, const T *items, typename CommMap< T >::Type &comm_map, bool keep_sorted_and_unique=true)
int localProc (MPI_Comm comm)
int numProcs (MPI_Comm comm)
void Barrier (MPI_Comm comm)
int mirrorProcs (MPI_Comm comm, std::vector< int > &toProcs, std::vector< int > &fromProcs)
int mirrorCommPattern (MPI_Comm comm, comm_map *inPattern, comm_map *&outPattern)
int exchangeIntData (MPI_Comm comm, const std::vector< int > &sendProcs, std::vector< int > &sendData, const std::vector< int > &recvProcs, std::vector< int > &recvData)
int Allreduce (MPI_Comm comm, bool localBool, bool &globalBool)
template<class T>
int GlobalMax (MPI_Comm comm, std::vector< T > &local, std::vector< T > &global)
template<class T>
int GlobalMax (MPI_Comm comm, T local, T &global)
template<class T>
int GlobalMin (MPI_Comm comm, T local, T &global)
template<class T>
int GlobalSum (MPI_Comm comm, std::vector< T > &local, std::vector< T > &global)
template<class T>
int GlobalSum (MPI_Comm comm, T local, T &global)
template<class T>
int Allgatherv (MPI_Comm comm, std::vector< T > &sendbuf, std::vector< int > &recvLengths, std::vector< T > &recvbuf)
template<class T>
int Bcast (MPI_Comm comm, std::vector< T > &sendbuf, int sourceProc)
template<typename T>
int exchangeCommMapData (MPI_Comm comm, const typename CommMap< T >::Type &sendCommMap, typename CommMap< T >::Type &recvCommMap, bool recvProcsKnownOnEntry=false, bool recvLengthsKnownOnEntry=false)
template<class T>
int exchangeData (MPI_Comm comm, std::vector< int > &sendProcs, std::vector< std::vector< T > > &sendData, std::vector< int > &recvProcs, bool recvDataLengthsKnownOnEntry, std::vector< std::vector< T > > &recvData)
template<class T>
int exchangeData (MPI_Comm comm, std::vector< int > &sendProcs, std::vector< std::vector< T > * > &sendData, std::vector< int > &recvProcs, bool recvLengthsKnownOnEntry, std::vector< std::vector< T > * > &recvData)
template<class T>
int exchange (MPI_Comm comm, MessageHandler< T > *msgHandler)
void multiply_CSRMat_CSVec (const CSRMat &A, const CSVec &x, CSVec &y)
void multiply_trans_CSRMat_CSVec (const CSRMat &A, const CSVec &x, CSVec &y)
void multiply_CSRMat_CSRMat (const CSRMat &A, const CSRMat &B, CSRMat &C, bool storeResultZeros)
void multiply_trans_CSRMat_CSRMat (const CSRMat &A, const CSRMat &B, CSRMat &C, bool storeResultZeros)
void add_CSRMat_to_FillableMat (const CSRMat &csrm, FillableMat &fm)
void add_entry (CSVec &vec, int eqn, double coef)
void put_entry (CSVec &vec, int eqn, double coef)
void remove_entry (CSVec &vec, int eqn)
void set_values (CSVec &vec, double scalar)
void add_CSVec_CSVec (const CSVec &u, CSVec &v)
FillableMat::feipoolmat::iterator insert_row (FillableMat::feipoolmat &matdata, FillableMat::feipoolmat::iterator iter, int row, fei_Pool_alloc< FillableVec > &vecpool)
int count_nnz (const FillableMat &mat)
void get_row_numbers (const FillableMat &mat, std::vector< int > &rows)
template<class LocalOrdinal, class GlobalOrdinal, class DofOrder>
void set_dof_mappings (GlobalOrdinal first_index, fei::DofMapper< LocalOrdinal, GlobalOrdinal, DofOrder > &dof_mapper)
void copy_into_shared_ids (const fei::CommMap< int >::Type &procs_to_ids_and_sharing_procs, const snl_fei::RecordCollection &records, fei::SharedIDs< int > &sharedIDs)
void copy_remotelyowned_ids_into_CommMap (int myProc, const fei::LinearDecomposition< int > &lindecomp, const snl_fei::RecordCollection &records, fei::CommMap< int >::Type &procs_to_shared_ids)
void set_shared_ids (MPI_Comm comm, const snl_fei::RecordCollection &records, fei::SharedIDs< int > &sharedIDs)
template<typename T, typename U>
bool operator== (const SharedPtr< T > &a, const SharedPtr< U > &b)
template<typename T, typename U>
bool operator!= (const SharedPtr< T > &a, const SharedPtr< U > &b)
int find_row_start (int row, const SparseRowGraph &srg)
template<typename SET_TYPE>
void copySetToArray (const SET_TYPE &set_obj, int lenList, int *list)
template<typename T>
void copySetToVector (const std::set< T > &set_obj, std::vector< T > &vec)
template<typename MAP_TYPE>
void copyKeysToArray (const MAP_TYPE &map_obj, unsigned lenList, int *list)
template<typename MAP_TYPE>
void copyKeysToVector (const MAP_TYPE &map_obj, std::vector< int > &keyvector)
template<typename T, typename U>
void copyMapOfSetsToVectorOfVectors (const std::map< T, std::set< U > > &mapset, std::vector< T > &keys, std::vector< std::vector< U > > &values)
template<typename MAP_TYPE>
void copyToArrays (MAP_TYPE &map_obj, int lenList, int *keylist, int *vallist)
template<typename MAP_TYPE>
void destroyValues (MAP_TYPE &map_obj)
template<typename MAP_TYPE, typename SET_TYPE>
void writeToStream (snl_fei::RaggedTable< MAP_TYPE, SET_TYPE > &table, FEI_OSTREAM &os, const char *lineprefix=NULL)
template<typename MAP_TYPE, typename SET_TYPE>
void packRaggedTable (snl_fei::RaggedTable< MAP_TYPE, SET_TYPE > &table, std::vector< int > &intdata)
template<typename MAP_TYPE, typename SET_TYPE>
fei::SharedPtr< fei::SparseRowGraphcreateSparseRowGraph (const std::vector< snl_fei::RaggedTable< MAP_TYPE, SET_TYPE > * > &tables)
template<typename MAP_TYPE, typename SET_TYPE>
void copyToSparseRowGraph (snl_fei::RaggedTable< MAP_TYPE, SET_TYPE > &table, fei::SparseRowGraph &srg)
template<typename MAP_TYPE, typename SET_TYPE>
fei::SharedPtr< fei::SparseRowGraphcreateSparseRowGraph (snl_fei::RaggedTable< MAP_TYPE, SET_TYPE > &table)
template<typename MAP_TYPE, typename SET_TYPE>
int countNonzeros (snl_fei::RaggedTable< MAP_TYPE, SET_TYPE > &table)
fei::SharedPtr< LibraryWrappercreate_LibraryWrapper (MPI_Comm comm, const char *libraryName)
fei::SharedPtr< fei::Factorycreate_fei_Factory (MPI_Comm comm, const char *libraryName)

Variables

const int Set_end_val = -99999999


Detailed Description

The fei namespace contains public functions, classes and interfaces.


Typedef Documentation

typedef snl_fei::Constraint<fei::Record<int>*> fei::ConstraintType

alias for constraint type

Definition at line 25 of file fei_MatrixGraph.hpp.


Enumeration Type Documentation

enum fei::OutputLevel

enumeration for various output levels

Definition at line 46 of file fei_fwd.hpp.


Function Documentation

template<typename T>
int fei::binarySearch ( const T &  item,
const T *  list,
int  len 
)

Binary search of a list that's assumed to be sorted.

Parameters:
item to be searched for.
list List to be searched.
len Length of list.
Returns:
offset Offset at which item was found, or -1 if not found.

Definition at line 27 of file fei_ArrayUtils.hpp.

template<typename T>
void fei::insertion_sort_with_companions ( int  len,
int *  array,
T *  companions 
)

sort the specified array, and move the contents of the specified companions array to match the new order. This is an implementation of the insertion sort algorithm.

Definition at line 63 of file fei_ArrayUtils.hpp.

template<typename T>
int fei::lowerBound ( const T &  item,
const T *  list,
int  len 
)

Lower bound finds the first entry in list that is not less than item. A binary search is used, and list is assumed to be sorted.

Definition at line 87 of file fei_ArrayUtils.hpp.

template<typename T>
int fei::binarySearch ( const T &  item,
const T *  list,
int  len,
int &  insertPoint 
)

Binary search of a list that's assumed to be sorted.

Parameters:
item to be searched for.
list List to be searched.
len Length of list.
insertPoint If item is not found, this is the offset into list at which item could be inserted while maintaining sortedness. Not referenced if item is found.
Returns:
offset Offset at which item was found, or -1 if not found.

Definition at line 128 of file fei_ArrayUtils.hpp.

template<typename T>
int fei::binarySearch ( const T &  item,
const std::vector< T > &  list,
int &  insertPoint 
)

Binary search of an std::vector that's assumed to be sorted.

Definition at line 191 of file fei_ArrayUtils.hpp.

template<typename T>
int fei::binarySearch ( const T &  item,
const std::vector< T > &  list 
)

Binary search of an std::vector that's assumed to be sorted.

Definition at line 203 of file fei_ArrayUtils.hpp.

template<typename T>
int fei::binarySearch ( const T &  item,
const T *  list,
int  ,
int  start,
int  end,
int &  insertPoint 
)

Perform a binary search but limit the search to a given range.

Parameters:
item Value to be searched for.
list 
listLength 
start Starting offset of search 'window'.
end Ending offset of search 'window'. end should be less than listLength.
insertPoint 
Returns:
offset position at which item was found. If not found, returns -1. (Since 0-based indexing is used, 'end' can't be greater than listLength-1.)

Definition at line 221 of file fei_ArrayUtils.hpp.

template<typename T>
int fei::binarySearch ( int  numItems,
const T *  items,
int *  offsets,
const T *  list,
int  listLength 
)

Perform a binary search for each item in a sorted input list.

Parameters:
numItems number of items to be searched for
items list of items (length numItems) to be searched for
offsets list (length numItems) allocated by caller. On exit, offsets[i] contains the offset of item in 'list', or -1 if item is not present in 'list'.
list array (length 'listLength') to be searched
listLength length of input array 'list'

Definition at line 291 of file fei_ArrayUtils.hpp.

template<class T>
int fei::sortedListInsert ( const T &  item,
std::vector< T > &  list 
)

Insert an item into a sorted list, maintaining sortedness. If the item is inserted, return the offset at which it was inserted. If the item was already present, return -1.

Definition at line 318 of file fei_ArrayUtils.hpp.

template<class T>
int fei::sortedListInsert ( const T &  item,
T *&  list,
int &  len,
int &  allocLen 
)

Insert an item into a sorted list, maintaining sortedness.

Definition at line 334 of file fei_ArrayUtils.hpp.

template<class T>
int fei::listInsert ( const T &  item,
int  offset,
T *&  list,
int &  usedLength,
int &  allocatedLength,
int  allocChunkSize = 200 
)

Insert an item into a list at a specified position.

Definition at line 364 of file fei_ArrayUtils.hpp.

template<class T>
int fei::searchList ( const T &  item,
const T *  list,
int  len 
)

Simple exhaustive search of a list.

Returns:
offset at which item is found, or -1 if not found.

Definition at line 405 of file fei_ArrayUtils.hpp.

template<typename T>
void fei::addItemsToCommMap ( int  proc,
size_t  numItems,
const T *  items,
typename CommMap< T >::Type &  comm_map,
bool  keep_sorted_and_unique = true 
)

Given a proc and an array of items, add the mapping proc -> items to the given comm_map. Optionally ensure that the comm_map's vector of items for proc remains sorted and unique.

Definition at line 32 of file fei_CommMap.hpp.

int fei::localProc ( MPI_Comm  comm  ) 

Return the MPI rank of the local processor. If the macro FEI_SER is defined, returns 0; otherwise calls MPI_Comm_rank.

Definition at line 13 of file fei_CommUtils.cpp.

int fei::numProcs ( MPI_Comm  comm  ) 

Return the number of processors (number of MPI ranks). If the macro FEI_SER is defined, returns 1; otherwise calls MPI_Comm_size.

Definition at line 25 of file fei_CommUtils.cpp.

int fei::mirrorProcs ( MPI_Comm  comm,
std::vector< int > &  toProcs,
std::vector< int > &  fromProcs 
)

Scenario: The local processor has a list of processors to which data will be sent, but doesn't know which processors data will be received from. This method produces that list of processors to be received from. This is a collective method.

Definition at line 45 of file fei_CommUtils.cpp.

int fei::mirrorCommPattern ( MPI_Comm  comm,
comm_map *  inPattern,
comm_map *&  outPattern 
)

Given a comm-pattern, create and initialize its mirror...

Definition at line 98 of file fei_CommUtils.cpp.

int fei::exchangeIntData ( MPI_Comm  comm,
const std::vector< int > &  sendProcs,
std::vector< int > &  sendData,
const std::vector< int > &  recvProcs,
std::vector< int > &  recvData 
)

Given a list of processors to send to, a scalar to send to each, and a list of processors to receive from, perform the exchange.

Parameters:
sendProcs Input. List of processors to send to.
sendData Input. List of data, same length as 'sendProcs', to be sent. (One item to be sent to each send proc.) Note: sendData is treated as const, but not declared const because it is passed to the MPI_Send routine which takes (non-const) void*.
recvProcs Input. List of processors to receive from. Note: if you don't know which procs will be recv'd from, see the 'mirrorProcs' function above.
recvData Output. On exit, contains one item received from each recv proc.
Returns:
error-code 0 if successful

Definition at line 215 of file fei_CommUtils.cpp.

int fei::Allreduce ( MPI_Comm  comm,
bool  localBool,
bool &  globalBool 
)

Perform a "global OR" to reduce the local-bool to a global-bool. i.e., if localBool is true on any processor, then on exit globalBool will be true on all processors.

Definition at line 265 of file fei_CommUtils.cpp.

template<class T>
int fei::GlobalMax ( MPI_Comm  comm,
std::vector< T > &  local,
std::vector< T > &  global 
)

Perform an MPI_Allreduce with op = MPI_MAX

Parameters:
local Input.
global Output.
Returns:
MPI error-code

Definition at line 91 of file fei_CommUtils.hpp.

template<class T>
int fei::GlobalMax ( MPI_Comm  comm,
local,
T &  global 
)

Perform an MPI_Allreduce with op = MPI_MAX

Parameters:
local Input.
global Output.
Returns:
MPI error-code

Definition at line 121 of file fei_CommUtils.hpp.

template<class T>
int fei::GlobalMin ( MPI_Comm  comm,
local,
T &  global 
)

Perform an MPI_Allreduce with op = MPI_MIN

Parameters:
local Input.
global Output.
Returns:
MPI error-code

Definition at line 140 of file fei_CommUtils.hpp.

template<class T>
int fei::GlobalSum ( MPI_Comm  comm,
std::vector< T > &  local,
std::vector< T > &  global 
)

Perform an MPI_Allreduce with op = MPI_SUM

Parameters:
local Input.
global Output.
Returns:
MPI error-code

Definition at line 159 of file fei_CommUtils.hpp.

template<class T>
int fei::GlobalSum ( MPI_Comm  comm,
local,
T &  global 
)

Single-scalar version of the GlobalSum function.

Definition at line 177 of file fei_CommUtils.hpp.

template<class T>
int fei::Allgatherv ( MPI_Comm  comm,
std::vector< T > &  sendbuf,
std::vector< int > &  recvLengths,
std::vector< T > &  recvbuf 
)

Allgatherv function that takes std::vectors.

Definition at line 193 of file fei_CommUtils.hpp.

template<typename T>
int fei::exchangeCommMapData ( MPI_Comm  comm,
const typename CommMap< T >::Type &  sendCommMap,
typename CommMap< T >::Type &  recvCommMap,
bool  recvProcsKnownOnEntry = false,
bool  recvLengthsKnownOnEntry = false 
)

Perform communication send data from one CommMap and receive into another CommMap.

Parameters:
comm Input. MPI communicator.
sendCommMap Input. Maps destination processors to vectors of data to be sent to them.
recvCommMap Output. On exit, will map source processors to vectors of data that was received from them.

Definition at line 273 of file fei_CommUtils.hpp.

void fei::multiply_CSRMat_CSVec ( const CSRMat &  A,
const CSVec &  x,
CSVec &  y 
)

form y = A*x

Definition at line 101 of file fei_CSRMat.cpp.

void fei::multiply_trans_CSRMat_CSVec ( const CSRMat &  A,
const CSVec &  x,
CSVec &  y 
)

form y = A^T*x

Definition at line 147 of file fei_CSRMat.cpp.

void fei::multiply_CSRMat_CSRMat ( const CSRMat &  A,
const CSRMat &  B,
CSRMat &  C,
bool  storeResultZeros = false 
)

form C = A*B

Definition at line 188 of file fei_CSRMat.cpp.

void fei::multiply_trans_CSRMat_CSRMat ( const CSRMat &  A,
const CSRMat &  B,
CSRMat &  C,
bool  storeResultZeros = false 
)

form C = A^T*B

Definition at line 267 of file fei_CSRMat.cpp.

void fei::add_CSVec_CSVec ( const CSVec &  u,
CSVec &  v 
)

form v = v + u

Definition at line 117 of file fei_CSVec.cpp.

int fei::count_nnz ( const FillableMat &  mat  ) 

Return the number of nonzeros in mat.

Definition at line 243 of file fei_FillableMat.cpp.

void fei::get_row_numbers ( const FillableMat &  mat,
std::vector< int > &  rows 
)

Fill a std::vector with the row-numbers from the given matrix.

Definition at line 260 of file fei_FillableMat.cpp.

void fei::set_shared_ids ( MPI_Comm  comm,
const snl_fei::RecordCollection records,
fei::SharedIDs< int > &  sharedIDs 
)

Given a record-collection, perform inter-processor communication to find out which IDs are shared among multiple processors, and fill the SharedIDs object with those mappings.

Definition at line 60 of file fei_set_shared_ids.cpp.

template<typename T, typename U>
bool fei::operator== ( const SharedPtr< T > &  a,
const SharedPtr< U > &  b 
) [inline]

Equals operator for shared pointers.

Definition at line 297 of file fei_SharedPtr.hpp.

template<typename T, typename U>
bool fei::operator!= ( const SharedPtr< T > &  a,
const SharedPtr< U > &  b 
) [inline]

Not equals operator for shared pointers.

Definition at line 304 of file fei_SharedPtr.hpp.

int fei::find_row_start ( int  row,
const SparseRowGraph &  srg 
) [inline]

Given a row-number and a SparseRowGraph object, return the offset at which that row's column-indices start in the SparseRowGraph object's packedColumnIndices vector.

If the given row-number is not found in the SparseRowGraph object's vector of row-numbers, return -1.

Definition at line 86 of file fei_SparseRowGraph.hpp.

template<typename SET_TYPE>
void fei::copySetToArray ( const SET_TYPE &  set_obj,
int  lenList,
int *  list 
)

dangerous function to copy a set to an array, assuming the set contents are of type int

Definition at line 30 of file fei_TemplateUtils.hpp.

template<typename T>
void fei::copySetToVector ( const std::set< T > &  set_obj,
std::vector< T > &  vec 
)

copy a set to a vector

Definition at line 48 of file fei_TemplateUtils.hpp.

template<typename MAP_TYPE>
void fei::copyKeysToArray ( const MAP_TYPE &  map_obj,
unsigned  lenList,
int *  list 
)

dangerous function to copy map keys to an array, assuming the keys are of type int

Definition at line 64 of file fei_TemplateUtils.hpp.

template<typename MAP_TYPE>
void fei::copyKeysToVector ( const MAP_TYPE &  map_obj,
std::vector< int > &  keyvector 
)

function to copy map keys to a vector, assuming the keys are of type int

Definition at line 82 of file fei_TemplateUtils.hpp.

template<typename MAP_TYPE>
void fei::copyToArrays ( MAP_TYPE &  map_obj,
int  lenList,
int *  keylist,
int *  vallist 
)

dangerous function to copy a map object to a pair of arrays, assuming the keys and values of the map are of type int.

Definition at line 116 of file fei_TemplateUtils.hpp.

template<typename MAP_TYPE>
void fei::destroyValues ( MAP_TYPE &  map_obj  ) 

iterate a map object, destroying its contents

Definition at line 135 of file fei_TemplateUtils.hpp.

template<typename MAP_TYPE, typename SET_TYPE>
void fei::writeToStream ( snl_fei::RaggedTable< MAP_TYPE, SET_TYPE > &  table,
FEI_OSTREAM &  os,
const char *  lineprefix = NULL 
)

write a ragged-table to a specified ostream

Definition at line 148 of file fei_TemplateUtils.hpp.

template<typename MAP_TYPE, typename SET_TYPE>
fei::SharedPtr<fei::SparseRowGraph> fei::createSparseRowGraph ( const std::vector< snl_fei::RaggedTable< MAP_TYPE, SET_TYPE > * > &  tables  ) 

create fei::SparseRowGraph object from a vector of ragged-tables. user is responsible for destroying the fei::SparseRowGraph

Definition at line 218 of file fei_TemplateUtils.hpp.

template<typename MAP_TYPE, typename SET_TYPE>
void fei::copyToSparseRowGraph ( snl_fei::RaggedTable< MAP_TYPE, SET_TYPE > &  table,
fei::SparseRowGraph srg 
)

copy a ragged-table to an existing fei::SparseRowGraph object.

Definition at line 267 of file fei_TemplateUtils.hpp.

template<typename MAP_TYPE, typename SET_TYPE>
fei::SharedPtr<fei::SparseRowGraph> fei::createSparseRowGraph ( snl_fei::RaggedTable< MAP_TYPE, SET_TYPE > &  table  ) 

create fei::SparseRowGraph object from a ragged-table.

Definition at line 315 of file fei_TemplateUtils.hpp.

template<typename MAP_TYPE, typename SET_TYPE>
int fei::countNonzeros ( snl_fei::RaggedTable< MAP_TYPE, SET_TYPE > &  table  ) 

function to count the "nonzeros" in a ragged-table

Definition at line 326 of file fei_TemplateUtils.hpp.

fei::SharedPtr< LibraryWrapper > fei::create_LibraryWrapper ( MPI_Comm  comm,
const char *  libraryName 
)

Create an instance of LibraryWrapper. Throws std::runtime_error if the input libraryName is not recognized. (names are case-sensitive)

Parameters:
libraryName Input name of the solver library that is to be used. Valid values of this parameter are:
  • Aztec
  • FETI
  • PETSc
Returns:
shared-pointer holding newly-created LibraryWrapper instance.

Definition at line 30 of file LibraryFactory.cpp.

fei::SharedPtr< fei::Factory > fei::create_fei_Factory ( MPI_Comm  comm,
const char *  libraryName 
)

Create an instance of the fei::Factory interface. Throws std::runtime_error if the input libraryName is not recognized. (names are case-sensitive)

Parameters:
libraryName Input name of solver library, same valid values as for 'create_LibraryWrapper' above, as well as allowing "Trilinos".
Returns:
shared-pointer holding newly-created fei::Factory instance.

Definition at line 77 of file LibraryFactory.cpp.


Generated on Mon Jul 12 09:31:41 2010 for FEI by  doxygen 1.4.7