Nektar::MultiRegions::PreconditionerLinear Class Reference

#include <PreconditionerLinear.h>

Inheritance diagram for Nektar::MultiRegions::PreconditionerLinear:

Public Member Functions
	PreconditionerLinear (const std::shared_ptr< GlobalLinSys > &plinsys, const AssemblyMapSharedPtr &pLocToGloMap)
	~PreconditionerLinear () override
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	className1
	Name of class. More...

Protected Member Functions
void	v_InitObject () override
void	v_DoPreconditionerWithNonVertOutput (const Array< OneD, NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const Array< OneD, NekDouble > &pNonVertOutput, Array< OneD, NekDouble > &pVertForce) override
	Apply a preconditioner to the conjugate gradient method with an output for non-vertex degrees of freedom. More...
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...
void	v_BuildPreconditioner () override
void	SetupInvMult (const std::shared_ptr< AssemblyMap > &pLocToGloMap)
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
GlobalLinSysSharedPtr	m_vertLinsys
std::shared_ptr< AssemblyMap >	m_vertLocToGloMap
Array< OneD, NekDouble >	m_invMult
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

Static Private Attributes
static std::string	solveType
static std::string	solveTypeIds []

Detailed Description

This class implements preconditioning for the conjugate gradient matrix solver.

Definition at line 54 of file PreconditionerLinear.h.

Constructor & Destructor Documentation

PreconditionerLinear()

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

Definition at line 77 of file PreconditionerLinear.cpp.

    : Preconditioner(plinsys, pLocToGloMap)
{
}

~PreconditionerLinear()

Nektar::MultiRegions::PreconditionerLinear::~PreconditionerLinear ( )

inlineoverride

Definition at line 77 of file PreconditionerLinear.h.

    {
    }

Member Function Documentation

create()

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

inlinestatic

Creates an instance of this class.

Definition at line 58 of file PreconditionerLinear.h.

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

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

SetupInvMult()

void Nektar::MultiRegions::PreconditionerLinear::SetupInvMult ( const std::shared_ptr< AssemblyMap > &  pLocToGloMap )

protected

Create the inverse multiplicity map.

Parameters

locToGloMap

Local to global mapping information.

Definition at line 317 of file PreconditionerLinear.cpp.

{
    const Array<OneD, const int> &vMap = pLocToGloMap->GetLocalToGlobalMap();
    unsigned int nGlo                  = pLocToGloMap->GetNumGlobalCoeffs();
    unsigned int nEntries              = pLocToGloMap->GetNumLocalCoeffs();
    unsigned int i;
 
    // Count the multiplicity of each global DOF on this process
    Array<OneD, NekDouble> vCounts(nGlo, 0.0);
    for (i = 0; i < nEntries; ++i)
    {
        vCounts[vMap[i]] += 1.0;
    }
 
    // Get universal multiplicity by globally assembling counts
    pLocToGloMap->UniversalAssemble(vCounts);
 
    // Construct a map of 1/multiplicity for use in XXT solve
    m_invMult = Array<OneD, NekDouble>(nEntries);
    for (i = 0; i < nEntries; ++i)
    {
        m_invMult[i] = 1.0 / vCounts[vMap[i]];
    }
}

References m_invMult.

Referenced by v_BuildPreconditioner().

v_BuildPreconditioner()

void Nektar::MultiRegions::PreconditionerLinear::v_BuildPreconditioner ( )

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::Preconditioner.

Definition at line 88 of file PreconditionerLinear.cpp.

{
    GlobalSysSolnType sType = m_locToGloMap.lock()->GetGlobalSysSolnType();
    ASSERTL0(sType == eIterativeStaticCond || sType == ePETScStaticCond,
             "This type of preconditioning is not implemented "
             "for this solver");
 
    std::shared_ptr<MultiRegions::ExpList> expList =
        ((m_linsys.lock())->GetLocMat()).lock();
 
    LinearPreconSolver solveType =
        expList->GetSession()->GetSolverInfoAsEnum<LinearPreconSolver>(
            "LinearPreconSolver");
 
    GlobalSysSolnType linSolveType;
 
    switch (solveType)
    {
        case eLinearPreconPETSc:
        {
            linSolveType = ePETScFullMatrix;
#ifndef NEKTAR_USING_PETSC
            NEKERROR(ErrorUtil::efatal, "Nektar++ has not been compiled with "
                                        "PETSc support.");
#endif
            break;
        }
        case eLinearPreconXxt:
        default:
        {
            linSolveType = eXxtFullMatrix;
            break;
        }
    }
 
    m_vertLocToGloMap =
        m_locToGloMap.lock()->LinearSpaceMap(*expList, linSolveType);
 
    SetupInvMult(m_vertLocToGloMap);
 
    // Generate linear solve system.
    StdRegions::MatrixType mType =
        m_linsys.lock()->GetKey().GetMatrixType() == StdRegions::eMass
            ? StdRegions::ePreconLinearSpaceMass
            : StdRegions::ePreconLinearSpace;
 
    GlobalLinSysKey preconKey(mType, m_vertLocToGloMap,
                              (m_linsys.lock())->GetKey().GetConstFactors());
 
    switch (solveType)
    {
        case eLinearPreconXxt:
        {
            m_vertLinsys =
                MemoryManager<GlobalLinSysXxtFull>::AllocateSharedPtr(
                    preconKey, expList, m_vertLocToGloMap);
            break;
        }
        case eLinearPreconPETSc:
        {
#ifdef NEKTAR_USING_PETSC
            m_vertLinsys =
                MemoryManager<GlobalLinSysPETScFull>::AllocateSharedPtr(
                    preconKey, expList, m_vertLocToGloMap);
#else
            ASSERTL0(false, "Nektar++ has not been compiled with "
                            "PETSc support.");
#endif
        }
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::ErrorUtil::efatal, Nektar::MultiRegions::eIterativeStaticCond, Nektar::MultiRegions::eLinearPreconPETSc, Nektar::MultiRegions::eLinearPreconXxt, Nektar::StdRegions::eMass, Nektar::MultiRegions::ePETScFullMatrix, Nektar::MultiRegions::ePETScStaticCond, Nektar::StdRegions::ePreconLinearSpace, Nektar::StdRegions::ePreconLinearSpaceMass, Nektar::MultiRegions::eXxtFullMatrix, Nektar::MultiRegions::Preconditioner::m_linsys, Nektar::MultiRegions::Preconditioner::m_locToGloMap, m_vertLinsys, m_vertLocToGloMap, NEKERROR, SetupInvMult(), and solveType.

v_DoPreconditioner()

void Nektar::MultiRegions::PreconditionerLinear::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.

Definition at line 163 of file PreconditionerLinear.cpp.

{
    ASSERTL0(isLocal == false, "PreconditionerLinear is only set up for Global"
                               " iteratives sovles");
    v_DoPreconditionerWithNonVertOutput(pInput, pOutput, NullNekDouble1DArray,
                                        NullNekDouble1DArray);
}

References ASSERTL0, Nektar::NullNekDouble1DArray, and v_DoPreconditionerWithNonVertOutput().

v_DoPreconditionerWithNonVertOutput()

void Nektar::MultiRegions::PreconditionerLinear::v_DoPreconditionerWithNonVertOutput ( const Array< OneD, NekDouble > &  pInput, Array< OneD, NekDouble > &  pOutput, const Array< OneD, NekDouble > &  pNonVertOutput, Array< OneD, NekDouble > &  pVertForce  )

overrideprotectedvirtual

Apply a preconditioner to the conjugate gradient method with an output for non-vertex degrees of freedom.

Reimplemented from Nektar::MultiRegions::Preconditioner.

Definition at line 176 of file PreconditionerLinear.cpp.

{
    GlobalSysSolnType solvertype = m_locToGloMap.lock()->GetGlobalSysSolnType();
    switch (solvertype)
    {
        case MultiRegions::eIterativeStaticCond:
        case MultiRegions::ePETScStaticCond:
        {
            int i, val;
            int nloc = m_vertLocToGloMap->GetNumLocalCoeffs();
            // mapping from full space to vertices
            Array<OneD, int> LocToGloBnd =
                m_vertLocToGloMap->GetLocalToGlobalBndMap();
 
            // Global to local for linear solver (different from above)
            Array<OneD, int> LocToGlo =
                m_vertLocToGloMap->GetLocalToGlobalMap();
 
            // number of Dir coeffs in from full problem
            int nDirFull = m_locToGloMap.lock()->GetNumGlobalDirBndCoeffs();
 
#if 0 
            int nglo = m_vertLocToGloMap->GetNumGlobalCoeffs();
            Array<OneD, NekDouble> In(nglo, 0.0);
            Array<OneD, NekDouble> Out(nglo, 0.0);
 
            // Gather rhs to local linear space.
            for (i = 0; i < nloc; ++i)
            {
                val = LocToGloBnd[i];
                if (val >= nDirFull)
                {
                    In[LocToGlo[i]] = pInput[val - nDirFull];
                }
            }
#else
            Array<OneD, NekDouble> In(nloc, 0.0);
            Array<OneD, NekDouble> Out(nloc, 0.0);
 
            // Gather rhs to local linear space.
            for (i = 0; i < nloc; ++i)
            {
                val = LocToGloBnd[i];
                if (val >= nDirFull)
                {
                    In[i] = pInput[val - nDirFull] * m_invMult[i];
                }
            }
#endif
 
            // Do solve without enforcing any boundary conditions.
            m_vertLinsys->SolveLinearSystem(
                m_vertLocToGloMap->GetNumGlobalCoeffs(), In, Out,
                m_vertLocToGloMap,
                m_vertLocToGloMap->GetNumGlobalDirBndCoeffs());
 
            if (pNonVertOutput != NullNekDouble1DArray)
            {
                ASSERTL1(pNonVertOutput.size() >= pOutput.size(),
                         "Non Vert output is not of sufficient length");
                Vmath::Vcopy(pOutput.size(), pNonVertOutput, 1, pOutput, 1);
            }
            else
            {
                // Copy input to output as a unit preconditioner on
                // any other value
                Vmath::Vcopy(pInput.size(), pInput, 1, pOutput, 1);
            }
 
#if 0 
            if (pVertForce != NullNekDouble1DArray)
            {
                Vmath::Zero(pVertForce.size(), pVertForce, 1);
                // Scatter back soln from linear solve
                for (i = 0; i < nloc; ++i)
                {
                    val = LocToGloBnd[i];
                    if (val >= nDirFull)
                    {
                        pOutput[val - nDirFull] = Out[LocToGlo[i]];
                        // copy vertex forcing into this vector
                        pVertForce[val - nDirFull] = In[LocToGlo[i]];
                    }
                }
            }
            else
            {
                // Scatter back soln from linear solve
                for (i = 0; i < nloc; ++i)
                {
                    val = LocToGloBnd[i];
                    if (val >= nDirFull)
                    {
                        pOutput[val - nDirFull] = Out[LocToGlo[i]];
                    }
                }
            }
#else
            if (pVertForce != NullNekDouble1DArray)
            {
                Vmath::Zero(pVertForce.size(), pVertForce, 1);
                // Scatter back soln from linear solve
                for (i = 0; i < nloc; ++i)
                {
                    val = LocToGloBnd[i];
                    if (val >= nDirFull)
                    {
                        pOutput[val - nDirFull] = Out[i];
                        // copy vertex forcing into this vector
                        pVertForce[val - nDirFull] = In[i];
                    }
                }
            }
            else
            {
                // Scatter back soln from linear solve
                for (i = 0; i < nloc; ++i)
                {
                    val = LocToGloBnd[i];
                    if (val >= nDirFull)
                    {
                        pOutput[val - nDirFull] = Out[i];
                    }
                }
            }
#endif
        }
        break;
        default:
            ASSERTL0(0, "Unsupported solver type");
            break;
    }
}

References ASSERTL0, ASSERTL1, Nektar::MultiRegions::eIterativeStaticCond, Nektar::MultiRegions::ePETScStaticCond, m_invMult, Nektar::MultiRegions::Preconditioner::m_locToGloMap, m_vertLinsys, m_vertLocToGloMap, Nektar::NullNekDouble1DArray, Vmath::Vcopy(), and Vmath::Zero().

Referenced by v_DoPreconditioner().

v_InitObject()

void Nektar::MultiRegions::PreconditionerLinear::v_InitObject ( )

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::Preconditioner.

Definition at line 84 of file PreconditionerLinear.cpp.

{
}

Member Data Documentation

className1

string Nektar::MultiRegions::PreconditionerLinear::className1

static

Initial value:

=
    GetPreconFactory().RegisterCreatorFunction(
        "FullLinearSpace", PreconditionerLinear::create,
        "Full Linear space inverse Preconditioning")

Name of class.

Registers the class with the Factory.

Definition at line 70 of file PreconditionerLinear.h.

m_invMult

Array<OneD, NekDouble> Nektar::MultiRegions::PreconditionerLinear::m_invMult

protected

Definition at line 85 of file PreconditionerLinear.h.

Referenced by SetupInvMult(), and v_DoPreconditionerWithNonVertOutput().

m_vertLinsys

GlobalLinSysSharedPtr Nektar::MultiRegions::PreconditionerLinear::m_vertLinsys

protected

Definition at line 82 of file PreconditionerLinear.h.

Referenced by v_BuildPreconditioner(), and v_DoPreconditionerWithNonVertOutput().

m_vertLocToGloMap

std::shared_ptr<AssemblyMap> Nektar::MultiRegions::PreconditionerLinear::m_vertLocToGloMap

protected

Definition at line 83 of file PreconditionerLinear.h.

Referenced by v_BuildPreconditioner(), and v_DoPreconditionerWithNonVertOutput().

solveType

std::string Nektar::MultiRegions::PreconditionerLinear::solveType

staticprivate

Initial value:

=
    LibUtilities::SessionReader::RegisterDefaultSolverInfo("LinearPreconSolver",
                                                           "Xxt")

Definition at line 103 of file PreconditionerLinear.h.

Referenced by v_BuildPreconditioner().

solveTypeIds

std::string Nektar::MultiRegions::PreconditionerLinear::solveTypeIds

staticprivate

Initial value:

= {
    LibUtilities::SessionReader::RegisterEnumValue(
        "LinearPreconSolver", "PETSc", MultiRegions::eLinearPreconPETSc),
    LibUtilities::SessionReader::RegisterEnumValue(
        "LinearPreconSolver", "Xxt", MultiRegions::eLinearPreconXxt)}

Definition at line 104 of file PreconditionerLinear.h.