#include <SubSteppingExtrapolate.h>

Inheritance diagram for Nektar::SubSteppingExtrapolate:

Static Public Member Functions
static ExtrapolateSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, MultiRegions::ExpListSharedPtr &pPressure, const Array< OneD, int > &pVel, const SolverUtils::AdvectionSharedPtr &advObject)
	Creates an instance of this class. More...

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

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

	~SubSteppingExtrapolate () override=default

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

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

void	v_SubStepSaveFields (int nstep) override

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

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

void	v_SubStepAdvance (int nstep, NekDouble time) override

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

std::string	v_GetSubStepName (void) override

void	SubStepAdvection (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)

void	SubStepProjection (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)

void	SubStepExtrapolateField (NekDouble toff, Array< OneD, Array< OneD, NekDouble > > &ExtVel, Array< OneD, NekDouble > &ExtVn)

void	AddAdvectionPenaltyFlux (const Array< OneD, NekDouble > &Vn, const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &outarray)

NekDouble	GetSubstepTimeStep ()

Protected Member Functions inherited from Nektar::Extrapolate
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)

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::TimeIntegrationSchemeSharedPtr	m_intScheme

LibUtilities::TimeIntegrationSchemeSharedPtr	m_subStepIntegrationScheme

LibUtilities::TimeIntegrationSchemeOperators	m_subStepIntegrationOps

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

Array< OneD, Array< OneD, NekDouble > >	m_previousVnFields

NekDouble	m_cflSafetyFactor

int	m_infosteps

int	m_minsubsteps

int	m_maxsubsteps

Protected Attributes inherited from Nektar::Extrapolate
LibUtilities::SessionReaderSharedPtr	m_session

LibUtilities::CommSharedPtr	m_comm

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

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

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

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

SolverUtils::AdvectionSharedPtr	m_advObject

std::vector< SolverUtils::ForcingSharedPtr >	m_forcing

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

int	m_curl_dim
	Curl-curl dimensionality. More...

int	m_bnd_dim
	bounday dimensionality More...

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

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

Array< OneD, MultiRegions::ExpListSharedPtr >	m_bndElmtExps
	Boundary expansions on each domain boundary. 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

Friends
class	MemoryManager< SubSteppingExtrapolate >

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

virtual	~Extrapolate ()=default

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

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

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

std::string	GetSubStepName (void)

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

void	GenerateHOPBCMap (const LibUtilities::SessionReaderSharedPtr &pSsession)

void	UpdateRobinPrimCoeff (void)

void	AddDuDt (void)

void	AddVelBC (void)

void	ExtrapolatePressureHBCs (void)

void	CopyPressureHBCsToPbndExp (void)

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

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

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

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	AddPressureToOutflowBCs (NekDouble kinvis)

void	GenerateBndElmtExpansion (void)

Static Protected Attributes inherited from Nektar::Extrapolate
static NekDouble	StifflyStable_Betaq_Coeffs [3][3]

static NekDouble	StifflyStable_Alpha_Coeffs [3][3]

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

Detailed Description

Definition at line 57 of file SubSteppingExtrapolate.h.

Constructor & Destructor Documentation

◆ SubSteppingExtrapolate()

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

protected

Definition at line 51 of file SubSteppingExtrapolate.cpp.

    : Extrapolate(pSession, pFields, pPressure, pVel, advObject)
{
    m_session->LoadParameter("IO_InfoSteps", m_infosteps, 0);
    m_session->LoadParameter("SubStepCFL", m_cflSafetyFactor, 0.5);
    m_session->LoadParameter("MinSubSteps", m_minsubsteps, 1);
    m_session->LoadParameter("MaxSubSteps", m_maxsubsteps, 100);
 
    size_t dim     = m_fields[0]->GetCoordim(0);
    m_traceNormals = Array<OneD, Array<OneD, NekDouble>>(dim);
 
    size_t nTracePts = m_fields[0]->GetTrace()->GetNpoints();
    for (size_t i = 0; i < dim; ++i)
    {
        m_traceNormals[i] = Array<OneD, NekDouble>(nTracePts);
    }
    m_fields[0]->GetTrace()->GetNormals(m_traceNormals);
}

References m_cflSafetyFactor, Nektar::Extrapolate::m_fields, m_infosteps, m_maxsubsteps, m_minsubsteps, Nektar::Extrapolate::m_session, and Nektar::Extrapolate::m_traceNormals.

◆ ~SubSteppingExtrapolate()

Nektar::SubSteppingExtrapolate::~SubSteppingExtrapolate ( )

overrideprotecteddefault

Member Function Documentation

◆ AddAdvectionPenaltyFlux()

void Nektar::SubSteppingExtrapolate::AddAdvectionPenaltyFlux	(	const Array< OneD, NekDouble > &	Vn,
		const Array< OneD, const Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	Outarray
	)

protected

Add the advection penalty term \( (\hat{u} - u^e)V_n \) given the normal velocity Vn at this time level and the physfield values containing the velocity field at this time level

Number of trace points

Forward state array

Backward state array

upwind numerical flux state array

Extract forwards/backwards trace spaces Note it is important to use the zeroth field but with the specialised method to use boudnary conditions from other fields since trace spaces may not be the same if there are mixed boundary conditions

Upwind between elements

Construct difference between numflux and Fwd,Bwd

Calculate the numerical fluxes multipling Fwd, Bwd and numflux by the normal advection velocity

Definition at line 519 of file SubSteppingExtrapolate.cpp.

{
    ASSERTL1(physfield.size() == Outarray.size(),
             "Physfield and outarray are of different dimensions");
 
    size_t i;
    Nektar::LibUtilities::Timer timer;
    timer.Start();
 
    /// Number of trace points
    size_t nTracePts = m_fields[0]->GetTrace()->GetNpoints();
 
    /// Forward state array
    Array<OneD, NekDouble> Fwd(3 * nTracePts);
 
    /// Backward state array
    Array<OneD, NekDouble> Bwd = Fwd + nTracePts;
 
    /// upwind numerical flux state array
    Array<OneD, NekDouble> numflux = Bwd + nTracePts;
 
    for (i = 0; i < physfield.size(); ++i)
    {
        /// Extract forwards/backwards trace spaces
        /// Note it is important to use the zeroth field but with the
        /// specialised method to use boudnary conditions from other
        /// fields since trace spaces may not be the same if there are
        /// mixed boundary conditions
        std::dynamic_pointer_cast<MultiRegions::DisContField>(m_fields[0])
            ->GetFwdBwdTracePhys(physfield[i], Fwd, Bwd,
                                 m_fields[i]->GetBndConditions(),
                                 m_fields[i]->GetBndCondExpansions());
 
        /// Upwind between elements
        m_fields[0]->GetTrace()->Upwind(Vn, Fwd, Bwd, numflux);
 
        /// Construct difference between numflux and Fwd,Bwd
        Vmath::Vsub(nTracePts, numflux, 1, Fwd, 1, Fwd, 1);
        Vmath::Vsub(nTracePts, numflux, 1, Bwd, 1, Bwd, 1);
 
        /// Calculate the numerical fluxes multipling Fwd, Bwd and
        /// numflux by the normal advection velocity
        Vmath::Vmul(nTracePts, Fwd, 1, Vn, 1, Fwd, 1);
        Vmath::Vmul(nTracePts, Bwd, 1, Vn, 1, Bwd, 1);
 
        m_fields[0]->AddFwdBwdTraceIntegral(Fwd, Bwd, Outarray[i]);
    }
    timer.Stop();
    timer.AccumulateRegion("SubSteppingExtrapolate:AddAdvectionPenaltyFlux",
                           10);
}

References Nektar::LibUtilities::Timer::AccumulateRegion(), ASSERTL1, Nektar::Extrapolate::m_fields, Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), Vmath::Vmul(), and Vmath::Vsub().

Referenced by SubStepAdvection().

◆ create()

static ExtrapolateSharedPtr Nektar::SubSteppingExtrapolate::create	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		Array< OneD, MultiRegions::ExpListSharedPtr > &	pFields,
		MultiRegions::ExpListSharedPtr &	pPressure,
		const Array< OneD, int > &	pVel,
		const SolverUtils::AdvectionSharedPtr &	advObject
	)

inlinestatic

Creates an instance of this class.

Definition at line 63 of file SubSteppingExtrapolate.h.

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

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

◆ GetSubstepTimeStep()

NekDouble Nektar::SubSteppingExtrapolate::GetSubstepTimeStep ( )

protected

Definition at line 478 of file SubSteppingExtrapolate.cpp.

{
    Nektar::LibUtilities::Timer timer;
    timer.Start();
    size_t n_element = m_fields[0]->GetExpSize();
 
    const Array<OneD, int> ExpOrder = m_fields[0]->EvalBasisNumModesMaxPerExp();
 
    const NekDouble cLambda = 0.2; // Spencer book pag. 317
 
    Array<OneD, NekDouble> tstep(n_element, 0.0);
    Array<OneD, NekDouble> stdVelocity(n_element, 0.0);
    Array<OneD, Array<OneD, NekDouble>> velfields(m_velocity.size());
 
    for (size_t i = 0; i < m_velocity.size(); ++i)
    {
        velfields[i] = m_fields[m_velocity[i]]->UpdatePhys();
    }
    stdVelocity = GetMaxStdVelocity(velfields);
 
    for (size_t el = 0; el < n_element; ++el)
    {
        tstep[el] =
            m_cflSafetyFactor / (stdVelocity[el] * cLambda *
                                 (ExpOrder[el] - 1) * (ExpOrder[el] - 1));
    }
 
    NekDouble TimeStep = Vmath::Vmin(n_element, tstep, 1);
    m_comm->AllReduce(TimeStep, LibUtilities::ReduceMin);
    timer.Stop();
    timer.AccumulateRegion("SubSteppingExtrapolate:GetSubStepTimeStep", 10);
 
    return TimeStep;
}

References Nektar::LibUtilities::Timer::AccumulateRegion(), Nektar::Extrapolate::GetMaxStdVelocity(), m_cflSafetyFactor, Nektar::Extrapolate::m_comm, Nektar::Extrapolate::m_fields, Nektar::Extrapolate::m_velocity, Nektar::LibUtilities::ReduceMin, Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), and Vmath::Vmin().

Referenced by v_SubStepAdvance().

◆ SubStepAdvection()

void Nektar::SubSteppingExtrapolate::SubStepAdvection	(	const Array< OneD, const Array< OneD, NekDouble > > &	inarray,
		Array< OneD, Array< OneD, NekDouble > > &	outarray,
		const NekDouble	time
	)

protected

Explicit Advection terms used by SubStepAdvance time integration

Get the number of coefficients

Define an auxiliary variable to compute the RHS

Operations to compute the RHS

Multiply the flux by the inverse of the mass matrix

Store in outarray the physical values of the RHS

Definition at line 158 of file SubSteppingExtrapolate.cpp.

{
    Nektar::LibUtilities::Timer timer, timer1;
    size_t i;
    size_t nVariables     = inarray.size();
    size_t nQuadraturePts = inarray[0].size();
 
    timer.Start();
    /// Get the number of coefficients
    size_t ncoeffs = m_fields[0]->GetNcoeffs();
 
    /// Define an auxiliary variable to compute the RHS
    Array<OneD, Array<OneD, NekDouble>> WeakAdv(nVariables);
    WeakAdv[0] = Array<OneD, NekDouble>(ncoeffs * nVariables);
    for (i = 1; i < nVariables; ++i)
    {
        WeakAdv[i] = WeakAdv[i - 1] + ncoeffs;
    }
 
    Array<OneD, Array<OneD, NekDouble>> Velfields(m_velocity.size());
 
    Velfields[0] = Array<OneD, NekDouble>(nQuadraturePts * m_velocity.size());
 
    for (i = 1; i < m_velocity.size(); ++i)
    {
        Velfields[i] = Velfields[i - 1] + nQuadraturePts;
    }
 
    Array<OneD, NekDouble> Vn(m_fields[0]->GetTrace()->GetTotPoints());
 
    SubStepExtrapolateField(fmod(time, m_timestep), Velfields, Vn);
 
    for (auto &x : m_forcing)
    {
        x->PreApply(m_fields, Velfields, Velfields, time);
    }
    timer1.Start();
    m_advObject->Advect(m_velocity.size(), m_fields, Velfields, inarray,
                        outarray, time);
    timer1.Stop();
    timer1.AccumulateRegion("SubStepAdvection:Advect", 10);
 
    for (auto &x : m_forcing)
    {
        x->Apply(m_fields, outarray, outarray, time);
    }
 
    for (i = 0; i < nVariables; ++i)
    {
        m_fields[i]->IProductWRTBase(outarray[i], WeakAdv[i]);
        // negation requried due to sign of DoAdvection term to be consistent
        Vmath::Neg(ncoeffs, WeakAdv[i], 1);
    }
 
    AddAdvectionPenaltyFlux(Vn, inarray, WeakAdv);
 
    /// Operations to compute the RHS
    for (i = 0; i < nVariables; ++i)
    {
        // Negate the RHS
        Vmath::Neg(ncoeffs, WeakAdv[i], 1);
 
        /// Multiply the flux by the inverse of the mass matrix
        m_fields[i]->MultiplyByElmtInvMass(WeakAdv[i], WeakAdv[i]);
 
        /// Store in outarray the physical values of the RHS
        m_fields[i]->BwdTrans(WeakAdv[i], outarray[i]);
    }
    timer.Stop();
    timer.AccumulateRegion("SubSteppingExtrapolate:SubStepAdvection", 10);
}

References Nektar::LibUtilities::Timer::AccumulateRegion(), AddAdvectionPenaltyFlux(), Nektar::Extrapolate::m_advObject, Nektar::Extrapolate::m_fields, Nektar::Extrapolate::m_forcing, Nektar::Extrapolate::m_timestep, Nektar::Extrapolate::m_velocity, Vmath::Neg(), Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), and SubStepExtrapolateField().

Referenced by v_SubSteppingTimeIntegration().

◆ SubStepExtrapolateField()

void Nektar::SubSteppingExtrapolate::SubStepExtrapolateField	(	NekDouble	toff,
		Array< OneD, Array< OneD, NekDouble > > &	ExtVel,
		Array< OneD, NekDouble > &	ExtVn
	)

protected

Extrapolate field using equally time spaced field un,un-1,un-2, (at dt intervals) to time for substep n+t at order m_intSteps. Also extrapolate the normal velocity along the trace at the same order

Definition at line 579 of file SubSteppingExtrapolate.cpp.

{
    size_t npts      = m_fields[0]->GetTotPoints();
    size_t ntracepts = m_fields[0]->GetTrace()->GetTotPoints();
    size_t nvel      = m_velocity.size();
    size_t i, j;
    Array<OneD, NekDouble> l(4);
    Nektar::LibUtilities::Timer timer;
    timer.Start();
 
    size_t ord = m_intSteps;
 
    // calculate Lagrange interpolants
    Vmath::Fill(4, 1.0, l, 1);
 
    for (i = 0; i <= ord; ++i)
    {
        for (j = 0; j <= ord; ++j)
        {
            if (i != j)
            {
                l[i] *= (j * m_timestep + toff);
                l[i] /= (j * m_timestep - i * m_timestep);
            }
        }
    }
 
    for (i = 0; i < nvel; ++i)
    {
        Vmath::Smul(npts, l[0], m_previousVelFields[i], 1, ExtVel[i], 1);
 
        for (j = 1; j <= ord; ++j)
        {
            Blas::Daxpy(npts, l[j], m_previousVelFields[j * nvel + i], 1,
                        ExtVel[i], 1);
        }
    }
 
    Vmath::Smul(ntracepts, l[0], m_previousVnFields[0], 1, ExtVn, 1);
    for (j = 1; j <= ord; ++j)
    {
        Blas::Daxpy(ntracepts, l[j], m_previousVnFields[j], 1, ExtVn, 1);
    }
    timer.Stop();
    timer.AccumulateRegion("SubSteppingExtrapolate:SubStepExtrapolateFields",
                           10);
}

References Nektar::LibUtilities::Timer::AccumulateRegion(), Blas::Daxpy(), Vmath::Fill(), Nektar::Extrapolate::m_fields, Nektar::Extrapolate::m_intSteps, m_previousVelFields, m_previousVnFields, Nektar::Extrapolate::m_timestep, Nektar::Extrapolate::m_velocity, Vmath::Smul(), Nektar::LibUtilities::Timer::Start(), and Nektar::LibUtilities::Timer::Stop().

Referenced by SubStepAdvection().

◆ SubStepProjection()

void Nektar::SubSteppingExtrapolate::SubStepProjection	(	const Array< OneD, const Array< OneD, NekDouble > > &	inarray,
		Array< OneD, Array< OneD, NekDouble > > &	outarray,
		const NekDouble	time
	)

protected

Projection used by SubStepAdvance time integration

Definition at line 235 of file SubSteppingExtrapolate.cpp.

{
    Nektar::LibUtilities::Timer timer;
    ASSERTL1(inarray.size() == outarray.size(),
             "Inarray and outarray of different sizes ");
 
    timer.Start();
    for (size_t i = 0; i < inarray.size(); ++i)
    {
        Vmath::Vcopy(inarray[i].size(), inarray[i], 1, outarray[i], 1);
    }
    timer.Stop();
    timer.AccumulateRegion("SubSteppingExtrapolate:SubStepProjection", 10);
}

References Nektar::LibUtilities::Timer::AccumulateRegion(), ASSERTL1, Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), and Vmath::Vcopy().

Referenced by v_SubSteppingTimeIntegration().

◆ v_AccelerationBDF()

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

overrideprotectedvirtual

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 from Nektar::Extrapolate.

Definition at line 292 of file SubSteppingExtrapolate.cpp.

{
    Nektar::LibUtilities::Timer timer;
    int nlevels = array.size();
    int nPts    = array[0].size();
 
    timer.Start();
    if (nPts)
    {
        // Update array
        RollOver(array);
 
        // Calculate acceleration using Backward Differentiation Formula
        Array<OneD, NekDouble> accelerationTerm(nPts, 0.0);
 
        int acc_order = std::min(m_pressureCalls, 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;
    }
    timer.Stop();
    timer.AccumulateRegion("SubSteppingExtrapolate:v_AccelerationBDF", 10);
}

References Nektar::LibUtilities::Timer::AccumulateRegion(), Nektar::Extrapolate::m_intSteps, Nektar::Extrapolate::m_pressureCalls, Nektar::Extrapolate::RollOver(), Vmath::Smul(), Nektar::LibUtilities::Timer::Start(), Nektar::Extrapolate::StifflyStable_Alpha_Coeffs, Nektar::Extrapolate::StifflyStable_Gamma0_Coeffs, Nektar::LibUtilities::Timer::Stop(), and Vmath::Svtvp().

◆ v_EvaluatePressureBCs()

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

overrideprotectedvirtual

Implements Nektar::Extrapolate.

Definition at line 74 of file SubSteppingExtrapolate.cpp.

{
    ASSERTL0(false, "This method should not be called by Substepping routine");
}

References ASSERTL0.

◆ v_GetSubStepName()

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

overrideprotectedvirtual

Reimplemented from Nektar::Extrapolate.

Definition at line 639 of file SubSteppingExtrapolate.cpp.

{
    return m_subStepIntegrationScheme->GetName();
}

References m_subStepIntegrationScheme.

◆ v_MountHOPBCs()

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

overrideprotectedvirtual

Implements Nektar::Extrapolate.

Definition at line 632 of file SubSteppingExtrapolate.cpp.

{
    Vmath::Smul(HBCdata, -kinvis, Q, 1, Q, 1);
}

References Vmath::Smul().

◆ v_SubStepAdvance()

void Nektar::SubSteppingExtrapolate::v_SubStepAdvance	(	int	nstep,
		NekDouble	time
	)

overrideprotectedvirtual

Implements Nektar::Extrapolate.

Definition at line 412 of file SubSteppingExtrapolate.cpp.

{
    int n;
    int nsubsteps;
    Nektar::LibUtilities::Timer timer;
 
    NekDouble dt;
 
    Array<OneD, Array<OneD, NekDouble>> fields;
 
    timer.Start();
    static int ncalls = 1;
    size_t nint       = std::min(ncalls++, m_intSteps);
 
    // this needs to change
    m_comm = m_fields[0]->GetComm()->GetRowComm();
 
    // Get the proper time step with CFL control
    dt = GetSubstepTimeStep();
 
    nsubsteps = (m_timestep > dt) ? ((int)(m_timestep / dt) + 1) : 1;
    nsubsteps = std::max(m_minsubsteps, nsubsteps);
 
    ASSERTL0(nsubsteps < m_maxsubsteps,
             "Number of substeps has exceeded maximum");
 
    dt = m_timestep / nsubsteps;
 
    if (m_infosteps && !((nstep + 1) % m_infosteps) && m_comm->GetRank() == 0)
    {
        std::cout << "Sub-integrating using " << nsubsteps
                  << " steps over Dt = " << m_timestep
                  << " (SubStep CFL=" << m_cflSafetyFactor << ")" << std::endl;
    }
 
    const TripleArray &solutionVector = m_intScheme->GetSolutionVector();
 
    for (size_t m = 0; m < nint; ++m)
    {
        // We need to update the fields held by the m_intScheme
        fields = solutionVector[m];
 
        // Initialise NS solver which is set up to use a GLM method
        // with calls to EvaluateAdvection_SetPressureBCs and
        // SolveUnsteadyStokesSystem
        m_subStepIntegrationScheme->InitializeScheme(dt, fields, time,
                                                     m_subStepIntegrationOps);
 
        for (n = 0; n < nsubsteps; ++n)
        {
            fields = m_subStepIntegrationScheme->TimeIntegrate(n, dt);
        }
 
        // set up HBC m_acceleration field for Pressure BCs
        IProductNormVelocityOnHBC(fields, m_iprodnormvel[m]);
 
        // Reset time integrated solution in m_intScheme
        m_intScheme->SetSolutionVector(m, fields);
    }
    timer.Stop();
    timer.AccumulateRegion("SubSteppingExtrapolate:v_SubStepAdvance", 10);
}

References Nektar::LibUtilities::Timer::AccumulateRegion(), ASSERTL0, GetSubstepTimeStep(), Nektar::Extrapolate::IProductNormVelocityOnHBC(), m_cflSafetyFactor, Nektar::Extrapolate::m_comm, Nektar::Extrapolate::m_fields, m_infosteps, m_intScheme, Nektar::Extrapolate::m_intSteps, Nektar::Extrapolate::m_iprodnormvel, m_maxsubsteps, m_minsubsteps, m_subStepIntegrationOps, m_subStepIntegrationScheme, Nektar::Extrapolate::m_timestep, Nektar::LibUtilities::Timer::Start(), and Nektar::LibUtilities::Timer::Stop().

◆ v_SubSteppingTimeIntegration()

void Nektar::SubSteppingExtrapolate::v_SubSteppingTimeIntegration ( const LibUtilities::TimeIntegrationSchemeSharedPtr & IntegrationScheme )

overrideprotectedvirtual

Implements Nektar::Extrapolate.

Definition at line 82 of file SubSteppingExtrapolate.cpp.

{
    Nektar::LibUtilities::Timer timer;
    m_intScheme = IntegrationScheme;
 
    timer.Start();
    size_t order = IntegrationScheme->GetOrder();
 
    // Set to 1 for first step and it will then be increased in
    // time advance routines
    if ((IntegrationScheme->GetName() == "Euler" &&
         IntegrationScheme->GetVariant() == "Backward") ||
 
        (IntegrationScheme->GetName() == "BDFImplicit" &&
         (order == 1 || order == 2)))
    {
        // Note RK first order SSP is just Forward Euler.
        std::string vSubStepIntScheme        = "RungeKutta";
        std::string vSubStepIntSchemeVariant = "SSP";
        int vSubStepIntSchemeOrder           = order;
 
        if (m_session->DefinesSolverInfo("SubStepIntScheme"))
        {
            vSubStepIntScheme = m_session->GetSolverInfo("SubStepIntScheme");
            vSubStepIntSchemeVariant = "";
            vSubStepIntSchemeOrder   = order;
        }
 
        m_subStepIntegrationScheme =
            LibUtilities::GetTimeIntegrationSchemeFactory().CreateInstance(
                vSubStepIntScheme, vSubStepIntSchemeVariant,
                vSubStepIntSchemeOrder, std::vector<NekDouble>());
 
        size_t nvel = m_velocity.size();
        size_t ndim = order + 1;
 
        // Fields for linear/quadratic interpolation
        m_previousVelFields = Array<OneD, Array<OneD, NekDouble>>(ndim * nvel);
        int ntotpts         = m_fields[0]->GetTotPoints();
        m_previousVelFields[0] = Array<OneD, NekDouble>(ndim * nvel * ntotpts);
 
        for (size_t i = 1; i < ndim * nvel; ++i)
        {
            m_previousVelFields[i] = m_previousVelFields[i - 1] + ntotpts;
        }
        // Vn fields
        m_previousVnFields    = Array<OneD, Array<OneD, NekDouble>>(ndim);
        ntotpts               = m_fields[0]->GetTrace()->GetTotPoints();
        m_previousVnFields[0] = Array<OneD, NekDouble>(ndim * ntotpts);
        for (size_t i = 1; i < ndim; ++i)
        {
            m_previousVnFields[i] = m_previousVnFields[i - 1] + ntotpts;
        }
    }
    else
    {
        ASSERTL0(0, "Integration method not suitable: Options include "
                    "BackwardEuler or BDFImplicitOrder{1,2}");
    }
 
    m_intSteps = IntegrationScheme->GetNumIntegrationPhases();
 
    // set explicit time-integration class operators
    m_subStepIntegrationOps.DefineOdeRhs(
        &SubSteppingExtrapolate::SubStepAdvection, this);
    m_subStepIntegrationOps.DefineProjection(
        &SubSteppingExtrapolate::SubStepProjection, this);
    timer.Stop();
    timer.AccumulateRegion(
        "SubSteppingExtrapolate:v_SubSteppingTimeIntegration", 10);
}

References Nektar::LibUtilities::Timer::AccumulateRegion(), ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineOdeRhs(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineProjection(), Nektar::LibUtilities::GetTimeIntegrationSchemeFactory(), Nektar::Extrapolate::m_fields, m_intScheme, Nektar::Extrapolate::m_intSteps, m_previousVelFields, m_previousVnFields, Nektar::Extrapolate::m_session, m_subStepIntegrationOps, m_subStepIntegrationScheme, Nektar::Extrapolate::m_velocity, Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), SubStepAdvection(), and SubStepProjection().

◆ v_SubStepSaveFields()

void Nektar::SubSteppingExtrapolate::v_SubStepSaveFields ( int nstep )

overrideprotectedvirtual

Save the current fields in m_previousVelFields and cycle out older previous fields so that it can be extrapolated to the new substeps of the next time step. Also extract the normal trace of the velocity field into m_previousVnFields along the trace so that this can also be extrapolated.

Implements Nektar::Extrapolate.

Definition at line 331 of file SubSteppingExtrapolate.cpp.

{
    Nektar::LibUtilities::Timer timer;
    size_t i, n;
    timer.Start();
    size_t nvel      = m_velocity.size();
    size_t npts      = m_fields[0]->GetTotPoints();
    size_t ntracepts = m_fields[0]->GetTrace()->GetTotPoints();
 
    // rotate fields
    size_t nblocks = m_previousVelFields.size() / nvel;
    Array<OneD, NekDouble> save;
 
    // rotate storage space
    for (n = 0; n < nvel; ++n)
    {
        save = m_previousVelFields[(nblocks - 1) * nvel + n];
 
        for (i = nblocks - 1; i > 0; --i)
        {
            m_previousVelFields[i * nvel + n] =
                m_previousVelFields[(i - 1) * nvel + n];
        }
 
        m_previousVelFields[n] = save;
    }
 
    save = m_previousVnFields[nblocks - 1];
    for (i = nblocks - 1; i > 0; --i)
    {
        m_previousVnFields[i] = m_previousVnFields[i - 1];
    }
    m_previousVnFields[0] = save;
 
    // Put previous field
    for (i = 0; i < nvel; ++i)
    {
        m_fields[m_velocity[i]]->BwdTrans(
            m_fields[m_velocity[i]]->GetCoeffs(),
            m_fields[m_velocity[i]]->UpdatePhys());
        Vmath::Vcopy(npts, m_fields[m_velocity[i]]->GetPhys(), 1,
                     m_previousVelFields[i], 1);
    }
 
    Array<OneD, NekDouble> Fwd(ntracepts);
 
    // calculate Vn
    m_fields[0]->ExtractTracePhys(m_previousVelFields[0], Fwd);
    Vmath::Vmul(ntracepts, m_traceNormals[0], 1, Fwd, 1, m_previousVnFields[0],
                1);
    for (i = 1; i < m_bnd_dim; ++i)
    {
        m_fields[0]->ExtractTracePhys(m_previousVelFields[i], Fwd);
        Vmath::Vvtvp(ntracepts, m_traceNormals[i], 1, Fwd, 1,
                     m_previousVnFields[0], 1, m_previousVnFields[0], 1);
    }
 
    if (nstep == 0) // initialise all levels with first field
    {
        for (n = 0; n < nvel; ++n)
        {
            for (i = 1; i < nblocks; ++i)
            {
                Vmath::Vcopy(npts, m_fields[m_velocity[n]]->GetPhys(), 1,
                             m_previousVelFields[i * nvel + n], 1);
            }
        }
 
        for (i = 1; i < nblocks; ++i)
        {
            Vmath::Vcopy(ntracepts, m_previousVnFields[0], 1,
                         m_previousVnFields[i], 1);
        }
    }
    timer.Stop();
    timer.AccumulateRegion("SubSteppingExtrapolate:v_SubStepSaveFields", 10);
}

References Nektar::LibUtilities::Timer::AccumulateRegion(), Nektar::Extrapolate::m_bnd_dim, Nektar::Extrapolate::m_fields, m_previousVelFields, m_previousVnFields, Nektar::Extrapolate::m_traceNormals, Nektar::Extrapolate::m_velocity, Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), Vmath::Vcopy(), Vmath::Vmul(), and Vmath::Vvtvp().

◆ v_SubStepSetPressureBCs()

void Nektar::SubSteppingExtrapolate::v_SubStepSetPressureBCs	(	const Array< OneD, const Array< OneD, NekDouble > > &	inarray,
		NekDouble	Aii_Dt,
		NekDouble	kinvis
	)

overrideprotectedvirtual

Implements Nektar::Extrapolate.

Reimplemented in Nektar::SubSteppingExtrapolateWeakPressure.

Definition at line 256 of file SubSteppingExtrapolate.cpp.

{
    Nektar::LibUtilities::Timer timer;
    // int nConvectiveFields =m_fields.size()-1;
    Array<OneD, Array<OneD, NekDouble>> nullvelfields;
 
    timer.Start();
    m_pressureCalls++;
 
    // Calculate viscous BCs at current level and
    // put in m_pressureHBCs[0]
    CalcNeumannPressureBCs(m_previousVelFields, nullvelfields, kinvis);
 
    // Extrapolate to m_pressureHBCs to n+1
    ExtrapolateArray(m_pressureHBCs);
 
    // Add (phi,Du/Dt) term to m_presureHBC
    AddDuDt();
 
    // Copy m_pressureHBCs to m_PbndExp
    CopyPressureHBCsToPbndExp();
 
    // Evaluate High order outflow conditiosn if required.
    CalcOutflowBCs(inarray, kinvis);
    timer.Stop();
    timer.AccumulateRegion("SubSteppingExtrapolate:SubStepSetPressureBCs", 10);
}

References Nektar::LibUtilities::Timer::AccumulateRegion(), Nektar::Extrapolate::AddDuDt(), Nektar::Extrapolate::CalcNeumannPressureBCs(), Nektar::Extrapolate::CalcOutflowBCs(), Nektar::Extrapolate::CopyPressureHBCsToPbndExp(), Nektar::Extrapolate::ExtrapolateArray(), Nektar::Extrapolate::m_pressureCalls, Nektar::Extrapolate::m_pressureHBCs, m_previousVelFields, Nektar::LibUtilities::Timer::Start(), and Nektar::LibUtilities::Timer::Stop().

Friends And Related Function Documentation

◆ MemoryManager< SubSteppingExtrapolate >

friend class MemoryManager< SubSteppingExtrapolate >

friend

Definition at line 55 of file SubSteppingExtrapolate.h.

Member Data Documentation

◆ className

std::string Nektar::SubSteppingExtrapolate::className

static

Initial value:

=
    GetExtrapolateFactory().RegisterCreatorFunction(
        "SubStepping", SubSteppingExtrapolate::create, "SubStepping")

Name of class.

Registers the class with the Factory.

Definition at line 76 of file SubSteppingExtrapolate.h.

◆ m_cflSafetyFactor

NekDouble Nektar::SubSteppingExtrapolate::m_cflSafetyFactor

protected

Definition at line 86 of file SubSteppingExtrapolate.h.

Referenced by GetSubstepTimeStep(), SubSteppingExtrapolate(), and v_SubStepAdvance().

◆ m_infosteps

int Nektar::SubSteppingExtrapolate::m_infosteps

protected

Definition at line 87 of file SubSteppingExtrapolate.h.

Referenced by SubSteppingExtrapolate(), and v_SubStepAdvance().

◆ m_intScheme

LibUtilities::TimeIntegrationSchemeSharedPtr Nektar::SubSteppingExtrapolate::m_intScheme

protected

Definition at line 79 of file SubSteppingExtrapolate.h.

Referenced by v_SubStepAdvance(), and v_SubSteppingTimeIntegration().

◆ m_maxsubsteps

int Nektar::SubSteppingExtrapolate::m_maxsubsteps

protected

Definition at line 89 of file SubSteppingExtrapolate.h.

Referenced by SubSteppingExtrapolate(), and v_SubStepAdvance().

◆ m_minsubsteps

int Nektar::SubSteppingExtrapolate::m_minsubsteps

protected

Definition at line 88 of file SubSteppingExtrapolate.h.

Referenced by SubSteppingExtrapolate(), and v_SubStepAdvance().

◆ m_previousVelFields

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

protected

Definition at line 83 of file SubSteppingExtrapolate.h.

Referenced by SubStepExtrapolateField(), v_SubSteppingTimeIntegration(), v_SubStepSaveFields(), and v_SubStepSetPressureBCs().

◆ m_previousVnFields

Array<OneD, Array<OneD, NekDouble> > Nektar::SubSteppingExtrapolate::m_previousVnFields

protected

Definition at line 84 of file SubSteppingExtrapolate.h.

Referenced by SubStepExtrapolateField(), v_SubSteppingTimeIntegration(), and v_SubStepSaveFields().

◆ m_subStepIntegrationOps

LibUtilities::TimeIntegrationSchemeOperators Nektar::SubSteppingExtrapolate::m_subStepIntegrationOps

protected

Definition at line 81 of file SubSteppingExtrapolate.h.

Referenced by v_SubStepAdvance(), and v_SubSteppingTimeIntegration().

◆ m_subStepIntegrationScheme

LibUtilities::TimeIntegrationSchemeSharedPtr Nektar::SubSteppingExtrapolate::m_subStepIntegrationScheme

protected

Definition at line 80 of file SubSteppingExtrapolate.h.

Referenced by v_GetSubStepName(), v_SubStepAdvance(), and v_SubSteppingTimeIntegration().

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SubSteppingExtrapolate()

◆ ~SubSteppingExtrapolate()

Member Function Documentation

◆ AddAdvectionPenaltyFlux()

◆ create()

◆ GetSubstepTimeStep()

◆ SubStepAdvection()

◆ SubStepExtrapolateField()

◆ SubStepProjection()

◆ v_AccelerationBDF()

◆ v_EvaluatePressureBCs()

◆ v_GetSubStepName()

◆ v_MountHOPBCs()

◆ v_SubStepAdvance()

◆ v_SubSteppingTimeIntegration()

◆ v_SubStepSaveFields()

◆ v_SubStepSetPressureBCs()

Friends And Related Function Documentation

◆ MemoryManager< SubSteppingExtrapolate >

Member Data Documentation

◆ className

◆ m_cflSafetyFactor

◆ m_infosteps

◆ m_intScheme

◆ m_maxsubsteps

◆ m_minsubsteps

◆ m_previousVelFields

◆ m_previousVnFields

◆ m_subStepIntegrationOps

◆ m_subStepIntegrationScheme