A global linear system. More...

#include <GlobalLinSysDirectStaticCond.h>

Inheritance diagram for Nektar::MultiRegions::GlobalLinSysDirectStaticCond:

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

	GlobalLinSysDirectStaticCond (const GlobalLinSysKey &mkey, const std::weak_ptr< ExpList > &pExpList, const DNekScalBlkMatSharedPtr pSchurCompl, const DNekScalBlkMatSharedPtr pBinvD, const DNekScalBlkMatSharedPtr pC, const DNekScalBlkMatSharedPtr pInvD, const std::shared_ptr< AssemblyMap > &locToGloMap)
	Constructor for full direct matrix solve. More...

	~GlobalLinSysDirectStaticCond () override

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

	~GlobalLinSysDirect () 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...

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

	~GlobalLinSysStaticCond () override

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

static std::string	className2

Protected Member Functions
void	v_AssembleSchurComplement (std::shared_ptr< AssemblyMap > pLocToGloMap) override

GlobalLinSysStaticCondSharedPtr	v_Recurse (const GlobalLinSysKey &mkey, const std::weak_ptr< ExpList > &pExpList, const DNekScalBlkMatSharedPtr pSchurCompl, const DNekScalBlkMatSharedPtr pBinvD, const DNekScalBlkMatSharedPtr pC, const DNekScalBlkMatSharedPtr pInvD, const std::shared_ptr< AssemblyMap > &l2gMap) override

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 Member Functions inherited from Nektar::MultiRegions::GlobalLinSysStaticCond
virtual void	v_PreSolve (int scLevel, Array< OneD, NekDouble > &F_bnd)

virtual void	v_BasisFwdTransform (Array< OneD, NekDouble > &pInOut)

virtual void	v_CoeffsBwdTransform (Array< OneD, NekDouble > &pInOut)

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

virtual void	v_AssembleSchurComplement (std::shared_ptr< AssemblyMap > pLoctoGloMap)

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

virtual GlobalLinSysStaticCondSharedPtr	v_Recurse (const GlobalLinSysKey &mkey, const std::weak_ptr< ExpList > &pExpList, const DNekScalBlkMatSharedPtr pSchurCompl, const DNekScalBlkMatSharedPtr pBinvD, const DNekScalBlkMatSharedPtr pC, const DNekScalBlkMatSharedPtr pInvD, const std::shared_ptr< AssemblyMap > &locToGloMap)=0

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_InitObject () override

void	v_Initialise (const std::shared_ptr< AssemblyMap > &locToGloMap) override
	Initialise this object. More...

void	SetupTopLevel (const std::shared_ptr< AssemblyMap > &locToGloMap)
	Set up the storage for the Schur complement or the top level of the multi-level Schur complement. More...

void	ConstructNextLevelCondensedSystem (const std::shared_ptr< AssemblyMap > &locToGloMap)

Private Member Functions
MatrixStorage	DetermineMatrixStorage (const std::shared_ptr< AssemblyMap > &locToGloMap)
	Matrix Storage type for known matrices. More...

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

Additional Inherited Members
Protected Attributes inherited from Nektar::MultiRegions::GlobalLinSysDirect
DNekLinSysSharedPtr	m_linSys
	Basic linear system object. More...

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

Protected Attributes inherited from Nektar::MultiRegions::GlobalLinSysStaticCond
GlobalLinSysStaticCondSharedPtr	m_recursiveSchurCompl
	Schur complement for Direct Static Condensation. More...

DNekScalBlkMatSharedPtr	m_schurCompl
	Block Schur complement matrix. More...

DNekScalBlkMatSharedPtr	m_BinvD
	Block \( BD^{-1} \) matrix. More...

DNekScalBlkMatSharedPtr	m_C
	Block \( C \) matrix. More...

DNekScalBlkMatSharedPtr	m_invD
	Block \( D^{-1} \) matrix. More...

std::weak_ptr< AssemblyMap >	m_locToGloMap
	Local to global map. More...

Array< OneD, NekDouble >	m_wsp
	Workspace array for matrix multiplication. More...

Array< OneD, const NekDouble >	m_sign

Detailed Description

A global linear system.

Definition at line 51 of file GlobalLinSysDirectStaticCond.h.

Constructor & Destructor Documentation

◆ GlobalLinSysDirectStaticCond() [1/2]

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

Constructor for full direct matrix solve.

For a matrix system of the form

\[ \left[ \begin{array}{cc} \boldsymbol{A} & \boldsymbol{B}\\ \boldsymbol{C} & \boldsymbol{D} \end{array} \right] \left[ \begin{array}{c} \boldsymbol{x_1}\\ \boldsymbol{x_2} \end{array}\right] = \left[ \begin{array}{c} \boldsymbol{y_1}\\ \boldsymbol{y_2} \end{array}\right], \]

where \(\boldsymbol{D}\) and \((\boldsymbol{A-BD^{-1}C})\) are invertible, store and assemble a static condensation system, according to a given local to global mapping. m_linSys is constructed by AssembleSchurComplement().

Parameters

mKey	Associated matrix key.
pLocMatSys	LocalMatrixSystem
locToGloMap	Local to global mapping.

Definition at line 78 of file GlobalLinSysDirectStaticCond.cpp.

    : GlobalLinSys(pKey, pExpList, pLocToGloMap),
      GlobalLinSysDirect(pKey, pExpList, pLocToGloMap),
      GlobalLinSysStaticCond(pKey, pExpList, pLocToGloMap)
{
    ASSERTL1((pKey.GetGlobalSysSolnType() == eDirectStaticCond) ||
                 (pKey.GetGlobalSysSolnType() == eDirectMultiLevelStaticCond),
             "This constructor is only valid when using static "
             "condensation");
    ASSERTL1(pKey.GetGlobalSysSolnType() ==
                 pLocToGloMap->GetGlobalSysSolnType(),
             "The local to global map is not set up for the requested "
             "solution type");
}

References ASSERTL1, Nektar::MultiRegions::eDirectMultiLevelStaticCond, Nektar::MultiRegions::eDirectStaticCond, and Nektar::MultiRegions::GlobalLinSysKey::GetGlobalSysSolnType().

◆ GlobalLinSysDirectStaticCond() [2/2]

Nektar::MultiRegions::GlobalLinSysDirectStaticCond::GlobalLinSysDirectStaticCond	(	const GlobalLinSysKey &	mkey,
		const std::weak_ptr< ExpList > &	pExpList,
		const DNekScalBlkMatSharedPtr	pSchurCompl,
		const DNekScalBlkMatSharedPtr	pBinvD,
		const DNekScalBlkMatSharedPtr	pC,
		const DNekScalBlkMatSharedPtr	pInvD,
		const std::shared_ptr< AssemblyMap > &	locToGloMap
	)

Constructor for full direct matrix solve.

Definition at line 98 of file GlobalLinSysDirectStaticCond.cpp.

    : GlobalLinSys(pKey, pExpList, pLocToGloMap),
      GlobalLinSysDirect(pKey, pExpList, pLocToGloMap),
      GlobalLinSysStaticCond(pKey, pExpList, pLocToGloMap)
{
    m_schurCompl = pSchurCompl;
    m_BinvD      = pBinvD;
    m_C          = pC;
    m_invD       = pInvD;
}

References Nektar::MultiRegions::GlobalLinSysStaticCond::m_BinvD, Nektar::MultiRegions::GlobalLinSysStaticCond::m_C, Nektar::MultiRegions::GlobalLinSysStaticCond::m_invD, and Nektar::MultiRegions::GlobalLinSysStaticCond::m_schurCompl.

◆ ~GlobalLinSysDirectStaticCond()

Nektar::MultiRegions::GlobalLinSysDirectStaticCond::~GlobalLinSysDirectStaticCond ( )

override

Definition at line 117 of file GlobalLinSysDirectStaticCond.cpp.

118{

119}

Member Function Documentation

◆ create()

static GlobalLinSysSharedPtr Nektar::MultiRegions::GlobalLinSysDirectStaticCond::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 56 of file GlobalLinSysDirectStaticCond.h.

    {
        GlobalLinSysDirectStaticCondSharedPtr ret =
            MemoryManager<GlobalLinSysDirectStaticCond>::AllocateSharedPtr(
                pLinSysKey, pExpList, pLocToGloMap);
        ret->InitObject();
        return ret;
    }

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

◆ DetermineMatrixStorage()

MatrixStorage Nektar::MultiRegions::GlobalLinSysDirectStaticCond::DetermineMatrixStorage ( const std::shared_ptr< AssemblyMap > & locToGloMap )

private

Matrix Storage type for known matrices.

Definition at line 121 of file GlobalLinSysDirectStaticCond.cpp.

{
    int nBndDofs      = pLocToGloMap->GetNumGlobalBndCoeffs();
    int NumDirBCs     = pLocToGloMap->GetNumGlobalDirBndCoeffs();
    unsigned int rows = nBndDofs - NumDirBCs;
    int bwidth        = pLocToGloMap->GetBndSystemBandWidth();
 
    MatrixStorage matStorage;
 
    switch (m_linSysKey.GetMatrixType())
    {
            // case for all symmetric matices
        case StdRegions::eMass:
        case StdRegions::eLaplacian:
        case StdRegions::eHelmholtz:
        case StdRegions::eHybridDGHelmBndLam:
        {
            if ((2 * (bwidth + 1)) < rows)
            {
                matStorage = ePOSITIVE_DEFINITE_SYMMETRIC_BANDED;
            }
            else
            {
                matStorage = ePOSITIVE_DEFINITE_SYMMETRIC;
            }
        }
        break;
        case StdRegions::eLinearAdvection:
        case StdRegions::eLinearAdvectionReaction:
        case StdRegions::eLinearAdvectionDiffusionReaction:
        default:
        {
            // Current inversion techniques do not seem to
            // allow banded matrices to be used as a linear
            // system
            matStorage = eFULL;
        }
        break;
    }
 
    return matStorage;
}

References Nektar::eFULL, Nektar::StdRegions::eHelmholtz, Nektar::StdRegions::eHybridDGHelmBndLam, Nektar::StdRegions::eLaplacian, Nektar::StdRegions::eLinearAdvection, Nektar::StdRegions::eLinearAdvectionDiffusionReaction, Nektar::StdRegions::eLinearAdvectionReaction, Nektar::StdRegions::eMass, Nektar::ePOSITIVE_DEFINITE_SYMMETRIC, Nektar::ePOSITIVE_DEFINITE_SYMMETRIC_BANDED, Nektar::MultiRegions::GlobalMatrixKey::GetMatrixType(), and Nektar::MultiRegions::GlobalLinSys::m_linSysKey.

Referenced by v_AssembleSchurComplement().

◆ v_AssembleSchurComplement()

void Nektar::MultiRegions::GlobalLinSysDirectStaticCond::v_AssembleSchurComplement ( std::shared_ptr< AssemblyMap > pLocToGloMap )

overrideprotectedvirtual

Assemble the schur complement matrix from the block matrices stored in #m_blkMatrices and the given local to global mapping information.

Parameters

locToGloMap Local to global mapping information.

Reimplemented from Nektar::MultiRegions::GlobalLinSysStaticCond.

Definition at line 170 of file GlobalLinSysDirectStaticCond.cpp.

{
    int i, j, n, cnt, gid1, gid2;
    NekDouble sign1, sign2, value;
 
    int nBndDofs  = pLocToGloMap->GetNumGlobalBndCoeffs();
    int NumDirBCs = pLocToGloMap->GetNumGlobalDirBndCoeffs();
 
    DNekScalBlkMatSharedPtr SchurCompl = m_schurCompl;
    DNekScalBlkMatSharedPtr BinvD      = m_BinvD;
    DNekScalBlkMatSharedPtr C          = m_C;
    DNekScalBlkMatSharedPtr invD       = m_invD;
 
    unsigned int rows = nBndDofs - NumDirBCs;
    unsigned int cols = nBndDofs - NumDirBCs;
 
    DNekMatSharedPtr Gmat;
    int bwidth = pLocToGloMap->GetBndSystemBandWidth();
 
    MatrixStorage matStorage = DetermineMatrixStorage(pLocToGloMap);
 
    switch (matStorage)
    {
        case ePOSITIVE_DEFINITE_SYMMETRIC_BANDED:
        {
            try
            {
                Gmat = MemoryManager<DNekMat>::AllocateSharedPtr(
                    rows, cols, 0.0, matStorage, bwidth, bwidth);
            }
            catch (...)
            {
                NEKERROR(ErrorUtil::efatal,
                         "Insufficient memory for GlobalLinSys.");
            }
            break;
        }
 
        case ePOSITIVE_DEFINITE_SYMMETRIC:
        case eFULL:
        {
            Gmat = MemoryManager<DNekMat>::AllocateSharedPtr(rows, cols, 0.0,
                                                             matStorage);
            break;
        }
 
        default:
        {
            NEKERROR(ErrorUtil::efatal,
                     "Unknown matrix storage type of type not set up");
        }
    }
 
    // fill global matrix
    DNekScalMatSharedPtr loc_mat;
    int loc_lda;
    for (n = cnt = 0; n < SchurCompl->GetNumberOfBlockRows(); ++n)
    {
        loc_mat = SchurCompl->GetBlock(n, n);
        loc_lda = loc_mat->GetRows();
 
        // Set up  Matrix;
        for (i = 0; i < loc_lda; ++i)
        {
            gid1  = pLocToGloMap->GetLocalToGlobalBndMap(cnt + i) - NumDirBCs;
            sign1 = pLocToGloMap->GetLocalToGlobalBndSign(cnt + i);
 
            if (gid1 >= 0)
            {
                for (j = 0; j < loc_lda; ++j)
                {
                    gid2 = pLocToGloMap->GetLocalToGlobalBndMap(cnt + j) -
                           NumDirBCs;
                    sign2 = pLocToGloMap->GetLocalToGlobalBndSign(cnt + j);
 
                    if (gid2 >= 0)
                    {
                        // As the global matrix should be symmetric,
                        // only add the value for the upper triangular
                        // part in order to avoid entries to be entered
                        // twice
                        if ((matStorage == eFULL) || (gid2 >= gid1))
                        {
                            value = Gmat->GetValue(gid1, gid2) +
                                    sign1 * sign2 * (*loc_mat)(i, j);
                            Gmat->SetValue(gid1, gid2, value);
                        }
                    }
                }
            }
        }
        cnt += loc_lda;
    }
 
    if (rows)
    {
        PointerWrapper w = eWrapper;
        m_linSys = MemoryManager<DNekLinSys>::AllocateSharedPtr(Gmat, w);
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), DetermineMatrixStorage(), Nektar::ErrorUtil::efatal, Nektar::eFULL, Nektar::ePOSITIVE_DEFINITE_SYMMETRIC, Nektar::ePOSITIVE_DEFINITE_SYMMETRIC_BANDED, Nektar::eWrapper, Nektar::MultiRegions::GlobalLinSysStaticCond::m_BinvD, Nektar::MultiRegions::GlobalLinSysStaticCond::m_C, Nektar::MultiRegions::GlobalLinSysStaticCond::m_invD, Nektar::MultiRegions::GlobalLinSysDirect::m_linSys, Nektar::MultiRegions::GlobalLinSysStaticCond::m_schurCompl, NEKERROR, and Nektar::UnitTests::w().

◆ v_Recurse()

GlobalLinSysStaticCondSharedPtr Nektar::MultiRegions::GlobalLinSysDirectStaticCond::v_Recurse	(	const GlobalLinSysKey &	mkey,
		const std::weak_ptr< ExpList > &	pExpList,
		const DNekScalBlkMatSharedPtr	pSchurCompl,
		const DNekScalBlkMatSharedPtr	pBinvD,
		const DNekScalBlkMatSharedPtr	pC,
		const DNekScalBlkMatSharedPtr	pInvD,
		const std::shared_ptr< AssemblyMap > &	l2gMap
	)

overrideprotectedvirtual

Implements Nektar::MultiRegions::GlobalLinSysStaticCond.

Definition at line 272 of file GlobalLinSysDirectStaticCond.cpp.

{
    GlobalLinSysDirectStaticCondSharedPtr sys =
        MemoryManager<GlobalLinSysDirectStaticCond>::AllocateSharedPtr(
            mkey, pExpList, pSchurCompl, pBinvD, pC, pInvD, l2gMap);
    sys->Initialise(l2gMap);
    return sys;
}

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

◆ v_SolveLinearSystem()

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

overrideprivatevirtual

Solve the linear system for given input and output vectors.

Implements Nektar::MultiRegions::GlobalLinSys.

Definition at line 287 of file GlobalLinSysDirectStaticCond.cpp.

{
    Array<OneD, NekDouble> tmp(pNumRows);
    Array<OneD, NekDouble> global(pNumRows, 0.0);
 
    pLocToGloMap->AssembleBnd(pInput, tmp);
 
    const int nHomDofs = pNumRows - pNumDir;
    DNekVec Vin(nHomDofs, tmp + pNumDir);
 
    Array<OneD, NekDouble> tmp1 = global + pNumDir;
    DNekVec Vout(nHomDofs, tmp1, eWrapper);
 
    m_linSys->Solve(Vin, Vout);
 
    pLocToGloMap->GlobalToLocalBnd(global, pOutput);
}

References Nektar::eWrapper, and Nektar::MultiRegions::GlobalLinSysDirect::m_linSys.

Member Data Documentation

◆ className

std::string Nektar::MultiRegions::GlobalLinSysDirectStaticCond::className

static

Initial value:

=
    GetGlobalLinSysFactory().RegisterCreatorFunction(
        "DirectStaticCond", GlobalLinSysDirectStaticCond::create,
        "Direct static condensation.")

Name of class.

Registers the class with the Factory.

Definition at line 69 of file GlobalLinSysDirectStaticCond.h.

◆ className2

std::string Nektar::MultiRegions::GlobalLinSysDirectStaticCond::className2

static

Initial value:

=
    GetGlobalLinSysFactory().RegisterCreatorFunction(
        "DirectMultiLevelStaticCond", GlobalLinSysDirectStaticCond::create,
        "Direct multi-level static condensation.")

Definition at line 70 of file GlobalLinSysDirectStaticCond.h.

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Private Member Functions

Additional Inherited Members