Inheritance diagram for FastElim:

Collaboration diagram for FastElim:

Public Member Functions
const double *	allEntries () const

void	buildBackwardSub (vector< unsigned int > &diag, vector< Triplet< double > > &bops, vector< double > &diagVal)

void	buildForwardElim (vector< unsigned int > &diag, vector< Triplet< double > > &fops)

bool	hinesReorder (const vector< unsigned int > &parentVoxel)

void	makeTestMatrix (const double *test, unsigned int numCompts)

void	shuffleRows (const vector< unsigned int > &lookupOldRowFromNew)

Public Member Functions inherited from SparseMatrix< double >
void	addRow (unsigned int rowNum, const vector< double > &row)

void	addRow (unsigned int rowNum, const vector< double > &entry, const vector< unsigned int > &colIndexArg)

void	clear ()

const vector< unsigned int > &	colIndex () const

double	get (unsigned int row, unsigned int column) const

unsigned int	getColumn (unsigned int col, vector< double > &entry, vector< unsigned int > &rowIndex) const

unsigned int	getRow (unsigned int row, const double entry, const unsigned int colIndex) const

unsigned int	getRow (unsigned int row, vector< double > &e, vector< unsigned int > &c) const

const vector< double > &	matrixEntry () const
	Here we expose the sparse matrix for MOOSE use. More...

unsigned int	nColumns () const

unsigned int	nEntries () const

unsigned int	nRows () const

void	pairFill (const vector< unsigned int > &row, const vector< unsigned int > &col, doublevalue)

void	print () const

void	printInternal () const

void	printTriplet (const vector< Triplet< double > > &t)

void	reorderColumns (const vector< unsigned int > &colMap)

const vector< unsigned int > &	rowStart () const

void	set (unsigned int row, unsigned int column, doublevalue)

void	setSize (unsigned int nrows, unsigned int ncolumns)

	SparseMatrix ()

	SparseMatrix (unsigned int nrows, unsigned int ncolumns)

void	transpose ()

void	tripletFill (const vector< unsigned int > &row, const vector< unsigned int > &col, const vector< double > &z, bool retainSize=false)

void	unset (unsigned int row, unsigned int column)

Additional Inherited Members
Protected Attributes inherited from SparseMatrix< double >
vector< unsigned int >	colIndex_
	Non-zero entries in the SparseMatrix. More...

vector< double >	N_

unsigned int	ncolumns_

unsigned int	nrows_

vector< unsigned int >	rowStart_
	Start index in the N_ and colIndex_ vectors, of each row. More...

Detailed Description

Definition at line 40 of file standaloneTestFastElim.cpp.

Member Function Documentation

const double * FastElim::allEntries ( ) const

Definition at line 73 of file standaloneTestFastElim.cpp.

                                          {
     return &N_[0];
 }

void FastElim::buildBackwardSub	(	vector< unsigned int > &	diag,
		vector< Triplet< double > > &	bops,
		vector< double > &	diagVal
	)

Operations to be done on the RHS for the back sub are generated and put into the bops (backward ops) vector. col > row here, row is the entry being operated on, and col is given by rowsToSub. offDiagVal is the value on the off-diagonal at row,col. diagVal is the value on the diagonal at [row][row]. RHS[row] = ( RHS[row] - offDiagVal * RHS[col] ) / diagVal

Definition at line 352 of file standaloneTestFastElim.cpp.

Referenced by main().

 {
     // This vec tells the routine which rows below have to be back-subbed.
     // This includes the rows if any in the tridiagonal band and also
     // rows, if any, on branches.
     vector< vector< unsigned int > > rowsToSub( nrows_ );
 
     for ( unsigned int i = 0; i < nrows_; ++i ) {
         unsigned int d = diag[i] + 1;
         unsigned int re = rowStart_[i+1];
         for ( unsigned int j = d; j < re; ++j ) {
             unsigned int k = colIndex_[j];
             // At this point the row to sub is at (i, k). We need to go down
             // to the (k,k) diagonal to sub it out.
             rowsToSub[ k ].push_back( i );
         }
     }
     for ( unsigned int i = 0; i < rowsToSub.size(); ++i ) {
         cout << i << " :        ";
         for ( unsigned int j = 0; j < rowsToSub[i].size(); ++j ) {
             cout << rowsToSub[i][j] << "    ";
         }
         cout << endl;
     }
 
     diagVal.resize( 0 );
     // Fill in the diagonal terms. Here we do all entries.
     for ( unsigned int i = 0; i != nrows_ ; ++i ) {
         diagVal.push_back( 1.0 / N_[diag[i]] );
     }
 
     // Fill in the back-sub operations. Note we don't need to check zero.
     for ( unsigned int i = nrows_-1; i != 0 ; --i ) {
         for ( unsigned int j = rowsToSub[i].size() - 1; j != -1; --j ) {
             unsigned int k = rowsToSub[i][j];
             double val = get( k, i ); //k is the row to go, i is the diag.
             bops.push_back( Triplet< double >( val * diagVal[i], i, k ) );
         }
     }
 
     for ( unsigned int i = 0; i < bops.size(); ++i ) {
         cout << i << ":     " << bops[i].a_ << "    " <<
                 bops[i].b_ << " " <<  // diagonal index
                 bops[i].c_ << " " <<  // off-diagonal index
                 1.0 / diagVal[bops[i].b_] << // diagonal value.
                 endl;
     }
 }

Here is the caller graph for this function:

void FastElim::buildForwardElim	(	vector< unsigned int > &	diag,
		vector< Triplet< double > > &	fops
	)

Builds the vector of forward ops: ratio, i, j RHS[i] = RHS[i] - RHS[j] * ratio This vec tells the routine which rows below have to be eliminated. This includes the rows if any in the tridiagonal band and also rows, if any, on branches.

Definition at line 286 of file standaloneTestFastElim.cpp.

Referenced by main().

 {
     vector< vector< unsigned int > > rowsToElim( nrows_ );
     diag.clear();
     for ( unsigned int i = 0; i < nrows_; ++i ) {
         unsigned int rs = rowStart_[i];
         unsigned int re = rowStart_[i+1];
         for ( unsigned int j = rs; j < re; ++j ) {
             unsigned int k = colIndex_[j];
             if ( k == i ) {
                 diag.push_back(j);
             } else if ( k > i ) {
                 rowsToElim[ i ].push_back( k );
             }
         }
     }
     for ( unsigned int i = 0; i < nrows_; ++i ) {
         double d = N_[diag[i]];
         unsigned int diagend = rowStart_[ i + 1 ];
         assert( diag[i] < diagend );
         vector< unsigned int >& elim = rowsToElim[i];
         for ( unsigned int j = 0; j < elim.size(); ++j ) {
             unsigned int erow = elim[j];
             if ( erow == i ) continue;
             unsigned int rs = rowStart_[ erow ];
             unsigned int re = rowStart_[ erow+1 ];
             // assert( colIndex_[rs] == i );
             double ratio = get( erow, i ) / d;
             // double ratio = N_[rs]/N_[diag[i]];
             for ( unsigned int k = diag[i]+1; k < diagend; ++k ) {
                 unsigned int col = colIndex_[k];
                 // findElimEntry, subtract it out.
                 for ( unsigned int q = rs; q < re; ++q ) {
                     if ( colIndex_[q] == col ) {
                         N_[q] -= N_[k] * ratio;
                     }
                 }
             }
             fops.push_back( Triplet< double >( ratio, i, erow) );
         }
     }
     for ( unsigned int i = 0; i < rowsToElim.size(); ++i ) {
         cout << i << " :        ";
         for ( unsigned int j = 0; j < rowsToElim[i].size(); ++j ) {
             cout << rowsToElim[i][j] << "   ";
         }
         cout << endl;
     }
     for ( unsigned int i = 0; i < fops.size(); ++i ) {
         cout << "fops[" << i << "]=     " << fops[i].b_ << "    " << fops[i].c_ <<
                 "   " << fops[i].a_ << endl;
     }
     /*
     */
 }

Here is the caller graph for this function:

bool FastElim::hinesReorder ( const vector< unsigned int > & parentVoxel )

Reorders rows and columns to put the matrix in the form suitable for rapid single-pass inversion. Returns 0 on failure.

Definition at line 85 of file standaloneTestFastElim.cpp.

Referenced by main().

 {
     // First we fill in the vector that specifies the old row number
     // assigned to each row of the reordered matrix.
     assert( parentVoxel.size() == nrows_ );
     vector< unsigned int > numKids( nrows_, 0 );
     vector< unsigned int > lookupOldRowFromNew;
     vector< bool > rowPending( nrows_, true );
     unsigned int numDone = 0;
     for ( unsigned int i = 0; i < nrows_; ++i ) {
         if ( parentVoxel[i] != -1 )
             numKids[ parentVoxel[i] ]++;
     }
     while ( numDone < nrows_ ) {
         for ( unsigned int i = 0; i < nrows_; ++i ) {
             if ( rowPending[i] && numKids[i] == 0 ) {
                 lookupOldRowFromNew.push_back( i );
                 rowPending[i] = false;
                 numDone++;
                 unsigned int pa = parentVoxel[i];
                 // Unsure what the root parent is. Assume it is -1
                 while ( pa != -1 && numKids[pa] == 1 ) {
                     assert( rowPending[pa] );
                     rowPending[pa] = false;
                     numDone++;
                     lookupOldRowFromNew.push_back( pa );
                     pa = parentVoxel[pa];
                 }
                 if ( pa != -1 ) {
                     assert( numKids[pa] > 0 );
                     numKids[pa]--;
                 }
             }
         }
     }
 
     cout << setprecision(4);
     cout << "oldRowFromNew= {" ;
     for ( int i = 0; i < nrows_; ++i )
         cout << lookupOldRowFromNew[i] << ", ";
     cout << "}\n";
     // Then we fill in the reordered matrix. Note we need to reorder
     // columns too.
     shuffleRows( lookupOldRowFromNew );
 }

Here is the caller graph for this function:

void FastElim::makeTestMatrix	(	const double *	test,
		unsigned int	numCompts
	)

Finds the 'twigs' of the matrix: Only one end connected. void FastElim::extractTwig( unsigned int i, vector< unsigned int >& rowReorder, vector< bool >& extracted ) { ; }

void FastElim::findClosedEnds( vector< unsigned int >& rowReorder, vector< bool >& extracted ) { ; }

void FastElim::extractClosedEnds( unsigned int i, vector< unsigned int >& rowReorder, vector< bool >& extracted ) { ; }

Definition at line 255 of file standaloneTestFastElim.cpp.

Referenced by main().

 {
     setSize( numCompts, numCompts );
     vector< double > row( numCompts, ~0 );
     unsigned int i = 1;
     for ( unsigned int i = 0; i < numCompts; ++i ) {
         for ( unsigned int j = 0; j < numCompts; ++j ) {
             unsigned int k = i * numCompts + j;
             if ( test[k] < 0.1 ) {
             } else {
                 N_.push_back( test[k] );
                 colIndex_.push_back( j );
             }
         }
         rowStart_[i + 1] = N_.size();
     }
 }

Here is the caller graph for this function:

void FastElim::shuffleRows ( const vector< unsigned int > & lookupOldRowFromNew )

Definition at line 132 of file standaloneTestFastElim.cpp.

References SparseMatrix< T >::getRow(), SparseMatrix< T >::nrows_, and sortByColumn().

 {
     vector< unsigned int > lookupNewRowFromOld( nrows_ );
     for ( unsigned int i = 0; i < nrows_; ++i )
         lookupNewRowFromOld[ lookupOldRowFromNew[i] ] = i;
 
     FastElim temp = *this;
     clear();
     setSize( temp.nrows_, temp.nrows_ );
     for ( unsigned int i = 0; i < lookupOldRowFromNew.size(); ++i ) {
         vector< unsigned int > c;
         vector< double > e;
         unsigned int num = temp.getRow( lookupOldRowFromNew[i], e, c );
         vector< unsigned int > newc( num );
         vector< double > newe( num );
         for ( unsigned int j = 0; j < num; ++j ) {
             newc[j] = lookupNewRowFromOld[ c[j] ];
             newe[j] = e[j];
         }
         // Now we need to sort the new row entries in increasing col order.
         /*
         sortByColumn( newc, newe );
         addRow( i, newe, newc );
         */
         sortByColumn( newc, e );
         addRow( i, e, newc );
     }
 }

Here is the call graph for this function:

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

moose-core/diffusion/standaloneTestFastElim.cpp

Public Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation