SparseGenColLinSOE

class SparseGenColLinSOE : public LinearSOE

Inheritance:

Public Methods
SparseGenColLinSOE(SparseGenColLinSolver &theSolver)
SparseGenColLinSOE(int N, int NNZ, int *rowStartA, int *colA, SparseGenColLinSolver &theSolver)
~SparseGenColLinSOE()
int getNumEqn(void) const
int setSize(Graph &theGraph)
int addA(const Matrix &, const ID &, double fact = 1.0)
int addB(const Vector &, const ID &, double fact = 1.0)
int setB(const Vector &, double fact = 1.0)
void zeroA(void)
void zeroB(void)
const Vector& getX(void)
const Vector& getB(void)
double normRHS(void)
void setX(int loc, double value)
int setSparseGenColSolver(SparseGenColLinSolver &newSolver)
int sendSelf(int commitTag, Channel &theChannel)
int recvSelf(int commitTag, Channel &theChannel, FEM_ObjectBroker &theBroker)

Inherited from LinearSOE:

Public Methods
virtual int solve(void)

Protected Methods
int setSolver(LinearSOESolver &newSolver)
LinearSOESolver* getSolver(void)

Inherited from SystemOfEqn:

Inherited from MovableObject:

Public Methods
int getClassTag(void) const
int getDbTag(void) const
void setDbTag(int dbTag)

Documentation

SparseGenColLinSOE is class which is used to store the matrix equation Ax=b of order size using a sparse column-compacted storage scheme for A. The A matrix is stored in a 1d double array with nnz elements, where nnz is the number of non-zeroes in the matrix A. Two additional 1d integer arrays rowA and colStartA are used to store information about the location of the coefficients, with colStartA(i) storing the location in the 1d double array of the start of column i and rowA(j) identifying the row in A to which the j'th component in the 1d double array. colStartA is of dimension size+1 and rowA of dimension nnz. For example
\left[ \begin{array}{ccccc} a_{0,0} & 0 & a_{0,2} & a_{0,3} & 0

SparseGenColLinSOE(SparseGenColLinSolver &theSolver)

SparseGenColLinSOE(int N, int NNZ, int *colStartA, int *rowA, SparseGenColLinSolver \&theSolver);

SparseGenColLinSOE(int N, int NNZ, int *rowStartA, int *colA, SparseGenColLinSolver &theSolver)

~SparseGenColLinSOE()

The solver and a unique class tag (defined in <classTags.h>) are passed to the LinearSOE constructor. The system size is set to 0 and the matrix A is marked as not having been factored. Invokes setLinearSOE(*this) on the solver. No memory is allocated for the 3 1d arrays.

int getNumEqn(void) const

A method which returns the current size of the system

int setSize(Graph &theGraph)

The size of the system is determined from the Graph object theGraph, which must contain size vertices labelled 0 through size-1, the adjacency list for each vertex containing the associated vertices in a column of the matrix A. The size is determined by invoking getNumVertex() on theGraph and the number of non-zeros is determined by looking at the size of the adjacenecy list of each vertex in the graph, allowing space for the diagonal term. If the old space allocated for the 1d arrays is not big enough, it the old space is returned to the heap and new space is allocated from the heap. Prints a warning message, sets size to 0 and returns a -1, if not enough memory is available on the heap for the 1d arrays. If memory is available, the components of the arrays are zeroed and A is marked as being unfactored. If the system size has increased, new Vector objects for x and b using the (double ,int) Vector constructor are created. The colStartA and rowA are then determined by looping through the vertices, setting colStartA(i) = colStartA(i-1) + 1 + the size of Vertices i adjacency list and placing the contents of i and the adjacency list into rowA in ascending order. Finally, the result of invoking setSize() on the associated Solver object is returned.

int addA(const Matrix &, const ID &, double fact = 1.0)

First tests that loc and M are of compatable sizes; if not a warning message is printed and a -1 is returned. The LinearSOE object then assembles fact times the Matrix M into the matrix A. The Matrix is assembled into A at the locations given by the ID object loc, i.e. a_{loc(i),loc(j)} += fact * M(i,j). If the location specified is outside the range, i.e. (-1,-1) the corrseponding entry in M is not added to A. If fact is equal to 0.0 or 1.0, more efficient steps are performed. Returns 0.

int addB(const Vector &, const ID &, double fact = 1.0)

First tests that loc and V are of compatable sizes; if not a warning message is printed and a -1 is returned. The LinearSOE object then assembles fact times the Vector V into the vector b. The Vector is assembled into b at the locations given by the ID object loc, i.e. b_{loc(i)} += fact * V(i). If a location specified is outside the range, e.g. -1, the corresponding entry in V is not added to b. If fact is equal to 0.0, 1.0 or -1.0, more efficient steps are performed. Returns 0.

int setB(const Vector &, double fact = 1.0)

First tests that V and the size of the system are of compatable sizes; if not a warning message is printed and a -1 is returned. The LinearSOE object then sets the vector b to be fact times the Vector V. If fact is equal to 0.0, 1.0 or -1.0, more efficient steps are performed. Returns 0.

void zeroA(void)