Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes | List of all members
Nektar::SubSteppingExtrapolate Class Reference

#include <SubSteppingExtrapolate.h>

Inheritance diagram for Nektar::SubSteppingExtrapolate:
Inheritance graph
[legend]
Collaboration diagram for Nektar::SubSteppingExtrapolate:
Collaboration graph
[legend]

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, NekDoubleGetMaxStdVelocity (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, HBCInfom_HBCdata
 data structure to old all the information regarding High order pressure BCs More...
 
Array< OneD, NekDoublem_wavenumber
 wave number 2 pi k /Lz More...
 
Array< OneD, NekDoublem_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, NekDoublem_nonlinearterm_phys
 (if homogeneous) More...
 
Array< OneD, NekDoublem_nonlinearterm_coeffs
 (if homogeneous) More...
 
Array< OneD, unsigned int > m_expsize_per_plane
 (if homogeneous) More...
 
Array< OneD, NekDoublem_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 51 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.

57  : Extrapolate(pSession,pFields,pPressure,pVel,advObject)
58  {
59  m_session->LoadParameter("IO_InfoSteps", m_infosteps, 0);
60  m_session->LoadParameter("SubStepCFL", m_cflSafetyFactor, 0.5);
61  m_session->LoadParameter("MinSubSteps", m_minsubsteps,1);
62  m_session->LoadParameter("MaxSubSteps", m_maxsubsteps,100);
63 
64  int dim = m_fields[0]->GetCoordim(0);
65  m_traceNormals = Array<OneD, Array<OneD, NekDouble> >(dim);
66 
67  int nTracePts = m_fields[0]->GetTrace()->GetNpoints();
68  for(int i = 0; i < dim; ++i)
69  {
70  m_traceNormals[i] = Array<OneD, NekDouble> (nTracePts);
71  }
72  m_fields[0]->GetTrace()->GetNormals(m_traceNormals);
73 
74  }
LibUtilities::SessionReaderSharedPtr m_session
Definition: Extrapolate.h:208
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Definition: Extrapolate.h:212
Extrapolate(const LibUtilities::SessionReaderSharedPtr pSession, Array< OneD, MultiRegions::ExpListSharedPtr > pFields, MultiRegions::ExpListSharedPtr pPressure, const Array< OneD, int > pVel, const SolverUtils::AdvectionSharedPtr advObject)
Definition: Extrapolate.cpp:59
Array< OneD, Array< OneD, NekDouble > > m_traceNormals
Definition: Extrapolate.h:288
Nektar::SubSteppingExtrapolate::~SubSteppingExtrapolate ( )
virtual

Definition at line 76 of file SubSteppingExtrapolate.cpp.

77  {
78  }

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

431  {
432  ASSERTL1(
433  physfield.num_elements() == Outarray.num_elements(),
434  "Physfield and outarray are of different dimensions");
435 
436  int i;
437 
438  /// Number of trace points
439  int nTracePts = m_fields[0]->GetTrace()->GetNpoints();
440 
441  /// Number of spatial dimensions
442  int nDimensions = m_bnd_dim;
443 
444  /// Forward state array
445  Array<OneD, NekDouble> Fwd(3*nTracePts);
446 
447  /// Backward state array
448  Array<OneD, NekDouble> Bwd = Fwd + nTracePts;
449 
450  /// upwind numerical flux state array
451  Array<OneD, NekDouble> numflux = Bwd + nTracePts;
452 
453  /// Normal velocity array
454  Array<OneD, NekDouble> Vn (nTracePts, 0.0);
455 
456  // Extract velocity field along the trace space and multiply by trace normals
457  for(i = 0; i < nDimensions; ++i)
458  {
459  m_fields[0]->ExtractTracePhys(velfield[i], Fwd);
460  Vmath::Vvtvp(nTracePts, m_traceNormals[i], 1, Fwd, 1, Vn, 1, Vn, 1);
461  }
462 
463  for(i = 0; i < physfield.num_elements(); ++i)
464  {
465  /// Extract forwards/backwards trace spaces
466  /// Note: Needs to have correct i value to get boundary conditions
467  m_fields[i]->GetFwdBwdTracePhys(physfield[i], Fwd, Bwd);
468 
469  /// Upwind between elements
470  m_fields[0]->GetTrace()->Upwind(Vn, Fwd, Bwd, numflux);
471 
472  /// Construct difference between numflux and Fwd,Bwd
473  Vmath::Vsub(nTracePts, numflux, 1, Fwd, 1, Fwd, 1);
474  Vmath::Vsub(nTracePts, numflux, 1, Bwd, 1, Bwd, 1);
475 
476  /// Calculate the numerical fluxes multipling Fwd, Bwd and
477  /// numflux by the normal advection velocity
478  Vmath::Vmul(nTracePts, Fwd, 1, Vn, 1, Fwd, 1);
479  Vmath::Vmul(nTracePts, Bwd, 1, Vn, 1, Bwd, 1);
480 
481  m_fields[0]->AddFwdBwdTraceIntegral(Fwd,Bwd,Outarray[i]);
482  }
483  }
void Vvtvp(int n, const T *w, const int incw, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
vvtvp (vector times vector plus vector): z = w*x + y
Definition: Vmath.cpp:428
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Definition: Extrapolate.h:212
int m_bnd_dim
bounday dimensionality
Definition: Extrapolate.h:229
void Vsub(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Subtract vector z = x-y.
Definition: Vmath.cpp:329
Array< OneD, Array< OneD, NekDouble > > m_traceNormals
Definition: Extrapolate.h:288
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:169
void Nektar::SubSteppingExtrapolate::AddDuDt ( void  )
protected

Definition at line 542 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().

543  {
544  int HBCPts = m_acceleration[0].num_elements();
545 
546  Array<OneD, NekDouble> accelerationTerm(HBCPts, 0.0);
547 
548  // Update velocity BF at n+1 (actually only needs doing if velocity is time dependent on HBCs)
550 
551  //Calculate acceleration term at level n based on previous steps
552  int acc_order = min(m_pressureCalls,m_intSteps);
554  m_acceleration[0], 1, accelerationTerm, 1);
555 
556  for(int i = 0; i < acc_order; i++)
557  {
558  Vmath::Svtvp(HBCPts,
559  -1*StifflyStable_Alpha_Coeffs[acc_order-1][i]/m_timestep,
560  m_acceleration[i+1], 1,
561  accelerationTerm, 1,
562  accelerationTerm, 1);
563  }
564 
565  // Subtract accleration term off m_pressureHBCs[nlevels-1]
566  int nlevels = m_pressureHBCs.num_elements();
567  Vmath::Vsub(HBCPts, m_pressureHBCs[nlevels-1],1,accelerationTerm, 1,
568  m_pressureHBCs[nlevels-1],1);
569  }
void Svtvp(int n, const T alpha, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
svtvp (scalar times vector plus vector): z = alpha*x + y
Definition: Vmath.cpp:471
static NekDouble StifflyStable_Gamma0_Coeffs[3]
Definition: Extrapolate.h:314
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*y.
Definition: Vmath.cpp:199
Array< OneD, Array< OneD, NekDouble > > m_acceleration
Storage for current and previous levels of the acceleration term.
Definition: Extrapolate.h:274
int m_intSteps
Maximum points used in pressure BC evaluation.
Definition: Extrapolate.h:247
int m_pressureCalls
number of times the high-order pressure BCs have been called
Definition: Extrapolate.h:238
void IProductNormVelocityBCOnHBC(Array< OneD, NekDouble > &IprodVn)
void Vsub(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Subtract vector z = x-y.
Definition: Vmath.cpp:329
Array< OneD, Array< OneD, NekDouble > > m_pressureHBCs
Storage for current and previous levels of high order pressure boundary conditions.
Definition: Extrapolate.h:271
static NekDouble StifflyStable_Alpha_Coeffs[3][3]
Definition: Extrapolate.h:313
NekDouble m_timestep
Definition: Extrapolate.h:249
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().

69  {
71  ::AllocateSharedPtr(pSession,pFields,pPressure,pVel,advObject);
72  return p;
73  }
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
boost::shared_ptr< Extrapolate > ExtrapolateSharedPtr
Definition: Extrapolate.h:72
NekDouble Nektar::SubSteppingExtrapolate::GetSubstepTimeStep ( )
protected

Definition at line 392 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().

393  {
394  int n_element = m_fields[0]->GetExpSize();
395 
396  const Array<OneD, int> ExpOrder=m_fields[0]->EvalBasisNumModesMaxPerExp();
397  Array<OneD, int> ExpOrderList (n_element, ExpOrder);
398 
399  const NekDouble cLambda = 0.2; // Spencer book pag. 317
400 
401  Array<OneD, NekDouble> tstep (n_element, 0.0);
402  Array<OneD, NekDouble> stdVelocity(n_element, 0.0);
403  Array<OneD, Array<OneD, NekDouble> > velfields(m_velocity.num_elements());
404 
405  for(int i = 0; i < m_velocity.num_elements(); ++i)
406  {
407  velfields[i] = m_fields[m_velocity[i]]->UpdatePhys();
408  }
409  stdVelocity = GetMaxStdVelocity(velfields);
410 
411  for(int el = 0; el < n_element; ++el)
412  {
413  tstep[el] = m_cflSafetyFactor /
414  (stdVelocity[el] * cLambda *
415  (ExpOrder[el]-1) * (ExpOrder[el]-1));
416  }
417 
418  NekDouble TimeStep = Vmath::Vmin(n_element, tstep, 1);
419  m_comm->AllReduce(TimeStep,LibUtilities::ReduceMin);
420 
421  return TimeStep;
422  }
Array< OneD, int > m_velocity
int which identifies which components of m_fields contains the velocity (u,v,w);
Definition: Extrapolate.h:219
T Vmin(int n, const T *x, const int incx)
Return the minimum element in x - called vmin to avoid conflict with min.
Definition: Vmath.cpp:857
LibUtilities::CommSharedPtr m_comm
Definition: Extrapolate.h:210
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Definition: Extrapolate.h:212
Array< OneD, NekDouble > GetMaxStdVelocity(const Array< OneD, Array< OneD, NekDouble > > inarray)
double NekDouble
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 161 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().

165  {
166  int i;
167  int nVariables = inarray.num_elements();
168  int nQuadraturePts = inarray[0].num_elements();
169 
170  /// Get the number of coefficients
171  int ncoeffs = m_fields[0]->GetNcoeffs();
172 
173  /// Define an auxiliary variable to compute the RHS
174  Array<OneD, Array<OneD, NekDouble> > WeakAdv(nVariables);
175  WeakAdv[0] = Array<OneD, NekDouble> (ncoeffs*nVariables);
176  for(i = 1; i < nVariables; ++i)
177  {
178  WeakAdv[i] = WeakAdv[i-1] + ncoeffs;
179  }
180 
181  Array<OneD, Array<OneD, NekDouble> > Velfields(m_velocity.num_elements());
182  Array<OneD, int> VelIds(m_velocity.num_elements());
183 
184  Velfields[0] = Array<OneD, NekDouble> (nQuadraturePts*m_velocity.num_elements());
185 
186  for(i = 1; i < m_velocity.num_elements(); ++i)
187  {
188  Velfields[i] = Velfields[i-1] + nQuadraturePts;
189  }
190 
191  SubStepExtrapolateField(fmod(time,m_timestep), Velfields);
192 
193  m_advObject->Advect(m_velocity.num_elements(), m_fields, Velfields, inarray, outarray, time);
194 
195  for(i = 0; i < nVariables; ++i)
196  {
197  m_fields[i]->IProductWRTBase(outarray[i],WeakAdv[i]);
198  // negation requried due to sign of DoAdvection term to be consistent
199  Vmath::Neg(ncoeffs, WeakAdv[i], 1);
200  }
201 
202  AddAdvectionPenaltyFlux(Velfields, inarray, WeakAdv);
203 
204  /// Operations to compute the RHS
205  for(i = 0; i < nVariables; ++i)
206  {
207  // Negate the RHS
208  Vmath::Neg(ncoeffs, WeakAdv[i], 1);
209 
210  /// Multiply the flux by the inverse of the mass matrix
211  m_fields[i]->MultiplyByElmtInvMass(WeakAdv[i], WeakAdv[i]);
212 
213  /// Store in outarray the physical values of the RHS
214  m_fields[i]->BwdTrans(WeakAdv[i], outarray[i]);
215  }
216  }
void SubStepExtrapolateField(NekDouble toff, Array< OneD, Array< OneD, NekDouble > > &ExtVel)
Array< OneD, int > m_velocity
int which identifies which components of m_fields contains the velocity (u,v,w);
Definition: Extrapolate.h:219
void AddAdvectionPenaltyFlux(const Array< OneD, const Array< OneD, NekDouble > > &velfield, const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &outarray)
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Definition: Extrapolate.h:212
void Neg(int n, T *x, const int incx)
Negate x = -x.
Definition: Vmath.cpp:382
SolverUtils::AdvectionSharedPtr m_advObject
Definition: Extrapolate.h:221
NekDouble m_timestep
Definition: Extrapolate.h:249
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 489 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().

492  {
493  int npts = m_fields[0]->GetTotPoints();
494  int nvel = m_velocity.num_elements();
495  int i,j;
496  Array<OneD, NekDouble> l(4);
497 
498  int ord = m_intSteps;
499 
500  // calculate Lagrange interpolants
501  Vmath::Fill(4,1.0,l,1);
502 
503  for(i = 0; i <= ord; ++i)
504  {
505  for(j = 0; j <= ord; ++j)
506  {
507  if(i != j)
508  {
509  l[i] *= (j*m_timestep+toff);
510  l[i] /= (j*m_timestep-i*m_timestep);
511  }
512  }
513  }
514 
515  for(i = 0; i < nvel; ++i)
516  {
517  Vmath::Smul(npts,l[0],m_previousVelFields[i],1,ExtVel[i],1);
518 
519  for(j = 1; j <= ord; ++j)
520  {
521  Blas::Daxpy(npts,l[j],m_previousVelFields[j*nvel+i],1,
522  ExtVel[i],1);
523  }
524  }
525  }
Array< OneD, int > m_velocity
int which identifies which components of m_fields contains the velocity (u,v,w);
Definition: Extrapolate.h:219
void Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
Definition: Vmath.cpp:46
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Definition: Extrapolate.h:212
Array< OneD, Array< OneD, NekDouble > > m_previousVelFields
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*y.
Definition: Vmath.cpp:199
int m_intSteps
Maximum points used in pressure BC evaluation.
Definition: Extrapolate.h:247
static std::string npts
Definition: InputFld.cpp:43
NekDouble m_timestep
Definition: Extrapolate.h:249
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 221 of file SubSteppingExtrapolate.cpp.

References ASSERTL1, and Vmath::Vcopy().

Referenced by v_SubSteppingTimeIntegration().

225  {
226  ASSERTL1(inarray.num_elements() == outarray.num_elements(),"Inarray and outarray of different sizes ");
227 
228  for(int i = 0; i < inarray.num_elements(); ++i)
229  {
230  Vmath::Vcopy(inarray[i].num_elements(),inarray[i],1,outarray[i],1);
231  }
232  }
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1047
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 80 of file SubSteppingExtrapolate.cpp.

References ASSERTL0.

81  {
82  ASSERTL0(false,"This method should not be called by Substepping routine");
83  }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:188
LibUtilities::TimeIntegrationMethod Nektar::SubSteppingExtrapolate::v_GetSubStepIntegrationMethod ( void  )
protectedvirtual

Reimplemented from Nektar::Extrapolate.

Definition at line 571 of file SubSteppingExtrapolate.cpp.

References m_subStepIntegrationScheme.

572  {
573  return m_subStepIntegrationScheme->GetIntegrationMethod();
574  }
LibUtilities::TimeIntegrationWrapperSharedPtr m_subStepIntegrationScheme
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 530 of file SubSteppingExtrapolate.cpp.

References Vmath::Smul().

535  {
536  Vmath::Smul(HBCdata,-kinvis,Q,1,Q,1);
537  }
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*y.
Definition: Vmath.cpp:199
void Nektar::SubSteppingExtrapolate::v_SubStepAdvance ( const LibUtilities::TimeIntegrationSolutionSharedPtr integrationSoln,
int  nstep,
NekDouble  time 
)
protectedvirtual

Implements Nektar::Extrapolate.

Definition at line 325 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.

329  {
330  int n;
331  int nsubsteps;
332 
333  NekDouble dt;
334 
335  Array<OneD, Array<OneD, NekDouble> > fields, velfields;
336 
337  static int ncalls = 1;
338  int nint = min(ncalls++, m_intSteps);
339 
340  Array<OneD, NekDouble> CFL(m_fields[0]->GetExpSize(),
342  //this needs to change
343  m_comm = m_fields[0]->GetComm()->GetRowComm();
344 
345  // Get the proper time step with CFL control
346  dt = GetSubstepTimeStep();
347 
348  nsubsteps = (m_timestep > dt)? ((int)(m_timestep/dt)+1):1;
349  nsubsteps = max(m_minsubsteps, nsubsteps);
350 
351  ASSERTL0(nsubsteps < m_maxsubsteps,"Number of substeps has exceeded maximum");
352 
353  dt = m_timestep/nsubsteps;
354 
355  if (m_infosteps && !((nstep+1)%m_infosteps) && m_comm->GetRank() == 0)
356  {
357  cout << "Sub-integrating using "<< nsubsteps
358  << " steps over Dt = " << m_timestep
359  << " (SubStep CFL=" << m_cflSafetyFactor << ")"<< endl;
360  }
361 
362  for (int m = 0; m < nint; ++m)
363  {
364  // We need to update the fields held by the m_integrationSoln
365  fields = integrationSoln->UpdateSolutionVector()[m];
366 
367  // Initialise NS solver which is set up to use a GLM method
368  // with calls to EvaluateAdvection_SetPressureBCs and
369  // SolveUnsteadyStokesSystem
371  SubIntegrationSoln = m_subStepIntegrationScheme->
372  InitializeScheme(dt, fields, time, m_subStepIntegrationOps);
373 
374  for(n = 0; n < nsubsteps; ++n)
375  {
376  fields = m_subStepIntegrationScheme->TimeIntegrate(n, dt, SubIntegrationSoln,
378  }
379 
380  // set up HBC m_acceleration field for Pressure BCs
382 
383  // Reset time integrated solution in m_integrationSoln
384  integrationSoln->SetSolVector(m,fields);
385  }
386  }
LibUtilities::TimeIntegrationWrapperSharedPtr m_subStepIntegrationScheme
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:188
void IProductNormVelocityOnHBC(const Array< OneD, const Array< OneD, NekDouble > > &Vel, Array< OneD, NekDouble > &IprodVn)
LibUtilities::CommSharedPtr m_comm
Definition: Extrapolate.h:210
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Definition: Extrapolate.h:212
Array< OneD, Array< OneD, NekDouble > > m_acceleration
Storage for current and previous levels of the acceleration term.
Definition: Extrapolate.h:274
int m_intSteps
Maximum points used in pressure BC evaluation.
Definition: Extrapolate.h:247
double NekDouble
boost::shared_ptr< TimeIntegrationSolution > TimeIntegrationSolutionSharedPtr
NekDouble m_timestep
Definition: Extrapolate.h:249
LibUtilities::TimeIntegrationSchemeOperators m_subStepIntegrationOps
void Nektar::SubSteppingExtrapolate::v_SubSteppingTimeIntegration ( int  intMethod,
const LibUtilities::TimeIntegrationWrapperSharedPtr IntegrationScheme 
)
protectedvirtual

Implements Nektar::Extrapolate.

Definition at line 86 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().

89  {
90  int i;
91 
92  // Set to 1 for first step and it will then be increased in
93  // time advance routines
94  switch(intMethod)
95  {
98  {
99  std::string vSubStepIntScheme = "ForwardEuler";
100 
101  if(m_session->DefinesSolverInfo("SubStepIntScheme"))
102  {
103  vSubStepIntScheme = m_session->GetSolverInfo("SubStepIntScheme");
104  }
105 
107 
108  int nvel = m_velocity.num_elements();
109 
110  // Fields for linear interpolation
111  m_previousVelFields = Array<OneD, Array<OneD, NekDouble> >(2*nvel);
112  int ntotpts = m_fields[0]->GetTotPoints();
113  m_previousVelFields[0] = Array<OneD, NekDouble>(2*nvel*ntotpts);
114  for(i = 1; i < 2*nvel; ++i)
115  {
116  m_previousVelFields[i] = m_previousVelFields[i-1] + ntotpts;
117  }
118 
119  }
120  break;
122  {
123  std::string vSubStepIntScheme = "RungeKutta2_ImprovedEuler";
124 
125  if(m_session->DefinesSolverInfo("SubStepIntScheme"))
126  {
127  vSubStepIntScheme = m_session->GetSolverInfo("SubStepIntScheme");
128  }
129 
131 
132  int nvel = m_velocity.num_elements();
133 
134  // Fields for quadratic interpolation
135  m_previousVelFields = Array<OneD, Array<OneD, NekDouble> >(3*nvel);
136 
137  int ntotpts = m_fields[0]->GetTotPoints();
138  m_previousVelFields[0] = Array<OneD, NekDouble>(3*nvel*ntotpts);
139  for(i = 1; i < 3*nvel; ++i)
140  {
141  m_previousVelFields[i] = m_previousVelFields[i-1] + ntotpts;
142  }
143 
144  }
145  break;
146  default:
147  ASSERTL0(0,"Integration method not suitable: Options include BackwardEuler or BDFImplicitOrder1");
148  break;
149  }
150 
151  m_intSteps = IntegrationScheme->GetIntegrationSteps();
152 
153  // set explicit time-integration class operators
156  }
void SubStepProjection(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
LibUtilities::TimeIntegrationWrapperSharedPtr m_subStepIntegrationScheme
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:188
LibUtilities::SessionReaderSharedPtr m_session
Definition: Extrapolate.h:208
Array< OneD, int > m_velocity
int which identifies which components of m_fields contains the velocity (u,v,w);
Definition: Extrapolate.h:219
BDF multi-step scheme of order 1 (implicit)
tBaseSharedPtr CreateInstance(tKey idKey BOOST_PP_COMMA_IF(MAX_PARAM) BOOST_PP_ENUM_BINARY_PARAMS(MAX_PARAM, tParam, x))
Create an instance of the class referred to by idKey.
Definition: NekFactory.hpp:162
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Definition: Extrapolate.h:212
Array< OneD, Array< OneD, NekDouble > > m_previousVelFields
void DefineProjection(FuncPointerT func, ObjectPointerT obj)
void DefineOdeRhs(FuncPointerT func, ObjectPointerT obj)
int m_intSteps
Maximum points used in pressure BC evaluation.
Definition: Extrapolate.h:247
TimeIntegrationWrapperFactory & GetTimeIntegrationWrapperFactory()
void SubStepAdvection(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
BDF multi-step scheme of order 2 (implicit)
LibUtilities::TimeIntegrationSchemeOperators m_subStepIntegrationOps
void Nektar::SubSteppingExtrapolate::v_SubStepSaveFields ( int  nstep)
protectedvirtual

Implements Nektar::Extrapolate.

Definition at line 276 of file SubSteppingExtrapolate.cpp.

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

277  {
278  int i,n;
279  int nvel = m_velocity.num_elements();
280  int npts = m_fields[0]->GetTotPoints();
281 
282  // rotate fields
283  int nblocks = m_previousVelFields.num_elements()/nvel;
284  Array<OneD, NekDouble> save;
285 
286  // rotate storage space
287  for(n = 0; n < nvel; ++n)
288  {
289  save = m_previousVelFields[(nblocks-1)*nvel+n];
290 
291  for(i = nblocks-1; i > 0; --i)
292  {
293  m_previousVelFields[i*nvel+n] = m_previousVelFields[(i-1)*nvel+n];
294  }
295 
296  m_previousVelFields[n] = save;
297  }
298 
299  // Put previous field
300  for(i = 0; i < nvel; ++i)
301  {
302  m_fields[m_velocity[i]]->BwdTrans(m_fields[m_velocity[i]]->GetCoeffs(),
303  m_fields[m_velocity[i]]->UpdatePhys());
304  Vmath::Vcopy(npts,m_fields[m_velocity[i]]->GetPhys(),1,
305  m_previousVelFields[i],1);
306  }
307 
308  if(nstep == 0)// initialise all levels with first field
309  {
310  for(n = 0; n < nvel; ++n)
311  {
312  for(i = 1; i < nblocks; ++i)
313  {
314  Vmath::Vcopy(npts,m_fields[m_velocity[n]]->GetPhys(),1,
315  m_previousVelFields[i*nvel+n],1);
316 
317  }
318  }
319  }
320  }
Array< OneD, int > m_velocity
int which identifies which components of m_fields contains the velocity (u,v,w);
Definition: Extrapolate.h:219
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Definition: Extrapolate.h:212
Array< OneD, Array< OneD, NekDouble > > m_previousVelFields
static std::string npts
Definition: InputFld.cpp:43
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1047
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 238 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().

242  {
243  int nConvectiveFields =m_fields.num_elements()-1;
244  Array<OneD, Array<OneD, NekDouble> > velfields(nConvectiveFields);
245 
246  for(int i = 0; i < nConvectiveFields; ++i)
247  {
248  velfields[i] = m_fields[m_velocity[i]]->GetPhys();
249  }
250 
251  m_pressureCalls++;
252 
253  // Rotate HOPBCs storage
255 
256  // Calculate non-linear and viscous BCs at current level and
257  // put in m_pressureHBCs[0]
258  CalcNeumannPressureBCs(inarray,velfields,kinvis);
259 
260  // Extrapolate to m_pressureHBCs to n+1
262 
263  // Add (phi,Du/Dt) term to m_presureHBC
264  AddDuDt();
265 
266  // Copy m_pressureHBCs to m_PbndExp
268 
269  // Evaluate High order outflow conditiosn if required.
270  CalcOutflowBCs(inarray, kinvis);
271  }
Array< OneD, int > m_velocity
int which identifies which components of m_fields contains the velocity (u,v,w);
Definition: Extrapolate.h:219
void RollOver(Array< OneD, Array< OneD, NekDouble > > &input)
void CopyPressureHBCsToPbndExp(void)
void ExtrapolatePressureHBCs(void)
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Definition: Extrapolate.h:212
int m_pressureCalls
number of times the high-order pressure BCs have been called
Definition: Extrapolate.h:238
Array< OneD, Array< OneD, NekDouble > > m_pressureHBCs
Storage for current and previous levels of high order pressure boundary conditions.
Definition: Extrapolate.h:271
void CalcOutflowBCs(const Array< OneD, const Array< OneD, NekDouble > > &fields, NekDouble kinvis)
void CalcNeumannPressureBCs(const Array< OneD, const Array< OneD, NekDouble > > &fields, const Array< OneD, const Array< OneD, NekDouble > > &N, NekDouble kinvis)
Definition: Extrapolate.h:179

Member Data Documentation

std::string Nektar::SubSteppingExtrapolate::className
static
Initial value:

Name of class.

Registers the class with the Factory.

Definition at line 76 of file SubSteppingExtrapolate.h.

NekDouble Nektar::SubSteppingExtrapolate::m_cflSafetyFactor
protected
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
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