#include <MappingExtrapolate.h>

Inheritance diagram for Nektar::MappingExtrapolate:

Static Public Member Functions
static ExtrapolateSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, MultiRegions::ExpListSharedPtr &pPressure, const Array< OneD, int > &pVel, const SolverUtils::AdvectionSharedPtr &advObject)
	Creates an instance of this class.

Static Public Member Functions inherited from Nektar::StandardExtrapolate
static ExtrapolateSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, MultiRegions::ExpListSharedPtr &pPressure, const Array< OneD, int > &pVel, const SolverUtils::AdvectionSharedPtr &advObject)
	Creates an instance of this class.

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

Static Public Attributes inherited from Nektar::StandardExtrapolate
static std::string	className
	Name of class.

Protected Member Functions
	MappingExtrapolate (const LibUtilities::SessionReaderSharedPtr pSession, Array< OneD, MultiRegions::ExpListSharedPtr > pFields, MultiRegions::ExpListSharedPtr pPressure, const Array< OneD, int > pVel, const SolverUtils::AdvectionSharedPtr advObject)

	~MappingExtrapolate () override=default

void	v_CorrectPressureBCs (const Array< OneD, NekDouble > &pressure) override

void	v_CalcNeumannPressureBCs (const Array< OneD, const Array< OneD, NekDouble > > &fields, const Array< OneD, const Array< OneD, NekDouble > > &N, NekDouble kinvis) override

Protected Member Functions inherited from Nektar::StandardExtrapolate
	StandardExtrapolate (const LibUtilities::SessionReaderSharedPtr pSession, Array< OneD, MultiRegions::ExpListSharedPtr > pFields, MultiRegions::ExpListSharedPtr pPressure, const Array< OneD, int > pVel, const SolverUtils::AdvectionSharedPtr advObject)

	~StandardExtrapolate () override=default

void	v_EvaluatePressureBCs (const Array< OneD, const Array< OneD, NekDouble > > &fields, const Array< OneD, const Array< OneD, NekDouble > > &N, NekDouble kinvis) override

void	v_SubSteppingTimeIntegration (const LibUtilities::TimeIntegrationSchemeSharedPtr &IntegrationScheme) override

void	v_SubStepSaveFields (int nstep) override

void	v_SubStepSetPressureBCs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, NekDouble Aii_DT, NekDouble kinvis) override

void	v_SubStepAdvance (int nstep, NekDouble time) override

void	v_MountHOPBCs (int HBCdata, NekDouble kinvis, Array< OneD, NekDouble > &Q, Array< OneD, const NekDouble > &Advection) override

void	v_AccelerationBDF (Array< OneD, Array< OneD, NekDouble > > &array) override

Protected Member Functions inherited from Nektar::Extrapolate
virtual std::string	v_GetSubStepName (void)

virtual void	v_AddNormVelOnOBC (const int nbcoeffs, const int nreg, Array< OneD, Array< OneD, NekDouble > > &u)

void	CalcOutflowBCs (const Array< OneD, const Array< OneD, NekDouble > > &fields, NekDouble kinvis)

void	RollOver (Array< OneD, Array< OneD, NekDouble > > &input)

Protected Attributes
GlobalMapping::MappingSharedPtr	m_mapping

Array< OneD, NekDouble >	m_bcCorrection

bool	m_implicitPressure

bool	m_implicitViscous

NekDouble	m_pressureRelaxation

Protected Attributes inherited from Nektar::Extrapolate
LibUtilities::SessionReaderSharedPtr	m_session

LibUtilities::CommSharedPtr	m_comm

Array< OneD, HBCType >	m_hbcType
	Array of type of high order BCs for splitting shemes.

Array< OneD, MultiRegions::ExpListSharedPtr >	m_fields
	Velocity fields.

MultiRegions::ExpListSharedPtr	m_pressure
	Pointer to field holding pressure field.

Array< OneD, int >	m_velocity
	int which identifies which components of m_fields contains the velocity (u,v,w);

SolverUtils::AdvectionSharedPtr	m_advObject

std::vector< SolverUtils::ForcingSharedPtr >	m_forcing

Array< OneD, Array< OneD, NekDouble > >	m_previousVelFields

int	m_curl_dim
	Curl-curl dimensionality.

int	m_bnd_dim
	bounday dimensionality

Array< OneD, const SpatialDomains::BoundaryConditionShPtr >	m_PBndConds
	pressure boundary conditions container

Array< OneD, MultiRegions::ExpListSharedPtr >	m_PBndExp
	pressure boundary conditions expansion container

Array< OneD, MultiRegions::ExpListSharedPtr >	m_bndElmtExps
	Boundary expansions on each domain boundary.

int	m_pressureCalls
	number of times the high-order pressure BCs have been called

int	m_numHBCDof

int	m_HBCnumber

int	m_intSteps
	Maximum points used in pressure BC evaluation.

NekDouble	m_timestep

Array< OneD, Array< OneD, NekDouble > >	m_pressureHBCs
	Storage for current and previous levels of high order pressure boundary conditions.

Array< OneD, Array< OneD, NekDouble > >	m_iprodnormvel
	Storage for current and previous levels of the inner product of normal velocity.

Array< OneD, Array< OneD, NekDouble > >	m_traceNormals

HighOrderOutflowSharedPtr	m_houtflow

Friends
class	MemoryManager< MappingExtrapolate >

Additional Inherited Members
Public Member Functions inherited from Nektar::Extrapolate
	Extrapolate (const LibUtilities::SessionReaderSharedPtr pSession, Array< OneD, MultiRegions::ExpListSharedPtr > pFields, MultiRegions::ExpListSharedPtr pPressure, const Array< OneD, int > pVel, const SolverUtils::AdvectionSharedPtr advObject)

virtual	~Extrapolate ()=default

void	SubSteppingTimeIntegration (const LibUtilities::TimeIntegrationSchemeSharedPtr &IntegrationScheme)

void	SubStepSaveFields (const int nstep)

void	SubStepSetPressureBCs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, const NekDouble Aii_DT, NekDouble kinvis)

void	SubStepAdvance (const int nstep, NekDouble time)

void	MountHOPBCs (int HBCdata, NekDouble kinvis, Array< OneD, NekDouble > &Q, Array< OneD, const NekDouble > &Advection)

void	EvaluatePressureBCs (const Array< OneD, const Array< OneD, NekDouble > > &fields, const Array< OneD, const Array< OneD, NekDouble > > &N, NekDouble kinvis)

void	AddNormVelOnOBC (const int nbcoeffs, const int nreg, Array< OneD, Array< OneD, NekDouble > > &u)

void	CorrectPressureBCs (const Array< OneD, NekDouble > &pressure)

void	CalcNeumannPressureBCs (const Array< OneD, const Array< OneD, NekDouble > > &fields, const Array< OneD, const Array< OneD, NekDouble > > &N, NekDouble kinvis)

std::string	GetSubStepName (void)

void	SetForcing (const std::vector< SolverUtils::ForcingSharedPtr > &forcing)

void	GenerateHOPBCMap (const LibUtilities::SessionReaderSharedPtr &pSsession)

void	UpdateRobinPrimCoeff (void)

void	AddDuDt (void)

void	AddVelBC (void)

void	ExtrapolatePressureHBCs (void)

void	CopyPressureHBCsToPbndExp (void)

Array< OneD, NekDouble >	GetMaxStdVelocity (const Array< OneD, Array< OneD, NekDouble > > inarray)

void	IProductNormVelocityOnHBC (const Array< OneD, const Array< OneD, NekDouble > > &Vel, Array< OneD, NekDouble > &IprodVn)

void	IProductNormVelocityBCOnHBC (Array< OneD, NekDouble > &IprodVn)

void	ExtrapolateArray (Array< OneD, Array< OneD, NekDouble > > &array)

void	EvaluateBDFArray (Array< OneD, Array< OneD, NekDouble > > &array)

void	ExtrapolateArray (Array< OneD, Array< OneD, NekDouble > > &oldarrays, Array< OneD, NekDouble > &newarray, Array< OneD, NekDouble > &outarray)

void	AddPressureToOutflowBCs (NekDouble kinvis)

void	GenerateBndElmtExpansion (void)

Static Protected Attributes inherited from Nektar::StandardExtrapolate
static NekDouble	DuDt_Coeffs [3][4]

Static Protected Attributes inherited from Nektar::Extrapolate
static NekDouble	StifflyStable_Betaq_Coeffs [3][3]

static NekDouble	StifflyStable_Alpha_Coeffs [3][3]

static NekDouble	StifflyStable_Gamma0_Coeffs [3] = {1.0, 1.5, 11.0 / 6.0}

Detailed Description

Definition at line 51 of file MappingExtrapolate.h.

Constructor & Destructor Documentation

◆ MappingExtrapolate()

Nektar::MappingExtrapolate::MappingExtrapolate	(	const LibUtilities::SessionReaderSharedPtr	pSession,
		Array< OneD, MultiRegions::ExpListSharedPtr >	pFields,
		MultiRegions::ExpListSharedPtr	pPressure,
		const Array< OneD, int >	pVel,
		const SolverUtils::AdvectionSharedPtr	advObject
	)

protected

Definition at line 46 of file MappingExtrapolate.cpp.

    : StandardExtrapolate(pSession, pFields, pPressure, pVel, advObject)
{
    m_mapping = GlobalMapping::Mapping::Load(m_session, m_fields);
 
    // Load solve parameters related to the mapping
    // Flags determining if pressure/viscous terms should be treated implicitly
    m_session->MatchSolverInfo("MappingImplicitPressure", "True",
                               m_implicitPressure, false);
    m_session->MatchSolverInfo("MappingImplicitViscous", "True",
                               m_implicitViscous, false);
 
    // Relaxation parameter for pressure system
    m_session->LoadParameter("MappingPressureRelaxation", m_pressureRelaxation,
                             1.0);
}

References Nektar::GlobalMapping::Mapping::Load(), Nektar::Extrapolate::m_fields, m_implicitPressure, m_implicitViscous, m_mapping, m_pressureRelaxation, and Nektar::Extrapolate::m_session.

◆ ~MappingExtrapolate()

Nektar::MappingExtrapolate::~MappingExtrapolate ( )

overrideprotecteddefault

Member Function Documentation

◆ create()

static ExtrapolateSharedPtr Nektar::MappingExtrapolate::create	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		Array< OneD, MultiRegions::ExpListSharedPtr > &	pFields,
		MultiRegions::ExpListSharedPtr &	pPressure,
		const Array< OneD, int > &	pVel,
		const SolverUtils::AdvectionSharedPtr &	advObject
	)

inlinestatic

Creates an instance of this class.

Definition at line 57 of file MappingExtrapolate.h.

    {
        ExtrapolateSharedPtr p =
            MemoryManager<MappingExtrapolate>::AllocateSharedPtr(
                pSession, pFields, pPressure, pVel, advObject);
        return p;
    }

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

◆ v_CalcNeumannPressureBCs()

void Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs	(	const Array< OneD, const Array< OneD, NekDouble > > &	fields,
		const Array< OneD, const Array< OneD, NekDouble > > &	N,
		NekDouble	kinvis
	)

overrideprotectedvirtual

Unified routine for calculation high-oder terms

Reimplemented from Nektar::Extrapolate.

Definition at line 201 of file MappingExtrapolate.cpp.

{
    if (m_mapping->HasConstantJacobian() && !m_implicitViscous)
    {
        Extrapolate::v_CalcNeumannPressureBCs(fields, N, kinvis);
    }
    else
    {
        size_t physTot = m_fields[0]->GetTotPoints();
        size_t nvel    = m_fields.size() - 1;
        size_t i, n, cnt;
 
        Array<OneD, NekDouble> Pvals;
        Array<OneD, NekDouble> Uvals;
 
        Array<OneD, Array<OneD, NekDouble>> Velocity(m_bnd_dim);
        Array<OneD, Array<OneD, NekDouble>> Advection(m_bnd_dim);
        // Get transformation Jacobian
        Array<OneD, NekDouble> Jac(physTot, 0.0);
        m_mapping->GetJacobian(Jac);
        // Declare variables
        Array<OneD, Array<OneD, NekDouble>> BndValues(m_bnd_dim);
        Array<OneD, Array<OneD, NekDouble>> Q(m_bnd_dim);
        Array<OneD, Array<OneD, NekDouble>> Q_field(nvel);
        Array<OneD, Array<OneD, NekDouble>> fields_new(nvel);
        Array<OneD, Array<OneD, NekDouble>> N_new(m_bnd_dim);
        // Temporary variables
        Array<OneD, NekDouble> tmp(physTot, 0.0);
        Array<OneD, NekDouble> tmp2(physTot, 0.0);
        for (int i = 0; i < m_bnd_dim; i++)
        {
            N_new[i] = Array<OneD, NekDouble>(physTot, 0.0);
        }
        for (i = 0; i < nvel; i++)
        {
            Q_field[i]    = Array<OneD, NekDouble>(physTot, 0.0);
            fields_new[i] = Array<OneD, NekDouble>(physTot, 0.0);
        }
 
        // Multiply convective terms by Jacobian
        for (int i = 0; i < m_bnd_dim; i++)
        {
            if (m_fields[0]->GetWaveSpace())
            {
                m_fields[0]->HomogeneousBwdTrans(physTot, N[i], N_new[i]);
            }
            else
            {
                Vmath::Vcopy(physTot, N[i], 1, N_new[i], 1);
            }
            Vmath::Vmul(physTot, Jac, 1, N_new[i], 1, N_new[i], 1);
            if (m_fields[0]->GetWaveSpace())
            {
                m_fields[0]->HomogeneousFwdTrans(physTot, N_new[i], N_new[i]);
            }
        }
 
        // Get velocity in physical space
        for (i = 0; i < nvel; i++)
        {
            if (m_fields[0]->GetWaveSpace())
            {
                m_fields[0]->HomogeneousBwdTrans(physTot, fields[i],
                                                 fields_new[i]);
            }
            else
            {
                Vmath::Vcopy(physTot, fields[i], 1, fields_new[i], 1);
            }
        }
 
        // Calculate appropriate form of the CurlCurl operator
        m_mapping->CurlCurlField(fields_new, Q_field, m_implicitViscous);
 
        // If viscous terms are treated explicitly,
        //     add grad(U/J \dot grad J) to CurlCurl
        if (!m_implicitViscous)
        {
            m_mapping->DotGradJacobian(fields_new, tmp);
            Vmath::Vdiv(physTot, tmp, 1, Jac, 1, tmp, 1);
 
            bool wavespace = m_fields[0]->GetWaveSpace();
            m_fields[0]->SetWaveSpace(false);
            for (int i = 0; i < m_bnd_dim; i++)
            {
                m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[i], tmp,
                                       tmp2);
                Vmath::Vadd(physTot, Q_field[i], 1, tmp2, 1, Q_field[i], 1);
            }
            m_fields[0]->SetWaveSpace(wavespace);
        }
 
        // Multiply by Jacobian and convert to wavespace (if necessary)
        for (int i = 0; i < m_bnd_dim; i++)
        {
            Vmath::Vmul(physTot, Jac, 1, fields_new[i], 1, fields_new[i], 1);
            Vmath::Vmul(physTot, Jac, 1, Q_field[i], 1, Q_field[i], 1);
            if (m_fields[0]->GetWaveSpace())
            {
                m_fields[0]->HomogeneousFwdTrans(physTot, fields_new[i],
                                                 fields_new[i]);
                m_fields[0]->HomogeneousFwdTrans(physTot, Q_field[i],
                                                 Q_field[i]);
            }
        }
 
        MultiRegions::ExpListSharedPtr BndElmtExp;
        for (n = cnt = 0; n < m_PBndConds.size(); ++n)
        {
            // High order boundary condition;
            if (boost::iequals(m_PBndConds[n]->GetUserDefined(), "H"))
            {
                m_fields[0]->GetBndElmtExpansion(n, BndElmtExp);
                size_t nq = BndElmtExp->GetTotPoints();
 
                // Obtaining fields on BndElmtExp
                for (int i = 0; i < m_bnd_dim; i++)
                {
                    m_fields[0]->ExtractPhysToBndElmt(n, fields_new[i],
                                                      Velocity[i]);
                    m_fields[0]->ExtractPhysToBndElmt(n, N_new[i],
                                                      Advection[i]);
                    m_fields[0]->ExtractPhysToBndElmt(n, Q_field[i], Q[i]);
                }
 
                // Mounting advection component into the high-order condition
                for (int i = 0; i < m_bnd_dim; i++)
                {
                    MountHOPBCs(nq, kinvis, Q[i], Advection[i]);
                }
 
                Pvals = (m_pressureHBCs[m_intSteps - 1]) + cnt;
                Uvals = (m_iprodnormvel[m_intSteps]) + cnt;
 
                // Getting values on the edge and filling the pressure boundary
                // expansion and the acceleration term. Multiplication by the
                // normal is required
                for (int i = 0; i < m_bnd_dim; i++)
                {
                    m_fields[0]->ExtractElmtToBndPhys(n, Q[i], BndValues[i]);
                }
                m_PBndExp[n]->NormVectorIProductWRTBase(BndValues, Pvals);
 
                for (int i = 0; i < m_bnd_dim; i++)
                {
                    m_fields[0]->ExtractElmtToBndPhys(n, Velocity[i],
                                                      BndValues[i]);
                }
                m_PBndExp[n]->NormVectorIProductWRTBase(BndValues, Uvals);
 
                // Get offset for next terms
                cnt += m_PBndExp[n]->GetNcoeffs();
            }
        }
    }
    // If pressure terms are treated implicitly, we need to multiply
    //     by the relaxation parameter, and zero the correction term
    if (m_implicitPressure)
    {
        Vmath::Smul(m_numHBCDof, m_pressureRelaxation,
                    m_pressureHBCs[m_intSteps - 1], 1,
                    m_pressureHBCs[m_intSteps - 1], 1);
    }
    m_bcCorrection = Array<OneD, NekDouble>(m_numHBCDof, 0.0);
}

◆ v_CorrectPressureBCs()

void Nektar::MappingExtrapolate::v_CorrectPressureBCs ( const Array< OneD, NekDouble > & pressure )

overrideprotectedvirtual

Reimplemented from Nektar::Extrapolate.

Definition at line 70 of file MappingExtrapolate.cpp.

{
    if (m_HBCnumber > 0)
    {
        size_t cnt, n;
        size_t physTot = m_fields[0]->GetTotPoints();
        size_t nvel    = m_fields.size() - 1;
 
        Array<OneD, NekDouble> Vals;
        // Remove previous correction
        for (cnt = n = 0; n < m_PBndConds.size(); ++n)
        {
            if (m_PBndConds[n]->GetUserDefined() == "H")
            {
                size_t nq = m_PBndExp[n]->GetNcoeffs();
                Vmath::Vsub(nq, &(m_PBndExp[n]->GetCoeffs()[0]), 1,
                            &(m_bcCorrection[cnt]), 1,
                            &(m_PBndExp[n]->UpdateCoeffs()[0]), 1);
                cnt += nq;
            }
        }
 
        // Calculate new correction
        Array<OneD, NekDouble> Jac(physTot, 0.0);
        m_mapping->GetJacobian(Jac);
 
        Array<OneD, Array<OneD, NekDouble>> correction(nvel);
        Array<OneD, Array<OneD, NekDouble>> gradP(nvel);
        Array<OneD, Array<OneD, NekDouble>> wk(nvel);
        Array<OneD, Array<OneD, NekDouble>> wk2(nvel);
        for (size_t i = 0; i < nvel; i++)
        {
            wk[i]         = Array<OneD, NekDouble>(physTot, 0.0);
            gradP[i]      = Array<OneD, NekDouble>(physTot, 0.0);
            correction[i] = Array<OneD, NekDouble>(physTot, 0.0);
        }
 
        // Calculate G(p)
        for (size_t i = 0; i < nvel; ++i)
        {
            m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[i], pressure,
                                   gradP[i]);
            if (m_fields[0]->GetWaveSpace())
            {
                m_fields[0]->HomogeneousBwdTrans(physTot, gradP[i], wk[i]);
            }
            else
            {
                Vmath::Vcopy(physTot, gradP[i], 1, wk[i], 1);
            }
        }
        m_mapping->RaiseIndex(wk, correction); // G(p)
 
        // alpha*J*(G(p))
        if (!m_mapping->HasConstantJacobian())
        {
            for (size_t i = 0; i < nvel; ++i)
            {
                Vmath::Vmul(physTot, correction[i], 1, Jac, 1, correction[i],
                            1);
            }
        }
        for (size_t i = 0; i < nvel; ++i)
        {
            Vmath::Smul(physTot, m_pressureRelaxation, correction[i], 1,
                        correction[i], 1);
        }
 
        if (m_pressure->GetWaveSpace())
        {
            for (size_t i = 0; i < nvel; ++i)
            {
                m_pressure->HomogeneousFwdTrans(physTot, correction[i],
                                                correction[i]);
            }
        }
        // p_i - alpha*J*div(G(p))
        for (size_t i = 0; i < nvel; ++i)
        {
            Vmath::Vsub(physTot, gradP[i], 1, correction[i], 1, correction[i],
                        1);
        }
 
        // Get value at boundary and calculate Inner product
        Array<OneD, Array<OneD, NekDouble>> correctionElmt(m_bnd_dim);
        Array<OneD, Array<OneD, NekDouble>> BndValues(m_bnd_dim);
        MultiRegions::ExpListSharedPtr BndElmtExp;
        for (n = cnt = 0; n < m_PBndConds.size(); ++n)
        {
            // High order boundary condition;
            if (boost::iequals(m_PBndConds[n]->GetUserDefined(), "H"))
            {
                m_fields[0]->GetBndElmtExpansion(n, BndElmtExp);
 
                // Obtaining fields on BndElmtExp
                for (int i = 0; i < m_bnd_dim; i++)
                {
                    m_fields[0]->ExtractPhysToBndElmt(n, correction[i],
                                                      correctionElmt[i]);
                }
 
                Vals = m_bcCorrection + cnt;
                // Getting values on the edge and filling the correction
                for (int i = 0; i < m_bnd_dim; i++)
                {
                    m_fields[0]->ExtractElmtToBndPhys(n, correctionElmt[i],
                                                      BndValues[i]);
                }
                m_PBndExp[n]->NormVectorIProductWRTBase(BndValues, Vals);
 
                // Get offset for next terms
                cnt += m_PBndExp[n]->GetNcoeffs();
            }
        }
 
        // Apply new correction
        for (size_t cnt = n = 0; n < m_PBndConds.size(); ++n)
        {
            if (m_PBndConds[n]->GetUserDefined() == "H")
            {
                size_t nq = m_PBndExp[n]->GetNcoeffs();
                Vmath::Vadd(nq, &(m_PBndExp[n]->GetCoeffs()[0]), 1,
                            &(m_bcCorrection[cnt]), 1,
                            &(m_PBndExp[n]->UpdateCoeffs()[0]), 1);
                cnt += nq;
            }
        }
    }
}

References Nektar::MultiRegions::DirCartesianMap, m_bcCorrection, Nektar::Extrapolate::m_bnd_dim, Nektar::Extrapolate::m_fields, Nektar::Extrapolate::m_HBCnumber, m_mapping, Nektar::Extrapolate::m_PBndConds, Nektar::Extrapolate::m_PBndExp, Nektar::Extrapolate::m_pressure, m_pressureRelaxation, Vmath::Smul(), Vmath::Vadd(), Vmath::Vcopy(), Vmath::Vmul(), and Vmath::Vsub().

Friends And Related Symbol Documentation

◆ MemoryManager< MappingExtrapolate >

friend class MemoryManager< MappingExtrapolate >

friend

Definition at line 49 of file MappingExtrapolate.h.

Member Data Documentation

◆ className

std::string Nektar::MappingExtrapolate::className

static

Initial value:

=
    GetExtrapolateFactory().RegisterCreatorFunction(
        "Mapping", MappingExtrapolate::create, "Mapping")

Name of class.

Registers the class with the Factory.

Definition at line 70 of file MappingExtrapolate.h.

◆ m_bcCorrection

Array<OneD, NekDouble> Nektar::MappingExtrapolate::m_bcCorrection

protected

Definition at line 76 of file MappingExtrapolate.h.

Referenced by v_CalcNeumannPressureBCs(), and v_CorrectPressureBCs().

◆ m_implicitPressure

bool Nektar::MappingExtrapolate::m_implicitPressure

protected

Definition at line 80 of file MappingExtrapolate.h.

Referenced by MappingExtrapolate(), and v_CalcNeumannPressureBCs().

◆ m_implicitViscous

bool Nektar::MappingExtrapolate::m_implicitViscous

protected

Definition at line 81 of file MappingExtrapolate.h.

Referenced by MappingExtrapolate(), and v_CalcNeumannPressureBCs().

◆ m_mapping

GlobalMapping::MappingSharedPtr Nektar::MappingExtrapolate::m_mapping

protected

Definition at line 74 of file MappingExtrapolate.h.

Referenced by MappingExtrapolate(), v_CalcNeumannPressureBCs(), and v_CorrectPressureBCs().

◆ m_pressureRelaxation

NekDouble Nektar::MappingExtrapolate::m_pressureRelaxation

protected

Definition at line 84 of file MappingExtrapolate.h.

Referenced by MappingExtrapolate(), v_CalcNeumannPressureBCs(), and v_CorrectPressureBCs().

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ MappingExtrapolate()

◆ ~MappingExtrapolate()

Member Function Documentation

◆ create()

◆ v_CalcNeumannPressureBCs()

◆ v_CorrectPressureBCs()

Friends And Related Symbol Documentation

◆ MemoryManager< MappingExtrapolate >

Member Data Documentation

◆ className

◆ m_bcCorrection

◆ m_implicitPressure

◆ m_implicitViscous

◆ m_mapping

◆ m_pressureRelaxation