A global linear system. More...

#include <GlobalLinSys.h>

Inheritance diagram for Nektar::MultiRegions::GlobalLinSys:

Public Member Functions
	GlobalLinSys (const GlobalLinSysKey &pKey, const std::weak_ptr< ExpList > &pExpList, const std::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 std::weak_ptr< ExpList > &	GetLocMat (void) const

void	InitObject ()

void	Initialise (const std::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.

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

int	GetNumBlocks ()

DNekScalMatSharedPtr	GetBlock (unsigned int n)

void	DropBlock (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 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 std::shared_ptr< AssemblyMap > &pLocToGloMap)

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 void	v_DropBlock (unsigned int n)
	Releases the local block matrix from NekManager of 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.

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

Protected Attributes
const GlobalLinSysKey	m_linSysKey
	Key associated with this linear system.

const std::weak_ptr< ExpList >	m_expList
	Local Matrix System.

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

bool	m_verbose

Private Member Functions
LocalRegions::MatrixKey	GetBlockMatrixKey (unsigned int n)

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 69 of file GlobalLinSys.h.

Constructor & Destructor Documentation

◆ GlobalLinSys()

Nektar::MultiRegions::GlobalLinSys::GlobalLinSys	(	const GlobalLinSysKey &	pKey,
		const std::weak_ptr< ExpList > &	pExpList,
		const std::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 194 of file GlobalLinSys.cpp.

    : m_linSysKey(pKey), m_expList(pExpList),
      m_robinBCInfo(m_expList.lock()->GetRobinBCInfo()),
      m_verbose(
          m_expList.lock()->GetSession()->DefinesCmdLineArgument("verbose"))
{
}

◆ ~GlobalLinSys()

virtual Nektar::MultiRegions::GlobalLinSys::~GlobalLinSys ( )

inlinevirtual

Definition at line 78 of file GlobalLinSys.h.

79 {

80 }

Member Function Documentation

◆ CreatePrecon()

PreconditionerSharedPtr Nektar::MultiRegions::GlobalLinSys::CreatePrecon ( AssemblyMapSharedPtr asmMap )

protected

Create a preconditioner object from the parameters defined in the supplied assembly map.

Parameters

asmMap Assembly map used to construct the global system.

Definition at line 210 of file GlobalLinSys.cpp.

{
    std::string PreconType = asmMap->GetPreconType();
    return GetPreconFactory().CreateInstance(PreconType, GetSharedThisPtr(),
                                             asmMap);
}

References Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::MultiRegions::GetPreconFactory(), and GetSharedThisPtr().

◆ DropBlock()

void Nektar::MultiRegions::GlobalLinSys::DropBlock ( unsigned int n )

inline

Definition at line 214 of file GlobalLinSys.h.

{
    return v_DropBlock(n);
}

References v_DropBlock().

◆ DropStaticCondBlock()

void Nektar::MultiRegions::GlobalLinSys::DropStaticCondBlock ( unsigned int n )

inline

Definition at line 224 of file GlobalLinSys.h.

{
    return v_DropStaticCondBlock(n);
}

References v_DropStaticCondBlock().

◆ GetBlock()

DNekScalMatSharedPtr Nektar::MultiRegions::GlobalLinSys::GetBlock ( unsigned int n )

inline

Definition at line 209 of file GlobalLinSys.h.

{
    return v_GetBlock(n);
}

References v_GetBlock().

Referenced by Nektar::MultiRegions::GlobalLinSysDirectFull::AssembleFullMatrix(), Nektar::MultiRegions::GlobalLinSysXxtFull::AssembleMatrixArrays(), and Nektar::MultiRegions::GlobalLinSysPETScFull::GlobalLinSysPETScFull().

◆ GetBlockMatrixKey()

LocalRegions::MatrixKey Nektar::MultiRegions::GlobalLinSys::GetBlockMatrixKey ( unsigned int n )

private

Assemble the matrix key for each block n

Definition at line 232 of file GlobalLinSys.cpp.

{
 
    std::shared_ptr<MultiRegions::ExpList> expList = m_expList.lock();
 
    LocalRegions::ExpansionSharedPtr vExp = expList->GetExp(n);
 
    // need to be initialised with zero size for non variable
    // coefficient case
    StdRegions::VarCoeffMap vVarCoeffMap;
    StdRegions::VarFactorsMap vVarFactorsMap;
    StdRegions::ConstFactorMap vConstFactorMap = m_linSysKey.GetConstFactors();
 
    // setup variable factors
    if (m_linSysKey.GetNVarFactors() > 0)
    {
        if (m_linSysKey.GetVarFactors().count(
                StdRegions::eFactorSVVDiffCoeff) != 0)
        {
            vConstFactorMap[StdRegions::eFactorSVVDiffCoeff] =
                m_linSysKey.GetVarFactors(StdRegions::eFactorSVVDiffCoeff)[n];
 
            ASSERTL1(m_linSysKey.GetConstFactors().count(
                         StdRegions::eFactorSVVCutoffRatio),
                     "VarCoeffSVVCuroffRatio is set but "
                     " not FactorSVVCutoffRatio");
 
            vConstFactorMap[StdRegions::eFactorSVVCutoffRatio] =
                m_linSysKey.GetVarFactors(StdRegions::eFactorSVVCutoffRatio)[n];
        }
 
        if (m_linSysKey.GetVarFactors().count(
                StdRegions::eFactorSVVPowerKerDiffCoeff) != 0)
        {
            vConstFactorMap[StdRegions::eFactorSVVPowerKerDiffCoeff] =
                m_linSysKey.GetVarFactors(
                    StdRegions::eFactorSVVPowerKerDiffCoeff)[n];
        }
 
        if (m_linSysKey.GetVarFactors().count(
                StdRegions::eFactorSVVDGKerDiffCoeff) != 0)
        {
            vConstFactorMap[StdRegions::eFactorSVVDGKerDiffCoeff] =
                m_linSysKey.GetVarFactors(
                    StdRegions::eFactorSVVDGKerDiffCoeff)[n];
        }
    }
 
    // retrieve variable coefficients
    if (m_linSysKey.GetNVarCoeffs() > 0)
    {
        vVarCoeffMap = StdRegions::RestrictCoeffMap(m_linSysKey.GetVarCoeffs(),
                                                    expList->GetPhys_Offset(n),
                                                    vExp->GetTotPoints());
    }
 
    StdRegions::MatrixType mtype = m_linSysKey.GetMatrixType();
 
    // replace mtype with GJP version if required - necessary for preconditioner
    if (vConstFactorMap.count(StdRegions::eFactorGJP) &&
        expList->GetGJPData()->IsImplicit())
    {
 
        switch (mtype)
        {
            case StdRegions::eHelmholtzGJP:
            case StdRegions::eLinearAdvectionDiffusionReactionGJP:
                // do nothing
                break;
            case StdRegions::eHelmholtz:
                mtype = StdRegions::eHelmholtzGJP;
                break;
            case StdRegions::eLinearAdvectionDiffusionReaction:
                mtype = StdRegions::eLinearAdvectionDiffusionReactionGJP;
                break;
            case StdRegions::eMass:
                mtype = StdRegions::eMassGJP;
                break;
            default:
                NEKERROR(ErrorUtil::ewarning,
                         "GJP matrix flag not being set in GlobalLinSys");
                break;
        }
    }
 
    if (vConstFactorMap.count(StdRegions::eFactorGJP) &&
        (expList->GetGJPData()->IsSemiImplicit() ||
         expList->GetGJPData()->IsImplicit()))
    {
        vVarFactorsMap[StdRegions::eFactorGJPTraceWeight] =
            Array<OneD, NekDouble>(
                6, m_linSysKey.GetVarFactors(StdRegions::eFactorGJPTraceWeight)
                           .data() +
                       6 * n);
    }
 
    LocalRegions::MatrixKey matkey(mtype, vExp->DetShapeType(), *vExp,
                                   vConstFactorMap, vVarCoeffMap,
                                   vVarFactorsMap);
    return matkey;
}

Referenced by v_DropBlock(), v_DropStaticCondBlock(), v_GetBlock(), and v_GetStaticCondBlock().

◆ GetKey()

const GlobalLinSysKey & Nektar::MultiRegions::GlobalLinSys::GetKey ( void ) const

inline

Returns the key associated with the system.

Definition at line 163 of file GlobalLinSys.h.

{
    return m_linSysKey;
}

References m_linSysKey.

◆ GetLocMat()

const std::weak_ptr< ExpList > & Nektar::MultiRegions::GlobalLinSys::GetLocMat ( void ) const

inline

Definition at line 171 of file GlobalLinSys.h.

{
    return m_expList;
}

References m_expList.

◆ GetNumBlocks()

int Nektar::MultiRegions::GlobalLinSys::GetNumBlocks ( )

inline

Definition at line 229 of file GlobalLinSys.h.

{
    return v_GetNumBlocks();
}

References v_GetNumBlocks().

◆ GetSharedThisPtr()

std::shared_ptr< GlobalLinSys > Nektar::MultiRegions::GlobalLinSys::GetSharedThisPtr ( )

inline

Returns a shared pointer to the current object.

Definition at line 100 of file GlobalLinSys.h.

    {
        return shared_from_this();
    }

Referenced by CreatePrecon().

◆ GetStaticCondBlock()

DNekScalBlkMatSharedPtr Nektar::MultiRegions::GlobalLinSys::GetStaticCondBlock ( unsigned int n )

inline

Definition at line 219 of file GlobalLinSys.h.

{
    return v_GetStaticCondBlock(n);
}

References v_GetStaticCondBlock().

◆ Initialise()

void Nektar::MultiRegions::GlobalLinSys::Initialise ( const std::shared_ptr< AssemblyMap > & pLocToGloMap )

inline

Definition at line 203 of file GlobalLinSys.h.

{
    v_Initialise(pLocToGloMap);
}

References v_Initialise().

Referenced by Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::v_InitObject(), Nektar::MultiRegions::GlobalLinSysPETScStaticCond::v_InitObject(), and Nektar::MultiRegions::GlobalLinSysStaticCond::v_InitObject().

◆ InitObject()

void Nektar::MultiRegions::GlobalLinSys::InitObject ( )

inline

Definition at line 198 of file GlobalLinSys.h.

{
    v_InitObject();
}

References v_InitObject().

◆ Solve()

void Nektar::MultiRegions::GlobalLinSys::Solve	(	const Array< OneD, const NekDouble > &	in,
		Array< OneD, NekDouble > &	out,
		const AssemblyMapSharedPtr &	locToGloMap,
		const Array< OneD, const NekDouble > &	dirForcing = `NullNekDouble1DArray`
	)

inline

Solve the linear system for given input and output vectors using a specified local to global map.

Definition at line 179 of file GlobalLinSys.h.

{
    v_Solve(in, out, locToGloMap, dirForcing);
}

References v_Solve().

◆ SolveLinearSystem()

void Nektar::MultiRegions::GlobalLinSys::SolveLinearSystem	(	const int	pNumRows,
		const Array< OneD, const NekDouble > &	pInput,
		Array< OneD, NekDouble > &	pOutput,
		const AssemblyMapSharedPtr &	locToGloMap,
		const int	pNumDir = `0`
	)

inline

Solve the linear system for given input and output vectors.

Definition at line 190 of file GlobalLinSys.h.

{
    v_SolveLinearSystem(pNumRows, pInput, pOutput, locToGloMap, pNumDir);
}

References v_SolveLinearSystem().

Referenced by Nektar::MultiRegions::GlobalLinSysIterativeFull::v_Solve(), Nektar::MultiRegions::GlobalLinSysPETScFull::v_Solve(), Nektar::MultiRegions::GlobalLinSysStaticCond::v_Solve(), Nektar::MultiRegions::GlobalLinSysXxtFull::v_Solve(), and Nektar::MultiRegions::GlobalLinSysDirectFull::v_Solve().

◆ v_DropBlock()

void Nektar::MultiRegions::GlobalLinSys::v_DropBlock ( unsigned int n )

protectedvirtual

Releases the local block matrix from NekManager of n-th expansion using the matrix key provided by the m_linSysKey.

Parameters

n	Number of the expansion

Definition at line 449 of file GlobalLinSys.cpp.

{
    LocalRegions::ExpansionSharedPtr vExp = m_expList.lock()->GetExp(n);
    vExp->DropLocMatrix(GetBlockMatrixKey(n));
}

References GetBlockMatrixKey(), and m_expList.

Referenced by DropBlock().

◆ v_DropStaticCondBlock()

void Nektar::MultiRegions::GlobalLinSys::v_DropStaticCondBlock ( unsigned int n )

protectedvirtual

Releases the static condensation block matrices from NekManager of n-th expansion using the matrix key provided by the m_linSysKey.

Parameters

n	Number of the expansion

Definition at line 437 of file GlobalLinSys.cpp.

{
    LocalRegions::ExpansionSharedPtr vExp = m_expList.lock()->GetExp(n);
    vExp->DropLocStaticCondMatrix(GetBlockMatrixKey(n));
}

References GetBlockMatrixKey(), and m_expList.

Referenced by DropStaticCondBlock(), and Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::PrepareLocalSchurComplement().

◆ v_GetBlock()

DNekScalMatSharedPtr Nektar::MultiRegions::GlobalLinSys::v_GetBlock ( unsigned int n )

protectedvirtual

Retrieves the block matrix from n-th expansion using the matrix key provided by the m_linSysKey.

Parameters

n	Number of the expansion.

Returns: Block matrix for the specified expansion.

Definition at line 341 of file GlobalLinSys.cpp.

{
    LocalRegions::ExpansionSharedPtr vExp = m_expList.lock()->GetExp(n);
    DNekScalMatSharedPtr loc_mat;
    loc_mat = vExp->GetLocMatrix(GetBlockMatrixKey(n));
 
    // apply robin boundary conditions to the matrix.
    if (m_robinBCInfo.count(n) != 0) // add robin mass matrix
    {
        RobinBCInfoSharedPtr rBC;
 
        // declare local matrix from scaled matrix.
        int rows             = loc_mat->GetRows();
        int cols             = loc_mat->GetColumns();
        const NekDouble *dat = loc_mat->GetRawPtr();
        DNekMatSharedPtr new_mat =
            MemoryManager<DNekMat>::AllocateSharedPtr(rows, cols, dat);
        Blas::Dscal(rows * cols, loc_mat->Scale(), new_mat->GetRawPtr(), 1);
 
        // add local matrix contribution
        for (rBC = m_robinBCInfo.find(n)->second; rBC; rBC = rBC->next)
        {
            vExp->AddRobinMassMatrix(rBC->m_robinID,
                                     rBC->m_robinPrimitiveCoeffs, new_mat);
        }
 
        // redeclare loc_mat to point to new_mat plus the scalar.
        loc_mat = MemoryManager<DNekScalMat>::AllocateSharedPtr(1.0, new_mat);
    }
 
    // finally return the matrix.
    return loc_mat;
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Blas::Dscal(), GetBlockMatrixKey(), m_expList, and m_robinBCInfo.

Referenced by GetBlock(), and Nektar::MultiRegions::GlobalLinSysStaticCond::SetupTopLevel().

◆ v_GetNumBlocks()

int Nektar::MultiRegions::GlobalLinSys::v_GetNumBlocks ( )

protectedvirtual

Get the number of blocks in this system.

At the top level this corresponds to the number of elements in the expansion list.

Reimplemented in Nektar::MultiRegions::GlobalLinSysStaticCond.

Definition at line 223 of file GlobalLinSys.cpp.

{
    return m_expList.lock()->GetExpSize();
}

References m_expList.

Referenced by GetNumBlocks().

◆ v_GetStaticCondBlock()

DNekScalBlkMatSharedPtr Nektar::MultiRegions::GlobalLinSys::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 in Nektar::MultiRegions::GlobalLinSysIterativeStaticCond, and Nektar::MultiRegions::GlobalLinSysPETScStaticCond.

Definition at line 383 of file GlobalLinSys.cpp.

{
 
    LocalRegions::ExpansionSharedPtr vExp = m_expList.lock()->GetExp(n);
    DNekScalBlkMatSharedPtr loc_mat;
    loc_mat = vExp->GetLocStaticCondMatrix(GetBlockMatrixKey(n));
 
    if (m_robinBCInfo.count(n) != 0) // add robin mass matrix
    {
        DNekScalMatSharedPtr tmp_mat;
        RobinBCInfoSharedPtr rBC;
 
        tmp_mat = loc_mat->GetBlock(0, 0);
 
        // declare local matrix from scaled matrix.
        int rows             = tmp_mat->GetRows();
        int cols             = tmp_mat->GetColumns();
        const NekDouble *dat = tmp_mat->GetRawPtr();
        DNekMatSharedPtr new_mat =
            MemoryManager<DNekMat>::AllocateSharedPtr(rows, cols, dat);
        Blas::Dscal(rows * cols, tmp_mat->Scale(), new_mat->GetRawPtr(), 1);
 
        // add local matrix contribution
        for (rBC = m_robinBCInfo.find(n)->second; rBC; rBC = rBC->next)
        {
            vExp->AddRobinMassMatrix(rBC->m_robinID,
                                     rBC->m_robinPrimitiveCoeffs, new_mat);
        }
 
        // redeclare loc_mat to point to new_mat plus the scalar.
        tmp_mat = MemoryManager<DNekScalMat>::AllocateSharedPtr(1.0, new_mat);
        DNekScalBlkMatSharedPtr new_loc_mat;
        unsigned int exp_size[] = {tmp_mat->GetRows(),
                                   loc_mat->GetBlock(1, 1)->GetRows()};
        unsigned int nblks      = 2;
        new_loc_mat = MemoryManager<DNekScalBlkMat>::AllocateSharedPtr(
            nblks, nblks, exp_size, exp_size);
 
        new_loc_mat->SetBlock(0, 0, tmp_mat);
        new_loc_mat->SetBlock(0, 1, loc_mat->GetBlock(0, 1));
        new_loc_mat->SetBlock(1, 0, loc_mat->GetBlock(1, 0));
        new_loc_mat->SetBlock(1, 1, loc_mat->GetBlock(1, 1));
        loc_mat = new_loc_mat;
    }
 
    return loc_mat;
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Blas::Dscal(), GetBlockMatrixKey(), m_expList, and m_robinBCInfo.

Referenced by GetStaticCondBlock(), and Nektar::MultiRegions::GlobalLinSysStaticCond::SetupTopLevel().

◆ v_Initialise()

void Nektar::MultiRegions::GlobalLinSys::v_Initialise ( const std::shared_ptr< AssemblyMap > & pLocToGloMap )

protectedvirtual

Reimplemented in Nektar::MultiRegions::GlobalLinSysStaticCond.

Definition at line 460 of file GlobalLinSys.cpp.

{
    NEKERROR(ErrorUtil::efatal, "Method does not exist");
}

References Nektar::ErrorUtil::efatal, and NEKERROR.

Referenced by Initialise().

◆ v_InitObject()

void Nektar::MultiRegions::GlobalLinSys::v_InitObject ( )

protectedvirtual

Reimplemented in Nektar::MultiRegions::GlobalLinSysIterativeStaticCond, Nektar::MultiRegions::GlobalLinSysPETScStaticCond, and Nektar::MultiRegions::GlobalLinSysStaticCond.

Definition at line 455 of file GlobalLinSys.cpp.

{
    NEKERROR(ErrorUtil::efatal, "Method does not exist");
}

References Nektar::ErrorUtil::efatal, and NEKERROR.

Referenced by InitObject().

◆ v_Solve()

virtual void Nektar::MultiRegions::GlobalLinSys::v_Solve	(	const Array< OneD, const NekDouble > &	in,
		Array< OneD, NekDouble > &	out,
		const AssemblyMapSharedPtr &	locToGloMap,
		const Array< OneD, const NekDouble > &	dirForcing = `NullNekDouble1DArray`
	)

protectedpure virtual

Solve a linear system based on mapping.

Implemented in Nektar::MultiRegions::GlobalLinSysIterativeFull, Nektar::MultiRegions::GlobalLinSysPETScFull, Nektar::MultiRegions::GlobalLinSysStaticCond, Nektar::MultiRegions::GlobalLinSysXxtFull, and Nektar::MultiRegions::GlobalLinSysDirectFull.

Referenced by Solve().

◆ v_SolveLinearSystem()

virtual void Nektar::MultiRegions::GlobalLinSys::v_SolveLinearSystem	(	const int	pNumRows,
		const Array< OneD, const NekDouble > &	pInput,
		Array< OneD, NekDouble > &	pOutput,
		const AssemblyMapSharedPtr &	locToGloMap,
		const int	pNumDir
	)

protectedpure virtual

Solve a basic matrix system.

Implemented in Nektar::MultiRegions::GlobalLinSysDirectFull, Nektar::MultiRegions::GlobalLinSysDirectStaticCond, Nektar::MultiRegions::GlobalLinSysIterativeFull, Nektar::MultiRegions::GlobalLinSysIterativeStaticCond, Nektar::MultiRegions::GlobalLinSysPETSc, Nektar::MultiRegions::GlobalLinSysPETScStaticCond, Nektar::MultiRegions::GlobalLinSysXxtStaticCond, and Nektar::MultiRegions::GlobalLinSysXxtFull.

Referenced by SolveLinearSystem().

Member Data Documentation

◆ def

std::string Nektar::MultiRegions::GlobalLinSys::def

staticprivate

Initial value:

=
    LibUtilities::SessionReader::RegisterDefaultSolverInfo("GlobalSysSoln",
                                                           "DirectStaticCond")

Definition at line 157 of file GlobalLinSys.h.

◆ lookupIds

std::string Nektar::MultiRegions::GlobalLinSys::lookupIds

staticprivate

Initial value:

= {
    LibUtilities::SessionReader::RegisterEnumValue(
        "GlobalSysSoln", "DirectFull", MultiRegions::eDirectFullMatrix),
    LibUtilities::SessionReader::RegisterEnumValue(
        "GlobalSysSoln", "DirectStaticCond", MultiRegions::eDirectStaticCond),
    LibUtilities::SessionReader::RegisterEnumValue(
        "GlobalSysSoln", "DirectMultiLevelStaticCond",
        MultiRegions::eDirectMultiLevelStaticCond),
    LibUtilities::SessionReader::RegisterEnumValue(
        "GlobalSysSoln", "IterativeFull", MultiRegions::eIterativeFull),
    LibUtilities::SessionReader::RegisterEnumValue(
        "GlobalSysSoln", "IterativeStaticCond",
        MultiRegions::eIterativeStaticCond),
    LibUtilities::SessionReader::RegisterEnumValue(
        "GlobalSysSoln", "IterativeMultiLevelStaticCond",
        MultiRegions::eIterativeMultiLevelStaticCond),
    LibUtilities::SessionReader::RegisterEnumValue(
        "GlobalSysSoln", "XxtFull", MultiRegions::eXxtFullMatrix),
    LibUtilities::SessionReader::RegisterEnumValue(
        "GlobalSysSoln", "XxtStaticCond", MultiRegions::eXxtStaticCond),
    LibUtilities::SessionReader::RegisterEnumValue(
        "GlobalSysSoln", "XxtMultiLevelStaticCond",
        MultiRegions::eXxtMultiLevelStaticCond),
    LibUtilities::SessionReader::RegisterEnumValue(
        "GlobalSysSoln", "PETScFull", MultiRegions::ePETScFullMatrix),
    LibUtilities::SessionReader::RegisterEnumValue(
        "GlobalSysSoln", "PETScStaticCond", MultiRegions::ePETScStaticCond),
    LibUtilities::SessionReader::RegisterEnumValue(
        "GlobalSysSoln", "PETScMultiLevelStaticCond",
        MultiRegions::ePETScMultiLevelStaticCond)}

Definition at line 156 of file GlobalLinSys.h.

◆ m_expList

const std::weak_ptr<ExpList> Nektar::MultiRegions::GlobalLinSys::m_expList

protected

Local Matrix System.

Definition at line 122 of file GlobalLinSys.h.

◆ m_linSysKey

const GlobalLinSysKey Nektar::MultiRegions::GlobalLinSys::m_linSysKey

protected

Key associated with this linear system.

Definition at line 120 of file GlobalLinSys.h.

◆ m_robinBCInfo

const std::map<int, RobinBCInfoSharedPtr> Nektar::MultiRegions::GlobalLinSys::m_robinBCInfo

protected

Robin boundary info.

Definition at line 124 of file GlobalLinSys.h.

Referenced by Nektar::MultiRegions::GlobalLinSysIterativeFull::v_DoMatrixMultiply(), v_GetBlock(), v_GetStaticCondBlock(), Nektar::MultiRegions::GlobalLinSysIterativeFull::v_Solve(), Nektar::MultiRegions::GlobalLinSysPETScFull::v_Solve(), Nektar::MultiRegions::GlobalLinSysXxtFull::v_Solve(), and Nektar::MultiRegions::GlobalLinSysDirectFull::v_Solve().

◆ m_verbose

bool Nektar::MultiRegions::GlobalLinSys::m_verbose

protected

Definition at line 126 of file GlobalLinSys.h.

Referenced by Nektar::MultiRegions::GlobalLinSysXxtFull::AssembleMatrixArrays(), Nektar::MultiRegions::GlobalLinSysIterative::DoProjection(), Nektar::MultiRegions::GlobalLinSysIterative::UpdateKnownSolutions(), and Nektar::MultiRegions::GlobalLinSysXxtStaticCond::v_AssembleSchurComplement().

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ GlobalLinSys()

◆ ~GlobalLinSys()

Member Function Documentation

◆ CreatePrecon()

◆ DropBlock()

◆ DropStaticCondBlock()

◆ GetBlock()

◆ GetBlockMatrixKey()

◆ GetKey()

◆ GetLocMat()

◆ GetNumBlocks()

◆ GetSharedThisPtr()

◆ GetStaticCondBlock()

◆ Initialise()

◆ InitObject()

◆ Solve()

◆ SolveLinearSystem()

◆ v_DropBlock()

◆ v_DropStaticCondBlock()

◆ v_GetBlock()

◆ v_GetNumBlocks()

◆ v_GetStaticCondBlock()

◆ v_Initialise()

◆ v_InitObject()

◆ v_Solve()

◆ v_SolveLinearSystem()

Member Data Documentation

◆ def

◆ lookupIds

◆ m_expList

◆ m_linSysKey

◆ m_robinBCInfo

◆ m_verbose