#include <Extrapolate.h>

Inheritance diagram for Nektar::Extrapolate:

Collaboration diagram for Nektar::Extrapolate:

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

virtual	~Extrapolate ()

void	GenerateHOPBCMap (const LibUtilities::SessionReaderSharedPtr &pSsession)

void	UpdateRobinPrimCoeff (void)

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

void	SubStepSaveFields (const int nstep)

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

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

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

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

void	AddDuDt (void)

void	AddVelBC (void)

void	ExtrapolatePressureHBCs (void)

void	CopyPressureHBCsToPbndExp (void)

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

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

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

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

LibUtilities::TimeIntegrationMethod	GetSubStepIntegrationMethod (void)

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

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

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

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

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

void	AddPressureToOutflowBCs (NekDouble kinvis)

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

virtual void	v_SubSteppingTimeIntegration (int intMethod, const LibUtilities::TimeIntegrationWrapperSharedPtr &IntegrationScheme)=0

virtual void	v_SubStepSaveFields (int nstep)=0

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

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

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

virtual LibUtilities::TimeIntegrationMethod	v_GetSubStepIntegrationMethod (void)

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

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

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

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

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

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

Protected Attributes
LibUtilities::SessionReaderSharedPtr	m_session

LibUtilities::CommSharedPtr	m_comm

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

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

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

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

SolverUtils::AdvectionSharedPtr	m_advObject

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

int	m_curl_dim
	Curl-curl dimensionality. More...

int	m_bnd_dim
	bounday dimensionality More...

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

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

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

int	m_numHBCDof

int	m_HBCnumber

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

NekDouble	m_timestep

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

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

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

HighOrderOutflowSharedPtr	m_houtflow

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

static NekDouble	StifflyStable_Alpha_Coeffs [3][3]

static NekDouble	StifflyStable_Gamma0_Coeffs [3]

Static Private Attributes
static std::string	def

Detailed Description

Definition at line 75 of file Extrapolate.h.

Constructor & Destructor Documentation

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

References m_comm, m_session, and m_timestep.

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

Nektar::Extrapolate::~Extrapolate ( )

virtual

Definition at line 75 of file Extrapolate.cpp.

76 {

77 }

Member Function Documentation

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

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

Definition at line 1042 of file Extrapolate.cpp.

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

Referenced by AddDuDt().

     {
         int nlevels  = array.num_elements();
         int nPts     = array[0].num_elements();
 
 
         if(nPts)
         {
             // Update array
             RollOver(array);
             
             // Calculate acceleration using Backward Differentiation Formula
             Array<OneD, NekDouble> accelerationTerm (nPts, 0.0);
             if (m_pressureCalls > 2)
             {
                 int acc_order = min(m_pressureCalls-2,m_intSteps);
                 Vmath::Smul(nPts,
                             StifflyStable_Gamma0_Coeffs[acc_order-1],
                             array[0], 1,
                              accelerationTerm,  1);
                 
                 for(int i = 0; i < acc_order; i++)
                 {
                     Vmath::Svtvp(nPts,
                                  -1*StifflyStable_Alpha_Coeffs[acc_order-1][i],
                                  array[i+1], 1,
                                  accelerationTerm,    1,
                                  accelerationTerm,    1);
                 }
             }
             array[nlevels-1] = accelerationTerm;
         }
     }

void Nektar::Extrapolate::AddDuDt ( void )

Definition at line 86 of file Extrapolate.cpp.

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

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

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

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

inline

Definition at line 423 of file Extrapolate.h.

References v_AddNormVelOnOBC().

Referenced by CalcOutflowBCs().

     {
         v_AddNormVelOnOBC(nbcoeffs,nreg,u);
     }

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

Definition at line 484 of file Extrapolate.cpp.

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

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

void Nektar::Extrapolate::AddVelBC ( void )

Definition at line 108 of file Extrapolate.cpp.

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

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

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

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

References v_CalcNeumannPressureBCs().

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

         {
             v_CalcNeumannPressureBCs( fields, N, kinvis);
         }

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

protected

Definition at line 216 of file Extrapolate.cpp.

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

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

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

void Nektar::Extrapolate::CopyPressureHBCsToPbndExp ( void )

Definition at line 1077 of file Extrapolate.cpp.

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

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

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

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

inline

Definition at line 413 of file Extrapolate.h.

References v_CorrectPressureBCs().

     {
         v_CorrectPressureBCs(pressure);
     }

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

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

Referenced by CalcOutflowBCs(), Nektar::SubSteppingExtrapolateWeakPressure::v_AddNormVelOnOBC(), and Nektar::WeakPressureExtrapolate::v_AddNormVelOnOBC().

     {
         int nint     = min(m_pressureCalls,m_intSteps);
         int nlevels  = array.num_elements();
         int nPts     = array[0].num_elements();
 
         // Update array
         RollOver(array);
 
         // Extrapolate to outarray
         Vmath::Smul(nPts, StifflyStable_Alpha_Coeffs[nint-1][nint-1],
                          array[nint-1],    1,
                          array[nlevels-1], 1);
 
         for(int n = 0; n < nint-1; ++n)
         {
             Vmath::Svtvp(nPts, StifflyStable_Alpha_Coeffs[nint-1][n],
                          array[n],1, array[nlevels-1],1,
                          array[nlevels-1],1);
         }
     }

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

inline

Evaluate Pressure Boundary Conditions for Standard Extrapolation

Definition at line 340 of file Extrapolate.h.

References v_EvaluatePressureBCs().

     {
         v_EvaluatePressureBCs(inarray,N,kinvis);
     }

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

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

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

     {
         int nint     = min(m_pressureCalls,m_intSteps);
         int nlevels  = array.num_elements();
         int nPts     = array[0].num_elements();
 
         // Update array
         RollOver(array);
 
         // Extrapolate to outarray
         Vmath::Smul(nPts, StifflyStable_Betaq_Coeffs[nint-1][nint-1],
                          array[nint-1],    1,
                          array[nlevels-1], 1);
 
         for(int n = 0; n < nint-1; ++n)
         {
             Vmath::Svtvp(nPts, StifflyStable_Betaq_Coeffs[nint-1][n],
                          array[n],1, array[nlevels-1],1,
                          array[nlevels-1],1);
         }
     }

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

void Nektar::Extrapolate::ExtrapolatePressureHBCs ( void )

void Nektar::Extrapolate::GenerateHOPBCMap ( const LibUtilities::SessionReaderSharedPtr & pSession )

Initialize HOBCs

Definition at line 634 of file Extrapolate.cpp.

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

     {
         m_PBndConds   = m_pressure->GetBndConditions();
         m_PBndExp     = m_pressure->GetBndCondExpansions();
 
         int cnt, n;
     
         // Storage array for high order pressure BCs
         m_pressureHBCs = Array<OneD, Array<OneD, NekDouble> > (m_intSteps);
         m_iprodnormvel = Array<OneD, Array<OneD, NekDouble> > (m_intSteps + 1);
 
         // Get useful values for HOBCs
         m_HBCnumber = 0;
         m_numHBCDof = 0;
 
         int outHBCnumber = 0;
         int numOutHBCPts = 0;
 
         m_hbcType = Array<OneD, HBCType> (m_PBndConds.num_elements(),eNOHBC);
         for( n = 0; n < m_PBndConds.num_elements(); ++n)
         {
             // High order boundary Neumann Condiiton 
             if(boost::iequals(m_PBndConds[n]->GetUserDefined(),"H"))
             {
                 m_hbcType[n] = eHBCNeumann;
                 m_numHBCDof += m_PBndExp[n]->GetNcoeffs();
                 m_HBCnumber += m_PBndExp[n]->GetExpSize();
             }
                        
             // High order outflow convective condition
             if(m_PBndConds[n]->GetBoundaryConditionType() ==
                SpatialDomains::eRobin &&
                boost::iequals(m_PBndConds[n]->GetUserDefined(),
                               "HOutflow"))
             {
                 m_hbcType[n]  = eConvectiveOBC;
                 m_numHBCDof  += m_PBndExp[n]->GetNcoeffs();
                 m_HBCnumber  += m_PBndExp[n]->GetExpSize();
                 numOutHBCPts += m_PBndExp[n]->GetTotPoints();
                 outHBCnumber++;
             }
             // High order outflow boundary condition;
             else if(boost::iequals(m_PBndConds[n]->GetUserDefined(),
                                    "HOutflow"))
             {
                 m_hbcType[n] = eOBC;
                 numOutHBCPts += m_PBndExp[n]->GetTotPoints();
                 outHBCnumber++;
             }
         }
 
         m_iprodnormvel[0] = Array<OneD, NekDouble>(m_numHBCDof, 0.0);
         for(n = 0; n < m_intSteps; ++n)
         {
             m_pressureHBCs[n]   = Array<OneD, NekDouble>(m_numHBCDof, 0.0);
             m_iprodnormvel[n+1] = Array<OneD, NekDouble>(m_numHBCDof, 0.0);
         }
 
         m_pressureCalls = 0;
         
         switch(m_pressure->GetExpType())
         {
         case MultiRegions::e2D:
             {
                 m_curl_dim = 2;
                 m_bnd_dim  = 2;
             }
             break;
         case MultiRegions::e3DH1D:
             {
                 m_curl_dim = 3;
                 m_bnd_dim  = 2;
             }
             break;
         case MultiRegions::e3DH2D:
             {
                 m_curl_dim = 3;
                 m_bnd_dim  = 1;
             }
             break;
         case MultiRegions::e3D:
             {
                 m_curl_dim = 3;
                 m_bnd_dim  = 3;
             }
             break;
         default:
             ASSERTL0(0,"Dimension not supported");
             break;
         }
 
         // Initialise storage for outflow HOBCs
         if(numOutHBCPts > 0)
         {
             m_houtflow  = MemoryManager<HighOrderOutflow>::AllocateSharedPtr(numOutHBCPts,  outHBCnumber, m_curl_dim, pSession);
                         
             MultiRegions::ExpListSharedPtr BndElmtExp;
 
             // set up boundary expansions link 
             for (int i = 0; i < m_curl_dim; ++i)
             {
                 m_houtflow->m_UBndExp[i] =
                     m_fields[m_velocity[i]]->GetBndCondExpansions();
             }
 
             for(n = 0, cnt = 0; n < m_PBndConds.num_elements(); ++n)
             {
                 if(boost::iequals(m_PBndConds[n]->GetUserDefined(),"HOutflow"))
                 {
                     m_houtflow->m_outflowVel[cnt] =
                         Array<OneD, Array<OneD,
                              Array<OneD, NekDouble> > > (m_curl_dim);
 
                     m_houtflow->m_outflowVelBnd[cnt] =
                         Array<OneD, Array<OneD,
                                  Array<OneD, NekDouble> > > (m_curl_dim);
                     
                     m_fields[0]->GetBndElmtExpansion(n, BndElmtExp, false);
                     int nqb = m_PBndExp[n]->GetTotPoints();
                     int nq  = BndElmtExp->GetTotPoints();
                     for(int j = 0; j < m_curl_dim; ++j)
                     {
                         m_houtflow->m_outflowVel[cnt][j] =
                             Array<OneD, Array<OneD, NekDouble> > (m_intSteps);
 
                         m_houtflow->m_outflowVelBnd[cnt][j] =
                             Array<OneD, Array<OneD, NekDouble> > (m_intSteps);
 
                         for(int k = 0; k < m_intSteps; ++k)
                         {
                             m_houtflow->m_outflowVel[cnt][j][k] =
                                 Array<OneD, NekDouble>(nq,0.0);
                             m_houtflow->m_outflowVelBnd[cnt][j][k] =
                                 Array<OneD, NekDouble>(nqb,0.0);
                         }
                     }
                     cnt++;
                 }
 
                 // evaluate convective primitive coefficient if
                 // convective OBCs are used
                 if(m_hbcType[n] == eConvectiveOBC)
                 {
                     // initialise convective members of
                     // HighOrderOutflow struct
                     if(m_houtflow->m_pressurePrimCoeff.num_elements() == 0)
                     {
                         m_houtflow->m_pressurePrimCoeff =
                             Array<OneD, NekDouble>
                             (m_PBndConds.num_elements(),0.0);
                         m_houtflow->m_velocityPrimCoeff =
                             Array<OneD, Array< OneD, NekDouble> >(m_curl_dim);
                         
                     
                         for(int i = 0; i < m_curl_dim; ++i)
                         {
                             m_houtflow->m_velocityPrimCoeff[i] =
                                 Array<OneD, NekDouble> (m_PBndConds.
                                                         num_elements(),0.0);
                         }
                     }
                     
                     LibUtilities::Equation coeff = 
                         boost::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 = 
                             boost::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();
                     }
                 }                
             }
                         
         }
     }

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

Definition at line 875 of file Extrapolate.cpp.

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

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

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

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

inline

Definition at line 405 of file Extrapolate.h.

References v_GetSubStepIntegrationMethod().

     {
         return v_GetSubStepIntegrationMethod();
     }

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

Definition at line 568 of file Extrapolate.cpp.

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

Referenced by AddDuDt(), and AddVelBC().

     {
 
         if(!m_HBCnumber)
         {
             return;
         }
         int i,n,cnt;
         Array<OneD, NekDouble> IProdVnTmp; 
         Array<OneD, Array<OneD, NekDouble> > velbc(m_bnd_dim);
         Array<OneD, Array<OneD, MultiRegions::ExpListSharedPtr> > VelBndExp(m_bnd_dim);
         for(i = 0; i < m_bnd_dim; ++i)
         {
             VelBndExp[i] = m_fields[m_velocity[i]]->GetBndCondExpansions();
         }
 
         for(n = cnt = 0; n < m_PBndConds.num_elements(); ++n)
         {
             // High order boundary condition;
             if(m_hbcType[n] == eHBCNeumann)
             {
                 for(i = 0; i < m_bnd_dim; ++i)
                 {
                     velbc[i] = Array<OneD, NekDouble> 
                         (VelBndExp[i][n]->GetTotPoints(), 0.0);
                     VelBndExp[i][n]->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();
             }
         }
     }

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

Definition at line 540 of file Extrapolate.cpp.

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

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

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

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

inline

Definition at line 392 of file Extrapolate.h.

References v_MountHOPBCs().

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

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

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

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

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

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

inline

Definition at line 381 of file Extrapolate.h.

References v_SubStepAdvance().

     {
         v_SubStepAdvance(integrationSoln,nstep, time);
     }

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

inline

Definition at line 351 of file Extrapolate.h.

References v_SubSteppingTimeIntegration().

     {
         v_SubSteppingTimeIntegration(intMethod, IntegrationScheme);
     }

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

inline

Definition at line 361 of file Extrapolate.h.

References v_SubStepSaveFields().

     {
         v_SubStepSaveFields(nstep);
     }

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

inline

Definition at line 370 of file Extrapolate.h.

References v_SubStepSetPressureBCs().

     {
         v_SubStepSetPressureBCs(inarray,Aii_DT,kinvis);
     }

void Nektar::Extrapolate::UpdateRobinPrimCoeff ( void )

Definition at line 832 of file Extrapolate.cpp.

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

Referenced by CalcOutflowBCs().

     {
         
         if((m_pressureCalls == 1) || (m_pressureCalls > m_intSteps))
         {
             return;
         }
         
         for(int n  = 0; n < m_PBndConds.num_elements(); ++n)
         {
             // Get expansion with element on this boundary
             if(m_hbcType[n] == eConvectiveOBC)
             {
                 for (int i = 0; i < m_curl_dim; ++i)
                 {
                     Array<OneD, SpatialDomains::BoundaryConditionShPtr>
                         UBndConds = m_fields[m_velocity[i]]->UpdateBndConditions();
                     
                     std::string primcoeff = m_houtflow->m_defVelPrimCoeff[i] + "*" +
                         boost::lexical_cast<std::string>(StifflyStable_Gamma0_Coeffs
                                                          [m_pressureCalls-1]);
                     
                     SpatialDomains::RobinBCShPtr rcond = 
                         boost::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;
                 }
                 
             }
         }
     }

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

protectedvirtual

Reimplemented in Nektar::WeakPressureExtrapolate, and Nektar::SubSteppingExtrapolateWeakPressure.

Definition at line 211 of file Extrapolate.cpp.

Referenced by AddNormVelOnOBC().

213 {

214 }

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

References Nektar::eConvectiveOBC, Nektar::eHBCNeumann, m_bnd_dim, m_curl_dim, m_fields, m_hbcType, m_intSteps, m_PBndConds, m_PBndExp, m_pressureHBCs, and MountHOPBCs().

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

     {
         int n, cnt;
 
         Array<OneD, NekDouble> Pvals;
 
         Array<OneD, Array<OneD, NekDouble> > Velocity(m_curl_dim);
         Array<OneD, Array<OneD, NekDouble> > Advection(m_bnd_dim);
 
         Array<OneD, Array<OneD, NekDouble> > BndValues(m_bnd_dim);
         Array<OneD, Array<OneD, NekDouble> > Q(m_curl_dim);
 
         MultiRegions::ExpListSharedPtr BndElmtExp;
         for(n = cnt = 0; n < m_PBndConds.num_elements(); ++n)
         {
             // High order boundary condition;
             if((m_hbcType[n] == eHBCNeumann)||(m_hbcType[n] == eConvectiveOBC))
             {
                 m_fields[0]->GetBndElmtExpansion(n, BndElmtExp, false);
                 int nqb = m_PBndExp[n]->GetTotPoints();
                 int nq  = BndElmtExp->GetTotPoints();
 
                 for(int i = 0; i < m_bnd_dim; i++)
                 {
                     BndValues[i] = Array<OneD, NekDouble> (nqb,0.0);
                 }
 
                 for(int i = 0; i < m_curl_dim; i++)
                 {
                     Q[i] = Array<OneD, NekDouble> (nq,0.0);
                 }
 
                 // Obtaining fields on BndElmtExp
                 for(int i = 0; i < m_curl_dim; i++)
                 {
                     m_fields[0]->ExtractPhysToBndElmt(n, fields[i],Velocity[i]);
                 }
                 
                 if(N.num_elements()) // not required for some extrapolation
                 {
                     for(int i = 0; i < m_bnd_dim; i++)
                     {
                         m_fields[0]->ExtractPhysToBndElmt(n, N[i], Advection[i]);
                     }
                 }
 
                 // CurlCurl
                 BndElmtExp->CurlCurl(Velocity, Q);
 
                 // Mounting advection component into the high-order condition
                 for(int i = 0; i < m_bnd_dim; i++)
                 {
                     MountHOPBCs(nq, kinvis,Q[i],Advection[i]);
                 }
 
                 Pvals = (m_pressureHBCs[m_intSteps-1]) + cnt;
 
                 // Getting values on the boundary and filling the pressure bnd
                 // expansion. Multiplication by the normal is required
                 for(int i = 0; i < m_bnd_dim; i++)
                 {
                     m_fields[0]->ExtractElmtToBndPhys(n, Q[i],BndValues[i]);
                 }
                 
                 m_PBndExp[n]->NormVectorIProductWRTBase(BndValues, Pvals);
 
                 // Get offset for next terms
                 cnt += m_PBndExp[n]->GetNcoeffs();
             }
         }
     }

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

protectedvirtual

Reimplemented in Nektar::MappingExtrapolate.

Definition at line 206 of file Extrapolate.cpp.

Referenced by CorrectPressureBCs().

207 {

208 }

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

protectedpure virtual

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

Referenced by EvaluatePressureBCs().

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

protectedvirtual

Reimplemented in Nektar::SubSteppingExtrapolate.

Definition at line 972 of file Extrapolate.cpp.

References Nektar::LibUtilities::eNoTimeIntegrationMethod.

Referenced by GetSubStepIntegrationMethod().

     {
         return LibUtilities::eNoTimeIntegrationMethod;
     }

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

protectedpure virtual

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

Referenced by MountHOPBCs().

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

protectedpure virtual

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

Referenced by SubStepAdvance().

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

protectedpure virtual

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

Referenced by SubSteppingTimeIntegration().

virtual void Nektar::Extrapolate::v_SubStepSaveFields ( int nstep )

protectedpure virtual

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

Referenced by SubStepSaveFields().

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

protectedpure virtual

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

Referenced by SubStepSetPressureBCs().

Member Data Documentation

std::string Nektar::Extrapolate::def

staticprivate

Initial value:

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

Definition at line 275 of file Extrapolate.h.

SolverUtils::AdvectionSharedPtr Nektar::Extrapolate::m_advObject

protected

Definition at line 228 of file Extrapolate.h.

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

int Nektar::Extrapolate::m_bnd_dim

protected

bounday dimensionality

Definition at line 236 of file Extrapolate.h.

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

LibUtilities::CommSharedPtr Nektar::Extrapolate::m_comm

protected

Definition at line 213 of file Extrapolate.h.

Referenced by Extrapolate(), Nektar::SubSteppingExtrapolate::GetSubstepTimeStep(), and Nektar::SubSteppingExtrapolate::v_SubStepAdvance().

int Nektar::Extrapolate::m_curl_dim

protected

Curl-curl dimensionality.

Definition at line 233 of file Extrapolate.h.

Referenced by AddPressureToOutflowBCs(), CalcOutflowBCs(), GenerateHOPBCMap(), GetMaxStdVelocity(), UpdateRobinPrimCoeff(), Nektar::SubSteppingExtrapolateWeakPressure::v_AddNormVelOnOBC(), Nektar::WeakPressureExtrapolate::v_AddNormVelOnOBC(), and v_CalcNeumannPressureBCs().

Array<OneD, MultiRegions::ExpListSharedPtr> Nektar::Extrapolate::m_fields

protected

Velocity fields.

Definition at line 219 of file Extrapolate.h.

int Nektar::Extrapolate::m_HBCnumber

protected

Definition at line 251 of file Extrapolate.h.

Referenced by GenerateHOPBCMap(), IProductNormVelocityBCOnHBC(), Nektar::MappingExtrapolate::v_CorrectPressureBCs(), Nektar::StandardExtrapolate::v_EvaluatePressureBCs(), and Nektar::WeakPressureExtrapolate::v_EvaluatePressureBCs().

Array<OneD, HBCType> Nektar::Extrapolate::m_hbcType

protected

Array of type of high order BCs for splitting shemes.

Definition at line 216 of file Extrapolate.h.

Referenced by AddPressureToOutflowBCs(), CalcOutflowBCs(), CopyPressureHBCsToPbndExp(), GenerateHOPBCMap(), IProductNormVelocityBCOnHBC(), IProductNormVelocityOnHBC(), UpdateRobinPrimCoeff(), and v_CalcNeumannPressureBCs().

HighOrderOutflowSharedPtr Nektar::Extrapolate::m_houtflow

protected

Definition at line 272 of file Extrapolate.h.

Referenced by AddPressureToOutflowBCs(), CalcOutflowBCs(), GenerateHOPBCMap(), UpdateRobinPrimCoeff(), Nektar::SubSteppingExtrapolateWeakPressure::v_AddNormVelOnOBC(), and Nektar::WeakPressureExtrapolate::v_AddNormVelOnOBC().

int Nektar::Extrapolate::m_intSteps

protected

Maximum points used in pressure BC evaluation.

Definition at line 254 of file Extrapolate.h.

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

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

protected

Storage for current and previous levels of the inner product of normal velocity.

Definition at line 262 of file Extrapolate.h.

Referenced by AddDuDt(), AddVelBC(), GenerateHOPBCMap(), Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs(), and Nektar::SubSteppingExtrapolate::v_SubStepAdvance().

int Nektar::Extrapolate::m_numHBCDof

protected

Definition at line 248 of file Extrapolate.h.

Referenced by AddDuDt(), AddVelBC(), GenerateHOPBCMap(), and Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs().

Array<OneD, const SpatialDomains::BoundaryConditionShPtr> Nektar::Extrapolate::m_PBndConds

protected

pressure boundary conditions container

Definition at line 239 of file Extrapolate.h.

Referenced by AddPressureToOutflowBCs(), CalcOutflowBCs(), CopyPressureHBCsToPbndExp(), GenerateHOPBCMap(), IProductNormVelocityBCOnHBC(), IProductNormVelocityOnHBC(), UpdateRobinPrimCoeff(), Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs(), v_CalcNeumannPressureBCs(), and Nektar::MappingExtrapolate::v_CorrectPressureBCs().

Array<OneD, MultiRegions::ExpListSharedPtr> Nektar::Extrapolate::m_PBndExp

protected

pressure boundary conditions expansion container

Definition at line 242 of file Extrapolate.h.

Referenced by AddPressureToOutflowBCs(), CalcOutflowBCs(), CopyPressureHBCsToPbndExp(), GenerateHOPBCMap(), IProductNormVelocityBCOnHBC(), IProductNormVelocityOnHBC(), Nektar::SubSteppingExtrapolateWeakPressure::v_AddNormVelOnOBC(), Nektar::WeakPressureExtrapolate::v_AddNormVelOnOBC(), Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs(), v_CalcNeumannPressureBCs(), and Nektar::MappingExtrapolate::v_CorrectPressureBCs().

MultiRegions::ExpListSharedPtr Nektar::Extrapolate::m_pressure

protected

Pointer to field holding pressure field.

Definition at line 222 of file Extrapolate.h.

Referenced by AddPressureToOutflowBCs(), GenerateHOPBCMap(), and Nektar::MappingExtrapolate::v_CorrectPressureBCs().

int Nektar::Extrapolate::m_pressureCalls

protected

number of times the high-order pressure BCs have been called

Definition at line 245 of file Extrapolate.h.

Referenced by AccelerationBDF(), AddVelBC(), EvaluateBDFArray(), ExtrapolateArray(), GenerateHOPBCMap(), UpdateRobinPrimCoeff(), Nektar::StandardExtrapolate::v_EvaluatePressureBCs(), Nektar::WeakPressureExtrapolate::v_EvaluatePressureBCs(), Nektar::SubSteppingExtrapolateWeakPressure::v_SubStepSetPressureBCs(), and Nektar::SubSteppingExtrapolate::v_SubStepSetPressureBCs().

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

protected

Storage for current and previous levels of high order pressure boundary conditions.

Definition at line 259 of file Extrapolate.h.

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

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

protected

Definition at line 230 of file Extrapolate.h.

LibUtilities::SessionReaderSharedPtr Nektar::Extrapolate::m_session

protected

Definition at line 211 of file Extrapolate.h.

Referenced by Extrapolate(), Nektar::MappingExtrapolate::MappingExtrapolate(), Nektar::SubSteppingExtrapolate::SubSteppingExtrapolate(), UpdateRobinPrimCoeff(), and Nektar::SubSteppingExtrapolate::v_SubSteppingTimeIntegration().

NekDouble Nektar::Extrapolate::m_timestep

protected

Definition at line 256 of file Extrapolate.h.

Referenced by AddDuDt(), AddVelBC(), Extrapolate(), Nektar::SubSteppingExtrapolate::SubStepAdvection(), Nektar::SubSteppingExtrapolate::SubStepExtrapolateField(), Nektar::SubSteppingExtrapolateWeakPressure::v_AddNormVelOnOBC(), Nektar::WeakPressureExtrapolate::v_AddNormVelOnOBC(), and Nektar::SubSteppingExtrapolate::v_SubStepAdvance().

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

protected

Definition at line 264 of file Extrapolate.h.

Referenced by Nektar::SubSteppingExtrapolate::AddAdvectionPenaltyFlux(), and Nektar::SubSteppingExtrapolate::SubSteppingExtrapolate().

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

NekDouble Nektar::Extrapolate::StifflyStable_Alpha_Coeffs

staticprotected

Initial value:

= {

{ 1.0, 0.0, 0.0},{ 2.0, -0.5, 0.0},{ 3.0, -1.5, 1.0/3.0}}

Definition at line 268 of file Extrapolate.h.

Referenced by AccelerationBDF(), and EvaluateBDFArray().

NekDouble Nektar::Extrapolate::StifflyStable_Betaq_Coeffs

staticprotected

Initial value:

= {

{ 1.0, 0.0, 0.0},{ 2.0, -1.0, 0.0},{ 3.0, -3.0, 1.0}}

Definition at line 267 of file Extrapolate.h.

Referenced by ExtrapolateArray().

NekDouble Nektar::Extrapolate::StifflyStable_Gamma0_Coeffs

staticprotected

Initial value:

= {

1.0, 1.5, 11.0/6.0}

Definition at line 269 of file Extrapolate.h.

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

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation