A global linear system. More...

#include <GlobalLinSysPETScStaticCond.h>

Inheritance diagram for Nektar::MultiRegions::GlobalLinSysPETScStaticCond:

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

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

	~GlobalLinSysPETScStaticCond () override

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

	~GlobalLinSysPETSc () override
	Clean up PETSc objects. More...

Public Member Functions inherited from 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. More...

virtual	~GlobalLinSys ()

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

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. More...

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

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. More...

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

	~GlobalLinSysStaticCond () override

Static Public Member Functions
static GlobalLinSysSharedPtr	create (const GlobalLinSysKey &pLinSysKey, const std::weak_ptr< ExpList > &pExpList, const std::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
void	v_InitObject () override

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

void	v_DoMatrixMultiply (const Array< OneD, const NekDouble > &input, Array< OneD, NekDouble > &output) override
	Apply matrix-vector multiplication using local approach and the assembly map. More...

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

void	v_PreSolve (int scLevel, Array< OneD, NekDouble > &F_bBnd) override

void	v_SolveLinearSystem (const int pNumRows, const Array< OneD, const NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const AssemblyMapSharedPtr &locToGloMap, const int pNumDir) override
	Solve linear system using PETSc. More...

void	v_BasisFwdTransform (Array< OneD, NekDouble > &pInOut) override

void	v_CoeffsBwdTransform (Array< OneD, NekDouble > &pInOut) override

void	v_CoeffsFwdTransform (const Array< OneD, NekDouble > &pInput, Array< OneD, NekDouble > &pOutput) override

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

Protected Member Functions inherited from Nektar::MultiRegions::GlobalLinSysPETSc
void	SetUpScatter ()
	Set up PETSc local (equivalent to Nektar++ global) and global (equivalent to universal) scatter maps. More...

void	SetUpMatVec (int nGlobal, int nDir)
	Construct PETSc matrix and vector handles. More...

void	SetUpSolver (NekDouble tolerance)
	Set up KSP solver object. More...

void	CalculateReordering (const Array< OneD, const int > &glo2uniMap, const Array< OneD, const int > &glo2unique, const AssemblyMapSharedPtr &pLocToGloMap)
	Calculate a reordering of universal IDs for PETSc. More...

void	v_SolveLinearSystem (const int pNumRows, const Array< OneD, const NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const AssemblyMapSharedPtr &locToGloMap, const int pNumDir) override
	Solve linear system using PETSc. More...

virtual void	v_DoMatrixMultiply (const Array< OneD, const NekDouble > &pInput, Array< OneD, NekDouble > &pOutput)=0

Protected Member Functions inherited from Nektar::MultiRegions::GlobalLinSys
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. More...

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. More...

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. More...

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_DropBlock (unsigned int n)
	Releases the local block matrix from NekManager of n-th expansion using the matrix key provided by the m_linSysKey. More...

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 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 void	v_PreSolve (int scLevel, Array< OneD, NekDouble > &F_bnd)

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

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

virtual void	v_CoeffsFwdTransform (const Array< OneD, NekDouble > &pInput, Array< OneD, NekDouble > &pOutput)

virtual void	v_AssembleSchurComplement (std::shared_ptr< AssemblyMap > pLoctoGloMap)

int	v_GetNumBlocks () override
	Get the number of blocks in this system. More...

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

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

void	v_InitObject () override

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

void	SetupTopLevel (const std::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 std::shared_ptr< AssemblyMap > &locToGloMap)

Additional Inherited Members
Protected Attributes inherited from Nektar::MultiRegions::GlobalLinSysPETSc
Mat	m_matrix
	PETSc matrix object. More...

Vec	m_x
	PETSc vector objects used for local storage. More...

Vec	m_b

Vec	m_locVec

KSP	m_ksp
	KSP object that represents solver system. More...

PC	m_pc
	PCShell for preconditioner. More...

PETScMatMult	m_matMult
	Enumerator to select matrix multiplication type. More...

std::vector< int >	m_reorderedMap
	Reordering that takes universal IDs to a unique row in the PETSc matrix. More...

VecScatter	m_ctx
	PETSc scatter context that takes us between Nektar++ global ordering and PETSc vector ordering. More...

int	m_nLocal
	Number of unique degrees of freedom on this process. More...

PreconditionerSharedPtr	m_precon

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

const std::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 \( C \) matrix. More...

DNekScalBlkMatSharedPtr	m_invD
	Block \( D^{-1} \) matrix. More...

std::weak_ptr< AssemblyMap >	m_locToGloMap
	Local to global map. More...

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

Array< OneD, const NekDouble >	m_sign

Detailed Description

A global linear system.

Definition at line 52 of file GlobalLinSysPETScStaticCond.h.

Constructor & Destructor Documentation

◆ GlobalLinSysPETScStaticCond() [1/2]

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

    : GlobalLinSys(pKey, pExpList, pLocToGloMap),
      GlobalLinSysPETSc(pKey, pExpList, pLocToGloMap),
      GlobalLinSysStaticCond(pKey, pExpList, pLocToGloMap)
{
    ASSERTL1((pKey.GetGlobalSysSolnType() == ePETScStaticCond) ||
                 (pKey.GetGlobalSysSolnType() == ePETScMultiLevelStaticCond),
             "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");
}

References ASSERTL1, Nektar::MultiRegions::ePETScMultiLevelStaticCond, Nektar::MultiRegions::ePETScStaticCond, and Nektar::MultiRegions::GlobalLinSysKey::GetGlobalSysSolnType().

◆ GlobalLinSysPETScStaticCond() [2/2]

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

Constructor for full direct matrix solve.

Definition at line 104 of file GlobalLinSysPETScStaticCond.cpp.

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

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

◆ ~GlobalLinSysPETScStaticCond()

Nektar::MultiRegions::GlobalLinSysPETScStaticCond::~GlobalLinSysPETScStaticCond ( )

override

Definition at line 125 of file GlobalLinSysPETScStaticCond.cpp.

126{

127}

Member Function Documentation

◆ create()

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

inlinestatic

Creates an instance of this class.

Definition at line 57 of file GlobalLinSysPETScStaticCond.h.

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

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and CellMLToNektar.cellml_metadata::p.

◆ v_AssembleSchurComplement()

void Nektar::MultiRegions::GlobalLinSysPETScStaticCond::v_AssembleSchurComplement ( std::shared_ptr< AssemblyMap > locToGloMap )

overrideprotectedvirtual

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 167 of file GlobalLinSysPETScStaticCond.cpp.

{
    int i, j, n, cnt, gid1, gid2, loc_lda;
    NekDouble sign1, sign2, value;
 
    const int nDirDofs = pLocToGloMap->GetNumGlobalDirBndCoeffs();
 
    DNekScalBlkMatSharedPtr SchurCompl = m_schurCompl;
    DNekScalBlkMatSharedPtr BinvD      = m_BinvD;
    DNekScalBlkMatSharedPtr C          = m_C;
    DNekScalBlkMatSharedPtr invD       = m_invD;
    DNekScalMatSharedPtr loc_mat;
 
    // Build precon again if we in multi-level static condensation (a
    // bit of a hack)
    if (m_linSysKey.GetGlobalSysSolnType() == ePETScMultiLevelStaticCond)
    {
        m_precon = CreatePrecon(m_locToGloMap.lock());
        m_precon->BuildPreconditioner();
    }
 
    // CALCULATE REORDERING MAPPING
    CalculateReordering(pLocToGloMap->GetGlobalToUniversalBndMap(),
                        pLocToGloMap->GetGlobalToUniversalBndMapUnique(),
                        pLocToGloMap);
 
    // SET UP VECTORS AND MATRIX
    SetUpMatVec(pLocToGloMap->GetNumGlobalBndCoeffs(), nDirDofs);
 
    // SET UP SCATTER OBJECTS
    SetUpScatter();
 
    // CONSTRUCT KSP OBJECT
    LibUtilities::SessionReaderSharedPtr pSession =
        m_expList.lock()->GetSession();
    string variable                    = pLocToGloMap->GetVariable();
    NekDouble IterativeSolverTolerance = NekConstants::kNekIterativeTol;
    if (pSession->DefinesGlobalSysSolnInfo(variable,
                                           "IterativeSolverTolerance"))
    {
        IterativeSolverTolerance = boost::lexical_cast<double>(
            pSession->GetGlobalSysSolnInfo(variable, "IterativeSolverTolerance")
                .c_str());
    }
    else if (pSession->DefinesParameter("IterativeSolverTolerance"))
    {
        IterativeSolverTolerance =
            pSession->GetParameter("IterativeSolverTolerance");
    }
    SetUpSolver(IterativeSolverTolerance);
 
    // If we are using the matrix multiplication shell don't try to
    // populate the matrix.
    if (m_matMult == ePETScMatMultShell)
    {
        return;
    }
 
    // POPULATE MATRIX
    for (n = cnt = 0; n < m_schurCompl->GetNumberOfBlockRows(); ++n)
    {
        loc_mat = m_schurCompl->GetBlock(n, n);
        loc_lda = loc_mat->GetRows();
 
        for (i = 0; i < loc_lda; ++i)
        {
            gid1  = pLocToGloMap->GetLocalToGlobalBndMap(cnt + i) - nDirDofs;
            sign1 = pLocToGloMap->GetLocalToGlobalBndSign(cnt + i);
            if (gid1 >= 0)
            {
                int gid1ro = m_reorderedMap[gid1];
                for (j = 0; j < loc_lda; ++j)
                {
                    gid2 = pLocToGloMap->GetLocalToGlobalBndMap(cnt + j) -
                           nDirDofs;
                    sign2 = pLocToGloMap->GetLocalToGlobalBndSign(cnt + j);
                    if (gid2 >= 0)
                    {
                        int gid2ro = m_reorderedMap[gid2];
                        value      = sign1 * sign2 * (*loc_mat)(i, j);
                        MatSetValue(m_matrix, gid1ro, gid2ro, value,
                                    ADD_VALUES);
                    }
                }
            }
        }
        cnt += loc_lda;
    }
 
    // ASSEMBLE MATRIX
    MatAssemblyBegin(m_matrix, MAT_FINAL_ASSEMBLY);
    MatAssemblyEnd(m_matrix, MAT_FINAL_ASSEMBLY);
}

◆ v_BasisFwdTransform()

void Nektar::MultiRegions::GlobalLinSysPETScStaticCond::v_BasisFwdTransform ( Array< OneD, NekDouble > & pInOut )

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::GlobalLinSysStaticCond.

Definition at line 348 of file GlobalLinSysPETScStaticCond.cpp.

{
    m_precon->DoTransformBasisToLowEnergy(pInOut);
}

References Nektar::MultiRegions::GlobalLinSysPETSc::m_precon.

◆ v_CoeffsBwdTransform()

void Nektar::MultiRegions::GlobalLinSysPETScStaticCond::v_CoeffsBwdTransform ( Array< OneD, NekDouble > & pInOut )

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::GlobalLinSysStaticCond.

Definition at line 354 of file GlobalLinSysPETScStaticCond.cpp.

{
    m_precon->DoTransformCoeffsFromLowEnergy(pInOut);
}

References Nektar::MultiRegions::GlobalLinSysPETSc::m_precon.

◆ v_CoeffsFwdTransform()

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

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::GlobalLinSysStaticCond.

Definition at line 360 of file GlobalLinSysPETScStaticCond.cpp.

{
    m_precon->DoTransformCoeffsToLowEnergy(pInput, pOutput);
}

References Nektar::MultiRegions::GlobalLinSysPETSc::m_precon.

◆ v_DoMatrixMultiply()

void Nektar::MultiRegions::GlobalLinSysPETScStaticCond::v_DoMatrixMultiply	(	const Array< OneD, const NekDouble > &	input,
		Array< OneD, NekDouble > &	output
	)

overrideprotectedvirtual

Apply matrix-vector multiplication using local approach and the assembly map.

Parameters

input	Vector input.
output	Result of multiplication.

Todo:: This can possibly be made faster by using the sparse block-matrix multiplication code from the iterative elastic systems.

Implements Nektar::MultiRegions::GlobalLinSysPETSc.

Definition at line 377 of file GlobalLinSysPETScStaticCond.cpp.

{
    auto asmMap = m_locToGloMap.lock();
 
    int nLocBndDofs = asmMap->GetNumLocalBndCoeffs();
    int nDirDofs    = asmMap->GetNumGlobalDirBndCoeffs();
 
    NekVector<NekDouble> in(nLocBndDofs), out(nLocBndDofs);
    asmMap->GlobalToLocalBnd(input, in.GetPtr(), nDirDofs);
    out = (*m_schurCompl) * in;
    asmMap->AssembleBnd(out.GetPtr(), output, nDirDofs);
}

References Nektar::NekVector< DataType >::GetPtr(), and Nektar::MultiRegions::GlobalLinSysStaticCond::m_locToGloMap.

◆ v_GetStaticCondBlock()

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

overrideprotectedvirtual

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 262 of file GlobalLinSysPETScStaticCond.cpp.

{
    DNekScalBlkMatSharedPtr schurComplBlock;
    DNekScalMatSharedPtr localMat = m_schurCompl->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;
}

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

◆ v_InitObject()

void Nektar::MultiRegions::GlobalLinSysPETScStaticCond::v_InitObject ( )

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::GlobalLinSys.

Definition at line 129 of file GlobalLinSysPETScStaticCond.cpp.

{
    auto asmMap = m_locToGloMap.lock();
 
    m_precon = CreatePrecon(asmMap);
 
    // Allocate memory for top-level structure
    SetupTopLevel(asmMap);
 
    // Setup Block Matrix systems
    int n, n_exp = m_expList.lock()->GetNumElmts();
 
    // Build preconditioner
    m_precon->BuildPreconditioner();
 
    // Do transform of Schur complement matrix
    int cnt = 0;
    for (n = 0; n < n_exp; ++n)
    {
        if (m_linSysKey.GetMatrixType() != StdRegions::eHybridDGHelmBndLam)
        {
            DNekScalMatSharedPtr mat = m_schurCompl->GetBlock(n, n);
            DNekScalMatSharedPtr t =
                m_precon->TransformedSchurCompl(n, cnt, mat);
            m_schurCompl->SetBlock(n, n, t);
            cnt += mat->GetRows();
        }
    }
 
    // Construct this level
    Initialise(asmMap);
}

◆ v_PreSolve()

void Nektar::MultiRegions::GlobalLinSysPETScStaticCond::v_PreSolve	(	int	scLevel,
		Array< OneD, NekDouble > &	F_bBnd
	)

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::GlobalLinSysStaticCond.

Definition at line 278 of file GlobalLinSysPETScStaticCond.cpp.

{
    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.lock());
            m_precon->BuildPreconditioner();
        }
    }
}

References Nektar::MultiRegions::GlobalLinSys::CreatePrecon(), Nektar::MultiRegions::GlobalLinSysStaticCond::m_locToGloMap, and Nektar::MultiRegions::GlobalLinSysPETSc::m_precon.

◆ v_Recurse()

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

overrideprotectedvirtual

Implements Nektar::MultiRegions::GlobalLinSysStaticCond.

Definition at line 391 of file GlobalLinSysPETScStaticCond.cpp.

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

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and Nektar::MultiRegions::GlobalLinSysPETSc::m_precon.

◆ v_SolveLinearSystem()

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

overrideprotectedvirtual

Solve linear system using PETSc.

The general strategy being a PETSc solve is to:

Copy values into the PETSc vector m_b
Solve the system m_ksp and place result into m_x.
Scatter results back into m_locVec using m_ctx scatter object.
Copy from m_locVec to output array #pOutput.

Reimplemented from Nektar::MultiRegions::GlobalLinSysPETSc.

Definition at line 303 of file GlobalLinSysPETScStaticCond.cpp.

{
    const int nHomDofs = pNumRows - pNumDir;
 
    if (!m_precon && m_matMult == ePETScMatMultShell)
    {
        m_precon = CreatePrecon(locToGloMap);
        m_precon->BuildPreconditioner();
    }
 
    Array<OneD, NekDouble> Glo(pNumRows);
    locToGloMap->AssembleBnd(pInput, Glo);
 
    // Populate RHS vector from input
    VecSetValues(m_b, nHomDofs, &m_reorderedMap[0], &Glo[pNumDir],
                 INSERT_VALUES);
 
    // Assemble RHS vector
    VecAssemblyBegin(m_b);
    VecAssemblyEnd(m_b);
 
    // Do system solve
    KSPSolve(m_ksp, m_b, m_x);
 
    KSPConvergedReason reason;
    KSPGetConvergedReason(m_ksp, &reason);
    ASSERTL0(reason > 0, "PETSc solver diverged, reason is: " +
                             std::string(KSPConvergedReasons[reason]));
 
    // Scatter results to local vector
    VecScatterBegin(m_ctx, m_x, m_locVec, INSERT_VALUES, SCATTER_FORWARD);
    VecScatterEnd(m_ctx, m_x, m_locVec, INSERT_VALUES, SCATTER_FORWARD);
 
    // Copy results into output vector
    PetscScalar *tmp;
    VecGetArray(m_locVec, &tmp);
    Vmath::Vcopy(nHomDofs, tmp, 1, &Glo[pNumDir], 1);
    Vmath::Zero(pNumDir, Glo, 1);
    locToGloMap->GlobalToLocalBnd(Glo, pOutput);
    VecRestoreArray(m_locVec, &tmp);
}

Member Data Documentation

◆ className

string Nektar::MultiRegions::GlobalLinSysPETScStaticCond::className

static

Initial value:

=
    GetGlobalLinSysFactory().RegisterCreatorFunction(
        "PETScStaticCond", GlobalLinSysPETScStaticCond::create,
        "PETSc static condensation.")

Name of class.

Registers the class with the Factory.

Definition at line 70 of file GlobalLinSysPETScStaticCond.h.

◆ className2

string Nektar::MultiRegions::GlobalLinSysPETScStaticCond::className2

static

Initial value:

=
    GetGlobalLinSysFactory().RegisterCreatorFunction(
        "PETScMultiLevelStaticCond", GlobalLinSysPETScStaticCond::create,
        "PETSc multi-level static condensation.")

Definition at line 71 of file GlobalLinSysPETScStaticCond.h.

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ GlobalLinSysPETScStaticCond() [1/2]

◆ GlobalLinSysPETScStaticCond() [2/2]

◆ ~GlobalLinSysPETScStaticCond()

Member Function Documentation

◆ create()

◆ v_AssembleSchurComplement()

◆ v_BasisFwdTransform()

◆ v_CoeffsBwdTransform()

◆ v_CoeffsFwdTransform()

◆ v_DoMatrixMultiply()

◆ v_GetStaticCondBlock()

◆ v_InitObject()

◆ v_PreSolve()

◆ v_Recurse()

◆ v_SolveLinearSystem()

Member Data Documentation

◆ className

◆ className2