Nektar::SubSteppingExtrapolate Class Reference

#include <SubSteppingExtrapolate.h>

Inheritance diagram for Nektar::SubSteppingExtrapolate:

Collaboration diagram for Nektar::SubSteppingExtrapolate:

Public Member Functions
	SubSteppingExtrapolate (const LibUtilities::SessionReaderSharedPtr pSession, Array< OneD, MultiRegions::ExpListSharedPtr > pFields, MultiRegions::ExpListSharedPtr pPressure, const Array< OneD, int > pVel, const SolverUtils::AdvectionSharedPtr advObject)
virtual	~SubSteppingExtrapolate ()
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 ()
void	GenerateHOPBCMap ()
void	SubSteppingTimeIntegration (const int intMethod, const LibUtilities::TimeIntegrationWrapperSharedPtr &IntegrationScheme)
void	SubStepSaveFields (const int nstep)
void	SubStepSetPressureBCs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, const NekDouble Aii_DT, NekDouble kinvis)
void	SubStepAdvance (const LibUtilities::TimeIntegrationSolutionSharedPtr &integrationSoln, const int nstep, NekDouble time)
void	MountHOPBCs (int HBCdata, NekDouble kinvis, Array< OneD, NekDouble > &Q, Array< OneD, const NekDouble > &Advection)
void	EvaluatePressureBCs (const Array< OneD, const Array< OneD, NekDouble > > &fields, const Array< OneD, const Array< OneD, NekDouble > > &N, NekDouble kinvis)
void	CalcExplicitDuDt (const Array< OneD, const Array< OneD, NekDouble > > &fields)
void	ExtrapolatePressureHBCs (void)
void	CopyPressureHBCsToPbndExp (void)
Array< OneD, NekDouble >	GetMaxStdVelocity (const Array< OneD, Array< OneD, NekDouble > > inarray)
void	CorrectPressureBCs (const Array< OneD, NekDouble > &pressure)
void	IProductNormVelocityOnHBC (const Array< OneD, const Array< OneD, NekDouble > > &Vel, Array< OneD, NekDouble > &IprodVn)
void	IProductNormVelocityBCOnHBC (Array< OneD, NekDouble > &IprodVn)
LibUtilities::TimeIntegrationMethod	GetSubStepIntegrationMethod (void)
void	ExtrapolateArray (Array< OneD, Array< OneD, NekDouble > > &oldarrays, Array< OneD, NekDouble > &newarray, Array< OneD, NekDouble > &outarray)

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
virtual void	v_EvaluatePressureBCs (const Array< OneD, const Array< OneD, NekDouble > > &fields, const Array< OneD, const Array< OneD, NekDouble > > &N, NekDouble kinvis)
virtual void	v_SubSteppingTimeIntegration (int intMethod, const LibUtilities::TimeIntegrationWrapperSharedPtr &IntegrationScheme)
virtual void	v_SubStepSaveFields (int nstep)
virtual void	v_SubStepSetPressureBCs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, NekDouble Aii_Dt, NekDouble kinvis)
virtual void	v_SubStepAdvance (const LibUtilities::TimeIntegrationSolutionSharedPtr &integrationSoln, int nstep, NekDouble time)
virtual void	v_MountHOPBCs (int HBCdata, NekDouble kinvis, Array< OneD, NekDouble > &Q, Array< OneD, const NekDouble > &Advection)
virtual LibUtilities::TimeIntegrationMethod	v_GetSubStepIntegrationMethod (void)
void	AddDuDt (void)
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)
void	AddAdvectionPenaltyFlux (const Array< OneD, const Array< OneD, NekDouble > > &velfield, const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &outarray)
NekDouble	GetSubstepTimeStep ()
Protected Member Functions inherited from Nektar::Extrapolate
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)
void	CalcOutflowBCs (const Array< OneD, const Array< OneD, NekDouble > > &fields, NekDouble kinvis)
void	RollOver (Array< OneD, Array< OneD, NekDouble > > &input)
void	CurlCurl (Array< OneD, Array< OneD, const NekDouble > > &Vel, Array< OneD, Array< OneD, NekDouble > > &Q, const int j)

Protected Attributes
LibUtilities::TimeIntegrationWrapperSharedPtr	m_subStepIntegrationScheme
LibUtilities::TimeIntegrationSchemeOperators	m_subStepIntegrationOps
Array< OneD, Array< OneD, NekDouble > >	m_previousVelFields
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, MultiRegions::ExpListSharedPtr >	m_fields
MultiRegions::ExpListSharedPtr	m_pressure
	Pointer to field holding pressure field. More...
Array< OneD, int >	m_velocity
	int which identifies which components of m_fields contains the velocity (u,v,w); More...
SolverUtils::AdvectionSharedPtr	m_advObject
Array< OneD, Array< OneD, NekDouble > >	m_previousVelFields
int	m_curl_dim
	Curl-curl dimensionality. More...
int	m_bnd_dim
	bounday dimensionality More...
Array< OneD, const SpatialDomains::BoundaryConditionShPtr >	m_PBndConds
	pressure boundary conditions container More...
Array< OneD, MultiRegions::ExpListSharedPtr >	m_PBndExp
	pressure boundary conditions expansion container More...
int	m_pressureCalls
	number of times the high-order pressure BCs have been called More...
int	m_pressureBCsMaxPts
	Maximum points used in pressure BC evaluation. More...
int	m_pressureBCsElmtMaxPts
	Maximum points used in Element adjacent to pressure BC evaluation. More...
int	m_intSteps
	Maximum points used in pressure BC evaluation. More...
NekDouble	m_timestep
bool	m_SingleMode
	Flag to determine if single homogeneous mode is used. More...
bool	m_HalfMode
	Flag to determine if half homogeneous mode is used. More...
bool	m_MultipleModes
	Flag to determine if use multiple homogenenous modes are used. More...
NekDouble	m_LhomZ
	physical length in Z direction (if homogeneous) More...
int	m_npointsX
	number of points in X direction (if homogeneous) More...
int	m_npointsY
	number of points in Y direction (if homogeneous) More...
int	m_npointsZ
	number of points in Z direction (if homogeneous) More...
Array< OneD, int >	m_pressureBCtoElmtID
	Id of element to which pressure boundary condition belongs. More...
Array< OneD, int >	m_pressureBCtoTraceID
	Id of edge (2D) or face (3D) to which pressure boundary condition belongs. More...
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_acceleration
	Storage for current and previous levels of the acceleration term. More...
Array< OneD, HBCInfo >	m_HBCdata
	data structure to old all the information regarding High order pressure BCs More...
Array< OneD, NekDouble >	m_wavenumber
	wave number 2 pi k /Lz More...
Array< OneD, NekDouble >	m_negWavenumberSq
	minus Square of wavenumber More...
Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	m_outflowVel
	Storage for current and previous velocity fields at the otuflow for high order outflow BCs. More...
Array< OneD, Array< OneD, NekDouble > >	m_traceNormals
Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	m_PhyoutfVel
	Storage for current and previous velocity fields in physical space at the otuflow for high order outflow BCs. More...
Array< OneD, NekDouble >	m_nonlinearterm_phys
	(if homogeneous) More...
Array< OneD, NekDouble >	m_nonlinearterm_coeffs
	(if homogeneous) More...
Array< OneD, unsigned int >	m_expsize_per_plane
	(if homogeneous) More...
Array< OneD, NekDouble >	m_PBndCoeffs
	(if homogeneous) More...
Array< OneD, Array< OneD, NekDouble > >	m_UBndCoeffs
	(if homogeneous) More...
int	m_totexps_per_plane
	(if homogeneous) More...

Additional Inherited Members
Static Protected Attributes inherited from Nektar::Extrapolate
static NekDouble	StifflyStable_Betaq_Coeffs [3][3]
	total number of expansion for each plane (if homogeneous) More...
static NekDouble	StifflyStable_Alpha_Coeffs [3][3]
static NekDouble	StifflyStable_Gamma0_Coeffs [3]

Detailed Description

Definition at line 58 of file SubSteppingExtrapolate.h.

Constructor & Destructor Documentation

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

Definition at line 49 of file SubSteppingExtrapolate.cpp.

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

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

        int dim = m_fields[0]->GetCoordim(0);
        m_traceNormals = Array<OneD, Array<OneD, NekDouble> >(dim);

        int nTracePts   = m_fields[0]->GetTrace()->GetNpoints();
        for(int i = 0; i < dim; ++i)
        {
            m_traceNormals[i] = Array<OneD, NekDouble> (nTracePts);
        }
        m_fields[0]->GetTrace()->GetNormals(m_traceNormals);

    }

Nektar::SubSteppingExtrapolate::~SubSteppingExtrapolate ( )

virtual

Definition at line 74 of file SubSteppingExtrapolate.cpp.

    {
    }

Member Function Documentation

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

protected

Number of trace points

Number of spatial dimensions

Forward state array

Backward state array

upwind numerical flux state array

Normal velocity array

Extract forwards/backwards trace spaces Note: Needs to have correct i value to get 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 425 of file SubSteppingExtrapolate.cpp.

References ASSERTL1, Nektar::Extrapolate::m_bnd_dim, Nektar::Extrapolate::m_fields, Nektar::Extrapolate::m_traceNormals, Vmath::Vmul(), Vmath::Vsub(), and Vmath::Vvtvp().

Referenced by SubStepAdvection().

    {
        ASSERTL1(
                 physfield.num_elements() == Outarray.num_elements(),
                 "Physfield and outarray are of different dimensions");
        
        int i;
        
        /// Number of trace points
        int nTracePts   = m_fields[0]->GetTrace()->GetNpoints();
        
        /// Number of spatial dimensions
        int nDimensions = m_bnd_dim;
        
        /// 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;
        
        /// Normal velocity array
        Array<OneD, NekDouble> Vn (nTracePts, 0.0);
        
        // Extract velocity field along the trace space and multiply by trace normals
        for(i = 0; i < nDimensions; ++i)
        {
            m_fields[0]->ExtractTracePhys(velfield[i], Fwd);
            Vmath::Vvtvp(nTracePts, m_traceNormals[i], 1, Fwd, 1, Vn, 1, Vn, 1);
        }
        
        for(i = 0; i < physfield.num_elements(); ++i)
        {
            /// Extract forwards/backwards trace spaces
            /// Note: Needs to have correct i value to get boundary conditions
            m_fields[i]->GetFwdBwdTracePhys(physfield[i], Fwd, Bwd);
                    
            /// 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]);
        }
    }

void Nektar::SubSteppingExtrapolate::AddDuDt ( void  )

protected

Definition at line 540 of file SubSteppingExtrapolate.cpp.

References Nektar::Extrapolate::IProductNormVelocityBCOnHBC(), Nektar::Extrapolate::m_acceleration, Nektar::Extrapolate::m_intSteps, Nektar::Extrapolate::m_pressureCalls, Nektar::Extrapolate::m_pressureHBCs, Nektar::Extrapolate::m_timestep, Vmath::Smul(), Nektar::Extrapolate::StifflyStable_Alpha_Coeffs, Nektar::Extrapolate::StifflyStable_Gamma0_Coeffs, Vmath::Svtvp(), and Vmath::Vsub().

Referenced by v_SubStepSetPressureBCs().

    {
        int HBCPts = m_acceleration[0].num_elements();

        Array<OneD, NekDouble> accelerationTerm(HBCPts, 0.0);

        // Update velocity BF at n+1 (actually only needs doing if velocity is time dependent on HBCs)
        IProductNormVelocityBCOnHBC(m_acceleration[0]);
        
        //Calculate acceleration term at level n based on previous steps
        int acc_order = min(m_pressureCalls,m_intSteps);
        Vmath::Smul(HBCPts, StifflyStable_Gamma0_Coeffs[acc_order-1]/m_timestep,
                    m_acceleration[0], 1, accelerationTerm,  1);
        
        for(int i = 0; i < acc_order; i++)
        {
            Vmath::Svtvp(HBCPts, 
                         -1*StifflyStable_Alpha_Coeffs[acc_order-1][i]/m_timestep,
                         m_acceleration[i+1], 1,
                         accelerationTerm,    1,
                         accelerationTerm,    1);
        }
        
        // Subtract accleration term off m_pressureHBCs[nlevels-1]
        int  nlevels = m_pressureHBCs.num_elements();
        Vmath::Vsub(HBCPts, m_pressureHBCs[nlevels-1],1,accelerationTerm, 1,
                    m_pressureHBCs[nlevels-1],1);
    }

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.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr().

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

NekDouble Nektar::SubSteppingExtrapolate::GetSubstepTimeStep ( )

protected

Definition at line 390 of file SubSteppingExtrapolate.cpp.

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

Referenced by v_SubStepAdvance().

    { 
        int n_element      = m_fields[0]->GetExpSize(); 

        const Array<OneD, int> ExpOrder=m_fields[0]->EvalBasisNumModesMaxPerExp();
        Array<OneD, int> ExpOrderList (n_element, ExpOrder);
        
        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.num_elements());
        
        for(int i = 0; i < m_velocity.num_elements(); ++i)
        {
            velfields[i] = m_fields[m_velocity[i]]->UpdatePhys();
        }        
        stdVelocity = GetMaxStdVelocity(velfields);
        
        for(int 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);        
        
        return TimeStep;
    }

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 159 of file SubSteppingExtrapolate.cpp.

References AddAdvectionPenaltyFlux(), Nektar::Extrapolate::m_advObject, Nektar::Extrapolate::m_fields, Nektar::Extrapolate::m_timestep, Nektar::Extrapolate::m_velocity, Vmath::Neg(), and SubStepExtrapolateField().

Referenced by v_SubSteppingTimeIntegration().

    {
        int i;
        int nVariables     = inarray.num_elements();
        int nQuadraturePts = inarray[0].num_elements();
        
        /// Get the number of coefficients
        int 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.num_elements());
        Array<OneD, int> VelIds(m_velocity.num_elements());
        
        Velfields[0] = Array<OneD, NekDouble> (nQuadraturePts*m_velocity.num_elements());
        
        for(i = 1; i < m_velocity.num_elements(); ++i)
        {
            Velfields[i] = Velfields[i-1] + nQuadraturePts; 
        }

        SubStepExtrapolateField(fmod(time,m_timestep), Velfields);
        
        m_advObject->Advect(m_velocity.num_elements(), m_fields, Velfields, inarray, 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(Velfields, 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]);
        }
    }

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

protected

Extrapolate field using equally time spaced field un,un-1,un-2, (at dt intervals) to time n+t at order Ord

Definition at line 487 of file SubSteppingExtrapolate.cpp.

References Vmath::Fill(), Nektar::Extrapolate::m_fields, Nektar::Extrapolate::m_intSteps, m_previousVelFields, Nektar::Extrapolate::m_timestep, Nektar::Extrapolate::m_velocity, npts, and Vmath::Smul().

Referenced by SubStepAdvection().

    {
        int npts = m_fields[0]->GetTotPoints();
        int nvel = m_velocity.num_elements();
        int i,j;
        Array<OneD, NekDouble> l(4);

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

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 219 of file SubSteppingExtrapolate.cpp.

References ASSERTL1, and Vmath::Vcopy().

Referenced by v_SubSteppingTimeIntegration().

    {
        ASSERTL1(inarray.num_elements() == outarray.num_elements(),"Inarray and outarray of different sizes ");

        for(int i = 0; i < inarray.num_elements(); ++i)
        {
            Vmath::Vcopy(inarray[i].num_elements(),inarray[i],1,outarray[i],1);
        }
    }

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

protectedvirtual

Implements Nektar::Extrapolate.

Definition at line 78 of file SubSteppingExtrapolate.cpp.

References ASSERTL0.

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

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

protectedvirtual

Reimplemented from Nektar::Extrapolate.

Definition at line 569 of file SubSteppingExtrapolate.cpp.

References m_subStepIntegrationScheme.

    {
        return m_subStepIntegrationScheme->GetIntegrationMethod();
    }

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

protectedvirtual

Implements Nektar::Extrapolate.

Definition at line 528 of file SubSteppingExtrapolate.cpp.

References Vmath::Smul().

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

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

protectedvirtual

Implements Nektar::Extrapolate.

Definition at line 323 of file SubSteppingExtrapolate.cpp.

References ASSERTL0, GetSubstepTimeStep(), Nektar::Extrapolate::IProductNormVelocityOnHBC(), Nektar::Extrapolate::m_acceleration, m_cflSafetyFactor, Nektar::Extrapolate::m_comm, Nektar::Extrapolate::m_fields, m_infosteps, Nektar::Extrapolate::m_intSteps, m_maxsubsteps, m_minsubsteps, m_subStepIntegrationOps, m_subStepIntegrationScheme, and Nektar::Extrapolate::m_timestep.

    {
        int n;
        int nsubsteps;
        
        NekDouble dt; 
        
        Array<OneD, Array<OneD, NekDouble> > fields, velfields;
        
        static int ncalls = 1;
        int  nint         = min(ncalls++, m_intSteps);
        
        Array<OneD, NekDouble> CFL(m_fields[0]->GetExpSize(), 
                                   m_cflSafetyFactor);
        //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 = 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)
        {
            cout << "Sub-integrating using "<< nsubsteps 
                 << " steps over Dt = "     << m_timestep 
                 << " (SubStep CFL="        << m_cflSafetyFactor << ")"<< endl;
        }

        for (int m = 0; m < nint; ++m)
        {
            // We need to update the fields held by the m_integrationSoln
            fields = integrationSoln->UpdateSolutionVector()[m];
            
            // Initialise NS solver which is set up to use a GLM method
            // with calls to EvaluateAdvection_SetPressureBCs and
            // SolveUnsteadyStokesSystem
            LibUtilities::TimeIntegrationSolutionSharedPtr 
                SubIntegrationSoln = m_subStepIntegrationScheme->
                InitializeScheme(dt, fields, time, m_subStepIntegrationOps);
            
            for(n = 0; n < nsubsteps; ++n)
            {
                fields = m_subStepIntegrationScheme->TimeIntegrate(n, dt, SubIntegrationSoln,
                                                                   m_subStepIntegrationOps);
            }
            
            // set up HBC m_acceleration field for Pressure BCs
            IProductNormVelocityOnHBC(fields,m_acceleration[m+1]);

            // Reset time integrated solution in m_integrationSoln 
            integrationSoln->SetSolVector(m,fields);
        }
    }

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

protectedvirtual

Implements Nektar::Extrapolate.

Definition at line 84 of file SubSteppingExtrapolate.cpp.

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, >::CreateInstance(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineOdeRhs(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineProjection(), Nektar::LibUtilities::eBackwardEuler, Nektar::LibUtilities::eBDFImplicitOrder1, Nektar::LibUtilities::eBDFImplicitOrder2, Nektar::LibUtilities::GetTimeIntegrationWrapperFactory(), Nektar::Extrapolate::m_fields, Nektar::Extrapolate::m_intSteps, m_previousVelFields, Nektar::Extrapolate::m_session, m_subStepIntegrationOps, m_subStepIntegrationScheme, Nektar::Extrapolate::m_velocity, SubStepAdvection(), and SubStepProjection().

    {
        int i;
        
        // Set to 1 for first step and it will then be increased in
        // time advance routines
        switch(intMethod)
        {
            case LibUtilities::eBackwardEuler:
            case LibUtilities::eBDFImplicitOrder1: 
            {
                std::string vSubStepIntScheme = "ForwardEuler";
                
                if(m_session->DefinesSolverInfo("SubStepIntScheme"))
                {
                    vSubStepIntScheme = m_session->GetSolverInfo("SubStepIntScheme");
                }

                m_subStepIntegrationScheme = LibUtilities::GetTimeIntegrationWrapperFactory().CreateInstance(vSubStepIntScheme);
                
                int nvel = m_velocity.num_elements();

                // Fields for linear interpolation
                m_previousVelFields = Array<OneD, Array<OneD, NekDouble> >(2*nvel);                    
                int ntotpts  = m_fields[0]->GetTotPoints();
                m_previousVelFields[0] = Array<OneD, NekDouble>(2*nvel*ntotpts);
                for(i = 1; i < 2*nvel; ++i)
                {
                    m_previousVelFields[i] = m_previousVelFields[i-1] + ntotpts; 
                }
                
            }
            break;
            case LibUtilities::eBDFImplicitOrder2:
            {
                std::string vSubStepIntScheme = "RungeKutta2_ImprovedEuler";
                
                if(m_session->DefinesSolverInfo("SubStepIntScheme"))
                {
                    vSubStepIntScheme = m_session->GetSolverInfo("SubStepIntScheme");
                }

                m_subStepIntegrationScheme = LibUtilities::GetTimeIntegrationWrapperFactory().CreateInstance(vSubStepIntScheme);
                    
                int nvel = m_velocity.num_elements();
                
                // Fields for quadratic interpolation
                m_previousVelFields = Array<OneD, Array<OneD, NekDouble> >(3*nvel);
                
                int ntotpts  = m_fields[0]->GetTotPoints();
                m_previousVelFields[0] = Array<OneD, NekDouble>(3*nvel*ntotpts);
                for(i = 1; i < 3*nvel; ++i)
                {
                    m_previousVelFields[i] = m_previousVelFields[i-1] + ntotpts; 
                }
                
            }
            break;
            default:
                ASSERTL0(0,"Integration method not suitable: Options include BackwardEuler or BDFImplicitOrder1");
                break;
        }
    
        m_intSteps = IntegrationScheme->GetIntegrationSteps();

        // set explicit time-integration class operators
        m_subStepIntegrationOps.DefineOdeRhs(&SubSteppingExtrapolate::SubStepAdvection, this);
        m_subStepIntegrationOps.DefineProjection(&SubSteppingExtrapolate::SubStepProjection, this);
    }

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

protectedvirtual

Implements Nektar::Extrapolate.

Definition at line 274 of file SubSteppingExtrapolate.cpp.

References Nektar::Extrapolate::m_fields, m_previousVelFields, Nektar::Extrapolate::m_velocity, npts, and Vmath::Vcopy().

    {
        int i,n;
        int nvel = m_velocity.num_elements();
        int npts = m_fields[0]->GetTotPoints();

        // rotate fields 
        int nblocks = m_previousVelFields.num_elements()/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; 
        }
        
        // 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);   
        }

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

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

protectedvirtual

Implements Nektar::Extrapolate.

Definition at line 236 of file SubSteppingExtrapolate.cpp.

References AddDuDt(), Nektar::Extrapolate::CalcNeumannPressureBCs(), Nektar::Extrapolate::CalcOutflowBCs(), Nektar::Extrapolate::CopyPressureHBCsToPbndExp(), Nektar::Extrapolate::ExtrapolatePressureHBCs(), Nektar::Extrapolate::m_fields, Nektar::Extrapolate::m_pressureCalls, Nektar::Extrapolate::m_pressureHBCs, Nektar::Extrapolate::m_velocity, and Nektar::Extrapolate::RollOver().

    {
        int nConvectiveFields =m_fields.num_elements()-1;
        Array<OneD, Array<OneD, NekDouble> > velfields(nConvectiveFields);
        
        for(int i = 0; i < nConvectiveFields; ++i)
        {
            velfields[i] = m_fields[m_velocity[i]]->GetPhys(); 
        }

        m_pressureCalls++;

        // Rotate HOPBCs storage
        RollOver(m_pressureHBCs);

        // Calculate non-linear and viscous BCs at current level and
        // put in m_pressureHBCs[0]
        CalcNeumannPressureBCs(inarray,velfields,kinvis);

        // Extrapolate to m_pressureHBCs to n+1
        ExtrapolatePressureHBCs();
        
        // 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);
    }

Member Data Documentation

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.

NekDouble Nektar::SubSteppingExtrapolate::m_cflSafetyFactor

protected

Definition at line 147 of file SubSteppingExtrapolate.h.

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

int Nektar::SubSteppingExtrapolate::m_infosteps

protected

Definition at line 148 of file SubSteppingExtrapolate.h.

Referenced by SubSteppingExtrapolate(), and v_SubStepAdvance().

int Nektar::SubSteppingExtrapolate::m_maxsubsteps

protected

Definition at line 150 of file SubSteppingExtrapolate.h.

Referenced by SubSteppingExtrapolate(), and v_SubStepAdvance().

int Nektar::SubSteppingExtrapolate::m_minsubsteps

protected

Definition at line 149 of file SubSteppingExtrapolate.h.

Referenced by SubSteppingExtrapolate(), and v_SubStepAdvance().

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

protected

Definition at line 145 of file SubSteppingExtrapolate.h.

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

LibUtilities::TimeIntegrationSchemeOperators Nektar::SubSteppingExtrapolate::m_subStepIntegrationOps

protected

Definition at line 143 of file SubSteppingExtrapolate.h.

Referenced by v_SubStepAdvance(), and v_SubSteppingTimeIntegration().

LibUtilities::TimeIntegrationWrapperSharedPtr Nektar::SubSteppingExtrapolate::m_subStepIntegrationScheme

protected

Definition at line 142 of file SubSteppingExtrapolate.h.

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