#include <MappingExtrapolate.h>

Inheritance diagram for Nektar::MappingExtrapolate:

Public Member Functions
virtual void	v_CorrectPressureBCs (const Array< OneD, NekDouble > &pressure)

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

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

virtual	~MappingExtrapolate ()

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

virtual	~StandardExtrapolate ()

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

void	GenerateHOPBCMap (const LibUtilities::SessionReaderSharedPtr &pSsession)

void	UpdateRobinPrimCoeff (void)

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	SetForcing (const std::vector< SolverUtils::ForcingSharedPtr > &forcing)

void	AddDuDt (void)

void	AddVelBC (void)

void	ExtrapolatePressureHBCs (void)

void	CopyPressureHBCsToPbndExp (void)

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

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

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

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

std::string	GetSubStepName (void)

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	AddNormVelOnOBC (const int nbcoeffs, const int nreg, Array< OneD, Array< OneD, NekDouble >> &u)

void	AddPressureToOutflowBCs (NekDouble kinvis)

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

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

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

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

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

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

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

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

SolverUtils::AdvectionSharedPtr	m_advObject

std::vector< SolverUtils::ForcingSharedPtr >	m_forcing

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

int	m_curl_dim
	Curl-curl dimensionality. More...

int	m_bnd_dim
	bounday dimensionality More...

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

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

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

int	m_numHBCDof

int	m_HBCnumber

int	m_intSteps
	Maximum points used in pressure BC evaluation. More...

NekDouble	m_timestep

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

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

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

HighOrderOutflowSharedPtr	m_houtflow

Additional Inherited Members
Protected Member Functions inherited from Nektar::StandardExtrapolate
virtual void	v_EvaluatePressureBCs (const Array< OneD, const Array< OneD, NekDouble >> &fields, const Array< OneD, const Array< OneD, NekDouble >> &N, NekDouble kinvis) override

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

virtual void	v_SubStepSaveFields (int nstep) override

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

virtual void	v_SubStepAdvance (int nstep, NekDouble time) override

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

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

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

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

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)

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
	)

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

virtual

Definition at line 68 of file MappingExtrapolate.cpp.

69 {

70 }

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 55 of file MappingExtrapolate.h.

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

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and CellMLToNektar.cellml_metadata::p.

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

virtual

Unified routine for calculation high-oder terms

Reimplemented from Nektar::Extrapolate.

Definition at line 206 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 )

virtual

Reimplemented from Nektar::Extrapolate.

Definition at line 75 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, CG_Iterations::pressure, Vmath::Smul(), Vmath::Vadd(), Vmath::Vcopy(), Vmath::Vmul(), and Vmath::Vsub().

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 68 of file MappingExtrapolate.h.

◆ m_bcCorrection

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

protected

Definition at line 88 of file MappingExtrapolate.h.

Referenced by v_CalcNeumannPressureBCs(), and v_CorrectPressureBCs().

◆ m_implicitPressure

bool Nektar::MappingExtrapolate::m_implicitPressure

protected

Definition at line 92 of file MappingExtrapolate.h.

Referenced by MappingExtrapolate(), and v_CalcNeumannPressureBCs().

◆ m_implicitViscous

bool Nektar::MappingExtrapolate::m_implicitViscous

protected

Definition at line 93 of file MappingExtrapolate.h.

Referenced by MappingExtrapolate(), and v_CalcNeumannPressureBCs().

◆ m_mapping

GlobalMapping::MappingSharedPtr Nektar::MappingExtrapolate::m_mapping

protected

Definition at line 86 of file MappingExtrapolate.h.

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

◆ m_pressureRelaxation

NekDouble Nektar::MappingExtrapolate::m_pressureRelaxation

protected

Definition at line 96 of file MappingExtrapolate.h.

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

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ MappingExtrapolate()

◆ ~MappingExtrapolate()

Member Function Documentation

◆ create()

◆ v_CalcNeumannPressureBCs()

◆ v_CorrectPressureBCs()

Member Data Documentation

◆ className

◆ m_bcCorrection

◆ m_implicitPressure

◆ m_implicitViscous

◆ m_mapping

◆ m_pressureRelaxation