#include <Extrapolate.h>

Inheritance diagram for Nektar::Extrapolate:

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

Protected Member Functions
virtual void	v_EvaluatePressureBCs (const Array< OneD, const Array< OneD, NekDouble >> &inarray, const Array< OneD, const Array< OneD, NekDouble >> &N, NekDouble kinvis)=0

virtual void	v_SubSteppingTimeIntegration (const LibUtilities::TimeIntegrationSchemeSharedPtr &IntegrationScheme)=0

virtual void	v_SubStepSaveFields (int nstep)=0

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

virtual void	v_SubStepAdvance (int nstep, NekDouble time)=0

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

virtual std::string	v_GetSubStepName (void)

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

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

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

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

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

Static Protected Attributes
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}

Static Private Attributes
static std::string	def

Detailed Description

Definition at line 73 of file Extrapolate.h.

Constructor & Destructor Documentation

◆ Extrapolate()

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

Definition at line 54 of file Extrapolate.cpp.

     : m_session(pSession), m_fields(pFields), m_pressure(pPressure),
       m_velocity(pVel), m_advObject(advObject)
 {
     m_session->LoadParameter("TimeStep", m_timestep, 0.01);
     m_comm = m_session->GetComm();
 }

References m_comm, m_session, and m_timestep.

◆ ~Extrapolate()

Nektar::Extrapolate::~Extrapolate ( )

virtual

Definition at line 66 of file Extrapolate.cpp.

67 {

68 }

Member Function Documentation

◆ AddDuDt()

void Nektar::Extrapolate::AddDuDt ( void )

Definition at line 77 of file Extrapolate.cpp.

 {
     if (m_numHBCDof)
     {
         // Update velocity BF at n+1 (actually only needs doing if
         // velocity is time dependent on HBCs)
         IProductNormVelocityBCOnHBC(m_iprodnormvel[m_intSteps]);
  
         // Calculate acceleration term at level n based on previous steps
         v_AccelerationBDF(m_iprodnormvel);
  
         // Subtract acceleration term off m_pressureHBCs[nlevels-1]
         Vmath::Svtvp(m_numHBCDof, -1.0 / m_timestep, m_iprodnormvel[m_intSteps],
                      1, m_pressureHBCs[m_intSteps - 1], 1,
                      m_pressureHBCs[m_intSteps - 1], 1);
     }
 }

References IProductNormVelocityBCOnHBC(), m_intSteps, m_iprodnormvel, m_numHBCDof, m_pressureHBCs, m_timestep, Vmath::Svtvp(), and v_AccelerationBDF().

Referenced by Nektar::StandardExtrapolate::v_EvaluatePressureBCs(), and Nektar::SubSteppingExtrapolate::v_SubStepSetPressureBCs().

◆ AddNormVelOnOBC()

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

inline

Definition at line 404 of file Extrapolate.h.

 {
     v_AddNormVelOnOBC(nbcoeffs, nreg, u);
 }

References v_AddNormVelOnOBC().

Referenced by CalcOutflowBCs().

◆ AddPressureToOutflowBCs()

void Nektar::Extrapolate::AddPressureToOutflowBCs ( NekDouble kinvis )

Definition at line 463 of file Extrapolate.cpp.

 {
     if (!m_houtflow.get())
     {
         return;
     }
  
     for (size_t n = 0; n < m_PBndConds.size(); ++n)
     {
         if (m_hbcType[n] == eConvectiveOBC)
         {
             int nqb = m_PBndExp[n]->GetTotPoints();
             int ncb = m_PBndExp[n]->GetNcoeffs();
  
             m_pressure->FillBndCondFromField(n, m_pressure->GetCoeffs());
             Array<OneD, NekDouble> pbc(nqb);
  
             m_PBndExp[n]->BwdTrans(m_PBndExp[n]->GetCoeffs(), pbc);
  
             if (m_PBndExp[n]->GetWaveSpace())
             {
                 m_PBndExp[n]->HomogeneousBwdTrans(nqb, pbc, pbc);
             }
  
             Array<OneD, NekDouble> wk(nqb);
             Array<OneD, NekDouble> wk1(ncb);
  
             // Get normal vector
             Array<OneD, Array<OneD, NekDouble>> normals;
             m_fields[0]->GetBoundaryNormals(n, normals);
  
             //  Add  1/kinvis * (pbc n )
             for (int i = 0; i < m_curl_dim; ++i)
             {
                 Vmath::Vmul(nqb, normals[i], 1, pbc, 1, wk, 1);
  
                 Vmath::Smul(nqb, 1.0 / kinvis, wk, 1, wk, 1);
  
                 if (m_houtflow->m_UBndExp[i][n]->GetWaveSpace())
                 {
                     m_houtflow->m_UBndExp[i][n]->HomogeneousFwdTrans(nqb, wk,
                                                                      wk);
                 }
                 m_houtflow->m_UBndExp[i][n]->IProductWRTBase(wk, wk1);
  
                 Vmath::Vadd(ncb, wk1, 1,
                             m_houtflow->m_UBndExp[i][n]->GetCoeffs(), 1,
                             m_houtflow->m_UBndExp[i][n]->UpdateCoeffs(), 1);
             }
         }
     }
 }

References Nektar::eConvectiveOBC, m_curl_dim, m_fields, m_hbcType, m_houtflow, m_PBndConds, m_PBndExp, m_pressure, Vmath::Smul(), Vmath::Vadd(), and Vmath::Vmul().

◆ AddVelBC()

void Nektar::Extrapolate::AddVelBC ( void )

Definition at line 98 of file Extrapolate.cpp.

 {
     if (m_numHBCDof)
     {
         int order = std::min(m_pressureCalls, m_intSteps);
  
         // Update velocity BF at n+1 (actually only needs doing if
         // velocity is time dependent on HBCs)
         IProductNormVelocityBCOnHBC(m_iprodnormvel[0]);
  
         // Subtract acceleration term off m_pressureHBCs[nlevels-1]
         Vmath::Svtvp(m_numHBCDof,
                      -1.0 * StifflyStable_Gamma0_Coeffs[order - 1] / m_timestep,
                      m_iprodnormvel[0], 1, m_pressureHBCs[m_intSteps - 1], 1,
                      m_pressureHBCs[m_intSteps - 1], 1);
     }
 }

References IProductNormVelocityBCOnHBC(), m_intSteps, m_iprodnormvel, m_numHBCDof, m_pressureCalls, m_pressureHBCs, m_timestep, StifflyStable_Gamma0_Coeffs, and Vmath::Svtvp().

Referenced by Nektar::WeakPressureExtrapolate::v_EvaluatePressureBCs(), and Nektar::SubSteppingExtrapolateWeakPressure::v_SubStepSetPressureBCs().

◆ CalcNeumannPressureBCs()

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

inlineprotected

Definition at line 170 of file Extrapolate.h.

     {
         v_CalcNeumannPressureBCs(fields, N, kinvis);
     }

References v_CalcNeumannPressureBCs().

Referenced by Nektar::StandardExtrapolate::v_EvaluatePressureBCs(), Nektar::WeakPressureExtrapolate::v_EvaluatePressureBCs(), Nektar::SubSteppingExtrapolate::v_SubStepSetPressureBCs(), and Nektar::SubSteppingExtrapolateWeakPressure::v_SubStepSetPressureBCs().

◆ CalcOutflowBCs()

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

protected

Definition at line 206 of file Extrapolate.cpp.

 {
     if (!m_houtflow.get())
     {
         return;
     }
  
     Array<OneD, Array<OneD, NekDouble>> Velocity(m_curl_dim);
  
     MultiRegions::ExpListSharedPtr BndElmtExp;
     size_t cnt = 0;
  
     // Evaluate robin primitive coefficient here so they can be
     // updated whem m_int > 1 Currently not using this update
     // since we only using u^n at outflow instead of BDF rule.
     UpdateRobinPrimCoeff();
  
     for (size_t n = 0; n < m_PBndConds.size(); ++n)
     {
         if ((m_hbcType[n] == eOBC) || (m_hbcType[n] == eConvectiveOBC))
         {
             // Get expansion with element on this boundary
             m_fields[0]->GetBndElmtExpansion(n, BndElmtExp, false);
             int nqb = m_PBndExp[n]->GetTotPoints();
             int nq  = BndElmtExp->GetTotPoints();
  
             // Get velocity and extrapolate
             for (int i = 0; i < m_curl_dim; i++)
             {
                 m_fields[0]->ExtractPhysToBndElmt(
                     n, fields[i],
                     m_houtflow->m_outflowVel[cnt][i][m_intSteps - 1]);
                 ExtrapolateArray(m_houtflow->m_outflowVel[cnt][i]);
                 Velocity[i] = m_houtflow->m_outflowVel[cnt][i][m_intSteps - 1];
             }
  
             // Homogeneous case needs conversion to physical space
             if (m_fields[0]->GetWaveSpace())
             {
                 for (int i = 0; i < m_curl_dim; i++)
                 {
                     BndElmtExp->HomogeneousBwdTrans(Velocity[i].size(),
                                                     Velocity[i], Velocity[i]);
                 }
                 BndElmtExp->SetWaveSpace(false);
             }
  
             // Get normal vector
             Array<OneD, Array<OneD, NekDouble>> normals;
             m_fields[0]->GetBoundaryNormals(n, normals);
  
             // Calculate n.gradU.n, div(U)
             Array<OneD, NekDouble> nGradUn(nqb, 0.0);
             Array<OneD, NekDouble> divU(nqb, 0.0);
             Array<OneD, Array<OneD, NekDouble>> grad(m_curl_dim);
             Array<OneD, NekDouble> bndVal(nqb, 0.0);
             for (int i = 0; i < m_curl_dim; i++)
             {
                 grad[i] = Array<OneD, NekDouble>(nq, 0.0);
             }
             for (int i = 0; i < m_curl_dim; i++)
             {
                 if (m_curl_dim == 2)
                 {
                     BndElmtExp->PhysDeriv(Velocity[i], grad[0], grad[1]);
                 }
                 else
                 {
                     BndElmtExp->PhysDeriv(Velocity[i], grad[0], grad[1],
                                           grad[2]);
                 }
  
                 for (int j = 0; j < m_curl_dim; j++)
                 {
                     m_fields[0]->ExtractElmtToBndPhys(n, grad[j], bndVal);
                     // div(U) = gradU_ii
                     if (i == j)
                     {
                         Vmath::Vadd(nqb, divU, 1, bndVal, 1, divU, 1);
                     }
                     // n.gradU.n = gradU_ij n_i n_j
                     Vmath::Vmul(nqb, normals[i], 1, bndVal, 1, bndVal, 1);
                     Vmath::Vvtvp(nqb, normals[j], 1, bndVal, 1, nGradUn, 1,
                                  nGradUn, 1);
                 }
             }
  
             // Obtain u at the boundary
             Array<OneD, Array<OneD, NekDouble>> u(m_curl_dim);
             for (int i = 0; i < m_curl_dim; i++)
             {
                 u[i] = Array<OneD, NekDouble>(nqb, 0.0);
                 m_fields[0]->ExtractElmtToBndPhys(n, Velocity[i], u[i]);
             }
  
             // Calculate u.n and u^2
             Array<OneD, NekDouble> un(nqb, 0.0);
             Array<OneD, NekDouble> u2(nqb, 0.0);
             for (int i = 0; i < m_curl_dim; i++)
             {
                 Vmath::Vvtvp(nqb, normals[i], 1, u[i], 1, un, 1, un, 1);
                 Vmath::Vvtvp(nqb, u[i], 1, u[i], 1, u2, 1, u2, 1);
             }
  
             // Calculate S_0(u.n) = 0.5*(1-tanh(u.n/*U0*delta))
             Array<OneD, NekDouble> S0(nqb, 0.0);
             for (int i = 0; i < nqb; i++)
             {
                 S0[i] = 0.5 * (1.0 - tanh(un[i] / (m_houtflow->m_U0 *
                                                    m_houtflow->m_delta)));
             }
  
             // Calculate E(n,u) = ((theta+alpha2)*0.5*(u^2)n +
             //                    (1-theta+alpha1)*0.5*(n.u)u ) * S_0(u.n)
             NekDouble k1 =
                 0.5 * (m_houtflow->m_obcTheta + m_houtflow->m_obcAlpha2);
             NekDouble k2 =
                 0.5 * (1 - m_houtflow->m_obcTheta + m_houtflow->m_obcAlpha1);
  
             Array<OneD, Array<OneD, NekDouble>> E(m_curl_dim);
             for (int i = 0; i < m_curl_dim; i++)
             {
                 E[i] = Array<OneD, NekDouble>(nqb, 0.0);
  
                 Vmath::Smul(nqb, k1, u2, 1, E[i], 1);
                 Vmath::Vmul(nqb, E[i], 1, normals[i], 1, E[i], 1);
                 // Use bndVal as a temporary storage
                 Vmath::Smul(nqb, k2, un, 1, bndVal, 1);
                 Vmath::Vvtvp(nqb, u[i], 1, bndVal, 1, E[i], 1, E[i], 1);
                 Vmath::Vmul(nqb, E[i], 1, S0, 1, E[i], 1);
             }
  
             // if non-zero forcing is provided we want to subtract
             // value if we want to interpret values as being the
             // desired pressure value. This is now precribed from
             // the velocity forcing to be consistent with the
             // paper except f_b = -f_b
  
             // Calculate (E(n,u) + f_b).n
             Array<OneD, NekDouble> En(nqb, 0.0);
             for (int i = 0; i < m_bnd_dim; i++)
             {
                 // Use bndVal as temporary
                 Vmath::Vsub(nqb, E[i], 1,
                             m_houtflow->m_UBndExp[i][n]->GetPhys(), 1, bndVal,
                             1);
  
                 Vmath::Vvtvp(nqb, normals[i], 1, bndVal, 1, En, 1, En, 1);
             }
  
             // Calculate pressure bc = kinvis*n.gradU.n - E.n + f_b.n
             Array<OneD, NekDouble> pbc(nqb, 0.0);
             Vmath::Svtvm(nqb, kinvis, nGradUn, 1, En, 1, pbc, 1);
  
             if (m_hbcType[n] == eOBC)
             {
  
                 if (m_PBndExp[n]->GetWaveSpace())
                 {
                     m_PBndExp[n]->HomogeneousFwdTrans(nqb, pbc, bndVal);
                     m_PBndExp[n]->FwdTrans(bndVal,
                                            m_PBndExp[n]->UpdateCoeffs());
                 }
                 else
                 {
                     m_PBndExp[n]->FwdTrans(pbc, m_PBndExp[n]->UpdateCoeffs());
                 }
             }
             else if (m_hbcType[n] == eConvectiveOBC) // add outflow values to
                                                      // calculation from HBC
             {
                 int nbcoeffs = m_PBndExp[n]->GetNcoeffs();
                 Array<OneD, NekDouble> bndCoeffs(nbcoeffs, 0.0);
                 if (m_PBndExp[n]->GetWaveSpace())
                 {
                     m_PBndExp[n]->HomogeneousFwdTrans(nqb, pbc, bndVal);
                     m_PBndExp[n]->IProductWRTBase(bndVal, bndCoeffs);
                 }
                 else
                 {
                     m_PBndExp[n]->IProductWRTBase(pbc, bndCoeffs);
                 }
                 // Note we have the negative of what is in the Dong paper in
                 // bndVal
                 Vmath::Svtvp(nbcoeffs, m_houtflow->m_pressurePrimCoeff[n],
                              bndCoeffs, 1, m_PBndExp[n]->UpdateCoeffs(), 1,
                              m_PBndExp[n]->UpdateCoeffs(), 1);
  
                 // evaluate u^n at outflow boundary for velocity BC
                 for (int i = 0; i < m_curl_dim; i++)
                 {
                     m_fields[0]->ExtractElmtToBndPhys(
                         n, m_houtflow->m_outflowVel[cnt][i][0],
                         m_houtflow->m_outflowVelBnd[cnt][i][m_intSteps - 1]);
  
                     EvaluateBDFArray(m_houtflow->m_outflowVelBnd[cnt][i]);
  
                     // point u[i] to BDF evalauted value \hat{u}
                     u[i] = m_houtflow->m_outflowVelBnd[cnt][i][m_intSteps - 1];
                 }
  
                 // Add normal velocity if weak pressure
                 // formulation. In this case there is an
                 // additional \int \hat{u}.n ds on the outflow
                 // boundary since we use the inner product wrt
                 // deriv of basis in pressure solve.
                 AddNormVelOnOBC(cnt, n, u);
             }
  
             // Calculate velocity boundary conditions
             if (m_hbcType[n] == eOBC)
             {
                 //    = (pbc n - kinvis divU n)
                 Vmath::Smul(nqb, kinvis, divU, 1, divU, 1);
                 Vmath::Vsub(nqb, pbc, 1, divU, 1, bndVal, 1);
             }
             else if (m_hbcType[n] == eConvectiveOBC)
             {
                 //    = (-kinvis divU n)
                 Vmath::Smul(nqb, -1.0 * kinvis, divU, 1, bndVal, 1);
  
                 // pbc  needs to be added after pressure solve
             }
  
             for (int i = 0; i < m_curl_dim; ++i)
             {
                 // Reuse divU  -> En
                 Vmath::Vvtvp(nqb, normals[i], 1, bndVal, 1, E[i], 1, divU, 1);
                 // - f_b
                 Vmath::Vsub(nqb, divU, 1,
                             m_houtflow->m_UBndExp[i][n]->GetPhys(), 1, divU, 1);
                 // * 1/kinvis
                 Vmath::Smul(nqb, 1.0 / kinvis, divU, 1, divU, 1);
  
                 if (m_hbcType[n] == eConvectiveOBC)
                 {
                     Vmath::Svtvp(nqb, m_houtflow->m_velocityPrimCoeff[i][n],
                                  u[i], 1, divU, 1, divU, 1);
                 }
  
                 if (m_houtflow->m_UBndExp[i][n]->GetWaveSpace())
                 {
                     m_houtflow->m_UBndExp[i][n]->HomogeneousFwdTrans(nqb, divU,
                                                                      divU);
                 }
  
                 m_houtflow->m_UBndExp[i][n]->IProductWRTBase(
                     divU, m_houtflow->m_UBndExp[i][n]->UpdateCoeffs());
             }
  
             // Get offset for next terms
             cnt++;
         }
     }
 }

References AddNormVelOnOBC(), Nektar::eConvectiveOBC, Nektar::eOBC, EvaluateBDFArray(), ExtrapolateArray(), m_bnd_dim, m_curl_dim, m_fields, m_hbcType, m_houtflow, m_intSteps, m_PBndConds, m_PBndExp, Vmath::Smul(), Vmath::Svtvm(), Vmath::Svtvp(), UpdateRobinPrimCoeff(), Vmath::Vadd(), Vmath::Vmul(), Vmath::Vsub(), and Vmath::Vvtvp().

Referenced by Nektar::StandardExtrapolate::v_EvaluatePressureBCs(), Nektar::WeakPressureExtrapolate::v_EvaluatePressureBCs(), Nektar::SubSteppingExtrapolate::v_SubStepSetPressureBCs(), and Nektar::SubSteppingExtrapolateWeakPressure::v_SubStepSetPressureBCs().

◆ CopyPressureHBCsToPbndExp()

void Nektar::Extrapolate::CopyPressureHBCsToPbndExp ( void )

Definition at line 1037 of file Extrapolate.cpp.

 {
     size_t n, cnt;
     for (cnt = n = 0; n < m_PBndConds.size(); ++n)
     {
         if ((m_hbcType[n] == eHBCNeumann) || (m_hbcType[n] == eConvectiveOBC))
         {
             int nq = m_PBndExp[n]->GetNcoeffs();
             Vmath::Vcopy(nq, &(m_pressureHBCs[m_intSteps - 1])[cnt], 1,
                          &(m_PBndExp[n]->UpdateCoeffs()[0]), 1);
             cnt += nq;
         }
     }
 }

References Nektar::eConvectiveOBC, Nektar::eHBCNeumann, m_hbcType, m_intSteps, m_PBndConds, m_PBndExp, m_pressureHBCs, and Vmath::Vcopy().

Referenced by Nektar::StandardExtrapolate::v_EvaluatePressureBCs(), Nektar::WeakPressureExtrapolate::v_EvaluatePressureBCs(), Nektar::SubSteppingExtrapolate::v_SubStepSetPressureBCs(), and Nektar::SubSteppingExtrapolateWeakPressure::v_SubStepSetPressureBCs().

◆ CorrectPressureBCs()

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

inline

Definition at line 395 of file Extrapolate.h.

 {
     v_CorrectPressureBCs(pressure);
 }

References CG_Iterations::pressure, and v_CorrectPressureBCs().

◆ EvaluateBDFArray()

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

At the start, the newest value is stored in array[nlevels-1] and the previous values in the first positions At the end, the value of the bdf explicit part is stored in array[nlevels-1] and the storage has been updated to included the new value

Definition at line 982 of file Extrapolate.cpp.

 {
     int nint    = min(m_pressureCalls, m_intSteps);
     int nlevels = array.size();
     int nPts    = array[0].size();
  
     // Update array
     RollOver(array);
  
     // Extrapolate to outarray
     Vmath::Smul(nPts, StifflyStable_Alpha_Coeffs[nint - 1][nint - 1],
                 array[nint - 1], 1, array[nlevels - 1], 1);
  
     for (int n = 0; n < nint - 1; ++n)
     {
         Vmath::Svtvp(nPts, StifflyStable_Alpha_Coeffs[nint - 1][n], array[n], 1,
                      array[nlevels - 1], 1, array[nlevels - 1], 1);
     }
 }

References m_intSteps, m_pressureCalls, RollOver(), Vmath::Smul(), StifflyStable_Alpha_Coeffs, and Vmath::Svtvp().

Referenced by CalcOutflowBCs(), Nektar::SubSteppingExtrapolateWeakPressure::v_AddNormVelOnOBC(), and Nektar::WeakPressureExtrapolate::v_AddNormVelOnOBC().

◆ EvaluatePressureBCs()

void Nektar::Extrapolate::EvaluatePressureBCs	(	const Array< OneD, const Array< OneD, NekDouble >> &	inarray,
		const Array< OneD, const Array< OneD, NekDouble >> &	N,
		NekDouble	kinvis
	)

inline

Evaluate Pressure Boundary Conditions for Standard Extrapolation

Definition at line 323 of file Extrapolate.h.

 {
     v_EvaluatePressureBCs(inarray, N, kinvis);
 }

References v_EvaluatePressureBCs().

◆ ExtrapolateArray() [1/2]

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

At the start, the newest value is stored in array[nlevels-1] and the previous values in the first positions At the end, the extrapolated value is stored in array[nlevels-1] and the storage has been updated to included the new value

Definition at line 956 of file Extrapolate.cpp.

 {
     int nint    = min(m_pressureCalls, m_intSteps);
     int nlevels = array.size();
     int nPts    = array[0].size();
  
     // Update array
     RollOver(array);
  
     // Extrapolate to outarray
     Vmath::Smul(nPts, StifflyStable_Betaq_Coeffs[nint - 1][nint - 1],
                 array[nint - 1], 1, array[nlevels - 1], 1);
  
     for (int n = 0; n < nint - 1; ++n)
     {
         Vmath::Svtvp(nPts, StifflyStable_Betaq_Coeffs[nint - 1][n], array[n], 1,
                      array[nlevels - 1], 1, array[nlevels - 1], 1);
     }
 }

References m_intSteps, m_pressureCalls, RollOver(), Vmath::Smul(), StifflyStable_Betaq_Coeffs, and Vmath::Svtvp().

Referenced by CalcOutflowBCs(), Nektar::StandardExtrapolate::v_EvaluatePressureBCs(), Nektar::WeakPressureExtrapolate::v_EvaluatePressureBCs(), Nektar::SubSteppingExtrapolate::v_SubStepSetPressureBCs(), and Nektar::SubSteppingExtrapolateWeakPressure::v_SubStepSetPressureBCs().

◆ ExtrapolateArray() [2/2]

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

◆ ExtrapolatePressureHBCs()

void Nektar::Extrapolate::ExtrapolatePressureHBCs ( void )

◆ GenerateHOPBCMap()

void Nektar::Extrapolate::GenerateHOPBCMap ( const LibUtilities::SessionReaderSharedPtr & pSession )

Initialize HOBCs

Definition at line 614 of file Extrapolate.cpp.

 {
     m_PBndConds = m_pressure->GetBndConditions();
     m_PBndExp   = m_pressure->GetBndCondExpansions();
  
     size_t cnt, n;
  
     // Storage array for high order pressure BCs
     m_pressureHBCs = Array<OneD, Array<OneD, NekDouble>>(m_intSteps);
     m_iprodnormvel = Array<OneD, Array<OneD, NekDouble>>(m_intSteps + 1);
  
     // Get useful values for HOBCs
     m_HBCnumber = 0;
     m_numHBCDof = 0;
  
     int outHBCnumber = 0;
     int numOutHBCPts = 0;
  
     m_hbcType = Array<OneD, HBCType>(m_PBndConds.size(), eNOHBC);
     for (n = 0; n < m_PBndConds.size(); ++n)
     {
         // High order boundary Neumann Condiiton
         if (boost::iequals(m_PBndConds[n]->GetUserDefined(), "H"))
         {
             m_hbcType[n] = eHBCNeumann;
             m_numHBCDof += m_PBndExp[n]->GetNcoeffs();
             m_HBCnumber += m_PBndExp[n]->GetExpSize();
         }
  
         // High order outflow convective condition
         if (m_PBndConds[n]->GetBoundaryConditionType() ==
                 SpatialDomains::eRobin &&
             boost::iequals(m_PBndConds[n]->GetUserDefined(), "HOutflow"))
         {
             m_hbcType[n] = eConvectiveOBC;
             m_numHBCDof += m_PBndExp[n]->GetNcoeffs();
             m_HBCnumber += m_PBndExp[n]->GetExpSize();
             numOutHBCPts += m_PBndExp[n]->GetTotPoints();
             outHBCnumber++;
         }
         // High order outflow boundary condition;
         else if (boost::iequals(m_PBndConds[n]->GetUserDefined(), "HOutflow"))
         {
             m_hbcType[n] = eOBC;
             numOutHBCPts += m_PBndExp[n]->GetTotPoints();
             outHBCnumber++;
         }
     }
  
     m_iprodnormvel[0] = Array<OneD, NekDouble>(m_numHBCDof, 0.0);
     for (int n = 0; n < m_intSteps; ++n)
     {
         m_pressureHBCs[n]     = Array<OneD, NekDouble>(m_numHBCDof, 0.0);
         m_iprodnormvel[n + 1] = Array<OneD, NekDouble>(m_numHBCDof, 0.0);
     }
  
     m_pressureCalls = 0;
  
     switch (m_pressure->GetExpType())
     {
         case MultiRegions::e2D:
         {
             m_curl_dim = 2;
             m_bnd_dim  = 2;
         }
         break;
         case MultiRegions::e3DH1D:
         {
             m_curl_dim = 3;
             m_bnd_dim  = 2;
         }
         break;
         case MultiRegions::e3DH2D:
         {
             m_curl_dim = 3;
             m_bnd_dim  = 1;
         }
         break;
         case MultiRegions::e3D:
         {
             m_curl_dim = 3;
             m_bnd_dim  = 3;
         }
         break;
         default:
             ASSERTL0(0, "Dimension not supported");
             break;
     }
  
     // Initialise storage for outflow HOBCs
     if (numOutHBCPts > 0)
     {
         m_houtflow = MemoryManager<HighOrderOutflow>::AllocateSharedPtr(
             numOutHBCPts, outHBCnumber, m_curl_dim, pSession);
  
         MultiRegions::ExpListSharedPtr BndElmtExp;
  
         // set up boundary expansions link
         for (int i = 0; i < m_curl_dim; ++i)
         {
             m_houtflow->m_UBndExp[i] =
                 m_fields[m_velocity[i]]->GetBndCondExpansions();
         }
  
         for (n = 0, cnt = 0; n < m_PBndConds.size(); ++n)
         {
             if (boost::iequals(m_PBndConds[n]->GetUserDefined(), "HOutflow"))
             {
                 m_houtflow->m_outflowVel[cnt] =
                     Array<OneD, Array<OneD, Array<OneD, NekDouble>>>(
                         m_curl_dim);
  
                 m_houtflow->m_outflowVelBnd[cnt] =
                     Array<OneD, Array<OneD, Array<OneD, NekDouble>>>(
                         m_curl_dim);
  
                 m_fields[0]->GetBndElmtExpansion(n, BndElmtExp, false);
                 int nqb = m_PBndExp[n]->GetTotPoints();
                 int nq  = BndElmtExp->GetTotPoints();
                 for (int j = 0; j < m_curl_dim; ++j)
                 {
                     m_houtflow->m_outflowVel[cnt][j] =
                         Array<OneD, Array<OneD, NekDouble>>(m_intSteps);
  
                     m_houtflow->m_outflowVelBnd[cnt][j] =
                         Array<OneD, Array<OneD, NekDouble>>(m_intSteps);
  
                     for (int k = 0; k < m_intSteps; ++k)
                     {
                         m_houtflow->m_outflowVel[cnt][j][k] =
                             Array<OneD, NekDouble>(nq, 0.0);
                         m_houtflow->m_outflowVelBnd[cnt][j][k] =
                             Array<OneD, NekDouble>(nqb, 0.0);
                     }
                 }
                 cnt++;
             }
  
             // evaluate convective primitive coefficient if
             // convective OBCs are used
             if (m_hbcType[n] == eConvectiveOBC)
             {
                 // initialise convective members of
                 // HighOrderOutflow struct
                 if (m_houtflow->m_pressurePrimCoeff.size() == 0)
                 {
                     m_houtflow->m_pressurePrimCoeff =
                         Array<OneD, NekDouble>(m_PBndConds.size(), 0.0);
                     m_houtflow->m_velocityPrimCoeff =
                         Array<OneD, Array<OneD, NekDouble>>(m_curl_dim);
  
                     for (int i = 0; i < m_curl_dim; ++i)
                     {
                         m_houtflow->m_velocityPrimCoeff[i] =
                             Array<OneD, NekDouble>(m_PBndConds.size(), 0.0);
                     }
                 }
  
                 LibUtilities::Equation coeff =
                     std::static_pointer_cast<
                         SpatialDomains::RobinBoundaryCondition>(m_PBndConds[n])
                         ->m_robinPrimitiveCoeff;
  
                 // checkout equation evaluation options!!
                 m_houtflow->m_pressurePrimCoeff[n] = coeff.Evaluate();
  
                 for (int i = 0; i < m_curl_dim; ++i)
                 {
                     Array<OneD, const SpatialDomains::BoundaryConditionShPtr>
                         UBndConds = m_fields[m_velocity[i]]->GetBndConditions();
  
                     LibUtilities::Equation coeff1 =
                         std::static_pointer_cast<
                             SpatialDomains::RobinBoundaryCondition>(
                             UBndConds[n])
                             ->m_robinPrimitiveCoeff;
  
                     m_houtflow->m_defVelPrimCoeff[i] = coeff1.GetExpression();
  
                     ASSERTL1(UBndConds[n]->GetBoundaryConditionType() ==
                                  SpatialDomains::eRobin,
                              "Require Velocity "
                              "conditions to be of Robin type when pressure"
                              "outflow is specticied as Robin Boundary type");
  
                     // checkout equation evaluation options!!
                     m_houtflow->m_velocityPrimCoeff[i][n] = coeff1.Evaluate();
                 }
             }
         }
     }
 }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, ASSERTL1, Nektar::MultiRegions::e2D, Nektar::MultiRegions::e3D, Nektar::MultiRegions::e3DH1D, Nektar::MultiRegions::e3DH2D, Nektar::eConvectiveOBC, Nektar::eHBCNeumann, Nektar::eNOHBC, Nektar::eOBC, Nektar::SpatialDomains::eRobin, Nektar::LibUtilities::Equation::Evaluate(), Nektar::LibUtilities::Equation::GetExpression(), m_bnd_dim, m_curl_dim, m_fields, m_HBCnumber, m_hbcType, m_houtflow, m_intSteps, m_iprodnormvel, m_numHBCDof, m_PBndConds, m_PBndExp, m_pressure, m_pressureCalls, m_pressureHBCs, and m_velocity.

◆ GetMaxStdVelocity()

Array< OneD, NekDouble > Nektar::Extrapolate::GetMaxStdVelocity ( const Array< OneD, Array< OneD, NekDouble >> inarray )

Definition at line 850 of file Extrapolate.cpp.

 {
     // Checking if the problem is 2D
     ASSERTL0(m_curl_dim >= 2, "Method not implemented for 1D");
  
     size_t n_points_0 = m_fields[0]->GetExp(0)->GetTotPoints();
     size_t n_element  = m_fields[0]->GetExpSize();
     size_t nvel       = inarray.size();
     size_t cnt;
  
     NekDouble pntVelocity;
  
     // Getting the standard velocity vector
     Array<OneD, Array<OneD, NekDouble>> stdVelocity(nvel);
     Array<OneD, NekDouble> tmp;
     Array<OneD, NekDouble> maxV(n_element, 0.0);
     LibUtilities::PointsKeyVector ptsKeys;
  
     for (size_t i = 0; i < nvel; ++i)
     {
         stdVelocity[i] = Array<OneD, NekDouble>(n_points_0);
     }
  
     cnt = 0.0;
     for (size_t el = 0; el < n_element; ++el)
     {
         size_t n_points = m_fields[0]->GetExp(el)->GetTotPoints();
         ptsKeys         = m_fields[0]->GetExp(el)->GetPointsKeys();
  
         // reset local space
         if (n_points != n_points_0)
         {
             for (size_t j = 0; j < nvel; ++j)
             {
                 stdVelocity[j] = Array<OneD, NekDouble>(n_points, 0.0);
             }
             n_points_0 = n_points;
         }
         else
         {
             for (size_t j = 0; j < nvel; ++j)
             {
                 Vmath::Zero(n_points, stdVelocity[j], 1);
             }
         }
  
         Array<TwoD, const NekDouble> gmat = m_fields[0]
                                                 ->GetExp(el)
                                                 ->GetGeom()
                                                 ->GetMetricInfo()
                                                 ->GetDerivFactors(ptsKeys);
  
         if (m_fields[0]->GetExp(el)->GetGeom()->GetMetricInfo()->GetGtype() ==
             SpatialDomains::eDeformed)
         {
             for (size_t j = 0; j < nvel; ++j)
             {
                 for (size_t k = 0; k < nvel; ++k)
                 {
                     Vmath::Vvtvp(n_points, gmat[k * nvel + j], 1,
                                  tmp = inarray[k] + cnt, 1, stdVelocity[j], 1,
                                  stdVelocity[j], 1);
                 }
             }
         }
         else
         {
             for (size_t j = 0; j < nvel; ++j)
             {
                 for (size_t k = 0; k < nvel; ++k)
                 {
                     Vmath::Svtvp(n_points, gmat[k * nvel + j][0],
                                  tmp = inarray[k] + cnt, 1, stdVelocity[j], 1,
                                  stdVelocity[j], 1);
                 }
             }
         }
         cnt += n_points;
  
         // Calculate total velocity in stdVelocity[0]
         Vmath::Vmul(n_points, stdVelocity[0], 1, stdVelocity[0], 1,
                     stdVelocity[0], 1);
         for (size_t k = 1; k < nvel; ++k)
         {
             Vmath::Vvtvp(n_points, stdVelocity[k], 1, stdVelocity[k], 1,
                          stdVelocity[0], 1, stdVelocity[0], 1);
         }
         pntVelocity = Vmath::Vmax(n_points, stdVelocity[0], 1);
         maxV[el]    = sqrt(pntVelocity);
     }
  
     return maxV;
 }

References ASSERTL0, Nektar::SpatialDomains::eDeformed, m_curl_dim, m_fields, tinysimd::sqrt(), Vmath::Svtvp(), Vmath::Vmax(), Vmath::Vmul(), Vmath::Vvtvp(), and Vmath::Zero().

Referenced by Nektar::SubSteppingExtrapolate::GetSubstepTimeStep().

◆ GetSubStepName()

std::string Nektar::Extrapolate::GetSubStepName ( void )

inline

Definition at line 387 of file Extrapolate.h.

 {
     return v_GetSubStepName();
 }

References v_GetSubStepName().

◆ IProductNormVelocityBCOnHBC()

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

Definition at line 545 of file Extrapolate.cpp.

 {
  
     if (!m_HBCnumber)
     {
         return;
     }
     int i;
     size_t n, cnt;
     Array<OneD, NekDouble> IProdVnTmp;
     Array<OneD, Array<OneD, NekDouble>> velbc(m_bnd_dim);
     Array<OneD, Array<OneD, MultiRegions::ExpListSharedPtr>> VelBndExp(
         m_bnd_dim);
     for (i = 0; i < m_bnd_dim; ++i)
     {
         VelBndExp[i] = m_fields[m_velocity[i]]->GetBndCondExpansions();
     }
  
     for (n = cnt = 0; n < m_PBndConds.size(); ++n)
     {
         // High order boundary condition;
         if (m_hbcType[n] == eHBCNeumann)
         {
             for (i = 0; i < m_bnd_dim; ++i)
             {
                 velbc[i] = Array<OneD, NekDouble>(
                     VelBndExp[i][n]->GetTotPoints(), 0.0);
                 VelBndExp[i][n]->SetWaveSpace(
                     m_fields[m_velocity[i]]->GetWaveSpace());
                 VelBndExp[i][n]->BwdTrans(VelBndExp[i][n]->GetCoeffs(),
                                           velbc[i]);
             }
             IProdVnTmp = IProdVn + cnt;
             m_PBndExp[n]->NormVectorIProductWRTBase(velbc, IProdVnTmp);
             cnt += m_PBndExp[n]->GetNcoeffs();
         }
         else if (m_hbcType[n] == eConvectiveOBC)
         {
             // skip over convective OBC
             cnt += m_PBndExp[n]->GetNcoeffs();
         }
     }
 }

References Nektar::eConvectiveOBC, Nektar::eHBCNeumann, m_bnd_dim, m_fields, m_HBCnumber, m_hbcType, m_PBndConds, m_PBndExp, and m_velocity.

Referenced by AddDuDt(), and AddVelBC().

◆ IProductNormVelocityOnHBC()

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

Definition at line 516 of file Extrapolate.cpp.

 {
     int i;
     size_t n, cnt;
     Array<OneD, NekDouble> IProdVnTmp;
     Array<OneD, Array<OneD, NekDouble>> velbc(m_bnd_dim);
  
     for (n = cnt = 0; n < m_PBndConds.size(); ++n)
     {
         // High order boundary condition;
         if (m_hbcType[n] == eHBCNeumann)
         {
             for (i = 0; i < m_bnd_dim; ++i)
             {
                 m_fields[0]->ExtractPhysToBnd(n, Vel[i], velbc[i]);
             }
             IProdVnTmp = IProdVn + cnt;
             m_PBndExp[n]->NormVectorIProductWRTBase(velbc, IProdVnTmp);
             cnt += m_PBndExp[n]->GetNcoeffs();
         }
         else if (m_hbcType[n] == eConvectiveOBC) // skip over conective OBC
         {
             cnt += m_PBndExp[n]->GetNcoeffs();
         }
     }
 }

References Nektar::eConvectiveOBC, Nektar::eHBCNeumann, m_bnd_dim, m_fields, m_hbcType, m_PBndConds, and m_PBndExp.

Referenced by Nektar::SubSteppingExtrapolate::v_SubStepAdvance().

◆ MountHOPBCs()

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

inline

Definition at line 377 of file Extrapolate.h.

 {
     v_MountHOPBCs(HBCdata, kinvis, Q, Advection);
 }

References v_MountHOPBCs().

Referenced by v_CalcNeumannPressureBCs(), and Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs().

◆ RollOver()

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

protected

Function to roll time-level storages to the next step layout. The stored data associated with the oldest time-level (not required anymore) are moved to the top, where they will be overwritten as the solution process progresses.

Definition at line 595 of file Extrapolate.cpp.

 {
     int nlevels = input.size();
  
     Array<OneD, NekDouble> tmp;
  
     tmp = input[nlevels - 1];
  
     for (int n = nlevels - 1; n > 0; --n)
     {
         input[n] = input[n - 1];
     }
  
     input[0] = tmp;
 }

Referenced by EvaluateBDFArray(), ExtrapolateArray(), v_AccelerationBDF(), and Nektar::StandardExtrapolate::v_AccelerationBDF().

◆ SetForcing()

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

inline

Definition at line 350 of file Extrapolate.h.

 {
     m_forcing = forcing;
 }

References m_forcing.

◆ SubStepAdvance()

void Nektar::Extrapolate::SubStepAdvance	(	const int	nstep,
		NekDouble	time
	)

inline

Definition at line 369 of file Extrapolate.h.

 {
     v_SubStepAdvance(nstep, time);
 }

References v_SubStepAdvance().

◆ SubSteppingTimeIntegration()

void Nektar::Extrapolate::SubSteppingTimeIntegration ( const LibUtilities::TimeIntegrationSchemeSharedPtr & IntegrationScheme )

inline

Definition at line 333 of file Extrapolate.h.

 {
     v_SubSteppingTimeIntegration(IntegrationScheme);
 }

References v_SubSteppingTimeIntegration().

◆ SubStepSaveFields()

void Nektar::Extrapolate::SubStepSaveFields ( const int nstep )

inline

Definition at line 342 of file Extrapolate.h.

 {
     v_SubStepSaveFields(nstep);
 }

References v_SubStepSaveFields().

◆ SubStepSetPressureBCs()

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

inline

Definition at line 359 of file Extrapolate.h.

 {
     v_SubStepSetPressureBCs(inarray, Aii_DT, kinvis);
 }

References v_SubStepSetPressureBCs().

◆ UpdateRobinPrimCoeff()

void Nektar::Extrapolate::UpdateRobinPrimCoeff ( void )

Definition at line 808 of file Extrapolate.cpp.

 {
  
     if ((m_pressureCalls == 1) || (m_pressureCalls > m_intSteps))
     {
         return;
     }
  
     for (size_t n = 0; n < m_PBndConds.size(); ++n)
     {
         // Get expansion with element on this boundary
         if (m_hbcType[n] == eConvectiveOBC)
         {
             for (int i = 0; i < m_curl_dim; ++i)
             {
                 Array<OneD, SpatialDomains::BoundaryConditionShPtr> UBndConds =
                     m_fields[m_velocity[i]]->UpdateBndConditions();
  
                 std::string primcoeff =
                     m_houtflow->m_defVelPrimCoeff[i] + "*" +
                     boost::lexical_cast<std::string>(
                         StifflyStable_Gamma0_Coeffs[m_pressureCalls - 1]);
  
                 SpatialDomains::RobinBCShPtr rcond = std::dynamic_pointer_cast<
                     SpatialDomains::RobinBoundaryCondition>(UBndConds[n]);
  
                 SpatialDomains::BoundaryConditionShPtr bcond =
                     MemoryManager<SpatialDomains::RobinBoundaryCondition>::
                         AllocateSharedPtr(
                             m_session, rcond->m_robinFunction.GetExpression(),
                             primcoeff, rcond->GetUserDefined(),
                             rcond->m_filename);
  
                 UBndConds[n] = bcond;
             }
         }
     }
 }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::eConvectiveOBC, m_curl_dim, m_fields, m_hbcType, m_houtflow, m_intSteps, m_PBndConds, m_pressureCalls, m_session, m_velocity, and StifflyStable_Gamma0_Coeffs.

Referenced by CalcOutflowBCs().

◆ v_AccelerationBDF()

void Nektar::Extrapolate::v_AccelerationBDF ( Array< OneD, Array< OneD, NekDouble >> & array )

protectedvirtual

At the start, the newest value is stored in array[nlevels-1] and the previous values in the first positions At the end, the acceleration from BDF is stored in array[nlevels-1] and the storage has been updated to included the new value

Reimplemented in Nektar::StandardExtrapolate.

Definition at line 1008 of file Extrapolate.cpp.

 {
     int nlevels = array.size();
     int nPts    = array[0].size();
  
     if (nPts)
     {
         // Update array
         RollOver(array);
  
         // Calculate acceleration using Backward Differentiation Formula
         Array<OneD, NekDouble> accelerationTerm(nPts, 0.0);
         if (m_pressureCalls > 2)
         {
             int acc_order = min(m_pressureCalls - 2, m_intSteps);
             Vmath::Smul(nPts, StifflyStable_Gamma0_Coeffs[acc_order - 1],
                         array[0], 1, accelerationTerm, 1);
  
             for (int i = 0; i < acc_order; i++)
             {
                 Vmath::Svtvp(
                     nPts, -1 * StifflyStable_Alpha_Coeffs[acc_order - 1][i],
                     array[i + 1], 1, accelerationTerm, 1, accelerationTerm, 1);
             }
         }
         array[nlevels - 1] = accelerationTerm;
     }
 }

References m_intSteps, m_pressureCalls, RollOver(), Vmath::Smul(), StifflyStable_Alpha_Coeffs, StifflyStable_Gamma0_Coeffs, and Vmath::Svtvp().

Referenced by AddDuDt().

◆ v_AddNormVelOnOBC()

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

protectedvirtual

Reimplemented in Nektar::WeakPressureExtrapolate, and Nektar::SubSteppingExtrapolateWeakPressure.

Definition at line 200 of file Extrapolate.cpp.

 {
     boost::ignore_unused(nbcoeffs, nreg, u);
 }

Referenced by AddNormVelOnOBC().

◆ v_CalcNeumannPressureBCs()

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

protectedvirtual

Unified routine for calculation high-oder terms

Reimplemented in Nektar::MappingExtrapolate.

Definition at line 119 of file Extrapolate.cpp.

 {
     size_t n, cnt;
  
     Array<OneD, NekDouble> Pvals;
  
     Array<OneD, Array<OneD, NekDouble>> Velocity(m_curl_dim);
     Array<OneD, Array<OneD, NekDouble>> Advection(m_bnd_dim);
  
     Array<OneD, Array<OneD, NekDouble>> BndValues(m_bnd_dim);
     Array<OneD, Array<OneD, NekDouble>> Q(m_curl_dim);
  
     MultiRegions::ExpListSharedPtr BndElmtExp;
     for (n = cnt = 0; n < m_PBndConds.size(); ++n)
     {
         // High order boundary condition;
         if ((m_hbcType[n] == eHBCNeumann) || (m_hbcType[n] == eConvectiveOBC))
         {
             m_fields[0]->GetBndElmtExpansion(n, BndElmtExp, false);
             int nqb = m_PBndExp[n]->GetTotPoints();
             int nq  = BndElmtExp->GetTotPoints();
  
             for (int i = 0; i < m_bnd_dim; i++)
             {
                 BndValues[i] = Array<OneD, NekDouble>(nqb, 0.0);
             }
  
             for (int i = 0; i < m_curl_dim; i++)
             {
                 Q[i] = Array<OneD, NekDouble>(nq, 0.0);
             }
  
             // Obtaining fields on BndElmtExp
             for (int i = 0; i < m_curl_dim; i++)
             {
                 m_fields[0]->ExtractPhysToBndElmt(n, fields[i], Velocity[i]);
             }
  
             if (N.size()) // not required for some extrapolation
             {
                 for (int i = 0; i < m_bnd_dim; i++)
                 {
                     m_fields[0]->ExtractPhysToBndElmt(n, N[i], Advection[i]);
                 }
             }
  
             // CurlCurl
             BndElmtExp->CurlCurl(Velocity, Q);
  
             // 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;
  
             // Getting values on the boundary and filling the pressure bnd
             // expansion. 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);
  
             // Get offset for next terms
             cnt += m_PBndExp[n]->GetNcoeffs();
         }
     }
 }

References Nektar::eConvectiveOBC, Nektar::eHBCNeumann, m_bnd_dim, m_curl_dim, m_fields, m_hbcType, m_intSteps, m_PBndConds, m_PBndExp, m_pressureHBCs, and MountHOPBCs().

Referenced by CalcNeumannPressureBCs(), and Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs().

◆ v_CorrectPressureBCs()

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

protectedvirtual

Reimplemented in Nektar::MappingExtrapolate.

Definition at line 194 of file Extrapolate.cpp.

 {
     boost::ignore_unused(pressure);
 }

References CG_Iterations::pressure.

Referenced by CorrectPressureBCs().

◆ v_EvaluatePressureBCs()

virtual void Nektar::Extrapolate::v_EvaluatePressureBCs	(	const Array< OneD, const Array< OneD, NekDouble >> &	inarray,
		const Array< OneD, const Array< OneD, NekDouble >> &	N,
		NekDouble	kinvis
	)

protectedpure virtual

Implemented in Nektar::WeakPressureExtrapolate, Nektar::SubSteppingExtrapolate, and Nektar::StandardExtrapolate.

Referenced by EvaluatePressureBCs().

◆ v_GetSubStepName()

std::string Nektar::Extrapolate::v_GetSubStepName ( void )

protectedvirtual

Reimplemented in Nektar::SubSteppingExtrapolate.

Definition at line 945 of file Extrapolate.cpp.

 {
     return "";
 }

Referenced by GetSubStepName().

◆ v_MountHOPBCs()

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

protectedpure virtual

Implemented in Nektar::WeakPressureExtrapolate, Nektar::SubSteppingExtrapolate, and Nektar::StandardExtrapolate.

Referenced by MountHOPBCs().

◆ v_SubStepAdvance()

virtual void Nektar::Extrapolate::v_SubStepAdvance	(	int	nstep,
		NekDouble	time
	)

protectedpure virtual

Implemented in Nektar::SubSteppingExtrapolate, and Nektar::StandardExtrapolate.

Referenced by SubStepAdvance().

◆ v_SubSteppingTimeIntegration()

virtual void Nektar::Extrapolate::v_SubSteppingTimeIntegration ( const LibUtilities::TimeIntegrationSchemeSharedPtr & IntegrationScheme )

protectedpure virtual

Implemented in Nektar::SubSteppingExtrapolate, and Nektar::StandardExtrapolate.

Referenced by SubSteppingTimeIntegration().

◆ v_SubStepSaveFields()

virtual void Nektar::Extrapolate::v_SubStepSaveFields ( int nstep )

protectedpure virtual

Implemented in Nektar::SubSteppingExtrapolate, and Nektar::StandardExtrapolate.

Referenced by SubStepSaveFields().

◆ v_SubStepSetPressureBCs()

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

protectedpure virtual

Implemented in Nektar::SubSteppingExtrapolateWeakPressure, Nektar::SubSteppingExtrapolate, and Nektar::StandardExtrapolate.

Referenced by SubStepSetPressureBCs().

Member Data Documentation

◆ def

std::string Nektar::Extrapolate::def

staticprivate

Initial value:

=
    LibUtilities::SessionReader::RegisterDefaultSolverInfo(
        "StandardExtrapolate", "StandardExtrapolate")

Definition at line 258 of file Extrapolate.h.

◆ m_advObject

SolverUtils::AdvectionSharedPtr Nektar::Extrapolate::m_advObject

protected

Definition at line 207 of file Extrapolate.h.

Referenced by Nektar::SubSteppingExtrapolate::SubStepAdvection().

◆ m_bnd_dim

int Nektar::Extrapolate::m_bnd_dim

protected

bounday dimensionality

Definition at line 217 of file Extrapolate.h.

Referenced by Nektar::SubSteppingExtrapolate::AddAdvectionPenaltyFlux(), CalcOutflowBCs(), GenerateHOPBCMap(), IProductNormVelocityBCOnHBC(), IProductNormVelocityOnHBC(), v_CalcNeumannPressureBCs(), Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs(), and Nektar::MappingExtrapolate::v_CorrectPressureBCs().

◆ m_comm

LibUtilities::CommSharedPtr Nektar::Extrapolate::m_comm

protected

Definition at line 192 of file Extrapolate.h.

Referenced by Extrapolate(), Nektar::SubSteppingExtrapolate::GetSubstepTimeStep(), and Nektar::SubSteppingExtrapolate::v_SubStepAdvance().

◆ m_curl_dim

int Nektar::Extrapolate::m_curl_dim

protected

Curl-curl dimensionality.

Definition at line 214 of file Extrapolate.h.

Referenced by AddPressureToOutflowBCs(), CalcOutflowBCs(), GenerateHOPBCMap(), GetMaxStdVelocity(), UpdateRobinPrimCoeff(), Nektar::SubSteppingExtrapolateWeakPressure::v_AddNormVelOnOBC(), Nektar::WeakPressureExtrapolate::v_AddNormVelOnOBC(), and v_CalcNeumannPressureBCs().

◆ m_fields

Array<OneD, MultiRegions::ExpListSharedPtr> Nektar::Extrapolate::m_fields

protected

Velocity fields.

Definition at line 198 of file Extrapolate.h.

◆ m_forcing

std::vector<SolverUtils::ForcingSharedPtr> Nektar::Extrapolate::m_forcing

protected

Definition at line 209 of file Extrapolate.h.

Referenced by SetForcing(), and Nektar::SubSteppingExtrapolate::SubStepAdvection().

◆ m_HBCnumber

int Nektar::Extrapolate::m_HBCnumber

protected

Definition at line 232 of file Extrapolate.h.

Referenced by GenerateHOPBCMap(), IProductNormVelocityBCOnHBC(), Nektar::MappingExtrapolate::v_CorrectPressureBCs(), Nektar::StandardExtrapolate::v_EvaluatePressureBCs(), and Nektar::WeakPressureExtrapolate::v_EvaluatePressureBCs().

◆ m_hbcType

Array<OneD, HBCType> Nektar::Extrapolate::m_hbcType

protected

Array of type of high order BCs for splitting shemes.

Definition at line 195 of file Extrapolate.h.

Referenced by AddPressureToOutflowBCs(), CalcOutflowBCs(), CopyPressureHBCsToPbndExp(), GenerateHOPBCMap(), IProductNormVelocityBCOnHBC(), IProductNormVelocityOnHBC(), UpdateRobinPrimCoeff(), and v_CalcNeumannPressureBCs().

◆ m_houtflow

HighOrderOutflowSharedPtr Nektar::Extrapolate::m_houtflow

protected

Definition at line 255 of file Extrapolate.h.

Referenced by AddPressureToOutflowBCs(), CalcOutflowBCs(), GenerateHOPBCMap(), UpdateRobinPrimCoeff(), Nektar::SubSteppingExtrapolateWeakPressure::v_AddNormVelOnOBC(), and Nektar::WeakPressureExtrapolate::v_AddNormVelOnOBC().

◆ m_intSteps

int Nektar::Extrapolate::m_intSteps

protected

◆ m_iprodnormvel

Array<OneD, Array<OneD, NekDouble> > Nektar::Extrapolate::m_iprodnormvel

protected

Storage for current and previous levels of the inner product of normal velocity.

Definition at line 245 of file Extrapolate.h.

Referenced by AddDuDt(), AddVelBC(), GenerateHOPBCMap(), Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs(), and Nektar::SubSteppingExtrapolate::v_SubStepAdvance().

◆ m_numHBCDof

int Nektar::Extrapolate::m_numHBCDof

protected

Definition at line 229 of file Extrapolate.h.

Referenced by AddDuDt(), AddVelBC(), GenerateHOPBCMap(), and Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs().

◆ m_PBndConds

Array<OneD, const SpatialDomains::BoundaryConditionShPtr> Nektar::Extrapolate::m_PBndConds

protected

pressure boundary conditions container

Definition at line 220 of file Extrapolate.h.

Referenced by AddPressureToOutflowBCs(), CalcOutflowBCs(), CopyPressureHBCsToPbndExp(), GenerateHOPBCMap(), IProductNormVelocityBCOnHBC(), IProductNormVelocityOnHBC(), UpdateRobinPrimCoeff(), v_CalcNeumannPressureBCs(), Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs(), and Nektar::MappingExtrapolate::v_CorrectPressureBCs().

◆ m_PBndExp

Array<OneD, MultiRegions::ExpListSharedPtr> Nektar::Extrapolate::m_PBndExp

protected

pressure boundary conditions expansion container

Definition at line 223 of file Extrapolate.h.

Referenced by AddPressureToOutflowBCs(), CalcOutflowBCs(), CopyPressureHBCsToPbndExp(), GenerateHOPBCMap(), IProductNormVelocityBCOnHBC(), IProductNormVelocityOnHBC(), Nektar::SubSteppingExtrapolateWeakPressure::v_AddNormVelOnOBC(), Nektar::WeakPressureExtrapolate::v_AddNormVelOnOBC(), v_CalcNeumannPressureBCs(), Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs(), and Nektar::MappingExtrapolate::v_CorrectPressureBCs().

◆ m_pressure

MultiRegions::ExpListSharedPtr Nektar::Extrapolate::m_pressure

protected

Pointer to field holding pressure field.

Definition at line 201 of file Extrapolate.h.

Referenced by AddPressureToOutflowBCs(), GenerateHOPBCMap(), and Nektar::MappingExtrapolate::v_CorrectPressureBCs().

◆ m_pressureCalls

int Nektar::Extrapolate::m_pressureCalls

protected

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

Definition at line 226 of file Extrapolate.h.

Referenced by AddVelBC(), EvaluateBDFArray(), ExtrapolateArray(), GenerateHOPBCMap(), UpdateRobinPrimCoeff(), v_AccelerationBDF(), Nektar::StandardExtrapolate::v_AccelerationBDF(), Nektar::StandardExtrapolate::v_EvaluatePressureBCs(), Nektar::WeakPressureExtrapolate::v_EvaluatePressureBCs(), Nektar::SubSteppingExtrapolate::v_SubStepSetPressureBCs(), and Nektar::SubSteppingExtrapolateWeakPressure::v_SubStepSetPressureBCs().

◆ m_pressureHBCs

Array<OneD, Array<OneD, NekDouble> > Nektar::Extrapolate::m_pressureHBCs

protected

Storage for current and previous levels of high order pressure boundary conditions.

Definition at line 241 of file Extrapolate.h.

Referenced by AddDuDt(), AddVelBC(), CopyPressureHBCsToPbndExp(), GenerateHOPBCMap(), v_CalcNeumannPressureBCs(), Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs(), Nektar::StandardExtrapolate::v_EvaluatePressureBCs(), Nektar::WeakPressureExtrapolate::v_EvaluatePressureBCs(), Nektar::SubSteppingExtrapolate::v_SubStepSetPressureBCs(), and Nektar::SubSteppingExtrapolateWeakPressure::v_SubStepSetPressureBCs().

◆ m_previousVelFields

Array<OneD, Array<OneD, NekDouble> > Nektar::Extrapolate::m_previousVelFields

protected

Definition at line 211 of file Extrapolate.h.

◆ m_session

LibUtilities::SessionReaderSharedPtr Nektar::Extrapolate::m_session

protected

Definition at line 190 of file Extrapolate.h.

Referenced by Extrapolate(), Nektar::MappingExtrapolate::MappingExtrapolate(), Nektar::SubSteppingExtrapolate::SubSteppingExtrapolate(), UpdateRobinPrimCoeff(), and Nektar::SubSteppingExtrapolate::v_SubSteppingTimeIntegration().

◆ m_timestep

NekDouble Nektar::Extrapolate::m_timestep

protected

Definition at line 237 of file Extrapolate.h.

Referenced by AddDuDt(), AddVelBC(), Extrapolate(), Nektar::SubSteppingExtrapolate::SubStepAdvection(), Nektar::SubSteppingExtrapolate::SubStepExtrapolateField(), Nektar::SubSteppingExtrapolateWeakPressure::v_AddNormVelOnOBC(), Nektar::WeakPressureExtrapolate::v_AddNormVelOnOBC(), and Nektar::SubSteppingExtrapolate::v_SubStepAdvance().

◆ m_traceNormals

Array<OneD, Array<OneD, NekDouble> > Nektar::Extrapolate::m_traceNormals

protected

Definition at line 247 of file Extrapolate.h.

Referenced by Nektar::SubSteppingExtrapolate::AddAdvectionPenaltyFlux(), and Nektar::SubSteppingExtrapolate::SubSteppingExtrapolate().

◆ m_velocity

Array<OneD, int> Nektar::Extrapolate::m_velocity

protected

int which identifies which components of m_fields contains the velocity (u,v,w);

Definition at line 205 of file Extrapolate.h.

Referenced by GenerateHOPBCMap(), Nektar::SubSteppingExtrapolate::GetSubstepTimeStep(), IProductNormVelocityBCOnHBC(), Nektar::SubSteppingExtrapolate::SubStepAdvection(), Nektar::SubSteppingExtrapolate::SubStepExtrapolateField(), UpdateRobinPrimCoeff(), Nektar::SubSteppingExtrapolate::v_SubSteppingTimeIntegration(), and Nektar::SubSteppingExtrapolate::v_SubStepSaveFields().

◆ StifflyStable_Alpha_Coeffs

NekDouble Nektar::Extrapolate::StifflyStable_Alpha_Coeffs

staticprotected

Initial value:

= {

{1.0, 0.0, 0.0}, {2.0, -0.5, 0.0}, {3.0, -1.5, 1.0 / 3.0}}

Definition at line 251 of file Extrapolate.h.

Referenced by EvaluateBDFArray(), and v_AccelerationBDF().

◆ StifflyStable_Betaq_Coeffs

NekDouble Nektar::Extrapolate::StifflyStable_Betaq_Coeffs

staticprotected

Initial value:

= {

{1.0, 0.0, 0.0}, {2.0, -1.0, 0.0}, {3.0, -3.0, 1.0}}

Definition at line 250 of file Extrapolate.h.

Referenced by ExtrapolateArray().

◆ StifflyStable_Gamma0_Coeffs

NekDouble Nektar::Extrapolate::StifflyStable_Gamma0_Coeffs = {1.0, 1.5, 11.0 / 6.0}

staticprotected

Definition at line 252 of file Extrapolate.h.

Referenced by AddVelBC(), UpdateRobinPrimCoeff(), and v_AccelerationBDF().

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Extrapolate()

◆ ~Extrapolate()

Member Function Documentation

◆ AddDuDt()

◆ AddNormVelOnOBC()

◆ AddPressureToOutflowBCs()

◆ AddVelBC()

◆ CalcNeumannPressureBCs()

◆ CalcOutflowBCs()

◆ CopyPressureHBCsToPbndExp()

◆ CorrectPressureBCs()

◆ EvaluateBDFArray()

◆ EvaluatePressureBCs()

◆ ExtrapolateArray() [1/2]

◆ ExtrapolateArray() [2/2]

◆ ExtrapolatePressureHBCs()

◆ GenerateHOPBCMap()

◆ GetMaxStdVelocity()

◆ GetSubStepName()

◆ IProductNormVelocityBCOnHBC()

◆ IProductNormVelocityOnHBC()

◆ MountHOPBCs()

◆ RollOver()

◆ SetForcing()

◆ SubStepAdvance()

◆ SubSteppingTimeIntegration()

◆ SubStepSaveFields()

◆ SubStepSetPressureBCs()

◆ UpdateRobinPrimCoeff()

◆ v_AccelerationBDF()

◆ v_AddNormVelOnOBC()

◆ v_CalcNeumannPressureBCs()

◆ v_CorrectPressureBCs()

◆ v_EvaluatePressureBCs()

◆ v_GetSubStepName()

◆ v_MountHOPBCs()

◆ v_SubStepAdvance()

◆ v_SubSteppingTimeIntegration()

◆ v_SubStepSaveFields()

◆ v_SubStepSetPressureBCs()

Member Data Documentation

◆ def

◆ m_advObject

◆ m_bnd_dim

◆ m_comm

◆ m_curl_dim

◆ m_fields

◆ m_forcing

◆ m_HBCnumber

◆ m_hbcType

◆ m_houtflow

◆ m_intSteps

◆ m_iprodnormvel

◆ m_numHBCDof

◆ m_PBndConds

◆ m_PBndExp

◆ m_pressure

◆ m_pressureCalls

◆ m_pressureHBCs

◆ m_previousVelFields

◆ m_session

◆ m_timestep

◆ m_traceNormals

◆ m_velocity

◆ StifflyStable_Alpha_Coeffs

◆ StifflyStable_Betaq_Coeffs

◆ StifflyStable_Gamma0_Coeffs