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

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 Attributes
Array< OneD, NekDouble >	m_diagonals

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
void	DiagonalPreconditionerSum (void)

void	StaticCondDiagonalPreconditionerSum (void)

virtual void	v_InitObject ()

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	lookupIds []

static std::string	def

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

Definition at line 49 of file PreconditionerDiagonal.h.

Constructor & Destructor Documentation

◆ PreconditionerDiagonal()

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

@class Preconditioner

This class implements diagonal preconditioning for the conjugate

gradient matrix solver.

Definition at line 62 of file PreconditionerDiagonal.cpp.

            : Preconditioner(plinsys, pLocToGloMap)
          {
      }

◆ ~PreconditionerDiagonal()

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

inlinevirtual

Definition at line 71 of file PreconditionerDiagonal.h.

71 {}

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 53 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 98 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 164 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 ( )

privatevirtual

Reimplemented from Nektar::MultiRegions::Preconditioner.

Definition at line 73 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().

◆ v_DoPreconditioner()

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

         {
             auto asmMap = m_locToGloMap.lock();
  
             GlobalSysSolnType solvertype = asmMap->GetGlobalSysSolnType();
  
             int nGlobal = solvertype == eIterativeFull ?
                 asmMap->GetNumGlobalCoeffs() :
                 asmMap->GetNumGlobalBndCoeffs();
             int nDir    = asmMap->GetNumGlobalDirBndCoeffs();
             int nNonDir = nGlobal-nDir;
             Vmath::Vmul(nNonDir, &pInput[0], 1, &m_diagonals[0], 1, &pOutput[0], 1);
     }

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

◆ v_InitObject()

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

privatevirtual

Reimplemented from Nektar::MultiRegions::Preconditioner.

Definition at line 69 of file PreconditionerDiagonal.cpp.

70 {

71 }

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 63 of file PreconditionerDiagonal.h.

◆ def

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

staticprivate

Definition at line 92 of file PreconditionerDiagonal.h.

◆ lookupIds

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

staticprivate

Definition at line 91 of file PreconditionerDiagonal.h.

◆ m_diagonals

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

protected

Definition at line 75 of file PreconditionerDiagonal.h.

Referenced by DiagonalPreconditionerSum(), StaticCondDiagonalPreconditionerSum(), and v_DoPreconditioner().

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

◆ PreconditionerDiagonal()

◆ ~PreconditionerDiagonal()

Member Function Documentation

◆ create()

◆ DiagonalPreconditionerSum()

◆ StaticCondDiagonalPreconditionerSum()

◆ v_BuildPreconditioner()

◆ v_DoPreconditioner()

◆ v_InitObject()

Member Data Documentation

◆ className

◆ def

◆ lookupIds

◆ m_diagonals