#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 int intMethod, const LibUtilities::TimeIntegrationWrapperSharedPtr &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 LibUtilities::TimeIntegrationSolutionSharedPtr &integrationSoln, 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	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)

LibUtilities::TimeIntegrationMethod	GetSubStepIntegrationMethod (void)

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

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

void	AccelerationBDF (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 (int intMethod, const LibUtilities::TimeIntegrationWrapperSharedPtr &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 (const LibUtilities::TimeIntegrationSolutionSharedPtr &integrationSoln, int nstep, NekDouble time)=0

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

virtual LibUtilities::TimeIntegrationMethod	v_GetSubStepIntegrationMethod (void)

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

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

References m_comm, m_session, and m_timestep.

         : 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();
     }

◆ ~Extrapolate()

Nektar::Extrapolate::~Extrapolate ( )

virtual

Definition at line 71 of file Extrapolate.cpp.

References def, and Nektar::LibUtilities::SessionReader::RegisterDefaultSolverInfo().

72 {

73 }

Member Function Documentation

◆ AccelerationBDF()

void Nektar::Extrapolate::AccelerationBDF ( 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 acceleration from BDF is stored in array[nlevels-1] and the storage has been updated to included the new value

Definition at line 1040 of file Extrapolate.cpp.

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

Referenced by AddDuDt().

     {
         int nlevels  = array.num_elements();
         int nPts     = array[0].num_elements();
 
 
         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;
         }
     }

◆ AddDuDt()

void Nektar::Extrapolate::AddDuDt ( void )

Definition at line 82 of file Extrapolate.cpp.

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

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

     {
         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
             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);
         }
     }

◆ AddNormVelOnOBC()

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

inline

Definition at line 422 of file Extrapolate.h.

References v_AddNormVelOnOBC().

Referenced by CalcOutflowBCs().

     {
         v_AddNormVelOnOBC(nbcoeffs,nreg,u);
     }

◆ AddPressureToOutflowBCs()

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

Definition at line 480 of file Extrapolate.cpp.

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

     {
         if(!m_houtflow.get())
         {
             return;
         }
         
         
         for(int n  = 0; n < m_PBndConds.num_elements(); ++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);
 
                 }
             }
         }
     }

◆ AddVelBC()

void Nektar::Extrapolate::AddVelBC ( void )

Definition at line 104 of file Extrapolate.cpp.

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

     {
         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);
         }
     }

◆ 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 187 of file Extrapolate.h.

References CalcOutflowBCs(), RollOver(), v_AddNormVelOnOBC(), v_CalcNeumannPressureBCs(), and v_CorrectPressureBCs().

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

         {
             v_CalcNeumannPressureBCs( fields, N, kinvis);
         }

◆ CalcOutflowBCs()

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

protected

Definition at line 212 of file Extrapolate.cpp.

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 CalcNeumannPressureBCs(), Nektar::WeakPressureExtrapolate::v_EvaluatePressureBCs(), Nektar::StandardExtrapolate::v_EvaluatePressureBCs(), Nektar::SubSteppingExtrapolateWeakPressure::v_SubStepSetPressureBCs(), and Nektar::SubSteppingExtrapolate::v_SubStepSetPressureBCs().

     {
         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.num_elements(); ++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++;
             }
         }
     }

◆ CopyPressureHBCsToPbndExp()

void Nektar::Extrapolate::CopyPressureHBCsToPbndExp ( void )

Definition at line 1075 of file Extrapolate.cpp.

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::SubSteppingExtrapolateWeakPressure::v_SubStepSetPressureBCs(), and Nektar::SubSteppingExtrapolate::v_SubStepSetPressureBCs().

     {
         int n, cnt;
         for(cnt = n = 0; n < m_PBndConds.num_elements(); ++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;
             }
         }
     }

◆ CorrectPressureBCs()

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

inline

Definition at line 412 of file Extrapolate.h.

References v_CorrectPressureBCs().

     {
         v_CorrectPressureBCs(pressure);
     }

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

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

     {
         int nint     = min(m_pressureCalls,m_intSteps);
         int nlevels  = array.num_elements();
         int nPts     = array[0].num_elements();
 
         // 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);
         }
     }

◆ 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 339 of file Extrapolate.h.

References v_EvaluatePressureBCs().

     {
         v_EvaluatePressureBCs(inarray,N,kinvis);
     }

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

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

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

     {
         int nint     = min(m_pressureCalls,m_intSteps);
         int nlevels  = array.num_elements();
         int nPts     = array[0].num_elements();
 
         // 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);
         }
     }

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

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.

     {
         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.num_elements(),eNOHBC);
         for( n = 0; n < m_PBndConds.num_elements(); ++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.num_elements(); ++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.num_elements() == 0)
                     {
                         m_houtflow->m_pressurePrimCoeff =
                             Array<OneD, NekDouble>
                             (m_PBndConds.num_elements(),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.
                                                         num_elements(),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();
                     }
                 }                
             }
                         
         }
     }

◆ GetMaxStdVelocity()

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

Definition at line 873 of file Extrapolate.cpp.

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

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

     {
         // 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.num_elements();
         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;
     }

◆ GetSubStepIntegrationMethod()

LibUtilities::TimeIntegrationMethod Nektar::Extrapolate::GetSubStepIntegrationMethod ( void )

inline

Definition at line 404 of file Extrapolate.h.

References v_GetSubStepIntegrationMethod().

     {
         return v_GetSubStepIntegrationMethod();
     }

◆ IProductNormVelocityBCOnHBC()

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

Definition at line 564 of file Extrapolate.cpp.

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

     {
 
         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.num_elements(); ++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();
             }
         }
     }

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

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

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

     {
         int i,n,cnt;
         Array<OneD, NekDouble> IProdVnTmp; 
         Array<OneD, Array<OneD, NekDouble> > velbc(m_bnd_dim);
 
         for(n = cnt = 0; n < m_PBndConds.num_elements(); ++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();
             }
         }
     }

◆ MountHOPBCs()

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

inline

Definition at line 391 of file Extrapolate.h.

References v_MountHOPBCs().

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

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

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

Referenced by AccelerationBDF(), CalcNeumannPressureBCs(), EvaluateBDFArray(), and ExtrapolateArray().

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

◆ SubStepAdvance()

void Nektar::Extrapolate::SubStepAdvance	(	const LibUtilities::TimeIntegrationSolutionSharedPtr &	integrationSoln,
		const int	nstep,
		NekDouble	time
	)

inline

Definition at line 380 of file Extrapolate.h.

References v_SubStepAdvance().

     {
         v_SubStepAdvance(integrationSoln,nstep, time);
     }

◆ SubSteppingTimeIntegration()

void Nektar::Extrapolate::SubSteppingTimeIntegration	(	const int	intMethod,
		const LibUtilities::TimeIntegrationWrapperSharedPtr &	IntegrationScheme
	)

inline

Definition at line 350 of file Extrapolate.h.

References v_SubSteppingTimeIntegration().

     {
         v_SubSteppingTimeIntegration(intMethod, IntegrationScheme);
     }

◆ SubStepSaveFields()

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

inline

Definition at line 360 of file Extrapolate.h.

References v_SubStepSaveFields().

     {
         v_SubStepSaveFields(nstep);
     }

◆ SubStepSetPressureBCs()

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

inline

Definition at line 369 of file Extrapolate.h.

References v_SubStepSetPressureBCs().

     {
         v_SubStepSetPressureBCs(inarray,Aii_DT,kinvis);
     }

◆ UpdateRobinPrimCoeff()

void Nektar::Extrapolate::UpdateRobinPrimCoeff ( void )

Definition at line 830 of file Extrapolate.cpp.

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

     {
         
         if((m_pressureCalls == 1) || (m_pressureCalls > m_intSteps))
         {
             return;
         }
         
         for(int n  = 0; n < m_PBndConds.num_elements(); ++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;
                 }
                 
             }
         }
     }

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

Referenced by AddNormVelOnOBC(), and CalcNeumannPressureBCs().

209 {

210 }

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

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

     {
         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.num_elements(); ++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.num_elements()) // 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();
             }
         }
     }

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

Referenced by CalcNeumannPressureBCs(), and CorrectPressureBCs().

203 {

204 }

◆ 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::StandardExtrapolate, Nektar::SubSteppingExtrapolate, and Nektar::WeakPressureExtrapolate.

Referenced by EvaluatePressureBCs().

◆ v_GetSubStepIntegrationMethod()

LibUtilities::TimeIntegrationMethod Nektar::Extrapolate::v_GetSubStepIntegrationMethod ( void )

protectedvirtual

Reimplemented in Nektar::SubSteppingExtrapolate.

Definition at line 970 of file Extrapolate.cpp.

References Nektar::LibUtilities::eNoTimeIntegrationMethod.

Referenced by GetSubStepIntegrationMethod().

     {
         return LibUtilities::eNoTimeIntegrationMethod;
     }

◆ 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::SubSteppingExtrapolate, Nektar::StandardExtrapolate, and Nektar::WeakPressureExtrapolate.

Referenced by MountHOPBCs().

◆ v_SubStepAdvance()

virtual void Nektar::Extrapolate::v_SubStepAdvance	(	const LibUtilities::TimeIntegrationSolutionSharedPtr &	integrationSoln,
		int	nstep,
		NekDouble	time
	)

protectedpure virtual

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

Referenced by SubStepAdvance().

◆ v_SubSteppingTimeIntegration()

virtual void Nektar::Extrapolate::v_SubSteppingTimeIntegration	(	int	intMethod,
		const LibUtilities::TimeIntegrationWrapperSharedPtr &	IntegrationScheme
	)

protectedpure virtual

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

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::SubSteppingExtrapolate, Nektar::StandardExtrapolate, and Nektar::SubSteppingExtrapolateWeakPressure.

Referenced by SubStepSetPressureBCs().

Member Data Documentation

◆ def

std::string Nektar::Extrapolate::def

staticprivate

Initial value:

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

Definition at line 274 of file Extrapolate.h.

Referenced by ~Extrapolate().

◆ m_advObject

SolverUtils::AdvectionSharedPtr Nektar::Extrapolate::m_advObject

protected

Definition at line 227 of file Extrapolate.h.

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

◆ m_bnd_dim

int Nektar::Extrapolate::m_bnd_dim

protected

bounday dimensionality

Definition at line 235 of file Extrapolate.h.

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

◆ m_comm

LibUtilities::CommSharedPtr Nektar::Extrapolate::m_comm

protected

Definition at line 212 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 232 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 218 of file Extrapolate.h.

◆ m_HBCnumber

int Nektar::Extrapolate::m_HBCnumber

protected

Definition at line 250 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 215 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 271 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

Maximum points used in pressure BC evaluation.

Definition at line 253 of file Extrapolate.h.

Referenced by AccelerationBDF(), AddDuDt(), AddVelBC(), CalcOutflowBCs(), CopyPressureHBCsToPbndExp(), EvaluateBDFArray(), ExtrapolateArray(), GenerateHOPBCMap(), Nektar::SubSteppingExtrapolate::SubStepExtrapolateField(), UpdateRobinPrimCoeff(), Nektar::SubSteppingExtrapolateWeakPressure::v_AddNormVelOnOBC(), Nektar::WeakPressureExtrapolate::v_AddNormVelOnOBC(), Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs(), v_CalcNeumannPressureBCs(), Nektar::SubSteppingExtrapolate::v_SubStepAdvance(), Nektar::StandardExtrapolate::v_SubSteppingTimeIntegration(), and Nektar::SubSteppingExtrapolate::v_SubSteppingTimeIntegration().

◆ 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 261 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 247 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 238 of file Extrapolate.h.

Referenced by AddPressureToOutflowBCs(), CalcOutflowBCs(), CopyPressureHBCsToPbndExp(), GenerateHOPBCMap(), IProductNormVelocityBCOnHBC(), IProductNormVelocityOnHBC(), UpdateRobinPrimCoeff(), Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs(), 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 241 of file Extrapolate.h.

Referenced by AddPressureToOutflowBCs(), CalcOutflowBCs(), CopyPressureHBCsToPbndExp(), GenerateHOPBCMap(), IProductNormVelocityBCOnHBC(), IProductNormVelocityOnHBC(), Nektar::SubSteppingExtrapolateWeakPressure::v_AddNormVelOnOBC(), Nektar::WeakPressureExtrapolate::v_AddNormVelOnOBC(), Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs(), 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 221 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 244 of file Extrapolate.h.

Referenced by AccelerationBDF(), AddVelBC(), EvaluateBDFArray(), ExtrapolateArray(), GenerateHOPBCMap(), UpdateRobinPrimCoeff(), Nektar::StandardExtrapolate::v_EvaluatePressureBCs(), Nektar::WeakPressureExtrapolate::v_EvaluatePressureBCs(), Nektar::SubSteppingExtrapolateWeakPressure::v_SubStepSetPressureBCs(), and Nektar::SubSteppingExtrapolate::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 258 of file Extrapolate.h.

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

◆ m_previousVelFields

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

protected

Definition at line 229 of file Extrapolate.h.

◆ m_session

LibUtilities::SessionReaderSharedPtr Nektar::Extrapolate::m_session

protected

Definition at line 210 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 255 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 263 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 225 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 267 of file Extrapolate.h.

Referenced by AccelerationBDF(), and EvaluateBDFArray().

◆ 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 266 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 268 of file Extrapolate.h.

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

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Extrapolate()

◆ ~Extrapolate()

Member Function Documentation

◆ AccelerationBDF()

◆ AddDuDt()

◆ AddNormVelOnOBC()

◆ AddPressureToOutflowBCs()

◆ AddVelBC()

◆ CalcNeumannPressureBCs()

◆ CalcOutflowBCs()

◆ CopyPressureHBCsToPbndExp()

◆ CorrectPressureBCs()

◆ EvaluateBDFArray()

◆ EvaluatePressureBCs()

◆ ExtrapolateArray() [1/2]

◆ ExtrapolateArray() [2/2]

◆ ExtrapolatePressureHBCs()

◆ GenerateHOPBCMap()

◆ GetMaxStdVelocity()

◆ GetSubStepIntegrationMethod()

◆ IProductNormVelocityBCOnHBC()

◆ IProductNormVelocityOnHBC()

◆ MountHOPBCs()

◆ RollOver()

◆ SubStepAdvance()

◆ SubSteppingTimeIntegration()

◆ SubStepSaveFields()

◆ SubStepSetPressureBCs()

◆ UpdateRobinPrimCoeff()

◆ v_AddNormVelOnOBC()

◆ v_CalcNeumannPressureBCs()

◆ v_CorrectPressureBCs()

◆ v_EvaluatePressureBCs()

◆ v_GetSubStepIntegrationMethod()

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