#include <PreconditionerLinear.h>

Inheritance diagram for Nektar::MultiRegions::PreconditionerLinear:

Collaboration diagram for Nektar::MultiRegions::PreconditionerLinear:

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

virtual	~PreconditionerLinear ()

Public Member Functions inherited from Nektar::MultiRegions::Preconditioner
	Preconditioner (const boost::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, const boost::shared_ptr< DNekScalMat > &loc_mat)

Static Public Member Functions
static PreconditionerSharedPtr	create (const boost::shared_ptr< GlobalLinSys > &plinsys, const boost::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

boost::shared_ptr< AssemblyMap >	m_vertLocToGloMap

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

PreconditionerType	m_preconType

DNekMatSharedPtr	m_preconditioner

boost::shared_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, const boost::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 58 of file PreconditionerLinear.h.

Constructor & Destructor Documentation

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

Definition at line 86 of file PreconditionerLinear.cpp.

             : Preconditioner(plinsys, pLocToGloMap)
         {
         }

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

inlinevirtual

Definition at line 80 of file PreconditionerLinear.h.

80 {}

Member Function Documentation

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

inlinestatic

Creates an instance of this class.

Definition at line 62 of file PreconditionerLinear.h.

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

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

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

privatevirtual

Reimplemented from Nektar::MultiRegions::Preconditioner.

Definition at line 97 of file PreconditionerLinear.cpp.

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

         {
             GlobalSysSolnType sType  = m_locToGloMap->GetGlobalSysSolnType();
             ASSERTL0(sType == eIterativeStaticCond,
                      "This type of preconditioning is not implemented "
                      "for this solver");
 
             boost::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
                     ASSERTL0(false, "Nektar++ has not been compiled with "
                                     "PETSc support.");
 #endif
                 }
                 case eLinearPreconXxt:
                 default:
                 {
                     linSolveType = eXxtFullMatrix;
                     break;
                 }
             }
 
             m_vertLocToGloMap = m_locToGloMap->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
                 }
             }
     }

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

References Nektar::NullNekDouble1DArray, and v_DoPreconditionerWithNonVertOutput().

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

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

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

Referenced by v_DoPreconditioner().

             {
             GlobalSysSolnType solvertype=m_locToGloMap->GetGlobalSysSolnType();
             switch(solvertype)
             {
                 case MultiRegions::eIterativeStaticCond:
                 {
                     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->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;
         }
         }

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

privatevirtual

Reimplemented from Nektar::MultiRegions::Preconditioner.

Definition at line 93 of file PreconditionerLinear.cpp.

94 {

95 }

Member Data Documentation

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

GlobalLinSysSharedPtr Nektar::MultiRegions::PreconditionerLinear::m_vertLinsys

protected

Definition at line 83 of file PreconditionerLinear.h.

Referenced by v_BuildPreconditioner(), and v_DoPreconditionerWithNonVertOutput().

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

protected

Definition at line 84 of file PreconditionerLinear.h.

Referenced by v_BuildPreconditioner(), and v_DoPreconditionerWithNonVertOutput().

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

staticprivate

Initial value:

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

Definition at line 87 of file PreconditionerLinear.h.

Referenced by v_BuildPreconditioner().

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 88 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

Member Function Documentation

Member Data Documentation