#include <PreconditionerLinear.h>

Inheritance diagram for Nektar::MultiRegions::PreconditionerLinear:

Public Member Functions
	PreconditionerLinear (const std::shared_ptr< GlobalLinSys > &plinsys, const AssemblyMapSharedPtr &pLocToGloMap)

virtual	~PreconditionerLinear ()

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)

void	DoPreconditionerWithNonVertOutput (const Array< OneD, NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const Array< OneD, NekDouble > &pNonVertOutput, Array< OneD, NekDouble > &pVertForce=NullNekDouble1DArray)

void	DoTransformToLowEnergy (Array< OneD, NekDouble > &pInOut, int offset)

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

void	DoTransformFromLowEnergy (Array< OneD, NekDouble > &pInOut)

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

void	DoMultiplybyInverseTransposedTransformationMatrix (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 Attributes
GlobalLinSysSharedPtr	m_vertLinsys

std::shared_ptr< AssemblyMap >	m_vertLocToGloMap

Protected Attributes inherited from Nektar::MultiRegions::Preconditioner
const std::weak_ptr< GlobalLinSys >	m_linsys

PreconditionerType	m_preconType

DNekMatSharedPtr	m_preconditioner

std::weak_ptr< AssemblyMap >	m_locToGloMap

LibUtilities::CommSharedPtr	m_comm

Private Member Functions
virtual void	v_InitObject ()

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_DoPreconditioner (const Array< OneD, NekDouble > &pInput, Array< OneD, NekDouble > &pOutput)
	Apply a preconditioner to the conjugate gradient method. More...

virtual void	v_BuildPreconditioner ()

Static Private Attributes
static std::string	solveType

static std::string	solveTypeIds []

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

Detailed Description

This class implements preconditioning for the conjugate gradient matrix solver.

Definition at line 57 of file PreconditionerLinear.h.

Constructor & Destructor Documentation

◆ PreconditionerLinear()

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

Definition at line 87 of file PreconditionerLinear.cpp.

             : Preconditioner(plinsys, pLocToGloMap)
         {
         }

◆ ~PreconditionerLinear()

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

inlinevirtual

Definition at line 78 of file PreconditionerLinear.h.

78 {}

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 61 of file PreconditionerLinear.h.

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

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

◆ v_BuildPreconditioner()

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

privatevirtual

Reimplemented from Nektar::MultiRegions::Preconditioner.

Definition at line 98 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);
 
             // 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
                 }
             }
     }

◆ v_DoPreconditioner()

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

privatevirtual

Apply a preconditioner to the conjugate gradient method.

Reimplemented from Nektar::MultiRegions::Preconditioner.

Definition at line 168 of file PreconditionerLinear.cpp.

References Nektar::NullNekDouble1DArray, and v_DoPreconditionerWithNonVertOutput().

         {
             v_DoPreconditionerWithNonVertOutput(pInput,pOutput,NullNekDouble1DArray,
                                                 NullNekDouble1DArray);
         }

◆ 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
	)

privatevirtual

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 179 of file PreconditionerLinear.cpp.

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

Referenced by v_DoPreconditioner().

             {
             GlobalSysSolnType solvertype=m_locToGloMap.lock()->GetGlobalSysSolnType();
             switch(solvertype)
             {
                 case MultiRegions::eIterativeStaticCond:
                 case MultiRegions::ePETScStaticCond:
                 {
                     int i,val;
                     int nloc = m_vertLocToGloMap->GetNumLocalCoeffs();
                     int nglo = m_vertLocToGloMap->GetNumGlobalCoeffs();
                     // 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();
                     
                     Array<OneD,NekDouble> In(nglo,0.0);
                     Array<OneD,NekDouble> Out(nglo,0.0);
 
                     // Gather rhs
                     for(i = 0; i < nloc; ++i)
                     {
                         val = LocToGloBnd[i];
                         if(val >= nDirFull)
                         {
                             In[LocToGlo[i]] = pInput[val-nDirFull];
                         }
                     }
                     
                     // 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.num_elements() >= pOutput.num_elements(),"Non Vert output is not of sufficient length");
                         Vmath::Vcopy(pOutput.num_elements(),pNonVertOutput,1,pOutput,1);
                     }
                     else
                     {
                         //Copy input to output as a unit preconditioner on
                         //any other value
                         Vmath::Vcopy(pInput.num_elements(),pInput,1,pOutput,1);
                     }
                     
                     if(pVertForce != NullNekDouble1DArray)
                     {
                         Vmath::Zero(pVertForce.num_elements(),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]];
                             }
                         }
                     }
                 }
                 break;
             default:
                 ASSERTL0(0,"Unsupported solver type");
                 break;
         }
         }

◆ v_InitObject()

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

privatevirtual

Reimplemented from Nektar::MultiRegions::Preconditioner.

Definition at line 94 of file PreconditionerLinear.cpp.

95 {

96 }

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 71 of file PreconditionerLinear.h.

◆ m_vertLinsys

GlobalLinSysSharedPtr Nektar::MultiRegions::PreconditionerLinear::m_vertLinsys

protected

Definition at line 81 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 82 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 85 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 86 of file PreconditionerLinear.h.

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Attributes

Private Member Functions

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ PreconditionerLinear()

◆ ~PreconditionerLinear()

Member Function Documentation

◆ create()

◆ v_BuildPreconditioner()

◆ v_DoPreconditioner()

◆ v_DoPreconditionerWithNonVertOutput()

◆ v_InitObject()

Member Data Documentation

◆ className1

◆ m_vertLinsys

◆ m_vertLocToGloMap

◆ solveType

◆ solveTypeIds