Nektar::MultiRegions::PreconditionerDiagonal Class Reference

#include <PreconditionerDiagonal.h>

Inheritance diagram for Nektar::MultiRegions::PreconditionerDiagonal:

Public Member Functions
	PreconditionerDiagonal (const std::shared_ptr< GlobalLinSys > &plinsys, const AssemblyMapSharedPtr &pLocToGloMap)
virtual	~PreconditionerDiagonal ()
Public Member Functions inherited from Nektar::MultiRegions::Preconditioner
	Preconditioner (const std::shared_ptr< GlobalLinSys > &plinsys, const AssemblyMapSharedPtr &pLocToGloMap)
virtual	~Preconditioner ()
void	DoPreconditioner (const Array< OneD, NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const bool &IsLocal=false)
void	DoAssembleLoc (const Array< OneD, NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const bool &ZeroDir)
	Apply an assembly and scatter back to lcoal array. More...
void	DoPreconditionerWithNonVertOutput (const Array< OneD, NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const Array< OneD, NekDouble > &pNonVertOutput, Array< OneD, NekDouble > &pVertForce=NullNekDouble1DArray)
void	DoTransformBasisToLowEnergy (Array< OneD, NekDouble > &pInOut)
void	DoTransformCoeffsFromLowEnergy (Array< OneD, NekDouble > &pInOut)
void	DoTransformCoeffsToLowEnergy (const Array< OneD, NekDouble > &pInput, Array< OneD, NekDouble > &pOutput)
void	DoTransformBasisFromLowEnergy (const Array< OneD, NekDouble > &pInput, Array< OneD, NekDouble > &pOutput)
void	BuildPreconditioner ()
void	InitObject ()
Array< OneD, NekDouble >	AssembleStaticCondGlobalDiagonals ()
	Performs global assembly of diagonal entries to global Schur complement matrix. More...
const DNekScalBlkMatSharedPtr &	GetBlockTransformedSchurCompl () const
const DNekScalBlkMatSharedPtr &	GetBlockCMatrix () const
const DNekScalBlkMatSharedPtr &	GetBlockInvDMatrix () const
const DNekScalBlkMatSharedPtr &	GetBlockSchurCompl () const
const DNekScalBlkMatSharedPtr &	GetBlockTransformationMatrix () const
const DNekScalBlkMatSharedPtr &	GetBlockTransposedTransformationMatrix () const
DNekScalMatSharedPtr	TransformedSchurCompl (int offset, int bndoffset, const std::shared_ptr< DNekScalMat > &loc_mat)

Static Public Member Functions
static PreconditionerSharedPtr	create (const std::shared_ptr< GlobalLinSys > &plinsys, const std::shared_ptr< AssemblyMap > &pLocToGloMap)
	Creates an instance of this class. More...

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

Protected Member Functions
virtual void	v_InitObject () override
virtual void	v_DoPreconditioner (const Array< OneD, NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const bool &IsLocal=false) override
	Apply a preconditioner to the conjugate gradient method. More...
virtual void	v_BuildPreconditioner () override
Protected Member Functions inherited from Nektar::MultiRegions::Preconditioner
virtual DNekScalMatSharedPtr	v_TransformedSchurCompl (int offset, int bndoffset, const std::shared_ptr< DNekScalMat > &loc_mat)
	Get block elemental transposed transformation matrix \(\mathbf{R}^{T}\). More...
virtual void	v_InitObject ()
virtual void	v_DoPreconditioner (const Array< OneD, NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const bool &isLocal=false)
	Apply a preconditioner to the conjugate gradient method. More...
virtual void	v_DoPreconditionerWithNonVertOutput (const Array< OneD, NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const Array< OneD, NekDouble > &pNonVertOutput, Array< OneD, NekDouble > &pVertForce)
	Apply a preconditioner to the conjugate gradient method with an output for non-vertex degrees of freedom. More...
virtual void	v_DoTransformBasisToLowEnergy (Array< OneD, NekDouble > &pInOut)
	Transform from original basis to low energy basis. More...
virtual void	v_DoTransformCoeffsFromLowEnergy (Array< OneD, NekDouble > &pInOut)
	Transform from low energy coeffs to orignal basis. More...
virtual void	v_DoTransformCoeffsToLowEnergy (const Array< OneD, NekDouble > &pInput, Array< OneD, NekDouble > &pOutput)
	Multiply by the block inverse transformation matrix. More...
virtual void	v_DoTransformBasisFromLowEnergy (const Array< OneD, NekDouble > &pInput, Array< OneD, NekDouble > &pOutput)
	Multiply by the block transposed inverse transformation matrix. More...
virtual void	v_BuildPreconditioner ()

Protected Attributes
Array< OneD, NekDouble >	m_diagonals
Protected Attributes inherited from Nektar::MultiRegions::Preconditioner
const std::weak_ptr< GlobalLinSys >	m_linsys
std::string	m_preconType
DNekMatSharedPtr	m_preconditioner
std::weak_ptr< AssemblyMap >	m_locToGloMap
LibUtilities::CommSharedPtr	m_comm

Private Member Functions
void	DiagonalPreconditionerSum (void)
void	StaticCondDiagonalPreconditionerSum (void)

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

Detailed Description

Definition at line 48 of file PreconditionerDiagonal.h.

Constructor & Destructor Documentation

PreconditionerDiagonal()

Nektar::MultiRegions::PreconditionerDiagonal::PreconditionerDiagonal	(	const std::shared_ptr< GlobalLinSys > &	plinsys,
		const AssemblyMapSharedPtr &	pLocToGloMap
	)

Definition at line 60 of file PreconditionerDiagonal.cpp.

    : Preconditioner(plinsys, pLocToGloMap)
{
}

~PreconditionerDiagonal()

virtual Nektar::MultiRegions::PreconditionerDiagonal::~PreconditionerDiagonal ( )

inlinevirtual

Definition at line 72 of file PreconditionerDiagonal.h.

    {
    }

Member Function Documentation

create()

static PreconditionerSharedPtr Nektar::MultiRegions::PreconditionerDiagonal::create ( const std::shared_ptr< GlobalLinSys > &  plinsys, const std::shared_ptr< AssemblyMap > &  pLocToGloMap  )

inlinestatic

Creates an instance of this class.

Definition at line 52 of file PreconditionerDiagonal.h.

    {
        PreconditionerSharedPtr p =
            MemoryManager<PreconditionerDiagonal>::AllocateSharedPtr(
                plinsys, pLocToGloMap);
        p->InitObject();
        return p;
    }

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

DiagonalPreconditionerSum()

void Nektar::MultiRegions::PreconditionerDiagonal::DiagonalPreconditionerSum ( void  )

private

Diagonal preconditioner computed by summing the relevant elements of the local matrix system.

Definition at line 95 of file PreconditionerDiagonal.cpp.

{
    std::shared_ptr<MultiRegions::ExpList> expList =
        ((m_linsys.lock())->GetLocMat()).lock();
 
    LocalRegions::ExpansionSharedPtr locExpansion;
 
    auto asmMap = m_locToGloMap.lock();
 
    int i, j, n, cnt, gid1, gid2;
    NekDouble sign1, sign2, value;
    int nGlobal = asmMap->GetNumGlobalCoeffs();
    int nDir    = asmMap->GetNumGlobalDirBndCoeffs();
    int nInt    = nGlobal - nDir;
 
    // fill global matrix
    DNekScalMatSharedPtr loc_mat;
    Array<OneD, NekDouble> vOutput(nGlobal, 0.0);
 
    int loc_row;
    int nElmt = expList->GetNumElmts();
    for (n = cnt = 0; n < nElmt; ++n)
    {
        loc_mat = (m_linsys.lock())->GetBlock(n);
        loc_row = loc_mat->GetRows();
 
        for (i = 0; i < loc_row; ++i)
        {
            gid1  = asmMap->GetLocalToGlobalMap(cnt + i) - nDir;
            sign1 = asmMap->GetLocalToGlobalSign(cnt + i);
 
            if (gid1 >= 0)
            {
                for (j = 0; j < loc_row; ++j)
                {
                    gid2  = asmMap->GetLocalToGlobalMap(cnt + j) - nDir;
                    sign2 = asmMap->GetLocalToGlobalSign(cnt + j);
                    if (gid2 == gid1)
                    {
                        // When global matrix is symmetric,
                        // only add the value for the upper
                        // triangular part in order to avoid
                        // entries to be entered twice
                        value = vOutput[gid1 + nDir] +
                                sign1 * sign2 * (*loc_mat)(i, j);
                        vOutput[gid1 + nDir] = value;
                    }
                }
            }
        }
        cnt += loc_row;
    }
 
    // Assemble diagonal contributions across processes
    asmMap->UniversalAssemble(vOutput);
 
    m_diagonals = Array<OneD, NekDouble>(nInt);
    Vmath::Sdiv(nInt, 1.0, &vOutput[nDir], 1, &m_diagonals[0], 1);
}

References m_diagonals, Nektar::MultiRegions::Preconditioner::m_linsys, Nektar::MultiRegions::Preconditioner::m_locToGloMap, and Vmath::Sdiv().

Referenced by v_BuildPreconditioner().

StaticCondDiagonalPreconditionerSum()

void Nektar::MultiRegions::PreconditionerDiagonal::StaticCondDiagonalPreconditionerSum ( void  )

private

Diagonal preconditioner defined as the inverse of the main diagonal of the Schur complement

Definition at line 160 of file PreconditionerDiagonal.cpp.

{
    auto asmMap = m_locToGloMap.lock();
 
    int nGlobalBnd = asmMap->GetNumGlobalBndCoeffs();
    int nDirBnd    = asmMap->GetNumGlobalDirBndCoeffs();
    int rows       = nGlobalBnd - nDirBnd;
 
    Array<OneD, NekDouble> vOutput(nGlobalBnd, 0.0);
 
    // Extract diagonal contributions
    Array<OneD, NekDouble> diagonals = AssembleStaticCondGlobalDiagonals();
    for (unsigned int i = 0; i < rows; ++i)
    {
        vOutput[nDirBnd + i] = diagonals[i];
    }
 
    // Assemble diagonal contributions across processes
    asmMap->UniversalAssembleBnd(vOutput);
 
    m_diagonals = Array<OneD, NekDouble>(rows);
    Vmath::Sdiv(rows, 1.0, &vOutput[nDirBnd], 1, &m_diagonals[0], 1);
}

References Nektar::MultiRegions::Preconditioner::AssembleStaticCondGlobalDiagonals(), m_diagonals, Nektar::MultiRegions::Preconditioner::m_locToGloMap, and Vmath::Sdiv().

Referenced by v_BuildPreconditioner().

v_BuildPreconditioner()

void Nektar::MultiRegions::PreconditionerDiagonal::v_BuildPreconditioner ( )

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::Preconditioner.

Reimplemented in Nektar::MultiRegions::PreconditionerJacobi.

Definition at line 71 of file PreconditionerDiagonal.cpp.

{
    GlobalSysSolnType solvertype = m_locToGloMap.lock()->GetGlobalSysSolnType();
    if (solvertype == eIterativeFull)
    {
        DiagonalPreconditionerSum();
    }
    else if (solvertype == eIterativeStaticCond ||
             solvertype == eIterativeMultiLevelStaticCond ||
             solvertype == ePETScStaticCond ||
             solvertype == ePETScMultiLevelStaticCond)
    {
        StaticCondDiagonalPreconditionerSum();
    }
    else
    {
        ASSERTL0(0, "Unsupported solver type");
    }
}

References ASSERTL0, DiagonalPreconditionerSum(), Nektar::MultiRegions::eIterativeFull, Nektar::MultiRegions::eIterativeMultiLevelStaticCond, Nektar::MultiRegions::eIterativeStaticCond, Nektar::MultiRegions::ePETScMultiLevelStaticCond, Nektar::MultiRegions::ePETScStaticCond, Nektar::MultiRegions::Preconditioner::m_locToGloMap, and StaticCondDiagonalPreconditionerSum().

Referenced by Nektar::MultiRegions::PreconditionerJacobi::v_BuildPreconditioner().

v_DoPreconditioner()

void Nektar::MultiRegions::PreconditionerDiagonal::v_DoPreconditioner ( const Array< OneD, NekDouble > &  pInput, Array< OneD, NekDouble > &  pOutput, const bool &  isLocal = false  )

overrideprotectedvirtual

Apply a preconditioner to the conjugate gradient method.

Reimplemented from Nektar::MultiRegions::Preconditioner.

Reimplemented in Nektar::MultiRegions::PreconditionerJacobi.

Definition at line 187 of file PreconditionerDiagonal.cpp.

{
    auto asmMap = m_locToGloMap.lock();
 
    GlobalSysSolnType solvertype = asmMap->GetGlobalSysSolnType();
 
    bool isFull = solvertype == eIterativeFull ? true : false;
 
    int nGlobal = (isFull) ? asmMap->GetNumGlobalCoeffs()
                           : asmMap->GetNumGlobalBndCoeffs();
    int nDir    = asmMap->GetNumGlobalDirBndCoeffs();
    int nNonDir = nGlobal - nDir;
 
    if (IsLocal)
    {
        Array<OneD, NekDouble> wk(nGlobal);
        (isFull) ? asmMap->Assemble(pInput, wk)
                 : asmMap->AssembleBnd(pInput, wk);
        Vmath::Vmul(nNonDir, wk.data() + nDir, 1, m_diagonals.data(), 1,
                    wk.data() + nDir, 1);
        Vmath::Zero(nDir, wk, 1);
        (isFull) ? asmMap->GlobalToLocal(wk, pOutput)
                 : asmMap->GlobalToLocalBnd(wk, pOutput);
    }
    else
    {
        Vmath::Vmul(nNonDir, &pInput[0], 1, &m_diagonals[0], 1, &pOutput[0], 1);
    }
}

References Nektar::MultiRegions::eIterativeFull, m_diagonals, Nektar::MultiRegions::Preconditioner::m_locToGloMap, Vmath::Vmul(), and Vmath::Zero().

v_InitObject()

void Nektar::MultiRegions::PreconditionerDiagonal::v_InitObject ( )

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::Preconditioner.

Reimplemented in Nektar::MultiRegions::PreconditionerJacobi.

Definition at line 67 of file PreconditionerDiagonal.cpp.

{
}

Member Data Documentation

className

string Nektar::MultiRegions::PreconditionerDiagonal::className

static

Initial value:

=
    GetPreconFactory().RegisterCreatorFunction(
        "Diagonal", PreconditionerDiagonal::create, "Diagonal Preconditioning")

Name of class.

Registers the class with the Factory.

Definition at line 64 of file PreconditionerDiagonal.h.

def

std::string Nektar::MultiRegions::PreconditionerDiagonal::def

staticprivate

Definition at line 93 of file PreconditionerDiagonal.h.

lookupIds

std::string Nektar::MultiRegions::PreconditionerDiagonal::lookupIds[]

staticprivate

Definition at line 92 of file PreconditionerDiagonal.h.

m_diagonals

Array<OneD, NekDouble> Nektar::MultiRegions::PreconditionerDiagonal::m_diagonals

protected

Definition at line 77 of file PreconditionerDiagonal.h.

Referenced by DiagonalPreconditionerSum(), StaticCondDiagonalPreconditionerSum(), v_DoPreconditioner(), and Nektar::MultiRegions::PreconditionerJacobi::v_DoPreconditioner().