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

Static Private Attributes
static std::string	def

Detailed Description

Definition at line 75 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 55 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 71 of file Extrapolate.cpp.

72 {

73 }

Member Function Documentation

◆ AddDuDt()

void Nektar::Extrapolate::AddDuDt ( void )

Definition at line 82 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 429 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 480 of file Extrapolate.cpp.

     {
         if(!m_houtflow.get())
         {
             return;
         }
  
  
         for(int 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);
                 Array<OneD, NekDouble> pbc(nqb);
  
                 m_PBndExp[n]->BwdTrans(m_PBndExp[n]->GetCoeffs(), pbc);
  
                 if (m_PBndExp[n]->GetWaveSpace())
                 {
                     m_PBndExp[n]->HomogeneousBwdTrans(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(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 104 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 186 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 212 of file Extrapolate.cpp.

     {
         if(!m_houtflow.get())
         {
            return;
         }
  
         Array<OneD, Array<OneD, NekDouble> > Velocity(m_curl_dim);
  
         MultiRegions::ExpListSharedPtr BndElmtExp;
         int 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(int 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],
                                                         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(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(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(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 1075 of file Extrapolate.cpp.

     {
         int 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 419 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 1011 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 340 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 981 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 632 of file Extrapolate.cpp.

     {
         m_PBndConds   = m_pressure->GetBndConditions();
         m_PBndExp     = m_pressure->GetBndCondExpansions();
  
         int 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(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 873 of file Extrapolate.cpp.

     {
         // Checking if the problem is 2D
         ASSERTL0(m_curl_dim >= 2, "Method not implemented for 1D");
  
         int n_points_0      = m_fields[0]->GetExp(0)->GetTotPoints();
         int n_element       = m_fields[0]->GetExpSize();
         int nvel            = inarray.size();
         int 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 (int i = 0; i < nvel; ++i)
         {
             stdVelocity[i] = Array<OneD, NekDouble>(n_points_0);
         }
  
         cnt = 0.0;
         for (int el = 0; el < n_element; ++el)
         {
             int 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 (int j = 0; j < nvel; ++j)
                 {
                     stdVelocity[j] = Array<OneD, NekDouble>(n_points, 0.0);
                 }
                 n_points_0 = n_points;
             }
             else
             {
                 for (int 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(int j = 0; j < nvel; ++j)
                 {
                     for(int 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(int j = 0; j < nvel; ++j)
                 {
                     for(int 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(int 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 411 of file Extrapolate.h.

     {
         return v_GetSubStepName();
     }

References v_GetSubStepName().

◆ IProductNormVelocityBCOnHBC()

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

Definition at line 564 of file Extrapolate.cpp.

     {
  
         if(!m_HBCnumber)
         {
             return;
         }
         int i,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 536 of file Extrapolate.cpp.

     {
         int i,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 399 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 612 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 369 of file Extrapolate.h.

     {
         m_forcing = forcing;
     }

References m_forcing.

◆ SubStepAdvance()

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

inline

Definition at line 389 of file Extrapolate.h.

     {
         v_SubStepAdvance(nstep, time);
     }

References v_SubStepAdvance().

◆ SubSteppingTimeIntegration()

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

inline

Definition at line 351 of file Extrapolate.h.

     {
         v_SubSteppingTimeIntegration(IntegrationScheme);
     }

References v_SubSteppingTimeIntegration().

◆ SubStepSaveFields()

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

inline

Definition at line 360 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 378 of file Extrapolate.h.

     {
         v_SubStepSetPressureBCs(inarray,Aii_DT,kinvis);
     }

References v_SubStepSetPressureBCs().

◆ UpdateRobinPrimCoeff()

void Nektar::Extrapolate::UpdateRobinPrimCoeff ( void )

Definition at line 830 of file Extrapolate.cpp.

     {
  
         if((m_pressureCalls == 1) || (m_pressureCalls > m_intSteps))
         {
             return;
         }
  
         for(int 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 1040 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 207 of file Extrapolate.cpp.

209 {

210 }

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 126 of file Extrapolate.cpp.

     {
         int 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 202 of file Extrapolate.cpp.

203 {

204 }

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 970 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 275 of file Extrapolate.h.

◆ m_advObject

SolverUtils::AdvectionSharedPtr Nektar::Extrapolate::m_advObject

protected

Definition at line 226 of file Extrapolate.h.

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

◆ m_bnd_dim

int Nektar::Extrapolate::m_bnd_dim

protected

bounday dimensionality

Definition at line 236 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 211 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 233 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 217 of file Extrapolate.h.

◆ m_forcing

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

protected

Definition at line 228 of file Extrapolate.h.

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

◆ m_HBCnumber

int Nektar::Extrapolate::m_HBCnumber

protected

Definition at line 251 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 214 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 272 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 262 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 248 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 239 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 242 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 220 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 245 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 259 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 230 of file Extrapolate.h.

◆ m_session

LibUtilities::SessionReaderSharedPtr Nektar::Extrapolate::m_session

protected

Definition at line 209 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 256 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 264 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 224 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 268 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 267 of file Extrapolate.h.

Referenced by ExtrapolateArray().

◆ StifflyStable_Gamma0_Coeffs

NekDouble Nektar::Extrapolate::StifflyStable_Gamma0_Coeffs

staticprotected

Initial value:

= {

1.0, 1.5, 11.0/6.0}

Definition at line 269 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