A global linear system. More...

#include <GlobalLinSys.h>

Inheritance diagram for Nektar::MultiRegions::GlobalLinSys:

Collaboration diagram for Nektar::MultiRegions::GlobalLinSys:

Public Member Functions
	GlobalLinSys (const GlobalLinSysKey &pKey, const boost::weak_ptr< ExpList > &pExpList, const boost::shared_ptr< AssemblyMap > &pLocToGloMap)
	Constructor for full direct matrix solve.
virtual	~GlobalLinSys ()
const GlobalLinSysKey &	GetKey (void) const
	Returns the key associated with the system.
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.
boost::shared_ptr< GlobalLinSys >	GetSharedThisPtr ()
	Returns a shared pointer to the current object.
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.

Protected Member Functions
virtual int	v_GetNumBlocks ()
	Get the number of blocks in this system.
virtual DNekScalMatSharedPtr	v_GetBlock (unsigned int n)
	Retrieves the block matrix from n-th expansion using the matrix key provided by the m_linSysKey.
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.
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.

Protected Attributes
const GlobalLinSysKey	m_linSysKey
	Key associated with this linear system.
const boost::weak_ptr< ExpList >	m_expList
	Local Matrix System.
const map< int, RobinBCInfoSharedPtr >	m_robinBCInfo
	Robin boundary info.

Private Member Functions
virtual void	v_Solve (const Array< OneD, const NekDouble > &in, Array< OneD, NekDouble > &out, const AssemblyMapSharedPtr &locToGloMap, const Array< OneD, const NekDouble > &dirForcing=NullNekDouble1DArray)=0
	Solve a linear system based on mapping.
virtual void	v_SolveLinearSystem (const int pNumRows, const Array< OneD, const NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const AssemblyMapSharedPtr &locToGloMap, const int pNumDir)=0
	Solve a basic matrix system.
virtual void	v_InitObject ()
virtual void	v_Initialise (const boost::shared_ptr< AssemblyMap > &pLocToGloMap)

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

Detailed Description

A global linear system.

Consider the linear system $\boldsymbol{M\hat{u}}_g=\boldsymbol{\hat{f}}$ . Distinguishing between the boundary and interior components of $\boldsymbol{\hat{u}}_g$ and $\boldsymbol{\hat{f}}$ using $\boldsymbol{\hat{u}}_b$ , $\boldsymbol{\hat{u}}_i$ and $\boldsymbol{\hat{f}}_b$ , $\boldsymbol{\hat{f}}_i$ respectively, this system can be split into its constituent parts as

$\left[\begin{array}{cc} \boldsymbol{M}_b&\boldsymbol{M}_{c1}\\ \boldsymbol{M}_{c2}&\boldsymbol{M}_i\\ \end{array}\right] \left[\begin{array}{c} \boldsymbol{\hat{u}_b}\\ \boldsymbol{\hat{u}_i}\\ \end{array}\right]= \left[\begin{array}{c} \boldsymbol{\hat{f}_b}\\ \boldsymbol{\hat{f}_i}\\ \end{array}\right]$

where $\boldsymbol{M}_b$ represents the components of $\boldsymbol{M}$ resulting from boundary-boundary mode interactions, $\boldsymbol{M}_{c1}$ and $\boldsymbol{M}_{c2}$ represent the components resulting from coupling between the boundary-interior modes, and $\boldsymbol{M}_i$ represents the components of $\boldsymbol{M}$ resulting from interior-interior mode interactions.

The solution of the linear system can now be determined in two steps:

$\begin{eqnarray*} \mathrm{step 1:}&\quad&(\boldsymbol{M}_b-\boldsymbol{M}_{c1} \boldsymbol{M}_i^{-1}\boldsymbol{M}_{c2}) \boldsymbol{\hat{u}_b} = \boldsymbol{\hat{f}}_b - \boldsymbol{M}_{c1}\boldsymbol{M}_i^{-1} \boldsymbol{\hat{f}}_i,\nonumber \\ \mathrm{step 2:}&\quad&\boldsymbol{\hat{u}_i}=\boldsymbol{M}_i^{-1} \left( \boldsymbol{\hat{f}}_i - \boldsymbol{M}_{c2}\boldsymbol{\hat{u}_b} \right). \nonumber \\ \end{eqnarray*}$

As the inverse of $\boldsymbol{M}_i^{-1}$ is

$\boldsymbol{M}_i^{-1} = \left [\underline{\boldsymbol{M}^e_i} \right ]^{-1} = \underline{[\boldsymbol{M}^e_i]}^{-1}$

and the following operations can be evaluated as,

$\begin{eqnarray*} \boldsymbol{M}_{c1}\boldsymbol{M}_i^{-1}\boldsymbol{\hat{f}}_i & =& \boldsymbol{\mathcal{A}}_b^T \underline{\boldsymbol{M}^e_{c1}} \underline{[\boldsymbol{M}^e_i]}^{-1} \boldsymbol{\hat{f}}_i \\ \boldsymbol{M}_{c2} \boldsymbol{\hat{u}_b} &=& \underline{\boldsymbol{M}^e_{c2}} \boldsymbol{\mathcal{A}}_b \boldsymbol{\hat{u}_b}.\end{eqnarray*}$

where $\boldsymbol{\mathcal{A}}_b$ is the permutation matrix which scatters from global to local degrees of freedom, only the following four matrices should be constructed:

$\underline{[\boldsymbol{M}^e_i]}^{-1}$
$\underline{\boldsymbol{M}^e_{c1}} \underline{[\boldsymbol{M}^e_i]}^{-1}$
$\underline{\boldsymbol{M}^e_{c2}}$
The Schur complement: $\boldsymbol{M}_{\mathrm{Schur}}= \quad\boldsymbol{M}_b-\boldsymbol{M}_{c1}\boldsymbol{M}_i^{-1} \boldsymbol{M}_{c2}$

The first three matrices are just a concatenation of the corresponding local matrices and they can be created as such. They also allow for an elemental evaluation of the operations concerned.

The global Schur complement however should be assembled from the concatenation of the local elemental Schur complements, that is,

$\boldsymbol{M}_{\mathrm{Schur}}=\boldsymbol{M}_b - \boldsymbol{M}_{c1} \boldsymbol{M}_i^{-1} \boldsymbol{M}_{c2} = \boldsymbol{\mathcal{A}}_b^T \left [\underline{\boldsymbol{M}^e_b - \boldsymbol{M}^e_{c1} [\boldsymbol{M}^e_i]^{-1} (\boldsymbol{M}^e_{c2})} \right ] \boldsymbol{\mathcal{A}}_b$

and it is the only matrix operation that need to be evaluated on a global level when using static condensation. However, due to the size and sparsity of the matrix $\boldsymbol{\mathcal{A}}_b$ , it is more efficient to assemble the global Schur matrix using the mapping array bmap $[e][i]$ contained in the input argument locToGloMap. The global Schur complement is then constructed as:

$\boldsymbol{M}_{\mathrm{Schur}}\left[\mathrm{\a bmap}[e][i]\right] \left[\mathrm{\a bmap}[e][j]\right]=\mathrm{\a bsign}[e][i]\cdot \mathrm{\a bsign}[e][j] \cdot\boldsymbol{M}^e_{\mathrm{Schur}}[i][j]$

All four matrices are stored in the GlobalLinSys returned by this function.

Definition at line 70 of file GlobalLinSys.h.

Constructor & Destructor Documentation

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.

Given a block matrix, construct a global matrix system according to a local to global mapping. #m_linSys is constructed by AssembleFullMatrix().

Parameters

pkey	Associated linear system key.
locToGloMap	Local to global mapping.

Definition at line 188 of file GlobalLinSys.cpp.

                                                 :
            m_linSysKey(pKey),
            m_expList(pExpList),
            m_robinBCInfo(m_expList.lock()->GetRobinBCInfo())
        {

        }

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation