Nektar::MultiRegions::GlobalMatrix Class Reference

Represents a matrix of all degrees of freedom. More...

#include <GlobalMatrix.h>

Public Types
typedef NekSparseMatrix< StorageSmvBsr< NekDouble > >	DNekSmvBsrMat
typedef std::shared_ptr< DNekSmvBsrMat >	DNekSmvBsrMatSharedPtr

Public Member Functions
	GlobalMatrix (const LibUtilities::SessionReaderSharedPtr &pSession, unsigned int rows, unsigned int columns, const COOMatType &cooMat, const MatrixStorage &matStorage=eFULL)
	Construct a new matrix. More...
	~GlobalMatrix ()
void	Multiply (const Array< OneD, const NekDouble > &in, Array< OneD, NekDouble > &out)
	Perform a matrix-vector multiply. More...
unsigned long	GetMulCallsCounter () const
unsigned int	GetNumNonZeroEntries () const

Private Attributes
DNekSmvBsrMatSharedPtr	m_smvbsrmatrix
	Pointer to a double-precision Nektar++ sparse matrix. More...
unsigned int	m_rows
Array< OneD, NekDouble >	m_tmpin
Array< OneD, NekDouble >	m_tmpout
unsigned long	m_mulCallsCounter
bool	m_copyOp

Static Private Attributes
static std::string	def
static std::string	lookupIds []

Detailed Description

Represents a matrix of all degrees of freedom.

This matrix is essentially a wrapper around a DNekSparseMat.

Definition at line 44 of file GlobalMatrix.h.

Member Typedef Documentation

DNekSmvBsrMat

typedef NekSparseMatrix<StorageSmvBsr<NekDouble> > Nektar::MultiRegions::GlobalMatrix::DNekSmvBsrMat

Definition at line 47 of file GlobalMatrix.h.

DNekSmvBsrMatSharedPtr

typedef std::shared_ptr<DNekSmvBsrMat> Nektar::MultiRegions::GlobalMatrix::DNekSmvBsrMatSharedPtr

Definition at line 48 of file GlobalMatrix.h.

Constructor & Destructor Documentation

GlobalMatrix()

Nektar::MultiRegions::GlobalMatrix::GlobalMatrix	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		unsigned int	rows,
		unsigned int	columns,
		const COOMatType &	cooMat,
		const MatrixStorage &	matStorage = eFULL
	)

Construct a new matrix.

Allocates a new DNekSparseMat object from the given specification.

Parameters

rows	Number of rows in matrix.
columns	Number of columns in matrix.
cooMat	?

Definition at line 65 of file GlobalMatrix.cpp.

    : m_smvbsrmatrix(), m_rows(rows), m_mulCallsCounter(0)
{
    MatrixStorageType storageType =
        pSession->GetSolverInfoAsEnum<MatrixStorageType>(
            "GlobalMatrixStorageType");
 
    unsigned int brows, bcols;
 
    // Size of dense matrix sub-blocks
    int block_size = 1;
 
    BCOMatType bcoMat;
 
    // assuming current sparse format allows
    // block-sparse data representation
 
    if (pSession->DefinesParameter("SparseBlockSize"))
    {
        pSession->LoadParameter("SparseBlockSize", block_size);
        ASSERTL1(block_size > 0,
                 "SparseBlockSize parameter must to be positive");
    }
 
    brows = rows / block_size + (rows % block_size > 0);
    bcols = columns / block_size + (columns % block_size > 0);
 
    if (rows % block_size > 0)
    {
        m_copyOp = true;
    }
 
    if (m_copyOp)
    {
        m_tmpin  = Array<OneD, NekDouble>(brows * block_size, 0.0);
        m_tmpout = Array<OneD, NekDouble>(brows * block_size, 0.0);
    }
 
    convertCooToBco(block_size, cooMat, bcoMat);
 
    size_t matBytes = 0;
    switch (storageType)
    {
        case eSmvBSR:
        {
 
            // Create zero-based Smv-multiply BSR sparse storage holder
            DNekSmvBsrMat::SparseStorageSharedPtr sparseStorage =
                MemoryManager<DNekSmvBsrMat::StorageType>::AllocateSharedPtr(
                    brows, bcols, block_size, bcoMat, matStorage);
 
            // Create sparse matrix
            m_smvbsrmatrix =
                MemoryManager<DNekSmvBsrMat>::AllocateSharedPtr(sparseStorage);
 
            matBytes = m_smvbsrmatrix->GetMemoryFootprint();
        }
        break;
 
        default:
            NEKERROR(ErrorUtil::efatal,
                     "Unsupported sparse storage type chosen");
    }
 
    cout << "Global matrix storage type: " << MatrixStorageTypeMap[storageType]
         << endl;
    std::cout << "Global matrix memory, bytes = " << matBytes;
    if (matBytes / (1024 * 1024) > 0)
    {
        std::cout << " (" << matBytes / (1024 * 1024) << " MB)" << std::endl;
    }
    else
    {
        std::cout << " (" << matBytes / 1024 << " KB)" << std::endl;
    }
    std::cout << "Sparse storage block size = " << block_size << std::endl;
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL1, Nektar::convertCooToBco(), Nektar::ErrorUtil::efatal, Nektar::MultiRegions::eSmvBSR, m_copyOp, m_smvbsrmatrix, m_tmpin, m_tmpout, Nektar::MultiRegions::MatrixStorageTypeMap, and NEKERROR.

~GlobalMatrix()

Nektar::MultiRegions::GlobalMatrix::~GlobalMatrix ( )

inline

Definition at line 56 of file GlobalMatrix.h.

    {
    }

Member Function Documentation

GetMulCallsCounter()

unsigned long Nektar::MultiRegions::GlobalMatrix::GetMulCallsCounter

(

)

const

Definition at line 179 of file GlobalMatrix.cpp.

{
    if (m_smvbsrmatrix)
    {
        return m_smvbsrmatrix->GetMulCallsCounter();
    }
    return -1;
}

References m_smvbsrmatrix.

GetNumNonZeroEntries()

unsigned int Nektar::MultiRegions::GlobalMatrix::GetNumNonZeroEntries

(

)

const

Definition at line 188 of file GlobalMatrix.cpp.

{
    if (m_smvbsrmatrix)
    {
        return m_smvbsrmatrix->GetNumNonZeroEntries();
    }
    return -1;
}

References m_smvbsrmatrix.

Multiply()

void Nektar::MultiRegions::GlobalMatrix::Multiply	(	const Array< OneD, const NekDouble > &	in,
		Array< OneD, NekDouble > &	out
	)

Perform a matrix-vector multiply.

Performs a matrix-vector multiply using the sparse format-specific multiply routine.

Parameters

in	Input vector.
out	Output vector.

Definition at line 152 of file GlobalMatrix.cpp.

{
    if (!m_copyOp)
    {
        if (m_smvbsrmatrix)
        {
            m_smvbsrmatrix->Multiply(in, out);
        }
    }
    else
    {
        // if block size makes the last row/column bigger, one needs
        // using temporary storage for rhs and result vectors.
        Vmath::Vcopy(m_rows, &in[0], 1, &m_tmpin[0], 1);
 
        if (m_smvbsrmatrix)
        {
            m_smvbsrmatrix->Multiply(m_tmpin, m_tmpout);
        }
 
        Vmath::Vcopy(m_rows, &m_tmpout[0], 1, &out[0], 1);
    }
 
    m_mulCallsCounter++;
}

References m_copyOp, m_mulCallsCounter, m_rows, m_smvbsrmatrix, m_tmpin, m_tmpout, and Vmath::Vcopy().

Member Data Documentation

def

std::string Nektar::MultiRegions::GlobalMatrix::def

staticprivate

Initial value:

=
    LibUtilities::SessionReader::RegisterDefaultSolverInfo(
        "GlobalMatrixStorageType", "SmvBSR")

Definition at line 79 of file GlobalMatrix.h.

lookupIds

std::string Nektar::MultiRegions::GlobalMatrix::lookupIds

staticprivate

Initial value:

= {
    LibUtilities::SessionReader::RegisterEnumValue(
        "GlobalMatrixStorageType", "SmvBSR", MultiRegions::eSmvBSR)}

Definition at line 80 of file GlobalMatrix.h.

m_copyOp

bool Nektar::MultiRegions::GlobalMatrix::m_copyOp

private

Definition at line 77 of file GlobalMatrix.h.

Referenced by GlobalMatrix(), and Multiply().

m_mulCallsCounter

unsigned long Nektar::MultiRegions::GlobalMatrix::m_mulCallsCounter

private

Definition at line 75 of file GlobalMatrix.h.

Referenced by Multiply().

m_rows

unsigned int Nektar::MultiRegions::GlobalMatrix::m_rows

private

Definition at line 71 of file GlobalMatrix.h.

Referenced by Multiply().

m_smvbsrmatrix

DNekSmvBsrMatSharedPtr Nektar::MultiRegions::GlobalMatrix::m_smvbsrmatrix

private

Pointer to a double-precision Nektar++ sparse matrix.

Definition at line 69 of file GlobalMatrix.h.

Referenced by GetMulCallsCounter(), GetNumNonZeroEntries(), GlobalMatrix(), and Multiply().

m_tmpin

Array<OneD, NekDouble> Nektar::MultiRegions::GlobalMatrix::m_tmpin

private

Definition at line 72 of file GlobalMatrix.h.

Referenced by GlobalMatrix(), and Multiply().

m_tmpout

Array<OneD, NekDouble> Nektar::MultiRegions::GlobalMatrix::m_tmpout

private

Definition at line 73 of file GlobalMatrix.h.

Referenced by GlobalMatrix(), and Multiply().