#include <Extrapolate.h>

Inheritance diagram for Nektar::Extrapolate:

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

virtual	~Extrapolate ()

void	GenerateHOPBCMap (const LibUtilities::SessionReaderSharedPtr &pSsession)

void	UpdateRobinPrimCoeff (void)

void	SubSteppingTimeIntegration (const LibUtilities::TimeIntegrationSchemeSharedPtr &IntegrationScheme)

void	SubStepSaveFields (const int nstep)

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

void	SubStepAdvance (const int nstep, NekDouble time)

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

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

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

void	AddDuDt (void)

void	AddVelBC (void)

void	ExtrapolatePressureHBCs (void)

void	CopyPressureHBCsToPbndExp (void)

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

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

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

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

std::string	GetSubStepName (void)

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

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

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

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

void	AddPressureToOutflowBCs (NekDouble kinvis)

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

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

virtual void	v_SubStepSaveFields (int nstep)=0

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

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

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

virtual std::string	v_GetSubStepName (void)

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

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

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

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

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

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

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

Protected Attributes
LibUtilities::SessionReaderSharedPtr	m_session

LibUtilities::CommSharedPtr	m_comm

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

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

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

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

SolverUtils::AdvectionSharedPtr	m_advObject

std::vector< SolverUtils::ForcingSharedPtr >	m_forcing

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

int	m_curl_dim
	Curl-curl dimensionality. More...

int	m_bnd_dim
	bounday dimensionality More...

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

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

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

int	m_numHBCDof

int	m_HBCnumber

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

NekDouble	m_timestep

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

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

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

HighOrderOutflowSharedPtr	m_houtflow

Static Protected Attributes
static NekDouble	StifflyStable_Betaq_Coeffs [3][3]

static NekDouble	StifflyStable_Alpha_Coeffs [3][3]

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

Static Private Attributes
static std::string	def

Detailed Description

Definition at line 73 of file Extrapolate.h.

Constructor & Destructor Documentation

◆ Extrapolate()

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

Definition at line 54 of file Extrapolate.cpp.

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

References m_comm, m_session, and m_timestep.

◆ ~Extrapolate()

Nektar::Extrapolate::~Extrapolate ( )

virtual

Definition at line 66 of file Extrapolate.cpp.

67{

68}

Member Function Documentation

◆ AddDuDt()

void Nektar::Extrapolate::AddDuDt ( void )

Definition at line 77 of file Extrapolate.cpp.

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

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

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

◆ AddNormVelOnOBC()

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

inline

Definition at line 405 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 465 of file Extrapolate.cpp.

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

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

◆ AddVelBC()

void Nektar::Extrapolate::AddVelBC ( void )

Definition at line 98 of file Extrapolate.cpp.

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

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

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

◆ CalcNeumannPressureBCs()

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

inlineprotected

Definition at line 170 of file Extrapolate.h.

    {
        v_CalcNeumannPressureBCs(fields, N, kinvis);
    }

References v_CalcNeumannPressureBCs().

Referenced by Nektar::ImplicitExtrapolate::v_EvaluatePressureBCs(), 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 208 of file Extrapolate.cpp.

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

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

Referenced by Nektar::ImplicitExtrapolate::v_EvaluatePressureBCs(), 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 1039 of file Extrapolate.cpp.

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

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

Referenced by Nektar::ImplicitExtrapolate::v_EvaluatePressureBCs(), 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 396 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 984 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 324 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 958 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 616 of file Extrapolate.cpp.

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

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

◆ GetMaxStdVelocity()

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

Definition at line 852 of file Extrapolate.cpp.

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

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

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

◆ GetSubStepName()

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

inline

Definition at line 388 of file Extrapolate.h.

{
    return v_GetSubStepName();
}

References v_GetSubStepName().

◆ IProductNormVelocityBCOnHBC()

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

Definition at line 547 of file Extrapolate.cpp.

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

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

Referenced by AddDuDt(), and AddVelBC().

◆ IProductNormVelocityOnHBC()

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

Definition at line 518 of file Extrapolate.cpp.

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

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

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

◆ MountHOPBCs()

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

inline

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

{
    m_forcing = forcing;
}

References m_forcing.

◆ SubStepAdvance()

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

inline

Definition at line 370 of file Extrapolate.h.

{
    v_SubStepAdvance(nstep, time);
}

References v_SubStepAdvance().

◆ SubSteppingTimeIntegration()

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

inline

Definition at line 334 of file Extrapolate.h.

{
    v_SubSteppingTimeIntegration(IntegrationScheme);
}

References v_SubSteppingTimeIntegration().

◆ SubStepSaveFields()

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

inline

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

{
    v_SubStepSetPressureBCs(inarray, Aii_DT, kinvis);
}

References v_SubStepSetPressureBCs().

◆ UpdateRobinPrimCoeff()

void Nektar::Extrapolate::UpdateRobinPrimCoeff ( void )

Definition at line 810 of file Extrapolate.cpp.

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

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

Referenced by CalcOutflowBCs().

◆ v_AccelerationBDF()

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

protectedvirtual

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

Reimplemented in Nektar::StandardExtrapolate.

Definition at line 1010 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::SubSteppingExtrapolateWeakPressure, and Nektar::WeakPressureExtrapolate.

Definition at line 202 of file Extrapolate.cpp.

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

Referenced by AddNormVelOnOBC().

◆ v_CalcNeumannPressureBCs()

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

protectedvirtual

Unified routine for calculation high-oder terms

Reimplemented in Nektar::MappingExtrapolate.

Definition at line 119 of file Extrapolate.cpp.

{
    size_t n, cnt;
 
    Array<OneD, NekDouble> Pvals;
 
    Array<OneD, Array<OneD, NekDouble>> Velocity(m_curl_dim);
    Array<OneD, Array<OneD, NekDouble>> Advection(m_bnd_dim);
 
    Array<OneD, Array<OneD, NekDouble>> BndValues(m_bnd_dim);
    Array<OneD, Array<OneD, NekDouble>> Q(m_curl_dim);
 
    // Loop all boundary conditions
    MultiRegions::ExpListSharedPtr BndElmtExp;
    for (n = cnt = 0; n < m_PBndConds.size(); ++n)
    {
        // Detect higher order boundary conditions
        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();
            int ncoeffs = m_PBndExp[n]->GetNcoeffs();
 
            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 += ncoeffs;
        }
    }
}

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

{
    boost::ignore_unused(pressure);
}

References CG_Iterations::pressure.

Referenced by CorrectPressureBCs().

◆ v_EvaluatePressureBCs()

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

protectedpure virtual

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

Referenced by EvaluatePressureBCs().

◆ v_GetSubStepName()

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

protectedvirtual

Reimplemented in Nektar::SubSteppingExtrapolate.

Definition at line 947 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::StandardExtrapolate, Nektar::SubSteppingExtrapolate, and Nektar::WeakPressureExtrapolate.

Referenced by MountHOPBCs().

◆ v_SubStepAdvance()

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

protectedpure virtual

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

Referenced by SubStepAdvance().

◆ v_SubSteppingTimeIntegration()

virtual void Nektar::Extrapolate::v_SubSteppingTimeIntegration ( const LibUtilities::TimeIntegrationSchemeSharedPtr & 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::StandardExtrapolate, and Nektar::SubSteppingExtrapolate.

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::StandardExtrapolate, Nektar::SubSteppingExtrapolate, 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 259 of file Extrapolate.h.

◆ m_advObject

SolverUtils::AdvectionSharedPtr Nektar::Extrapolate::m_advObject

protected

Definition at line 208 of file Extrapolate.h.

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

◆ m_bnd_dim

int Nektar::Extrapolate::m_bnd_dim

protected

bounday dimensionality

Definition at line 218 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 193 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 215 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 199 of file Extrapolate.h.

◆ m_forcing

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

protected

Definition at line 210 of file Extrapolate.h.

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

◆ m_HBCnumber

int Nektar::Extrapolate::m_HBCnumber

protected

Definition at line 233 of file Extrapolate.h.

Referenced by GenerateHOPBCMap(), IProductNormVelocityBCOnHBC(), Nektar::MappingExtrapolate::v_CorrectPressureBCs(), Nektar::ImplicitExtrapolate::v_EvaluatePressureBCs(), 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 196 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 256 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 246 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 230 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 221 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 224 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 202 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 227 of file Extrapolate.h.

Referenced by AddVelBC(), EvaluateBDFArray(), ExtrapolateArray(), GenerateHOPBCMap(), UpdateRobinPrimCoeff(), v_AccelerationBDF(), Nektar::StandardExtrapolate::v_AccelerationBDF(), Nektar::ImplicitExtrapolate::v_EvaluatePressureBCs(), 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 242 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 212 of file Extrapolate.h.

◆ m_session

LibUtilities::SessionReaderSharedPtr Nektar::Extrapolate::m_session

protected

Definition at line 191 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 238 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 248 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 206 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 252 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 251 of file Extrapolate.h.

Referenced by ExtrapolateArray().

◆ StifflyStable_Gamma0_Coeffs

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

staticprotected

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