Nektar::MultiRegions::GlobalMatrix Class Reference

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

#include <GlobalMatrix.h>

Collaboration diagram for Nektar::MultiRegions::GlobalMatrix:

Public Types
typedef NekSparseMatrix < StorageSmvBsr< NekDouble > >	DNekSmvBsrMat
typedef boost::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.
	~GlobalMatrix ()
void	Multiply (const Array< OneD, const NekDouble > &in, Array< OneD, NekDouble > &out)
	Perform a matrix-vector multiply.
const unsigned long	GetMulCallsCounter () const
const unsigned int	GetNumNonZeroEntries () const

Private Attributes
DNekSmvBsrMatSharedPtr	m_smvbsrmatrix
	Pointer to a double-precision Nektar++ sparse matrix.
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 47 of file GlobalMatrix.h.

Member Typedef Documentation

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

Definition at line 50 of file GlobalMatrix.h.

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

Definition at line 51 of file GlobalMatrix.h.

Constructor & Destructor Documentation

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 68 of file GlobalMatrix.cpp.

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

                                                                   :
            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(brows, bcols, block_size, cooMat, bcoMat);

            size_t matBytes;
            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;