A global linear system. More...

#include <GlobalLinSysIterativeStaticCond.h>

Inheritance diagram for Nektar::MultiRegions::GlobalLinSysIterativeStaticCond:

Collaboration diagram for Nektar::MultiRegions::GlobalLinSysIterativeStaticCond:

Public Types
typedef NekSparseDiagBlkMatrix < StorageSmvBsr< NekDouble > >	DNekSmvBsrDiagBlkMat

typedef boost::shared_ptr < DNekSmvBsrDiagBlkMat >	DNekSmvBsrDiagBlkMatSharedPtr

Public Member Functions
	GlobalLinSysIterativeStaticCond (const GlobalLinSysKey &mkey, const boost::weak_ptr< ExpList > &pExpList, const boost::shared_ptr< AssemblyMap > &locToGloMap)
	Constructor for full direct matrix solve. More...

	GlobalLinSysIterativeStaticCond (const GlobalLinSysKey &mkey, const boost::weak_ptr< ExpList > &pExpList, const DNekScalBlkMatSharedPtr pSchurCompl, const DNekScalBlkMatSharedPtr pBinvD, const DNekScalBlkMatSharedPtr pC, const DNekScalBlkMatSharedPtr pInvD, const boost::shared_ptr< AssemblyMap > &locToGloMap, const PreconditionerSharedPtr pPrecon)
	Constructor for full direct matrix solve. More...

virtual	~GlobalLinSysIterativeStaticCond ()

Public Member Functions inherited from Nektar::MultiRegions::GlobalLinSysIterative
	GlobalLinSysIterative (const GlobalLinSysKey &pKey, const boost::weak_ptr< ExpList > &pExpList, const boost::shared_ptr< AssemblyMap > &pLocToGloMap)
	Constructor for full direct matrix solve. More...

virtual	~GlobalLinSysIterative ()

Public Member Functions inherited from Nektar::MultiRegions::GlobalLinSys
	GlobalLinSys (const GlobalLinSysKey &pKey, const boost::weak_ptr< ExpList > &pExpList, const boost::shared_ptr< AssemblyMap > &pLocToGloMap)
	Constructor for full direct matrix solve. More...

virtual	~GlobalLinSys ()

const GlobalLinSysKey &	GetKey (void) const
	Returns the key associated with the system. More...

const boost::weak_ptr< ExpList > &	GetLocMat (void) const

void	InitObject ()

void	Initialise (const boost::shared_ptr< AssemblyMap > &pLocToGloMap)

void	Solve (const Array< OneD, const NekDouble > &in, Array< OneD, NekDouble > &out, const AssemblyMapSharedPtr &locToGloMap, const Array< OneD, const NekDouble > &dirForcing=NullNekDouble1DArray)
	Solve the linear system for given input and output vectors using a specified local to global map. More...

boost::shared_ptr< GlobalLinSys >	GetSharedThisPtr ()
	Returns a shared pointer to the current object. More...

int	GetNumBlocks ()

DNekScalMatSharedPtr	GetBlock (unsigned int n)

DNekScalBlkMatSharedPtr	GetStaticCondBlock (unsigned int n)

void	DropStaticCondBlock (unsigned int n)

void	SolveLinearSystem (const int pNumRows, const Array< OneD, const NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const AssemblyMapSharedPtr &locToGloMap, const int pNumDir=0)
	Solve the linear system for given input and output vectors. More...

Public Member Functions inherited from Nektar::MultiRegions::GlobalLinSysStaticCond
	GlobalLinSysStaticCond (const GlobalLinSysKey &mkey, const boost::weak_ptr< ExpList > &pExpList, const boost::shared_ptr< AssemblyMap > &locToGloMap)
	Constructor for full direct matrix solve. More...

virtual	~GlobalLinSysStaticCond ()

Static Public Member Functions
static GlobalLinSysSharedPtr	create (const GlobalLinSysKey &pLinSysKey, const boost::weak_ptr< ExpList > &pExpList, const boost::shared_ptr< AssemblyMap > &pLocToGloMap)
	Creates an instance of this class. More...

Static Public Attributes
static std::string	className
	Name of class. More...

static std::string	className2

Protected Member Functions
virtual DNekScalBlkMatSharedPtr	v_GetStaticCondBlock (unsigned int n)
	Retrieves a the static condensation block matrices from n-th expansion using the matrix key provided by the m_linSysKey. More...

virtual GlobalLinSysStaticCondSharedPtr	v_Recurse (const GlobalLinSysKey &mkey, const boost::weak_ptr< ExpList > &pExpList, const DNekScalBlkMatSharedPtr pSchurCompl, const DNekScalBlkMatSharedPtr pBinvD, const DNekScalBlkMatSharedPtr pC, const DNekScalBlkMatSharedPtr pInvD, const boost::shared_ptr< AssemblyMap > &locToGloMap)

virtual DNekScalBlkMatSharedPtr	v_PreSolve (int scLevel, NekVector< NekDouble > &F_GlobBnd)

virtual void	v_BasisTransform (Array< OneD, NekDouble > &pInOut, int offset)

virtual void	v_BasisInvTransform (Array< OneD, NekDouble > &pInOut)

Protected Member Functions inherited from Nektar::MultiRegions::GlobalLinSysIterative
void	DoAconjugateProjection (const int pNumRows, const Array< OneD, const NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const AssemblyMapSharedPtr &locToGloMap, const int pNumDir)
	A-conjugate projection technique. More...

void	DoConjugateGradient (const int pNumRows, const Array< OneD, const NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const AssemblyMapSharedPtr &locToGloMap, const int pNumDir)
	Actual iterative solve. More...

void	Set_Rhs_Magnitude (const NekVector< NekDouble > &pIn)

Protected Member Functions inherited from Nektar::MultiRegions::GlobalLinSys
virtual DNekScalMatSharedPtr	v_GetBlock (unsigned int n)
	Retrieves the block matrix from n-th expansion using the matrix key provided by the m_linSysKey. More...

virtual void	v_DropStaticCondBlock (unsigned int n)
	Releases the static condensation block matrices from NekManager of n-th expansion using the matrix key provided by the m_linSysKey. More...

PreconditionerSharedPtr	CreatePrecon (AssemblyMapSharedPtr asmMap)
	Create a preconditioner object from the parameters defined in the supplied assembly map. More...

Protected Member Functions inherited from Nektar::MultiRegions::GlobalLinSysStaticCond
virtual int	v_GetNumBlocks ()
	Get the number of blocks in this system. More...

virtual void	v_Solve (const Array< OneD, const NekDouble > &in, Array< OneD, NekDouble > &out, const AssemblyMapSharedPtr &locToGloMap, const Array< OneD, const NekDouble > &dirForcing=NullNekDouble1DArray)
	Solve the linear system for given input and output vectors using a specified local to global map. More...

virtual void	v_Initialise (const boost::shared_ptr< AssemblyMap > &locToGloMap)
	Initialise this object. More...

void	SetupTopLevel (const boost::shared_ptr< AssemblyMap > &locToGloMap)
	Set up the storage for the Schur complement or the top level of the multi-level Schur complement. More...

void	ConstructNextLevelCondensedSystem (const boost::shared_ptr< AssemblyMap > &locToGloMap)

Private Member Functions
virtual void	v_InitObject ()

void	v_AssembleSchurComplement (const boost::shared_ptr< AssemblyMap > locToGloMap)
	Assemble the Schur complement matrix. More...

void	PrepareLocalSchurComplement ()
	Prepares local representation of Schur complement stored as a sparse block-diagonal matrix. More...

virtual void	v_DoMatrixMultiply (const Array< OneD, NekDouble > &pInput, Array< OneD, NekDouble > &pOutput)
	Perform a Shur-complement matrix multiply operation. More...

virtual void	v_UniqueMap ()

Private Attributes
DNekScalBlkMatSharedPtr	m_S1Blk

std::vector< double >	m_storage
	Dense storage for block Schur complement matrix. More...

std::vector< const double * >	m_denseBlocks
	Vector of pointers to local matrix data. More...

Array< OneD, unsigned int >	m_rows
	Ranks of local matrices. More...

Array< OneD, NekDouble >	m_scale
	Scaling factors for local matrices. More...

DNekSmvBsrDiagBlkMatSharedPtr	m_sparseSchurCompl
	Sparse representation of Schur complement matrix at this level. More...

Static Private Attributes
static std::string	storagedef
	Utility strings. More...

static std::string	storagelookupIds []

Additional Inherited Members
Protected Attributes inherited from Nektar::MultiRegions::GlobalLinSysIterative
Array< OneD, int >	m_map
	Global to universal unique map. More...

int	m_maxiter
	maximum iterations More...

NekDouble	m_tolerance
	Tolerance of iterative solver. More...

NekDouble	m_rhs_magnitude
	dot product of rhs to normalise stopping criterion More...

NekDouble	m_rhs_mag_sm
	cnt to how many times rhs_magnitude is called More...

PreconditionerSharedPtr	m_precon

MultiRegions::PreconditionerType	m_precontype

int	m_totalIterations

bool	m_useProjection
	Whether to apply projection technique. More...

bool	m_root
	Root if parallel. More...

boost::circular_buffer< Array < OneD, NekDouble > >	m_prevLinSol
	Storage for solutions to previous linear problems. More...

int	m_numPrevSols
	Total counter of previous solutions. More...

Protected Attributes inherited from Nektar::MultiRegions::GlobalLinSys
const GlobalLinSysKey	m_linSysKey
	Key associated with this linear system. More...

const boost::weak_ptr< ExpList >	m_expList
	Local Matrix System. More...

const std::map< int, RobinBCInfoSharedPtr >	m_robinBCInfo
	Robin boundary info. More...

bool	m_verbose

Protected Attributes inherited from Nektar::MultiRegions::GlobalLinSysStaticCond
GlobalLinSysStaticCondSharedPtr	m_recursiveSchurCompl
	Schur complement for Direct Static Condensation. More...

DNekScalBlkMatSharedPtr	m_schurCompl
	Block Schur complement matrix. More...

DNekScalBlkMatSharedPtr	m_BinvD
	Block $BD^{-1}$ matrix. More...

DNekScalBlkMatSharedPtr	m_C
	Block matrix. More...

DNekScalBlkMatSharedPtr	m_invD
	Block $D^{-1}$ matrix. More...

boost::shared_ptr< AssemblyMap >	m_locToGloMap
	Local to global map. More...

Array< OneD, NekDouble >	m_wsp
	Workspace array for matrix multiplication. More...

Detailed Description

A global linear system.

Solves a linear system iteratively using single- or multi-level static condensation.

Definition at line 72 of file GlobalLinSysIterativeStaticCond.h.

Member Typedef Documentation

typedef NekSparseDiagBlkMatrix<StorageSmvBsr<NekDouble> > Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::DNekSmvBsrDiagBlkMat

Definition at line 77 of file GlobalLinSysIterativeStaticCond.h.

typedef boost::shared_ptr<DNekSmvBsrDiagBlkMat> Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::DNekSmvBsrDiagBlkMatSharedPtr

Definition at line 79 of file GlobalLinSysIterativeStaticCond.h.

Constructor & Destructor Documentation

Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::GlobalLinSysIterativeStaticCond	(	const GlobalLinSysKey &	pKey,
		const boost::weak_ptr< ExpList > &	pExpList,
		const boost::shared_ptr< AssemblyMap > &	pLocToGloMap
	)

Constructor for full direct matrix solve.

For a matrix system of the form

$\left[ \begin{array}{cc} \boldsymbol{A} & \boldsymbol{B}\\ \boldsymbol{C} & \boldsymbol{D} \end{array} \right] \left[ \begin{array}{c} \boldsymbol{x_1}\\ \boldsymbol{x_2} \end{array}\right] = \left[ \begin{array}{c} \boldsymbol{y_1}\\ \boldsymbol{y_2} \end{array}\right],$

where $\boldsymbol{D}$ and $(\boldsymbol{A-BD^{-1}C})$ are invertible, store and assemble a static condensation system, according to a given local to global mapping. #m_linSys is constructed by AssembleSchurComplement().

Parameters

mKey	Associated matrix key.
pLocMatSys	LocalMatrixSystem
locToGloMap	Local to global mapping.

Definition at line 111 of file GlobalLinSysIterativeStaticCond.cpp.

References ASSERTL1, Nektar::MultiRegions::eIterativeMultiLevelStaticCond, Nektar::MultiRegions::eIterativeStaticCond, and Nektar::MultiRegions::GlobalLinSysKey::GetGlobalSysSolnType().

             : GlobalLinSys          (pKey, pExpList, pLocToGloMap),
               GlobalLinSysIterative (pKey, pExpList, pLocToGloMap),
               GlobalLinSysStaticCond(pKey, pExpList, pLocToGloMap)
         {
             ASSERTL1((pKey.GetGlobalSysSolnType()==eIterativeStaticCond)||
                      (pKey.GetGlobalSysSolnType()==eIterativeMultiLevelStaticCond),
                      "This constructor is only valid when using static "
                      "condensation");
             ASSERTL1(pKey.GetGlobalSysSolnType()
                         == pLocToGloMap->GetGlobalSysSolnType(),
                      "The local to global map is not set up for the requested "
                      "solution type");
         }

Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::GlobalLinSysIterativeStaticCond	(	const GlobalLinSysKey &	mkey,
		const boost::weak_ptr< ExpList > &	pExpList,
		const DNekScalBlkMatSharedPtr	pSchurCompl,
		const DNekScalBlkMatSharedPtr	pBinvD,
		const DNekScalBlkMatSharedPtr	pC,
		const DNekScalBlkMatSharedPtr	pInvD,
		const boost::shared_ptr< AssemblyMap > &	locToGloMap,
		const PreconditionerSharedPtr	pPrecon
	)

Constructor for full direct matrix solve.

Definition at line 133 of file GlobalLinSysIterativeStaticCond.cpp.

References Nektar::MultiRegions::GlobalLinSysStaticCond::m_BinvD, Nektar::MultiRegions::GlobalLinSysStaticCond::m_C, Nektar::MultiRegions::GlobalLinSysStaticCond::m_invD, Nektar::MultiRegions::GlobalLinSysIterative::m_precon, m_S1Blk, and Nektar::MultiRegions::GlobalLinSysStaticCond::m_schurCompl.

             : GlobalLinSys          (pKey, pExpList, pLocToGloMap),
               GlobalLinSysIterative (pKey, pExpList, pLocToGloMap),
               GlobalLinSysStaticCond(pKey, pExpList, pLocToGloMap)
         {
             m_schurCompl  = pSchurCompl;
             m_S1Blk       = pSchurCompl;
             m_BinvD       = pBinvD;
             m_C           = pC;
             m_invD        = pInvD;
             m_precon      = pPrecon;
         }

Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::~GlobalLinSysIterativeStaticCond ( )

virtual

Definition at line 201 of file GlobalLinSysIterativeStaticCond.cpp.

         {
             
         }

Member Function Documentation

static GlobalLinSysSharedPtr Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::create	(	const GlobalLinSysKey &	pLinSysKey,
		const boost::weak_ptr< ExpList > &	pExpList,
		const boost::shared_ptr< AssemblyMap > &	pLocToGloMap
	)

inlinestatic

Creates an instance of this class.

Definition at line 82 of file GlobalLinSysIterativeStaticCond.h.

References CellMLToNektar.cellml_metadata::p.

             {
                 GlobalLinSysSharedPtr p = MemoryManager<
                     GlobalLinSysIterativeStaticCond>::
                     AllocateSharedPtr(pLinSysKey, pExpList, pLocToGloMap);
                 p->InitObject();
                 return p;
             }

void Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::PrepareLocalSchurComplement ( )

private

Prepares local representation of Schur complement stored as a sparse block-diagonal matrix.

Populates sparse block-diagonal schur complement matrix from the block matrices stored in #m_blkMatrices.

Definition at line 322 of file GlobalLinSysIterativeStaticCond.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL1, Nektar::MultiRegions::eContiguous, Nektar::eFULL, Nektar::MultiRegions::eNonContiguous, Nektar::MultiRegions::eSparse, Nektar::NekConstants::kNekZeroTol, m_denseBlocks, Nektar::MultiRegions::GlobalLinSys::m_expList, m_rows, m_scale, Nektar::MultiRegions::GlobalLinSysStaticCond::m_schurCompl, m_sparseSchurCompl, m_storage, Vmath::Smul(), and Nektar::MultiRegions::GlobalLinSys::v_DropStaticCondBlock().

Referenced by v_AssembleSchurComplement().

         {
             LocalMatrixStorageStrategy storageStrategy =
                 m_expList.lock()->GetSession()->
                     GetSolverInfoAsEnum<LocalMatrixStorageStrategy>(
                                        "LocalMatrixStorageStrategy");
 
             switch(storageStrategy)
             {
                 case MultiRegions::eContiguous:
                 case MultiRegions::eNonContiguous:
                 {
                     size_t storageSize = 0;
                     int nBlk           = m_schurCompl->GetNumberOfBlockRows();
 
                     m_scale = Array<OneD, NekDouble> (nBlk, 1.0);
                     m_rows  = Array<OneD, unsigned int> (nBlk, 0U);
 
                     // Determine storage requirements for dense blocks.
                     for (int i = 0; i < nBlk; ++i)
                     {
                         m_rows[i]    = m_schurCompl->GetBlock(i,i)->GetRows();
                         m_scale[i]   = m_schurCompl->GetBlock(i,i)->Scale();
                         storageSize += m_rows[i] * m_rows[i];
                     }
 
                     // Assemble dense storage blocks.
                     DNekScalMatSharedPtr loc_mat;
                     m_denseBlocks.resize(nBlk);
                     double *ptr = 0;
 
                     if (MultiRegions::eContiguous == storageStrategy)
                     {
                         m_storage.resize    (storageSize);
                         ptr = &m_storage[0];
                     }
 
                     for (unsigned int n = 0; n < nBlk; ++n)
                     {
                         loc_mat = m_schurCompl->GetBlock(n,n);
 
                         if (MultiRegions::eContiguous == storageStrategy)
                         {
                             int loc_lda      = loc_mat->GetRows();
                             int blockSize    = loc_lda * loc_lda;
                             m_denseBlocks[n] = ptr;
                             for(int i = 0; i < loc_lda; ++i)
                             {
                                 for(int j = 0; j < loc_lda; ++j)
                                 {
                                     ptr[j*loc_lda+i] = (*loc_mat)(i,j);
                                 }
                             }
                             ptr += blockSize;
                             GlobalLinSys::v_DropStaticCondBlock(n);
                         }
                         else
                         {
                             m_denseBlocks[n] = loc_mat->GetRawPtr();
                         }
                     }
                     break;
                 }
                 case MultiRegions::eSparse:
                 {
                     DNekScalMatSharedPtr loc_mat;
                     int loc_lda;
                     int blockSize = 0;
                     
                     // First run through to split the set of local matrices into
                     // partitions of fixed block size, and count number of local
                     // matrices that belong to each partition.
                     std::vector<std::pair<int,int> > partitions;
                     for(int n = 0; n < m_schurCompl->GetNumberOfBlockRows(); ++n)
                     {
                         loc_mat = m_schurCompl->GetBlock(n,n);
                         loc_lda = loc_mat->GetRows();
 
                         ASSERTL1(loc_lda >= 0,
                                  boost::lexical_cast<std::string>(n) + "-th "
                                  "matrix block in Schur complement has "
                                  "rank 0!");
 
                         if (blockSize == loc_lda)
                         {
                             partitions[partitions.size()-1].first++;
                         }
                         else
                         {
                             blockSize = loc_lda;
                             partitions.push_back(make_pair(1,loc_lda));
                         }
                     }
 
                     MatrixStorage matStorage = eFULL;
 
                     // Create a vector of sparse storage holders
                     DNekSmvBsrDiagBlkMat::SparseStorageSharedPtrVector
                             sparseStorage (partitions.size());
 
                     for (int part = 0, n = 0; part < partitions.size(); ++part)
                     {
                         BCOMatType partMat;
 
                         for(int k = 0; k < partitions[part].first; ++k, ++n)
                         {
                             loc_mat = m_schurCompl->GetBlock(n,n);
                             loc_lda = loc_mat->GetRows();
 
                             ASSERTL1(loc_lda == partitions[part].second,
                                      boost::lexical_cast<std::string>(n) + "-th"
                                      " matrix block in Schur complement has "
                                      "unexpected rank");
 
                             NekDouble scale = loc_mat->Scale();
                             if(fabs(scale-1.0) > NekConstants::kNekZeroTol)
                             {
                                 Array<OneD, NekDouble>  matarray(loc_lda*loc_lda);
                                 Vmath::Smul(loc_lda*loc_lda,scale,
                                             loc_mat->GetRawPtr(),1,&matarray[0],1);
                                 partMat[make_pair(k,k)] = BCOEntryType(matarray);
                             }
                             else // scale factor is 1.0
                             {
                                 partMat[make_pair(k,k)] = BCOEntryType(
                                 loc_lda*loc_lda, loc_mat->GetRawPtr());
                             }
 
                             GlobalLinSys::v_DropStaticCondBlock(n);
                         }
 
                         sparseStorage[part] =
                         MemoryManager<DNekSmvBsrDiagBlkMat::StorageType>::
                             AllocateSharedPtr(
                                 partitions[part].first, partitions[part].first,
                                 partitions[part].second, partMat, matStorage );
                     }
 
                     // Create block diagonal matrix
                     m_sparseSchurCompl = MemoryManager<DNekSmvBsrDiagBlkMat>::
                                             AllocateSharedPtr(sparseStorage);
 
                     break;
                 }
                 default:
                     ErrorUtil::NekError("Solver info property \
                         LocalMatrixStorageStrategy takes values \
                         Contiguous, Non-contiguous and Sparse");
             }
         }

void Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::v_AssembleSchurComplement ( const boost::shared_ptr< AssemblyMap > locToGloMap )

privatevirtual

Assemble the Schur complement matrix.

Assemble the schur complement matrix from the block matrices stored in #m_blkMatrices and the given local to global mapping information.

Parameters

locToGloMap Local to global mapping information.

Reimplemented from Nektar::MultiRegions::GlobalLinSysStaticCond.

Definition at line 229 of file GlobalLinSysIterativeStaticCond.cpp.

         {
             int i,j,n,cnt,gid1,gid2;
             NekDouble sign1,sign2;
 
             bool doGlobalOp = m_expList.lock()->GetGlobalOptParam()->
                 DoGlobalMatOp(m_linSysKey.GetMatrixType());
 
             // Set up unique map
             v_UniqueMap();
 
             // Build precon again if we in multi-level static condensation (a
             // bit of a hack)
             if (m_linSysKey.GetGlobalSysSolnType() ==
                     eIterativeMultiLevelStaticCond)
             {
                 m_precon = CreatePrecon(m_locToGloMap);
                 m_precon->BuildPreconditioner();
             }
 
             if (!doGlobalOp)
             {
                 PrepareLocalSchurComplement();
                 return;
             }
 
             int nBndDofs  = pLocToGloMap->GetNumGlobalBndCoeffs();
             int NumDirBCs = pLocToGloMap->GetNumGlobalDirBndCoeffs();
             unsigned int rows = nBndDofs - NumDirBCs;
             unsigned int cols = nBndDofs - NumDirBCs;
 
             // COO sparse storage to assist in assembly
             COOMatType gmat_coo;
 
             // Get the matrix storage structure
             // (whether to store only one triangular part, if symmetric)
             MatrixStorage matStorage = eFULL;
 
             // assemble globally
             DNekScalMatSharedPtr loc_mat;
             int loc_lda;
             for(n = cnt = 0; n < m_schurCompl->GetNumberOfBlockRows(); ++n)
             {
                 loc_mat = m_schurCompl->GetBlock(n,n);
                 loc_lda = loc_mat->GetRows();
 
                 // Set up  Matrix;
                 for(i = 0; i < loc_lda; ++i)
                 {
                     gid1  = pLocToGloMap->GetLocalToGlobalBndMap (cnt + i)
                                                                     - NumDirBCs;
                     sign1 = pLocToGloMap->GetLocalToGlobalBndSign(cnt + i);
 
                     if(gid1 >= 0)
                     {
                         for(j = 0; j < loc_lda; ++j)
                         {
                             gid2  = pLocToGloMap->GetLocalToGlobalBndMap(cnt+j)
                                                                  - NumDirBCs;
                             sign2 = pLocToGloMap->GetLocalToGlobalBndSign(cnt+j);
 
                             if (gid2 >= 0)
                             {
                                 gmat_coo[std::make_pair(gid1,gid2)] +=
                                     sign1*sign2*(*loc_mat)(i,j);
                             }
                         }
                     }
                 }
                 cnt += loc_lda;
             }
 
             DNekSmvBsrDiagBlkMat::SparseStorageSharedPtrVector
                 sparseStorage (1);
 
             BCOMatType partMat;
             convertCooToBco(rows, cols, 1, gmat_coo, partMat);
 
             sparseStorage[0] =
                  MemoryManager<DNekSmvBsrDiagBlkMat::StorageType>::
                     AllocateSharedPtr(rows, cols, 1, partMat, matStorage );
 
             // Create block diagonal matrix
             m_sparseSchurCompl = MemoryManager<DNekSmvBsrDiagBlkMat>::
                                             AllocateSharedPtr(sparseStorage);
         }

void Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::v_BasisInvTransform ( Array< OneD, NekDouble > & pInOut )

protectedvirtual

Reimplemented from Nektar::MultiRegions::GlobalLinSysStaticCond.

Definition at line 561 of file GlobalLinSysIterativeStaticCond.cpp.

References Nektar::MultiRegions::GlobalLinSysIterative::m_precon.

         {
             m_precon->DoTransformFromLowEnergy(pInOut);
         }

void Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::v_BasisTransform	(	Array< OneD, NekDouble > &	pInOut,
		int	offset
	)

protectedvirtual

Reimplemented from Nektar::MultiRegions::GlobalLinSysStaticCond.

Definition at line 554 of file GlobalLinSysIterativeStaticCond.cpp.

References Nektar::MultiRegions::GlobalLinSysIterative::m_precon.

         {
             m_precon->DoTransformToLowEnergy(pInOut, offset);
         }

void Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::v_DoMatrixMultiply	(	const Array< OneD, NekDouble > &	pInput,
		Array< OneD, NekDouble > &	pOutput
	)

privatevirtual

Perform a Shur-complement matrix multiply operation.

Implements Nektar::MultiRegions::GlobalLinSysIterative.

Definition at line 476 of file GlobalLinSysIterativeStaticCond.cpp.

References Nektar::MultiRegions::GlobalMatrixKey::GetMatrixType(), m_denseBlocks, Nektar::MultiRegions::GlobalLinSys::m_expList, Nektar::MultiRegions::GlobalLinSys::m_linSysKey, Nektar::MultiRegions::GlobalLinSysStaticCond::m_locToGloMap, m_rows, m_scale, m_sparseSchurCompl, and Nektar::MultiRegions::GlobalLinSysStaticCond::m_wsp.

         {
             int nLocal = m_locToGloMap->GetNumLocalBndCoeffs();
             int nDir = m_locToGloMap->GetNumGlobalDirBndCoeffs();
             bool doGlobalOp = m_expList.lock()->GetGlobalOptParam()->
                     DoGlobalMatOp(m_linSysKey.GetMatrixType());
 
             if(doGlobalOp)
             {
                 // Do matrix multiply globally
                 Array<OneD, NekDouble> in  = pInput  + nDir;
                 Array<OneD, NekDouble> out = pOutput + nDir;
 
                 m_sparseSchurCompl->Multiply(in,out);
                 m_locToGloMap->UniversalAssembleBnd(pOutput, nDir);
             }
             else if (m_sparseSchurCompl)
             {
                 // Do matrix multiply locally using block-diagonal sparse matrix
                 Array<OneD, NekDouble> tmp = m_wsp + nLocal;
 
                 m_locToGloMap->GlobalToLocalBnd(pInput, m_wsp);
                 m_sparseSchurCompl->Multiply(m_wsp,tmp);
                 m_locToGloMap->AssembleBnd(tmp, pOutput);
             }
             else
             {
                 // Do matrix multiply locally, using direct BLAS calls
                 m_locToGloMap->GlobalToLocalBnd(pInput, m_wsp);
                 int i, cnt;
                 Array<OneD, NekDouble> tmpout = m_wsp + nLocal;
                 for (i = cnt = 0; i < m_denseBlocks.size(); cnt += m_rows[i], ++i)
                 {
                     const int rows = m_rows[i];
                     Blas::Dgemv('N', rows, rows,
                                 m_scale[i], m_denseBlocks[i], rows,
                                 m_wsp.get()+cnt, 1,
                                 0.0, tmpout.get()+cnt, 1);
                 }
                 m_locToGloMap->AssembleBnd(tmpout, pOutput);
             }
         }

DNekScalBlkMatSharedPtr Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::v_GetStaticCondBlock ( unsigned int n )

protectedvirtual

Retrieves a the static condensation block matrices from n-th expansion using the matrix key provided by the m_linSysKey.

Parameters

n	Number of the expansion

Returns: 2x2 Block matrix holding the static condensation matrices for the n-th expansion.

Reimplemented from Nektar::MultiRegions::GlobalLinSys.

Definition at line 207 of file GlobalLinSysIterativeStaticCond.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::MultiRegions::GlobalLinSysStaticCond::m_locToGloMap, m_S1Blk, and Nektar::MultiRegions::GlobalLinSysStaticCond::m_schurCompl.

         {
             DNekScalBlkMatSharedPtr schurComplBlock;
             int  scLevel           = m_locToGloMap->GetStaticCondLevel();
             DNekScalBlkMatSharedPtr sc = scLevel == 0 ? m_S1Blk : m_schurCompl;
             DNekScalMatSharedPtr    localMat = sc->GetBlock(n,n);
             unsigned int nbdry    = localMat->GetRows();
             unsigned int nblks    = 1;
             unsigned int esize[1] = {nbdry};
 
             schurComplBlock = MemoryManager<DNekScalBlkMat>
                 ::AllocateSharedPtr(nblks, nblks, esize, esize);
             schurComplBlock->SetBlock(0, 0, localMat);
 
             return schurComplBlock;
         }

void Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::v_InitObject ( )

privatevirtual

Reimplemented from Nektar::MultiRegions::GlobalLinSysStaticCond.

Definition at line 155 of file GlobalLinSysIterativeStaticCond.cpp.

         {
             m_precon = CreatePrecon(m_locToGloMap);
 
             // Allocate memory for top-level structure
             SetupTopLevel(m_locToGloMap);
 
             // Setup Block Matrix systems
             int n, n_exp = m_expList.lock()->GetNumElmts();
 
             MatrixStorage blkmatStorage = eDIAGONAL;
             const Array<OneD,const unsigned int>& nbdry_size
                     = m_locToGloMap->GetNumLocalBndCoeffsPerPatch();
 
             m_S1Blk      = MemoryManager<DNekScalBlkMat>
                 ::AllocateSharedPtr(nbdry_size, nbdry_size, blkmatStorage);
 
             // Preserve original matrix in m_S1Blk
             for (n = 0; n < n_exp; ++n)
             {
                 DNekScalMatSharedPtr mat = m_schurCompl->GetBlock(n, n);
                 m_S1Blk->SetBlock(n, n, mat);
             }
 
             // Build preconditioner
             m_precon->BuildPreconditioner();
 
             // Do transform of Schur complement matrix
             for (n = 0; n < n_exp; ++n)
             {
                 if (m_linSysKey.GetMatrixType() !=
                         StdRegions::eHybridDGHelmBndLam)
                 {
                     DNekScalMatSharedPtr mat = m_S1Blk->GetBlock(n, n);
                     DNekScalMatSharedPtr t = m_precon->TransformedSchurCompl(n, mat);
                     m_schurCompl->SetBlock(n, n, t);
                 }
             }
 
             // Construct this level
             Initialise(m_locToGloMap);
         }

DNekScalBlkMatSharedPtr Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::v_PreSolve	(	int	scLevel,
		NekVector< NekDouble > &	F_GlobBnd
	)

protectedvirtual

Reimplemented from Nektar::MultiRegions::GlobalLinSysStaticCond.

Definition at line 526 of file GlobalLinSysIterativeStaticCond.cpp.

References Nektar::MultiRegions::GlobalLinSys::CreatePrecon(), Nektar::NekConstants::kNekUnsetDouble, Nektar::MultiRegions::GlobalLinSysStaticCond::m_locToGloMap, Nektar::MultiRegions::GlobalLinSysIterative::m_precon, Nektar::MultiRegions::GlobalLinSysIterative::m_rhs_magnitude, m_S1Blk, Nektar::MultiRegions::GlobalLinSysStaticCond::m_schurCompl, and Nektar::MultiRegions::GlobalLinSysIterative::Set_Rhs_Magnitude().

         {
             if (scLevel == 0)
             {
                 // When matrices are supplied to the constructor at the top
                 // level, the preconditioner is never set up.
                 if (!m_precon)
                 {
                     m_precon = CreatePrecon(m_locToGloMap);
                     m_precon->BuildPreconditioner();
                 }
                 
                 Set_Rhs_Magnitude(F_GlobBnd);
 
                 return m_S1Blk;
             }
             else
             {
                 // for multilevel iterative solver always use rhs
                 // vector value with no weighting
                 m_rhs_magnitude = NekConstants::kNekUnsetDouble;
 
                 return m_schurCompl;
             }
         }

GlobalLinSysStaticCondSharedPtr Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::v_Recurse	(	const GlobalLinSysKey &	mkey,
		const boost::weak_ptr< ExpList > &	pExpList,
		const DNekScalBlkMatSharedPtr	pSchurCompl,
		const DNekScalBlkMatSharedPtr	pBinvD,
		const DNekScalBlkMatSharedPtr	pC,
		const DNekScalBlkMatSharedPtr	pInvD,
		const boost::shared_ptr< AssemblyMap > &	locToGloMap
	)

protectedvirtual

Implements Nektar::MultiRegions::GlobalLinSysStaticCond.

Definition at line 567 of file GlobalLinSysIterativeStaticCond.cpp.

References Nektar::MultiRegions::GlobalLinSysIterative::m_precon.

         {
             GlobalLinSysIterativeStaticCondSharedPtr sys = MemoryManager<
                 GlobalLinSysIterativeStaticCond>::AllocateSharedPtr(
                     mkey, pExpList, pSchurCompl, pBinvD, pC, pInvD, l2gMap,
                     m_precon);
             sys->Initialise(l2gMap);
             return sys;
         }

void Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::v_UniqueMap ( )

privatevirtual

Implements Nektar::MultiRegions::GlobalLinSysIterative.

Definition at line 521 of file GlobalLinSysIterativeStaticCond.cpp.

References Nektar::MultiRegions::GlobalLinSysStaticCond::m_locToGloMap, and Nektar::MultiRegions::GlobalLinSysIterative::m_map.

Referenced by v_AssembleSchurComplement().

         {
             m_map = m_locToGloMap->GetGlobalToUniversalBndMapUnique();
         }

Member Data Documentation

string Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::className

static

Initial value:

= GetGlobalLinSysFactory().RegisterCreatorFunction(
                    "IterativeStaticCond",
                    GlobalLinSysIterativeStaticCond::create,
                    "Iterative static condensation.")

Name of class.

Registers the class with the Factory.

Definition at line 95 of file GlobalLinSysIterativeStaticCond.h.

string Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::className2

static

Initial value:

= GetGlobalLinSysFactory().RegisterCreatorFunction(
                    "IterativeMultiLevelStaticCond",
                    GlobalLinSysIterativeStaticCond::create,
                    "Iterative multi-level static condensation.")

Definition at line 96 of file GlobalLinSysIterativeStaticCond.h.

std::vector<const double*> Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::m_denseBlocks

private

Vector of pointers to local matrix data.

Definition at line 142 of file GlobalLinSysIterativeStaticCond.h.

Referenced by PrepareLocalSchurComplement(), and v_DoMatrixMultiply().

Array<OneD, unsigned int> Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::m_rows

private

Ranks of local matrices.

Definition at line 144 of file GlobalLinSysIterativeStaticCond.h.

Referenced by PrepareLocalSchurComplement(), and v_DoMatrixMultiply().

DNekScalBlkMatSharedPtr Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::m_S1Blk

private

Definition at line 138 of file GlobalLinSysIterativeStaticCond.h.

Referenced by GlobalLinSysIterativeStaticCond(), v_GetStaticCondBlock(), v_InitObject(), and v_PreSolve().

Array<OneD, NekDouble> Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::m_scale

private

Scaling factors for local matrices.

Definition at line 146 of file GlobalLinSysIterativeStaticCond.h.

Referenced by PrepareLocalSchurComplement(), and v_DoMatrixMultiply().

DNekSmvBsrDiagBlkMatSharedPtr Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::m_sparseSchurCompl

private

Sparse representation of Schur complement matrix at this level.

Definition at line 148 of file GlobalLinSysIterativeStaticCond.h.

Referenced by PrepareLocalSchurComplement(), v_AssembleSchurComplement(), and v_DoMatrixMultiply().

std::vector<double> Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::m_storage

private

Dense storage for block Schur complement matrix.

Definition at line 140 of file GlobalLinSysIterativeStaticCond.h.

Referenced by PrepareLocalSchurComplement().

std::string Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::storagedef

staticprivate

Initial value:

= 
            LibUtilities::SessionReader::RegisterDefaultSolverInfo(
                "LocalMatrixStorageStrategy",
                "Sparse")

Utility strings.

Definition at line 150 of file GlobalLinSysIterativeStaticCond.h.

std::string Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::storagelookupIds

staticprivate

Initial value:

= {
            LibUtilities::SessionReader::RegisterEnumValue(
                "LocalMatrixStorageStrategy",
                "Contiguous",
                MultiRegions::eContiguous),
            LibUtilities::SessionReader::RegisterEnumValue(
                "LocalMatrixStorageStrategy",
                "Non-contiguous",
                MultiRegions::eNonContiguous),
            LibUtilities::SessionReader::RegisterEnumValue(
                "LocalMatrixStorageStrategy",
                "Sparse",
                MultiRegions::eSparse),
        }

Definition at line 151 of file GlobalLinSysIterativeStaticCond.h.

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation