#include <StorageSmvBsr.hpp>

Classes
class	const_iterator

Public Types
typedef T	DataType

typedef Array< OneD, DataType >	DataVectorType

typedef Array< OneD, const DataType >	ConstDataVectorType

typedef Array< OneD, IndexType >	IndexVectorType

typedef void(*	MultiplyKernel) (const double , const double , double *)

Public Member Functions
	StorageSmvBsr (const IndexType blkRows, const IndexType blkCols, const IndexType blkDim, const BCOMatType &bcoMat, const MatrixStorage matType=eFULL)

	StorageSmvBsr (const StorageSmvBsr &src)

	~StorageSmvBsr ()

IndexType	GetRows () const

IndexType	GetColumns () const

IndexType	GetNumNonZeroEntries () const

IndexType	GetNumStoredDoubles () const

IndexType	GetBlkSize () const

DataType	GetFillInRatio () const

size_t	GetMemoryUsage () const

const_iterator	begin () const

const_iterator	end () const

const DataType &	GetValue (IndexType row, IndexType column) const

void	Multiply (const DataType in, DataType out)

void	Multiply (const DataVectorType &in, DataVectorType &out)

void	MultiplyLight (const DataVectorType &in, DataVectorType &out)

Protected Member Functions
void	processBcoInput (const IndexType blkRows, const IndexType blkDim, const BCOMatType &bcoMat)

void	Multiply_1x1 (const int mb, const double val, const int bindx, const int bpntrb, const int bpntre, const double b, double c)
	Zero-based CSR multiply. Essentially this is slightly modified copy-paste from NIST Sparse Blas 0.9b routine CSR_VecMult_CAB_double() More...

void	Multiply_2x2 (const int mb, const double val, const int bindx, const int bpntrb, const int bpntre, const double b, double c)
	Zero-based BSR multiply unrolled for 2x2 blocks. Essentially this is slightly optimised copy-paste from NIST Sparse Blas 0.9b routine BSR_VecMult_BAB_double() More...

void	Multiply_3x3 (const int mb, const double val, const int bindx, const int bpntrb, const int bpntre, const double b, double c)
	Zero-based BSR multiply unrolled for 3x3 blocks. More...

void	Multiply_4x4 (const int mb, const double val, const int bindx, const int bpntrb, const int bpntre, const double b, double c)
	Zero-based BSR multiply unrolled for 4x4 blocks. More...

void	Multiply_generic (const int mb, const double val, const int bindx, const int bpntrb, const int bpntre, const double b, double c)
	Generic zero-based BSR multiply for higher matrix ranks. More...

Protected Attributes
MultiplyKernel	m_mvKernel

MatrixStorage	m_matType

IndexType	m_blkRows

IndexType	m_blkCols

IndexType	m_blkDim

IndexType	m_bnnz

IndexType	m_nnz

DataVectorType	m_val

IndexVectorType	m_indx

IndexVectorType	m_pntr

Detailed Description

template<typename T>
class Nektar::StorageSmvBsr< T >

Definition at line 62 of file StorageSmvBsr.hpp.

Member Typedef Documentation

◆ ConstDataVectorType

template<typename T >

typedef Array<OneD, const DataType> Nektar::StorageSmvBsr< T >::ConstDataVectorType

Definition at line 68 of file StorageSmvBsr.hpp.

◆ DataType

template<typename T >

typedef T Nektar::StorageSmvBsr< T >::DataType

Definition at line 66 of file StorageSmvBsr.hpp.

◆ DataVectorType

template<typename T >

typedef Array<OneD, DataType> Nektar::StorageSmvBsr< T >::DataVectorType

Definition at line 67 of file StorageSmvBsr.hpp.

◆ IndexVectorType

template<typename T >

typedef Array<OneD, IndexType> Nektar::StorageSmvBsr< T >::IndexVectorType

Definition at line 69 of file StorageSmvBsr.hpp.

◆ MultiplyKernel

template<typename T >

typedef void(* Nektar::StorageSmvBsr< T >::MultiplyKernel) (const double *, const double *, double *)

Definition at line 71 of file StorageSmvBsr.hpp.

Constructor & Destructor Documentation

◆ StorageSmvBsr() [1/2]

template<typename DataType >

Nektar::StorageSmvBsr< DataType >::StorageSmvBsr	(	const IndexType	blkRows,
		const IndexType	blkCols,
		const IndexType	blkDim,
		const BCOMatType &	bcoMat,
		const MatrixStorage	matType = `eFULL`
	)

Todo:

: - iterators over strictly lower-triangular part

number off-diagonal elements calculation
clear distinction between stored and factual nonzeros (row density)

Definition at line 204 of file StorageSmvBsr.cpp.

     : m_matType(matType), m_blkRows(blkRows), m_blkCols(blkCols),
       m_blkDim(blkDim), m_bnnz(bcoMat.size()), m_nnz(0),
       m_val(m_bnnz * blkDim * blkDim), m_indx(m_bnnz + 1), m_pntr(blkRows + 1)
 {
     if (matType != Nektar::eFULL)
     {
         /// \todo: - iterators over strictly lower-triangular part
         ///        - number off-diagonal elements calculation
         ///        - clear distinction between stored and factual nonzeros
         ///          (row density)
         std::cout << "matrix type not implemented" << std::endl;
         throw 1;
     }
  
     processBcoInput(blkRows, blkDim, bcoMat);
 }

References Nektar::eFULL, and Nektar::StorageSmvBsr< T >::processBcoInput().

◆ StorageSmvBsr() [2/2]

template<typename DataType >

Nektar::StorageSmvBsr< DataType >::StorageSmvBsr ( const StorageSmvBsr< T > & src )

Definition at line 227 of file StorageSmvBsr.cpp.

     : m_matType(src.m_matType), m_blkRows(src.m_blkRows),
       m_blkCols(src.m_blkCols), m_blkDim(src.m_blkDim), m_bnnz(src.m_bnnz),
       m_nnz(src.m_nnz), m_val(src.m_val), m_indx(src.m_indx), m_pntr(src.m_pntr)
 {
 }

◆ ~StorageSmvBsr()

template<typename DataType >

Nektar::StorageSmvBsr< DataType >::~StorageSmvBsr

Definition at line 234 of file StorageSmvBsr.cpp.

235 {

236 }

Member Function Documentation

◆ begin()

template<typename DataType >

StorageSmvBsr< DataType >::const_iterator Nektar::StorageSmvBsr< DataType >::begin

Definition at line 312 of file StorageSmvBsr.cpp.

 {
     return const_iterator(m_matType, 0, m_nnz, m_blkDim, m_val, m_indx, m_pntr);
 }

Referenced by Nektar::StorageSmvBsr< T >::const_iterator::const_iterator().

◆ end()

template<typename DataType >

StorageSmvBsr< DataType >::const_iterator Nektar::StorageSmvBsr< DataType >::end

Definition at line 318 of file StorageSmvBsr.cpp.

 {
     return const_iterator(m_matType, m_nnz, m_nnz, m_blkDim, m_val, m_indx,
                           m_pntr);
 }

Referenced by Nektar::StorageSmvBsr< T >::const_iterator::const_iterator().

◆ GetBlkSize()

template<typename DataType >

IndexType Nektar::StorageSmvBsr< DataType >::GetBlkSize

Definition at line 256 of file StorageSmvBsr.cpp.

 {
     return m_blkDim;
 }

◆ GetColumns()

template<typename DataType >

IndexType Nektar::StorageSmvBsr< DataType >::GetColumns

Definition at line 244 of file StorageSmvBsr.cpp.

 {
     return m_blkCols * m_blkDim;
 }

◆ GetFillInRatio()

template<typename DataType >

DataType Nektar::StorageSmvBsr< DataType >::GetFillInRatio

Definition at line 268 of file StorageSmvBsr.cpp.

 {
     return (DataType)(m_bnnz * m_blkDim * m_blkDim) / (DataType)m_nnz;
 }

◆ GetMemoryUsage()

template<typename DataType >

size_t Nektar::StorageSmvBsr< DataType >::GetMemoryUsage

Definition at line 274 of file StorageSmvBsr.cpp.

 {
     return sizeof(DataType) * m_val.capacity() +
            sizeof(IndexType) * m_indx.capacity() +
            sizeof(IndexType) * m_pntr.capacity() +
            sizeof(IndexType) * 5 + //< blkRows + blkCols + blkDim + nnz + bnnz
            sizeof(MatrixStorage);
 }

◆ GetNumNonZeroEntries()

template<typename DataType >

IndexType Nektar::StorageSmvBsr< DataType >::GetNumNonZeroEntries

Definition at line 250 of file StorageSmvBsr.cpp.

 {
     return m_nnz;
 }

◆ GetNumStoredDoubles()

template<typename DataType >

IndexType Nektar::StorageSmvBsr< DataType >::GetNumStoredDoubles

Definition at line 262 of file StorageSmvBsr.cpp.

 {
     return m_bnnz * m_blkDim * m_blkDim;
 }

◆ GetRows()

template<typename DataType >

IndexType Nektar::StorageSmvBsr< DataType >::GetRows

Definition at line 238 of file StorageSmvBsr.cpp.

 {
     return m_blkRows * m_blkDim;
 }

◆ GetValue()

template<typename DataType >

const DataType & Nektar::StorageSmvBsr< DataType >::GetValue	(	IndexType	row,
		IndexType	column
	)		const

Definition at line 284 of file StorageSmvBsr.cpp.

 {
     IndexType brow = grow / m_blkDim;
     IndexType bcol = gcolumn / m_blkDim;
     IndexType lrow = grow % m_blkDim;
     IndexType lcol = gcolumn % m_blkDim;
  
     // rewind to the first entry of the first
     // block in the current block row
     IndexType offset = m_pntr[brow] * m_blkDim * m_blkDim;
  
     IndexType i;
     static DataType defaultReturnValue;
     for (i = m_pntr[brow]; i < m_pntr[brow + 1]; i++)
     {
         if (bcol == m_indx[i])
         {
             return m_val[offset + lrow + lcol * m_blkDim];
         }
         offset += m_blkDim * m_blkDim;
     }
  
     return defaultReturnValue;
 }

◆ Multiply() [1/2]

template<typename DataType >

void Nektar::StorageSmvBsr< DataType >::Multiply	(	const DataType *	in,
		DataType *	out
	)

Definition at line 357 of file StorageSmvBsr.cpp.

 {
     const double *b   = &in[0];
     double *c         = &out[0];
     const double *val = &m_val[0];
     const int *bindx  = (int *)&m_indx[0];
     const int *bpntrb = (int *)&m_pntr[0];
     const int *bpntre = (int *)&m_pntr[0] + 1;
     const int mb      = m_blkRows;
  
     switch (m_blkDim)
     {
         case 1:
             Multiply_1x1(mb, val, bindx, bpntrb, bpntre, b, c);
             return;
         case 2:
             Multiply_2x2(mb, val, bindx, bpntrb, bpntre, b, c);
             return;
         default:
         {
             Multiply_generic(mb, val, bindx, bpntrb, bpntre, b, c);
             return;
         }
     }
 }

◆ Multiply() [2/2]

template<typename DataType >

void Nektar::StorageSmvBsr< DataType >::Multiply	(	const DataVectorType &	in,
		DataVectorType &	out
	)

Definition at line 329 of file StorageSmvBsr.cpp.

 {
     const double *b   = &in[0];
     double *c         = &out[0];
     const double *val = &m_val[0];
     const int *bindx  = (int *)&m_indx[0];
     const int *bpntrb = (int *)&m_pntr[0];
     const int *bpntre = (int *)&m_pntr[0] + 1;
     const int mb      = m_blkRows;
  
     switch (m_blkDim)
     {
         case 1:
             Multiply_1x1(mb, val, bindx, bpntrb, bpntre, b, c);
             return;
         case 2:
             Multiply_2x2(mb, val, bindx, bpntrb, bpntre, b, c);
             return;
         default:
         {
             Multiply_generic(mb, val, bindx, bpntrb, bpntre, b, c);
             return;
         }
     }
 }

◆ Multiply_1x1()

template<typename DataType >

void Nektar::StorageSmvBsr< DataType >::Multiply_1x1	(	const int	mb,
		const double *	val,
		const int *	bindx,
		const int *	bpntrb,
		const int *	bpntre,
		const double *	b,
		double *	c
	)

protected

Zero-based CSR multiply. Essentially this is slightly modified copy-paste from NIST Sparse Blas 0.9b routine CSR_VecMult_CAB_double()

Definition at line 417 of file StorageSmvBsr.cpp.

 {
     for (int i = 0; i != mb; i++)
     {
         double t = 0;
         int jb   = bpntrb[i];
         int je   = bpntre[i];
         for (int j = jb; j != je; j++)
         {
             t += b[bindx[j]] * (*val++);
         }
         c[i] = t;
     }
 }

◆ Multiply_2x2()

template<typename DataType >

void Nektar::StorageSmvBsr< DataType >::Multiply_2x2	(	const int	mb,
		const double *	val,
		const int *	bindx,
		const int *	bpntrb,
		const int *	bpntre,
		const double *	b,
		double *	c
	)

protected

Zero-based BSR multiply unrolled for 2x2 blocks. Essentially this is slightly optimised copy-paste from NIST Sparse Blas 0.9b routine BSR_VecMult_BAB_double()

Definition at line 439 of file StorageSmvBsr.cpp.

 {
     const int lb = 2;
  
     const double *pval = val;
     double *pc         = c;
  
     for (int i = 0; i != mb; i++)
     {
         int jb = bpntrb[i];
         int je = bpntre[i];
         pc[0]  = 0;
         pc[1]  = 0;
         for (int j = jb; j != je; j++)
         {
             int bs           = bindx[j] * lb;
             const double *pb = &b[bs];
  
             pc[0] += pb[0] * pval[0] + pb[1] * pval[2];
             pc[1] += pb[0] * pval[1] + pb[1] * pval[3];
             pval += 4;
         }
         pc += 2;
     }
 }

◆ Multiply_3x3()

template<typename DataType >

void Nektar::StorageSmvBsr< DataType >::Multiply_3x3	(	const int	mb,
		const double *	val,
		const int *	bindx,
		const int *	bpntrb,
		const int *	bpntre,
		const double *	b,
		double *	c
	)

protected

Zero-based BSR multiply unrolled for 3x3 blocks.

Definition at line 470 of file StorageSmvBsr.cpp.

 {
     const int lb = 3;
  
     const double *pval = val;
     double *pc         = c;
  
     for (int i = 0; i != mb; i++)
     {
         int jb = bpntrb[i];
         int je = bpntre[i];
         pc[0]  = 0;
         pc[1]  = 0;
         pc[2]  = 0;
         for (int j = jb; j != je; j++)
         {
             int bs           = bindx[j] * lb;
             const double *pb = &b[bs];
  
             pc[0] += pb[0] * pval[0] + pb[1] * pval[3] + pb[2] * pval[6];
             pc[1] += pb[0] * pval[1] + pb[1] * pval[4] + pb[2] * pval[7];
             pc[2] += pb[0] * pval[2] + pb[1] * pval[5] + pb[2] * pval[8];
             pval += 9;
         }
         pc += 3;
     }
 }

◆ Multiply_4x4()

template<typename DataType >

void Nektar::StorageSmvBsr< DataType >::Multiply_4x4	(	const int	mb,
		const double *	val,
		const int *	bindx,
		const int *	bpntrb,
		const int *	bpntre,
		const double *	b,
		double *	c
	)

protected

Zero-based BSR multiply unrolled for 4x4 blocks.

Definition at line 503 of file StorageSmvBsr.cpp.

 {
     const int lb = 4;
  
     const double *pval = val;
     double *pc         = c;
  
     for (int i = 0; i != mb; i++)
     {
         int jb = bpntrb[i];
         int je = bpntre[i];
         pc[0]  = 0;
         pc[1]  = 0;
         pc[2]  = 0;
         pc[3]  = 0;
         for (int j = jb; j != je; j++)
         {
             int bs           = bindx[j] * lb;
             const double *pb = &b[bs];
  
             pc[0] += pb[0] * pval[0] + pb[1] * pval[4] + pb[2] * pval[8] +
                      pb[3] * pval[12];
             pc[1] += pb[0] * pval[1] + pb[1] * pval[5] + pb[2] * pval[9] +
                      pb[3] * pval[13];
             pc[2] += pb[0] * pval[2] + pb[1] * pval[6] + pb[2] * pval[10] +
                      pb[3] * pval[14];
             pc[3] += pb[0] * pval[3] + pb[1] * pval[7] + pb[2] * pval[11] +
                      pb[3] * pval[15];
             pval += 16;
         }
         pc += 4;
     }
 }

◆ Multiply_generic()

template<typename DataType >

void Nektar::StorageSmvBsr< DataType >::Multiply_generic	(	const int	mb,
		const double *	val,
		const int *	bindx,
		const int *	bpntrb,
		const int *	bpntre,
		const double *	b,
		double *	c
	)

protected

Generic zero-based BSR multiply for higher matrix ranks.

Definition at line 542 of file StorageSmvBsr.cpp.

 {
     const int lb       = m_blkDim;
     const double *pval = val;
     const int mm       = lb * lb;
     double *pc         = c;
     for (int i = 0; i != mb * lb; i++)
         *pc++ = 0;
  
     pc = c;
     for (int i = 0; i != mb; i++)
     {
         int jb = bpntrb[i];
         int je = bpntre[i];
         for (int j = jb; j != je; j++)
         {
             Blas::Dgemv('N', lb, lb, 1.0, pval, lb, &b[bindx[j] * lb], 1, 1.0,
                         pc, 1);
             pval += mm;
         }
         pc += lb;
     }
 }

References Blas::Dgemv().

◆ MultiplyLight()

template<typename DataType >

void Nektar::StorageSmvBsr< DataType >::MultiplyLight	(	const DataVectorType &	in,
		DataVectorType &	out
	)

Definition at line 386 of file StorageSmvBsr.cpp.

 {
     const double *b   = &in[0];
     double *c         = &out[0];
     const double *val = &m_val[0];
     const int *bindx  = (int *)&m_indx[0];
     const int *bpntrb = (int *)&m_pntr[0];
     const int *bpntre = (int *)&m_pntr[0] + 1;
     const int mb      = m_blkRows;
  
     switch (m_blkDim)
     {
         case 1:
             Multiply_1x1(mb, val, bindx, bpntrb, bpntre, b, c);
             return;
         case 2:
             Multiply_2x2(mb, val, bindx, bpntrb, bpntre, b, c);
             return;
         default:
         {
             Multiply_generic(mb, val, bindx, bpntrb, bpntre, b, c);
             return;
         }
     }
 }

◆ processBcoInput()

template<typename DataType >

void Nektar::StorageSmvBsr< DataType >::processBcoInput	(	const IndexType	blkRows,
		const IndexType	blkDim,
		const BCOMatType &	bcoMat
	)

protected

Definition at line 573 of file StorageSmvBsr.cpp.

 {
     IndexType i;
     BCOMatTypeConstIt entry;
     IndexType rowcoord;
     IndexType colcoord;
     BCOEntryType value;
  
     std::vector<IndexType> tmp(blkRows + 1, 0);
  
     // calculate the number of entries on each row
     // and store the result in tmp
     for (entry = bcoMat.begin(); entry != bcoMat.end(); entry++)
     {
         rowcoord = (entry->first).first;
         tmp[rowcoord]++;
     }
     // Based upon this information, fill the array m_pntr
     // which basically contains the offset of each row's
     // first entry in the other arrays m_val and m_indx
     m_pntr[0] = 0;
     for (i = 0; i < blkRows; i++)
     {
         m_pntr[i + 1] = m_pntr[i] + tmp[i];
     }
  
     // Copy the values of m_pntr into tmp as this will be needed
     // in the following step
     std::copy(&m_pntr[0], &m_pntr[0] + blkRows + 1, &tmp[0]);
  
     // Now, fill in index and value entries.
     for (entry = bcoMat.begin(); entry != bcoMat.end(); entry++)
     {
         rowcoord    = (entry->first).first;
         colcoord    = (entry->first).second;
         value       = entry->second;
         int blkSize = blkDim * blkDim;
  
         for (i = 0; i < blkSize; i++)
         {
             m_val[blkSize * (tmp[rowcoord]) + i] = value[i];
             if (std::abs(value[i]) > NekConstants::kNekSparseNonZeroTol)
                 m_nnz++;
         }
  
         m_indx[tmp[rowcoord]] = colcoord;
         tmp[rowcoord]++;
     }
 }