Nektar::MultiRegions::PreconditionerLOR Class Reference

Low-order representation (LOR) preconditioner. More...

#include <PreconditionerLOR.h>

Inheritance diagram for Nektar::MultiRegions::PreconditionerLOR:

Public Member Functions
	PreconditionerLOR (const std::shared_ptr< GlobalLinSys > &plinsys, const AssemblyMapSharedPtr &pLocToGloMap)
	Constructor.
	~PreconditionerLOR () 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.
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.
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.

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

Protected Member Functions
void	v_InitObject () override
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.
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}\).
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.
virtual void	v_DoTransformBasisToLowEnergy (Array< OneD, NekDouble > &pInOut)
	Transform from original basis to low energy basis.
virtual void	v_DoTransformCoeffsFromLowEnergy (Array< OneD, NekDouble > &pInOut)
	Transform from low energy coeffs to orignal basis.
virtual void	v_DoTransformCoeffsToLowEnergy (const Array< OneD, NekDouble > &pInput, Array< OneD, NekDouble > &pOutput)
	Multiply by the block inverse transformation matrix.
virtual void	v_DoTransformBasisFromLowEnergy (const Array< OneD, NekDouble > &pInput, Array< OneD, NekDouble > &pOutput)
	Multiply by the block transposed inverse transformation matrix.

Private Member Functions
void	CreateInvMultiplicity (void)

Private Attributes
GlobalLinSysSharedPtr	m_LORLinSys
	Linear solver for LOR system.
std::string	m_slvType
	Solution type for LOR space, DirectFull, IterativeFull, PETScFull.
bool	m_equiSpaced = false
	Flag that determines whether to use equispaced point distributions or GLL.
bool	m_useSimplex = false
	Use a simplex distribution in the LOR system so that e.g. quadrilaterals are split into triangles.
unsigned int	m_nsplit
SpatialDomains::MeshGraphSharedPtr	m_lor_graph
	MeshGraph for the LOR system.
MultiRegions::ContFieldSharedPtr	m_lor_field
	Field object for the LOR system.
unsigned int	m_nDir
	Number of Dirichlet values on original mesh.
Array< OneD, int >	m_ho2lor
	Map from high-order node numbers to LOR representation.
Array< OneD, NekDouble >	m_invMultiplicity
	Inverse of multiplicity of each global DOF in the high-order mesh.
Array< OneD, NekDouble >	m_invLinMeshMultiplicity
	Inverse of multiplicity of each global DOF in the LOR mesh.
bool	m_verboseIter
	Whether to be verbose.

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

Additional Inherited Members
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

Detailed Description

Low-order representation (LOR) preconditioner.

This preconditioner works by taking a high-order element and splitting into P1 elements that 'join the dots' of a quadrature distribution on the element.

This class implements LOR preconditioning for the conjugate gradient matrix solver.

Definition at line 55 of file PreconditionerLOR.h.

Constructor & Destructor Documentation

PreconditionerLOR()

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

Constructor.

Definition at line 68 of file PreconditionerLOR.cpp.

    : Preconditioner(plinsys, pLocToGloMap), m_verboseIter(false)
{
}

~PreconditionerLOR()

Nektar::MultiRegions::PreconditionerLOR::~PreconditionerLOR ( )

inlineoverride

Definition at line 78 of file PreconditionerLOR.h.

    {
    }

Member Function Documentation

create()

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

inlinestatic

Creates an instance of this class.

Definition at line 59 of file PreconditionerLOR.h.

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

References Nektar::MemoryManager< DataType >::AllocateSharedPtr().

CreateInvMultiplicity()

void Nektar::MultiRegions::PreconditionerLOR::CreateInvMultiplicity ( void  )

private

Create inv multiplicity

Definition at line 427 of file PreconditionerLOR.cpp.

{
    auto asmMap      = m_locToGloMap.lock();
    unsigned nGlobal = asmMap->GetNumGlobalCoeffs();
    unsigned nLocal  = asmMap->GetNumLocalCoeffs();
 
    // Construct a mask array
    m_invMultiplicity = Array<OneD, NekDouble>(nGlobal, 0.0);
 
    const Array<OneD, const int> &map = asmMap->GetLocalToGlobalMap();
 
    for (unsigned i = 0; i < nLocal; ++i)
    {
        m_invMultiplicity[map[i]] += 1.0;
    }
 
    asmMap->UniversalAssemble(m_invMultiplicity);
    Vmath::Sdiv(nGlobal, 1.0, m_invMultiplicity, 1, m_invMultiplicity, 1);
 
    auto lor_nLocal          = m_ho2lor.size();
    m_invLinMeshMultiplicity = Array<OneD, NekDouble>(nLocal, 0.0);
 
    for (unsigned i = 0; i < lor_nLocal; ++i)
    {
        m_invLinMeshMultiplicity[m_ho2lor[i]] += 1.0;
    }
    for (unsigned i = 0; i < nLocal; ++i)
    {
        m_invLinMeshMultiplicity[i] = 1.0 / m_invLinMeshMultiplicity[i];
    }
}

References m_ho2lor, m_invLinMeshMultiplicity, m_invMultiplicity, Nektar::MultiRegions::Preconditioner::m_locToGloMap, and Vmath::Sdiv().

Referenced by v_BuildPreconditioner().

v_BuildPreconditioner()

void Nektar::MultiRegions::PreconditionerLOR::v_BuildPreconditioner ( )

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::Preconditioner.

Definition at line 79 of file PreconditionerLOR.cpp.

{
    GlobalSysSolnType solvertype = m_locToGloMap.lock()->GetGlobalSysSolnType();
 
    ASSERTL0(solvertype == eIterativeFull, "Only works for full iterative");
 
    // Grab explist
    auto expList = ((m_linsys.lock())->GetLocMat()).lock();
 
    std::shared_ptr<LibUtilities::SessionReader> session =
        expList->GetSession();
 
    m_nsplit = expList->GetExp(0)->GetBasisNumModes(0) - 1;
 
    std::string var = m_locToGloMap.lock()->GetVariable();
 
    m_equiSpaced = false;
    if (session->DefinesGlobalSysSolnInfo(var, "LORPointDistribution"))
    {
        if (boost::iequals("GLL", session->GetGlobalSysSolnInfo(
                                      var, "LORPointDistribution")))
        {
            m_equiSpaced = false;
        }
        else if (boost::iequals("Equispaced", session->GetGlobalSysSolnInfo(
                                                  var, "LORPointDistribution")))
        {
            m_equiSpaced = true;
        }
    }
 
    m_useSimplex = false;
    if (session->DefinesGlobalSysSolnInfo(var, "LORSimplex"))
    {
        if (boost::iequals("True",
                           session->GetGlobalSysSolnInfo(var, "LORSimplex")))
        {
            m_useSimplex = true;
        }
    }
 
    // Setup session !m_equispaced since true means GLL distribution
    std::map<int, std::pair<int, std::vector<int>>> coeffmap;
    SpatialDomains::LinearMeshGraph linear(expList->GetGraph());
    linear.CreateLinearGraph(m_nsplit, coeffmap, !m_equiSpaced, m_useSimplex);
    m_lor_graph = linear.GetLinearGraph();
 
    std::string preconType;
 
    if (session->DefinesGlobalSysSolnInfo(var, "LORSolverType"))
    {
        m_slvType = session->GetGlobalSysSolnInfo(var, "LORSolverType");
    }
    else
    {
        NEKERROR(
            ErrorUtil::efatal,
            "Need to define LORSolverType "
            "(DirectFull, IterativeFull, Preconditioner, PETScFull, XxtFull)"
            "with LOR Preconditioner");
    }
 
    if (session->GetComm()->GetRank() == 0)
    {
        std::cout << "LOR Solve Type: " << m_slvType << std::endl;
    }
 
    std::string LinSysIterSolver;
    if (session->DefinesGlobalSysSolnInfo(var, "LORLinSysIterSolver"))
    {
        LinSysIterSolver =
            session->GetGlobalSysSolnInfo(var, "LORLinSysIterSolver");
    }
    else
    {
        LinSysIterSolver = "ConjugateGradient";
    }
 
    if (session->DefinesGlobalSysSolnInfo(var, "LORPreconditioner"))
    {
        preconType = session->GetGlobalSysSolnInfo(var, "LORPreconditioner");
    }
    else
    {
        preconType = "Diagonal";
    }
 
    if (boost::iequals(m_slvType, "Preconditioner"))
    {
        session->SetGlobalSysSolnInfo(var, "GlobalSysSoln", "IterativeFull");
    }
    else
    {
        session->SetGlobalSysSolnInfo(var, "GlobalSysSoln", m_slvType.c_str());
 
        if (boost::iequals(m_slvType, "IterativeFull"))
        {
            m_verboseIter =
                expList->GetSession()->DefinesCmdLineArgument("verbose");
        }
    }
 
    session->SetGlobalSysSolnInfo(var, "Preconditioner", preconType.c_str());
 
    // setup Fixed iteration if difined in GlobalSysSoln section
    std::string prevFixedIter;
    if (session->DefinesGlobalSysSolnInfo(var, "LORFixedIterations"))
    {
 
        if (session->DefinesGlobalSysSolnInfo(var, "NekLinSysFixedIterations"))
        {
            prevFixedIter =
                session->GetGlobalSysSolnInfo(var, "NekLinSysFixedIterations");
        }
 
        session->SetGlobalSysSolnInfo(
            var, "NekLinSysFixedIterations",
            session->GetGlobalSysSolnInfo(var, "LORFixedIterations"));
    }
 
    std::string prevIterTol;
    if (session->DefinesGlobalSysSolnInfo(var, "LORIterativeTolerance"))
    {
 
        if (session->DefinesGlobalSysSolnInfo(var, "IterativeSolverTolerance"))
        {
            prevIterTol =
                session->GetGlobalSysSolnInfo(var, "IterativeSolverTolerance");
        }
 
        session->SetGlobalSysSolnInfo(
            var, "IterativeSolverTolerance",
            session->GetGlobalSysSolnInfo(var, "LORIterativeTolerance"));
    }
 
    session->SetGlobalSysSolnInfo(var, "LinSysIterSolver",
                                  LinSysIterSolver.c_str());
 
    // Create contfield
    m_lor_field = MemoryManager<MultiRegions::ContField>::AllocateSharedPtr(
        session, m_lor_graph, var);
 
    // Set up high-order to LOR map
    m_ho2lor = Array<OneD, int>(m_lor_field->GetNcoeffs());
    std::map<int, int> offset;
 
    // check if the coeffmap has been setup correctly in the LOR space
    for (int e = 0; e < expList->GetNumElmts(); ++e)
    {
        offset[expList->GetExp(e)->GetGeom()->GetGlobalID()] =
            expList->GetCoeff_Offset(e);
    }
 
    int cnt = 0;
    for (int e = 0; e < m_lor_field->GetNumElmts(); ++e)
    {
        int gid = m_lor_field->GetExp(e)->GetGeom()->GetGlobalID();
        int id  = coeffmap[gid].first;
 
        for (int i = 0; i < coeffmap[gid].second.size(); ++i)
        {
            m_ho2lor[cnt++] = offset[id] + coeffmap[gid].second[i];
        }
    }
    ASSERTL1(cnt == m_lor_field->GetNcoeffs(),
             "Error in setting up high order to lower order map");
 
    // for preconditioner have a homogeneous system so need to set boundary
    // conditions to homogeneous too
    m_lor_field->SetBCsToHomogeneous();
 
    GlobalLinSysKey preconKey(m_linsys.lock()->GetKey().GetMatrixType(),
                              m_lor_field->GetLocalToGlobalMap(),
                              m_linsys.lock()->GetKey().GetConstFactors());
 
    if (boost::iequals(m_slvType, "DirectFull"))
    {
        m_LORLinSys = MemoryManager<GlobalLinSysDirectFull>::AllocateSharedPtr(
            preconKey, m_lor_field, m_lor_field->GetLocalToGlobalMap());
    }
    else if (boost::iequals(m_slvType, "XxtFull"))
    {
#ifdef NEKTAR_USE_MPI
        m_LORLinSys = MemoryManager<GlobalLinSysXxtFull>::AllocateSharedPtr(
            preconKey, m_lor_field, m_lor_field->GetLocalToGlobalMap());
#else
        ASSERTL0(false, "Nektar++ has not been compiled with MPI support.");
#endif
    }
    else if (boost::iequals(m_slvType, "IterativeFull"))
    {
        m_LORLinSys =
            MemoryManager<GlobalLinSysIterativeFull>::AllocateSharedPtr(
                preconKey, m_lor_field, m_lor_field->GetLocalToGlobalMap());
    }
    else if (boost::iequals(m_slvType, "PETScFull"))
    {
#ifdef NEKTAR_USING_PETSC
        m_LORLinSys = MemoryManager<GlobalLinSysPETScFull>::AllocateSharedPtr(
            preconKey, m_lor_field, m_lor_field->GetLocalToGlobalMap());
#else
        ASSERTL0(false, "Nektar++ has not been compiled with PETSc support.");
#endif
    }
    else if (boost::iequals(m_slvType, "Preconditioner"))
    {
        AssemblyMapSharedPtr l2gmap = m_lor_field->GetLocalToGlobalMap();
 
        m_LORLinSys =
            MemoryManager<GlobalLinSysIterativeFull>::AllocateSharedPtr(
                preconKey, m_lor_field, l2gmap);
 
        std::dynamic_pointer_cast<GlobalLinSysIterativeFull>(m_LORLinSys)
            ->Initialise(l2gmap->GetNumGlobalCoeffs(), l2gmap,
                         l2gmap->GetNumGlobalDirBndCoeffs());
    }
    else
    {
        NEKERROR(ErrorUtil::efatal,
                 "LORSlvType must be specified as one of "
                 "DirectFull, IterativeFull, Preconditioner, PETScFull");
    }
 
    // reset GlobalSysSolnType
    session->SetGlobalSysSolnInfo(var, "GlobalSysSoln",
                                  GlobalSysSolnTypeMap[solvertype]);
 
    // set fixed iterations if required;
    if (prevFixedIter.size())
    {
        session->SetGlobalSysSolnInfo(var, "NekLinSysFixedIterations",
                                      prevFixedIter);
    }
 
    // reset iterative tolerance
    if (prevIterTol.size())
    {
        session->SetGlobalSysSolnInfo(var, "IterativeSolverTolerance",
                                      prevIterTol);
    }
 
    CreateInvMultiplicity();
 
    // store ndir for easy access in DoPreconditioner
    m_nDir = m_locToGloMap.lock()->GetNumGlobalDirBndCoeffs();
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, ASSERTL1, CreateInvMultiplicity(), Nektar::SpatialDomains::LinearMeshGraph::CreateLinearGraph(), Nektar::ErrorUtil::efatal, Nektar::MultiRegions::eIterativeFull, Nektar::SpatialDomains::LinearMeshGraph::GetLinearGraph(), Nektar::MultiRegions::GlobalSysSolnTypeMap, m_equiSpaced, m_ho2lor, Nektar::MultiRegions::Preconditioner::m_linsys, Nektar::MultiRegions::Preconditioner::m_locToGloMap, m_lor_field, m_lor_graph, m_LORLinSys, m_nDir, m_nsplit, m_slvType, m_useSimplex, m_verboseIter, and NEKERROR.

v_DoPreconditioner()

void Nektar::MultiRegions::PreconditionerLOR::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 329 of file PreconditionerLOR.cpp.

{
    auto expList = ((m_linsys.lock())->GetLocMat()).lock();
 
    int nLocal     = expList->GetNcoeffs();
    int lor_nLocal = m_lor_field->GetNcoeffs();
 
    Array<OneD, NekDouble> tmp, solve(std::max(nLocal, lor_nLocal), 0.0);
    Array<OneD, NekDouble> Local(nLocal);
 
    if (isLocal)
    {
        // Input array is in local (non-assembled format) and to reproduce the
        // globally assembled problem the LOR preconditioner works best if we
        // take the averaged value so assemble and then divide by the
        // multiplicity.
        //
        // Note: Not entirely clear to me why we cannot take the input value
        m_locToGloMap.lock()->Assemble(pInput, solve);
        Vmath::Vmul(m_invMultiplicity.size() - m_nDir,
                    m_invMultiplicity + m_nDir, 1, solve + m_nDir, 1,
                    tmp = solve + m_nDir, 1);
        Vmath::Zero(m_nDir, solve, 1);
        expList->GlobalToLocal(solve, Local);
    }
    else // recover local forcing coefficients
    {
        Vmath::Vmul(m_invMultiplicity.size() - m_nDir,
                    m_invMultiplicity + m_nDir, 1, pInput, 1,
                    tmp = solve + m_nDir, 1);
        Vmath::Zero(m_nDir, solve, 1);
 
        expList->GlobalToLocal(solve, Local);
    }
 
    StdRegions::MatrixType mtype = (m_equiSpaced)
                                       ? StdRegions::eEquiSpacedToCoeffs
                                       : StdRegions::eGLLToCoeffs;
    GlobalMatrixKey key(mtype, m_locToGloMap.lock(),
                        m_linsys.lock()->GetKey().GetConstFactors());
 
    // Transform inner product to equispaced polynomial  with transpose multiply
    expList->MultiplyByBlockMatrix(key, Local, solve, true);
 
    // Get force for LOR system
    Array<OneD, NekDouble> fce(lor_nLocal);
    // makes inner system symmetric by dividing by linear mesh elemental
    // multiplicity
    Vmath::Vmul(nLocal, m_invLinMeshMultiplicity, 1, solve, 1, solve, 1);
    Vmath::Gathr(lor_nLocal, solve, m_ho2lor, fce);
 
    // solve linear sys solve for low order system
    AssemblyMapSharedPtr l2gmap = m_lor_field->GetLocalToGlobalMap();
    Vmath::Zero(lor_nLocal, solve, 1);
 
    if (boost::iequals(m_slvType, "DirectFull") ||
        boost::iequals(m_slvType, "IterativeFull") ||
        boost::iequals(m_slvType, "XxtFull") ||
        boost::iequals(m_slvType, "PETScFull"))
    {
        m_LORLinSys->SolveLinearSystem(l2gmap->GetNumGlobalCoeffs(), fce, solve,
                                       l2gmap,
                                       l2gmap->GetNumGlobalDirBndCoeffs());
    }
    else
    {
        std::dynamic_pointer_cast<GlobalLinSysIterativeFull>(m_LORLinSys)
            ->DoPreconditionerFlag(fce, solve, true);
    }
 
    // Project solution back to p-expansion and in Lagrange space
    Vmath::Scatr(lor_nLocal, solve, m_ho2lor, Local);
 
    if (isLocal)
    {
        // Transform residual to  polynomial
 
        expList->MultiplyByBlockMatrix(key, Local, pOutput);
 
        // enforce zero Bcs - should be done with a mask on local variables.
        expList->LocalToGlobal(pOutput, solve);
        Vmath::Zero(m_nDir, solve, 1);
        expList->GlobalToLocal(solve, pOutput);
    }
    else
    {
        // Transform residual to polynomial
        expList->MultiplyByBlockMatrix(key, Local, solve);
        expList->LocalToGlobal(solve, Local);
        Vmath::Vcopy(pOutput.size(), Local + m_nDir, 1, pOutput, 1);
    }
}

References Nektar::StdRegions::eEquiSpacedToCoeffs, Nektar::StdRegions::eGLLToCoeffs, Vmath::Gathr(), m_equiSpaced, m_ho2lor, m_invLinMeshMultiplicity, m_invMultiplicity, Nektar::MultiRegions::Preconditioner::m_linsys, Nektar::MultiRegions::Preconditioner::m_locToGloMap, m_lor_field, m_LORLinSys, m_nDir, m_slvType, Vmath::Scatr(), Vmath::Vcopy(), Vmath::Vmul(), and Vmath::Zero().

v_InitObject()

void Nektar::MultiRegions::PreconditionerLOR::v_InitObject ( )

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::Preconditioner.

Definition at line 75 of file PreconditionerLOR.cpp.

{
}

Member Data Documentation

className

std::string Nektar::MultiRegions::PreconditionerLOR::className

static

Initial value:

=
    GetPreconFactory().RegisterCreatorFunction("LOR", PreconditionerLOR::create,
                                               "LOR Preconditioning")

Name of class.

Registers the class with the Factory.

Definition at line 71 of file PreconditionerLOR.h.

def

std::string Nektar::MultiRegions::PreconditionerLOR::def

staticprivate

Definition at line 93 of file PreconditionerLOR.h.

lookupIds

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

staticprivate

Definition at line 92 of file PreconditionerLOR.h.

m_equiSpaced

bool Nektar::MultiRegions::PreconditionerLOR::m_equiSpaced = false

private

Flag that determines whether to use equispaced point distributions or GLL.

Definition at line 101 of file PreconditionerLOR.h.

Referenced by v_BuildPreconditioner(), and v_DoPreconditioner().

m_ho2lor

Array<OneD, int> Nektar::MultiRegions::PreconditionerLOR::m_ho2lor

private

Map from high-order node numbers to LOR representation.

Definition at line 115 of file PreconditionerLOR.h.

Referenced by CreateInvMultiplicity(), v_BuildPreconditioner(), and v_DoPreconditioner().

m_invLinMeshMultiplicity

Array<OneD, NekDouble> Nektar::MultiRegions::PreconditionerLOR::m_invLinMeshMultiplicity

private

Inverse of multiplicity of each global DOF in the LOR mesh.

Definition at line 119 of file PreconditionerLOR.h.

Referenced by CreateInvMultiplicity(), and v_DoPreconditioner().

m_invMultiplicity

Array<OneD, NekDouble> Nektar::MultiRegions::PreconditionerLOR::m_invMultiplicity

private

Inverse of multiplicity of each global DOF in the high-order mesh.

Definition at line 117 of file PreconditionerLOR.h.

Referenced by CreateInvMultiplicity(), and v_DoPreconditioner().

m_lor_field

MultiRegions::ContFieldSharedPtr Nektar::MultiRegions::PreconditionerLOR::m_lor_field

private

Field object for the LOR system.

Definition at line 111 of file PreconditionerLOR.h.

Referenced by v_BuildPreconditioner(), and v_DoPreconditioner().

m_lor_graph

SpatialDomains::MeshGraphSharedPtr Nektar::MultiRegions::PreconditionerLOR::m_lor_graph

private

MeshGraph for the LOR system.

Definition at line 109 of file PreconditionerLOR.h.

Referenced by v_BuildPreconditioner().

m_LORLinSys

GlobalLinSysSharedPtr Nektar::MultiRegions::PreconditionerLOR::m_LORLinSys

private

Linear solver for LOR system.

Definition at line 96 of file PreconditionerLOR.h.

Referenced by v_BuildPreconditioner(), and v_DoPreconditioner().

m_nDir

unsigned int Nektar::MultiRegions::PreconditionerLOR::m_nDir

private

Number of Dirichlet values on original mesh.

Definition at line 113 of file PreconditionerLOR.h.

Referenced by v_BuildPreconditioner(), and v_DoPreconditioner().

m_nsplit

unsigned int Nektar::MultiRegions::PreconditionerLOR::m_nsplit

private

Definition at line 107 of file PreconditionerLOR.h.

Referenced by v_BuildPreconditioner().

m_slvType

std::string Nektar::MultiRegions::PreconditionerLOR::m_slvType

private

Solution type for LOR space, DirectFull, IterativeFull, PETScFull.

Definition at line 98 of file PreconditionerLOR.h.

Referenced by v_BuildPreconditioner(), and v_DoPreconditioner().

m_useSimplex

bool Nektar::MultiRegions::PreconditionerLOR::m_useSimplex = false

private

Use a simplex distribution in the LOR system so that e.g. quadrilaterals are split into triangles.

Definition at line 104 of file PreconditionerLOR.h.

Referenced by v_BuildPreconditioner().

m_verboseIter

bool Nektar::MultiRegions::PreconditionerLOR::m_verboseIter

private

Whether to be verbose.

Definition at line 121 of file PreconditionerLOR.h.

Referenced by v_BuildPreconditioner().