A global linear system. More...

#include <GlobalLinSysXxtFull.h>

Inheritance diagram for Nektar::MultiRegions::GlobalLinSysXxtFull:

Public Member Functions
	GlobalLinSysXxtFull (const GlobalLinSysKey &pLinSysKey, const std::weak_ptr< ExpList > &pExpList, const std::shared_ptr< AssemblyMap > &pLocToGloMap)
	Constructor for full direct matrix solve. More...

	~GlobalLinSysXxtFull () override=default

Public Member Functions inherited from Nektar::MultiRegions::GlobalLinSysXxt
	GlobalLinSysXxt (const GlobalLinSysKey &pKey, const std::weak_ptr< ExpList > &pExp, const std::shared_ptr< AssemblyMap > &pLocToGloMap)
	Constructor for full direct matrix solve. More...

	~GlobalLinSysXxt () override

Public Member Functions inherited from Nektar::MultiRegions::GlobalLinSys
	GlobalLinSys (const GlobalLinSysKey &pKey, const std::weak_ptr< ExpList > &pExpList, const std::shared_ptr< AssemblyMap > &pLocToGloMap)
	Constructor for full direct matrix solve. More...

virtual	~GlobalLinSys ()

const GlobalLinSysKey &	GetKey (void) const
	Returns the key associated with the system. More...

const std::weak_ptr< ExpList > &	GetLocMat (void) const

void	InitObject ()

void	Initialise (const std::shared_ptr< AssemblyMap > &pLocToGloMap)

void	Solve (const Array< OneD, const NekDouble > &in, Array< OneD, NekDouble > &out, const AssemblyMapSharedPtr &locToGloMap, const Array< OneD, const NekDouble > &dirForcing=NullNekDouble1DArray)
	Solve the linear system for given input and output vectors using a specified local to global map. More...

std::shared_ptr< GlobalLinSys >	GetSharedThisPtr ()
	Returns a shared pointer to the current object. More...

int	GetNumBlocks ()

DNekScalMatSharedPtr	GetBlock (unsigned int n)

void	DropBlock (unsigned int n)

DNekScalBlkMatSharedPtr	GetStaticCondBlock (unsigned int n)

void	DropStaticCondBlock (unsigned int n)

void	SolveLinearSystem (const int pNumRows, const Array< OneD, const NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const AssemblyMapSharedPtr &locToGloMap, const int pNumDir=0)
	Solve the linear system for given input and output vectors. More...

Static Public Member Functions
static GlobalLinSysSharedPtr	create (const GlobalLinSysKey &pLinSysKey, const std::weak_ptr< ExpList > &pExpList, const std::shared_ptr< AssemblyMap > &pLocToGloMap)
	Creates an instance of this class. More...

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

Private Member Functions
void	AssembleMatrixArrays (const std::shared_ptr< AssemblyMap > &pLocToGloMap)

void	v_Solve (const Array< OneD, const NekDouble > &in, Array< OneD, NekDouble > &out, const AssemblyMapSharedPtr &locToGloMap, const Array< OneD, const NekDouble > &dirForcing=NullNekDouble1DArray) override
	Solve the linear system for given input and output vectors using a specified local to global map. More...

void	v_SolveLinearSystem (const int pNumRows, const Array< OneD, const NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const AssemblyMapSharedPtr &locToGloMap, const int pNumDir=0) override
	Solve the linear system for given input and output vectors. More...

Additional Inherited Members
Protected Member Functions inherited from Nektar::MultiRegions::GlobalLinSys
virtual void	v_Solve (const Array< OneD, const NekDouble > &in, Array< OneD, NekDouble > &out, const AssemblyMapSharedPtr &locToGloMap, const Array< OneD, const NekDouble > &dirForcing=NullNekDouble1DArray)=0
	Solve a linear system based on mapping. More...

virtual void	v_SolveLinearSystem (const int pNumRows, const Array< OneD, const NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const AssemblyMapSharedPtr &locToGloMap, const int pNumDir)=0
	Solve a basic matrix system. More...

virtual void	v_InitObject ()

virtual void	v_Initialise (const std::shared_ptr< AssemblyMap > &pLocToGloMap)

virtual int	v_GetNumBlocks ()
	Get the number of blocks in this system. More...

virtual DNekScalMatSharedPtr	v_GetBlock (unsigned int n)
	Retrieves the block matrix from n-th expansion using the matrix key provided by the m_linSysKey. More...

virtual void	v_DropBlock (unsigned int n)
	Releases the local block matrix from NekManager of n-th expansion using the matrix key provided by the m_linSysKey. More...

virtual DNekScalBlkMatSharedPtr	v_GetStaticCondBlock (unsigned int n)
	Retrieves a the static condensation block matrices from n-th expansion using the matrix key provided by the m_linSysKey. More...

virtual void	v_DropStaticCondBlock (unsigned int n)
	Releases the static condensation block matrices from NekManager of n-th expansion using the matrix key provided by the m_linSysKey. More...

PreconditionerSharedPtr	CreatePrecon (AssemblyMapSharedPtr asmMap)
	Create a preconditioner object from the parameters defined in the supplied assembly map. More...

Protected Attributes inherited from Nektar::MultiRegions::GlobalLinSysXxt
struct Xxt::crs_data *	m_crsData

Array< OneD, unsigned int >	m_Ai

Array< OneD, unsigned int >	m_Aj

Array< OneD, double >	m_Ar

Protected Attributes inherited from Nektar::MultiRegions::GlobalLinSys
const GlobalLinSysKey	m_linSysKey
	Key associated with this linear system. More...

const std::weak_ptr< ExpList >	m_expList
	Local Matrix System. More...

const std::map< int, RobinBCInfoSharedPtr >	m_robinBCInfo
	Robin boundary info. More...

bool	m_verbose

Detailed Description

A global linear system.

Definition at line 50 of file GlobalLinSysXxtFull.h.

Constructor & Destructor Documentation

◆ GlobalLinSysXxtFull()

Nektar::MultiRegions::GlobalLinSysXxtFull::GlobalLinSysXxtFull	(	const GlobalLinSysKey &	pLinSysKey,
		const std::weak_ptr< ExpList > &	pExpList,
		const std::shared_ptr< AssemblyMap > &	pLocToGloMap
	)

Constructor for full direct matrix solve.

Definition at line 55 of file GlobalLinSysXxtFull.cpp.

    : GlobalLinSys(pLinSysKey, pExp, pLocToGloMap),
      GlobalLinSysXxt(pLinSysKey, pExp, pLocToGloMap)
{
 
    ASSERTL1(m_linSysKey.GetGlobalSysSolnType() == eXxtFullMatrix,
             "This routine should only be used when using a Full XXT"
             " matrix solve");
 
    AssembleMatrixArrays(pLocToGloMap);
}

References AssembleMatrixArrays(), ASSERTL1, Nektar::MultiRegions::eXxtFullMatrix, Nektar::MultiRegions::GlobalLinSysKey::GetGlobalSysSolnType(), and Nektar::MultiRegions::GlobalLinSys::m_linSysKey.

◆ ~GlobalLinSysXxtFull()

Nektar::MultiRegions::GlobalLinSysXxtFull::~GlobalLinSysXxtFull ( )

overridedefault

Member Function Documentation

◆ AssembleMatrixArrays()

void Nektar::MultiRegions::GlobalLinSysXxtFull::AssembleMatrixArrays ( const std::shared_ptr< AssemblyMap > & pLocToGloMap )

private

Construct the local matrix row index, column index and value index arrays and initialize the XXT data structure with this information.

Parameters

locToGloMap Local to global mapping information.

Definition at line 74 of file GlobalLinSysXxtFull.cpp.

{
    ExpListSharedPtr vExp = m_expList.lock();
    unsigned int nElmt    = vExp->GetNumElmts();
    DNekScalMatSharedPtr loc_mat;
    unsigned int iCount    = 0;
    unsigned int rCount    = 0;
    unsigned int nRows     = 0;
    unsigned int nEntries  = 0;
    unsigned int numDirBnd = pLocToGloMap->GetNumGlobalDirBndCoeffs();
    unsigned int nLocal    = pLocToGloMap->GetNumLocalCoeffs();
    const Array<OneD, NekDouble> &vMapSign =
        pLocToGloMap->GetLocalToGlobalSign();
    bool doSign    = pLocToGloMap->GetSignChange();
    unsigned int i = 0, j = 0, k = 0, n = 0;
    int gid1;
    Array<OneD, unsigned int> vSizes(nElmt);
 
    // First construct a map of the number of local DOFs in each block
    // and the number of matrix entries for each block
 
    // Dimension of matrix is just the linear vertex space
    if ((m_linSysKey.GetMatrixType() == StdRegions::ePreconLinearSpace) ||
        (m_linSysKey.GetMatrixType() == StdRegions::ePreconLinearSpaceMass))
    {
        for (n = 0; n < nElmt; ++n)
        {
            vSizes[n] = vExp->GetExp(n)->GetNverts();
            nEntries += vSizes[n] * vSizes[n];
        }
    }
    else
    {
        for (n = 0; n < nElmt; ++n)
        {
            vSizes[n] = vExp->GetExp(n)->GetNcoeffs();
            nEntries += vSizes[n] * vSizes[n];
        }
    }
 
    // Set up i-index, j-index and value arrays
    m_Ai = Array<OneD, unsigned int>(nEntries);
    m_Aj = Array<OneD, unsigned int>(nEntries);
    m_Ar = Array<OneD, double>(nEntries, 0.0);
 
    // Set up the universal ID array for XXT
    Array<OneD, unsigned long> vId(nLocal);
 
    // Loop over each elemental block, extract matrix indices and value
    // and set the universal ID array
    for (n = iCount = 0; n < nElmt; ++n)
    {
        loc_mat = GetBlock(n);
        nRows   = loc_mat->GetRows();
 
        for (i = 0; i < nRows; ++i)
        {
            gid1 = pLocToGloMap->GetLocalToGlobalMap(iCount + i);
            for (j = 0; j < nRows; ++j)
            {
                k       = rCount + i * vSizes[n] + j;
                m_Ai[k] = iCount + i;
                m_Aj[k] = iCount + j;
                m_Ar[k] = (*loc_mat)(i, j);
                if (doSign)
                {
                    m_Ar[k] *= vMapSign[iCount + i] * vMapSign[iCount + j];
                }
            }
 
            // Dirichlet DOFs are not included in the solve, so we set
            // these to the special XXT id=0.
            if (gid1 < numDirBnd)
            {
                vId[iCount + i] = 0;
            }
            else
            {
                vId[iCount + i] = pLocToGloMap->GetGlobalToUniversalMap(gid1);
            }
        }
        iCount += vSizes[n];
        rCount += vSizes[n] * vSizes[n];
    }
 
    // Set up XXT and output some stats
    LibUtilities::CommSharedPtr vComm = pLocToGloMap->GetComm();
    m_crsData = Xxt::Init(nLocal, vId, m_Ai, m_Aj, m_Ar, vComm);
    if (m_verbose)
    {
        Xxt::nektar_crs_stats(m_crsData);
    }
}

Referenced by GlobalLinSysXxtFull().

◆ create()

static GlobalLinSysSharedPtr Nektar::MultiRegions::GlobalLinSysXxtFull::create	(	const GlobalLinSysKey &	pLinSysKey,
		const std::weak_ptr< ExpList > &	pExpList,
		const std::shared_ptr< AssemblyMap > &	pLocToGloMap
	)

inlinestatic

Creates an instance of this class.

Definition at line 54 of file GlobalLinSysXxtFull.h.

    {
        return MemoryManager<GlobalLinSysXxtFull>::AllocateSharedPtr(
            pLinSysKey, pExpList, pLocToGloMap);
    }

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

◆ v_Solve()

void Nektar::MultiRegions::GlobalLinSysXxtFull::v_Solve	(	const Array< OneD, const NekDouble > &	pLocInput,
		Array< OneD, NekDouble > &	pLocOutput,
		const AssemblyMapSharedPtr &	pLocToGloMap,
		const Array< OneD, const NekDouble > &	pDirForcing = `NullNekDouble1DArray`
	)

overrideprivatevirtual

Solve the linear system for given input and output vectors using a specified local to global map.

Solve the linear system using a full global matrix system.

Implements Nektar::MultiRegions::GlobalLinSys.

Definition at line 172 of file GlobalLinSysXxtFull.cpp.

{
    bool dirForcCalculated = (bool)pDirForcing.size();
    int nDirDofs           = pLocToGloMap->GetNumGlobalDirBndCoeffs();
    int nLocDofs           = pLocToGloMap->GetNumLocalCoeffs();
 
    if (nDirDofs)
    {
        std::shared_ptr<MultiRegions::ExpList> expList = m_expList.lock();
        Array<OneD, NekDouble> rhs(nLocDofs);
 
        // Calculate the Dirichlet forcing
        if (dirForcCalculated)
        {
            // Assume pDirForcing is in local space
            ASSERTL0(
                pDirForcing.size() >= nLocDofs,
                "DirForcing is not of sufficient size. Is it in local space?");
            Vmath::Vsub(nLocDofs, pLocInput, 1, pDirForcing, 1, rhs, 1);
        }
        else
        {
            // Calculate initial condition and Dirichlet forcing and subtract it
            // from the rhs
            expList->GeneralMatrixOp(m_linSysKey, pLocOutput, rhs);
 
            // Iterate over all the elements computing Robin BCs where
            // necessary
            for (auto &r : m_robinBCInfo) // add robin mass matrix
            {
                RobinBCInfoSharedPtr rBC;
                Array<OneD, NekDouble> rhsloc;
 
                int n      = r.first;
                int offset = expList->GetCoeff_Offset(n);
 
                LocalRegions::ExpansionSharedPtr vExp = expList->GetExp(n);
                // Add local matrix contribution
                for (rBC = r.second; rBC; rBC = rBC->next)
                {
                    vExp->AddRobinTraceContribution(
                        rBC->m_robinID, rBC->m_robinPrimitiveCoeffs,
                        pLocOutput + offset, rhsloc = rhs + offset);
                }
            }
            Vmath::Vsub(nLocDofs, pLocInput, 1, rhs, 1, rhs, 1);
        }
 
        Array<OneD, NekDouble> diff(nLocDofs);
 
        // Solve for perturbation from initial guess in pOutput
        SolveLinearSystem(nLocDofs, rhs, diff, pLocToGloMap);
 
        // Add back initial and boundary condition
        Vmath::Vadd(nLocDofs, diff, 1, pLocOutput, 1, pLocOutput, 1);
    }
    else
    {
        SolveLinearSystem(nLocDofs, pLocInput, pLocOutput, pLocToGloMap);
    }
}

References ASSERTL0, Nektar::MultiRegions::GlobalLinSys::m_expList, Nektar::MultiRegions::GlobalLinSys::m_linSysKey, Nektar::MultiRegions::GlobalLinSys::m_robinBCInfo, Nektar::MultiRegions::GlobalLinSys::SolveLinearSystem(), Vmath::Vadd(), and Vmath::Vsub().

◆ v_SolveLinearSystem()

void Nektar::MultiRegions::GlobalLinSysXxtFull::v_SolveLinearSystem	(	const int	pNumRows,
		const Array< OneD, const NekDouble > &	pInput,
		Array< OneD, NekDouble > &	pOutput,
		const AssemblyMapSharedPtr &	locToGloMap,
		const int	pNumDir = `0`
	)

overrideprivatevirtual

Solve the linear system for given input and output vectors.

Implements Nektar::MultiRegions::GlobalLinSys.

Definition at line 239 of file GlobalLinSysXxtFull.cpp.

{
    int nLocal = pNumRows;
 
    Vmath::Zero(nLocal, pOutput, 1);
 
    // Set Output into correct sign
    if (pLocToGloMap->GetSignChange())
    {
        Array<OneD, NekDouble> vlocal(nLocal);
        Vmath::Vmul(nLocal, pLocToGloMap->GetLocalToGlobalSign(), 1, pInput, 1,
                    vlocal, 1);
 
        Xxt::Solve(pOutput, m_crsData, vlocal);
 
        Vmath::Vmul(nLocal, pLocToGloMap->GetLocalToGlobalSign(), 1, pOutput, 1,
                    pOutput, 1);
    }
    else
    {
        Xxt::Solve(pOutput, m_crsData, pInput);
    }
}

References Nektar::MultiRegions::GlobalLinSysXxt::m_crsData, Xxt::Solve(), Vmath::Vmul(), and Vmath::Zero().

Member Data Documentation

◆ className

string Nektar::MultiRegions::GlobalLinSysXxtFull::className

static

Initial value:

=
    GetGlobalLinSysFactory().RegisterCreatorFunction(
        "XxtFull", GlobalLinSysXxtFull::create, "Xxt Full Matrix.")

Name of class.

Registers the class with the Factory.

Definition at line 64 of file GlobalLinSysXxtFull.h.

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Additional Inherited Members