Nektar++
Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Attributes | List of all members
Nektar::MappingExtrapolate Class Reference

#include <MappingExtrapolate.h>

Inheritance diagram for Nektar::MappingExtrapolate:
[legend]

Public Member Functions

virtual void v_CorrectPressureBCs (const Array< OneD, NekDouble > &pressure)
 
virtual void v_CalcNeumannPressureBCs (const Array< OneD, const Array< OneD, NekDouble >> &fields, const Array< OneD, const Array< OneD, NekDouble >> &N, NekDouble kinvis)
 
 MappingExtrapolate (const LibUtilities::SessionReaderSharedPtr pSession, Array< OneD, MultiRegions::ExpListSharedPtr > pFields, MultiRegions::ExpListSharedPtr pPressure, const Array< OneD, int > pVel, const SolverUtils::AdvectionSharedPtr advObject)
 
virtual ~MappingExtrapolate ()
 
- Public Member Functions inherited from Nektar::StandardExtrapolate
 StandardExtrapolate (const LibUtilities::SessionReaderSharedPtr pSession, Array< OneD, MultiRegions::ExpListSharedPtr > pFields, MultiRegions::ExpListSharedPtr pPressure, const Array< OneD, int > pVel, const SolverUtils::AdvectionSharedPtr advObject)
 
virtual ~StandardExtrapolate ()
 
- 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 (const LibUtilities::SessionReaderSharedPtr &pSsession)
 
void UpdateRobinPrimCoeff (void)
 
void SubSteppingTimeIntegration (const LibUtilities::TimeIntegrationSchemeSharedPtr &IntegrationScheme)
 
void SubStepSaveFields (const int nstep)
 
void SubStepSetPressureBCs (const Array< OneD, const Array< OneD, NekDouble >> &inarray, const NekDouble Aii_DT, NekDouble kinvis)
 
void SubStepAdvance (const int nstep, NekDouble time)
 
void MountHOPBCs (int HBCdata, NekDouble kinvis, Array< OneD, NekDouble > &Q, Array< OneD, const NekDouble > &Advection)
 
void EvaluatePressureBCs (const Array< OneD, const Array< OneD, NekDouble >> &fields, const Array< OneD, const Array< OneD, NekDouble >> &N, NekDouble kinvis)
 
void SetForcing (const std::vector< SolverUtils::ForcingSharedPtr > &forcing)
 
void AddDuDt (void)
 
void AddVelBC (void)
 
void ExtrapolatePressureHBCs (void)
 
void CopyPressureHBCsToPbndExp (void)
 
Array< OneD, 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)
 
std::string GetSubStepName (void)
 
void ExtrapolateArray (Array< OneD, Array< OneD, NekDouble >> &array)
 
void EvaluateBDFArray (Array< OneD, Array< OneD, NekDouble >> &array)
 
void ExtrapolateArray (Array< OneD, Array< OneD, NekDouble >> &oldarrays, Array< OneD, NekDouble > &newarray, Array< OneD, NekDouble > &outarray)
 
void AddNormVelOnOBC (const int nbcoeffs, const int nreg, Array< OneD, Array< OneD, NekDouble >> &u)
 
void AddPressureToOutflowBCs (NekDouble kinvis)
 

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 Member Functions inherited from Nektar::StandardExtrapolate
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...
 
- Static Public Attributes inherited from Nektar::StandardExtrapolate
static std::string className
 Name of class. More...
 

Protected Attributes

GlobalMapping::MappingSharedPtr m_mapping
 
Array< OneD, NekDoublem_bcCorrection
 
bool m_implicitPressure
 
bool m_implicitViscous
 
NekDouble m_pressureRelaxation
 
- Protected Attributes inherited from Nektar::Extrapolate
LibUtilities::SessionReaderSharedPtr m_session
 
LibUtilities::CommSharedPtr m_comm
 
Array< OneD, HBCTypem_hbcType
 Array of type of high order BCs for splitting shemes. More...
 
Array< OneD, MultiRegions::ExpListSharedPtrm_fields
 Velocity fields. More...
 
MultiRegions::ExpListSharedPtr m_pressure
 Pointer to field holding pressure field. More...
 
Array< OneD, int > m_velocity
 int which identifies which components of m_fields contains the velocity (u,v,w); More...
 
SolverUtils::AdvectionSharedPtr m_advObject
 
std::vector< SolverUtils::ForcingSharedPtrm_forcing
 
Array< OneD, Array< OneD, NekDouble > > m_previousVelFields
 
int m_curl_dim
 Curl-curl dimensionality. More...
 
int m_bnd_dim
 bounday dimensionality More...
 
Array< OneD, const SpatialDomains::BoundaryConditionShPtrm_PBndConds
 pressure boundary conditions container More...
 
Array< OneD, MultiRegions::ExpListSharedPtrm_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
 

Additional Inherited Members

- Protected Member Functions inherited from Nektar::StandardExtrapolate
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 (const LibUtilities::TimeIntegrationSchemeSharedPtr &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 (int nstep, NekDouble time)
 
virtual void v_MountHOPBCs (int HBCdata, NekDouble kinvis, Array< OneD, NekDouble > &Q, Array< OneD, const NekDouble > &Advection)
 
virtual void v_AccelerationBDF (Array< OneD, Array< OneD, NekDouble >> &array)
 
- Protected Member Functions inherited from Nektar::Extrapolate
virtual std::string v_GetSubStepName (void)
 
void CalcNeumannPressureBCs (const Array< OneD, const Array< OneD, NekDouble >> &fields, const Array< OneD, const Array< OneD, NekDouble >> &N, NekDouble kinvis)
 
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)
 
- Static Protected Attributes inherited from Nektar::StandardExtrapolate
static NekDouble DuDt_Coeffs [3][4]
 
- Static Protected Attributes inherited from Nektar::Extrapolate
static NekDouble StifflyStable_Betaq_Coeffs [3][3]
 
static NekDouble StifflyStable_Alpha_Coeffs [3][3]
 
static NekDouble StifflyStable_Gamma0_Coeffs [3] = {1.0, 1.5, 11.0 / 6.0}
 

Detailed Description

Definition at line 51 of file MappingExtrapolate.h.

Constructor & Destructor Documentation

◆ MappingExtrapolate()

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

Definition at line 47 of file MappingExtrapolate.cpp.

52  : StandardExtrapolate(pSession, pFields, pPressure, pVel, advObject)
53 {
55 
56  // Load solve parameters related to the mapping
57  // Flags determining if pressure/viscous terms should be treated implicitly
58  m_session->MatchSolverInfo("MappingImplicitPressure", "True",
59  m_implicitPressure, false);
60  m_session->MatchSolverInfo("MappingImplicitViscous", "True",
61  m_implicitViscous, false);
62 
63  // Relaxation parameter for pressure system
64  m_session->LoadParameter("MappingPressureRelaxation", m_pressureRelaxation,
65  1.0);
66 }
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Velocity fields.
Definition: Extrapolate.h:198
LibUtilities::SessionReaderSharedPtr m_session
Definition: Extrapolate.h:190
static GLOBAL_MAPPING_EXPORT MappingSharedPtr Load(const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)
Return a pointer to the mapping, creating it on first call.
Definition: Mapping.cpp:269
GlobalMapping::MappingSharedPtr m_mapping
StandardExtrapolate(const LibUtilities::SessionReaderSharedPtr pSession, Array< OneD, MultiRegions::ExpListSharedPtr > pFields, MultiRegions::ExpListSharedPtr pPressure, const Array< OneD, int > pVel, const SolverUtils::AdvectionSharedPtr advObject)

References Nektar::GlobalMapping::Mapping::Load(), Nektar::Extrapolate::m_fields, m_implicitPressure, m_implicitViscous, m_mapping, m_pressureRelaxation, and Nektar::Extrapolate::m_session.

◆ ~MappingExtrapolate()

Nektar::MappingExtrapolate::~MappingExtrapolate ( )
virtual

Definition at line 68 of file MappingExtrapolate.cpp.

69 {
70 }

Member Function Documentation

◆ create()

static ExtrapolateSharedPtr Nektar::MappingExtrapolate::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 55 of file MappingExtrapolate.h.

60  {
63  pSession, pFields, pPressure, pVel, advObject);
64  return p;
65  }
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
std::shared_ptr< Extrapolate > ExtrapolateSharedPtr
Definition: Extrapolate.h:59

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

◆ v_CalcNeumannPressureBCs()

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

Unified routine for calculation high-oder terms

Reimplemented from Nektar::Extrapolate.

Definition at line 205 of file MappingExtrapolate.cpp.

208 {
209  if (m_mapping->HasConstantJacobian() && !m_implicitViscous)
210  {
211  Extrapolate::v_CalcNeumannPressureBCs(fields, N, kinvis);
212  }
213  else
214  {
215  int physTot = m_fields[0]->GetTotPoints();
216  int nvel = m_fields.size() - 1;
217  int i, n, cnt;
218 
219  Array<OneD, NekDouble> Pvals;
220  Array<OneD, NekDouble> Uvals;
221 
222  Array<OneD, Array<OneD, NekDouble>> Velocity(m_bnd_dim);
223  Array<OneD, Array<OneD, NekDouble>> Advection(m_bnd_dim);
224  // Get transformation Jacobian
225  Array<OneD, NekDouble> Jac(physTot, 0.0);
226  m_mapping->GetJacobian(Jac);
227  // Declare variables
228  Array<OneD, Array<OneD, NekDouble>> BndValues(m_bnd_dim);
229  Array<OneD, Array<OneD, NekDouble>> Q(m_bnd_dim);
230  Array<OneD, Array<OneD, NekDouble>> Q_field(nvel);
231  Array<OneD, Array<OneD, NekDouble>> fields_new(nvel);
232  Array<OneD, Array<OneD, NekDouble>> N_new(m_bnd_dim);
233  // Temporary variables
234  Array<OneD, NekDouble> tmp(physTot, 0.0);
235  Array<OneD, NekDouble> tmp2(physTot, 0.0);
236  for (i = 0; i < m_bnd_dim; i++)
237  {
238  N_new[i] = Array<OneD, NekDouble>(physTot, 0.0);
239  }
240  for (int i = 0; i < nvel; i++)
241  {
242  Q_field[i] = Array<OneD, NekDouble>(physTot, 0.0);
243  fields_new[i] = Array<OneD, NekDouble>(physTot, 0.0);
244  }
245 
246  // Multiply convective terms by Jacobian
247  for (i = 0; i < m_bnd_dim; i++)
248  {
249  if (m_fields[0]->GetWaveSpace())
250  {
251  m_fields[0]->HomogeneousBwdTrans(N[i], N_new[i]);
252  }
253  else
254  {
255  Vmath::Vcopy(physTot, N[i], 1, N_new[i], 1);
256  }
257  Vmath::Vmul(physTot, Jac, 1, N_new[i], 1, N_new[i], 1);
258  if (m_fields[0]->GetWaveSpace())
259  {
260  m_fields[0]->HomogeneousFwdTrans(N_new[i], N_new[i]);
261  }
262  }
263 
264  // Get velocity in physical space
265  for (i = 0; i < nvel; i++)
266  {
267  if (m_fields[0]->GetWaveSpace())
268  {
269  m_fields[0]->HomogeneousBwdTrans(fields[i], fields_new[i]);
270  }
271  else
272  {
273  Vmath::Vcopy(physTot, fields[i], 1, fields_new[i], 1);
274  }
275  }
276 
277  // Calculate appropriate form of the CurlCurl operator
278  m_mapping->CurlCurlField(fields_new, Q_field, m_implicitViscous);
279 
280  // If viscous terms are treated explicitly,
281  // add grad(U/J \dot grad J) to CurlCurl
282  if (!m_implicitViscous)
283  {
284  m_mapping->DotGradJacobian(fields_new, tmp);
285  Vmath::Vdiv(physTot, tmp, 1, Jac, 1, tmp, 1);
286 
287  bool wavespace = m_fields[0]->GetWaveSpace();
288  m_fields[0]->SetWaveSpace(false);
289  for (int i = 0; i < m_bnd_dim; i++)
290  {
291  m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[i], tmp,
292  tmp2);
293  Vmath::Vadd(physTot, Q_field[i], 1, tmp2, 1, Q_field[i], 1);
294  }
295  m_fields[0]->SetWaveSpace(wavespace);
296  }
297 
298  // Multiply by Jacobian and convert to wavespace (if necessary)
299  for (i = 0; i < m_bnd_dim; i++)
300  {
301  Vmath::Vmul(physTot, Jac, 1, fields_new[i], 1, fields_new[i], 1);
302  Vmath::Vmul(physTot, Jac, 1, Q_field[i], 1, Q_field[i], 1);
303  if (m_fields[0]->GetWaveSpace())
304  {
305  m_fields[0]->HomogeneousFwdTrans(fields_new[i], fields_new[i]);
306  m_fields[0]->HomogeneousFwdTrans(Q_field[i], Q_field[i]);
307  }
308  }
309 
311  for (n = cnt = 0; n < m_PBndConds.size(); ++n)
312  {
313  // High order boundary condition;
314  if (boost::iequals(m_PBndConds[n]->GetUserDefined(), "H"))
315  {
316  m_fields[0]->GetBndElmtExpansion(n, BndElmtExp);
317  int nq = BndElmtExp->GetTotPoints();
318 
319  // Obtaining fields on BndElmtExp
320  for (int i = 0; i < m_bnd_dim; i++)
321  {
322  m_fields[0]->ExtractPhysToBndElmt(n, fields_new[i],
323  Velocity[i]);
324  m_fields[0]->ExtractPhysToBndElmt(n, N_new[i],
325  Advection[i]);
326  m_fields[0]->ExtractPhysToBndElmt(n, Q_field[i], Q[i]);
327  }
328 
329  // Mounting advection component into the high-order condition
330  for (int i = 0; i < m_bnd_dim; i++)
331  {
332  MountHOPBCs(nq, kinvis, Q[i], Advection[i]);
333  }
334 
335  Pvals = (m_pressureHBCs[m_intSteps - 1]) + cnt;
336  Uvals = (m_iprodnormvel[m_intSteps]) + cnt;
337 
338  // Getting values on the edge and filling the pressure boundary
339  // expansion and the acceleration term. Multiplication by the
340  // normal is required
341  for (int i = 0; i < m_bnd_dim; i++)
342  {
343  m_fields[0]->ExtractElmtToBndPhys(n, Q[i], BndValues[i]);
344  }
345  m_PBndExp[n]->NormVectorIProductWRTBase(BndValues, Pvals);
346 
347  for (int i = 0; i < m_bnd_dim; i++)
348  {
349  m_fields[0]->ExtractElmtToBndPhys(n, Velocity[i],
350  BndValues[i]);
351  }
352  m_PBndExp[n]->NormVectorIProductWRTBase(BndValues, Uvals);
353 
354  // Get offset for next terms
355  cnt += m_PBndExp[n]->GetNcoeffs();
356  }
357  }
358  }
359  // If pressure terms are treated implicitly, we need to multiply
360  // by the relaxation parameter, and zero the correction term
361  if (m_implicitPressure)
362  {
364  m_pressureHBCs[m_intSteps - 1], 1,
365  m_pressureHBCs[m_intSteps - 1], 1);
366  }
367  m_bcCorrection = Array<OneD, NekDouble>(m_numHBCDof, 0.0);
368 }
Array< OneD, Array< OneD, NekDouble > > m_pressureHBCs
Storage for current and previous levels of high order pressure boundary conditions.
Definition: Extrapolate.h:241
int m_bnd_dim
bounday dimensionality
Definition: Extrapolate.h:217
Array< OneD, Array< OneD, NekDouble > > m_iprodnormvel
Storage for current and previous levels of the inner product of normal velocity.
Definition: Extrapolate.h:245
virtual void v_CalcNeumannPressureBCs(const Array< OneD, const Array< OneD, NekDouble >> &fields, const Array< OneD, const Array< OneD, NekDouble >> &N, NekDouble kinvis)
int m_intSteps
Maximum points used in pressure BC evaluation.
Definition: Extrapolate.h:235
Array< OneD, MultiRegions::ExpListSharedPtr > m_PBndExp
pressure boundary conditions expansion container
Definition: Extrapolate.h:223
void MountHOPBCs(int HBCdata, NekDouble kinvis, Array< OneD, NekDouble > &Q, Array< OneD, const NekDouble > &Advection)
Definition: Extrapolate.h:377
Array< OneD, const SpatialDomains::BoundaryConditionShPtr > m_PBndConds
pressure boundary conditions container
Definition: Extrapolate.h:220
Array< OneD, NekDouble > m_bcCorrection
MultiRegions::Direction const DirCartesianMap[]
Definition: ExpList.h:89
std::shared_ptr< ExpList > ExpListSharedPtr
Shared pointer to an ExpList object.
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:209
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition: Vmath.cpp:359
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*x.
Definition: Vmath.cpp:248
void Vdiv(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:284
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1255

References Nektar::MultiRegions::DirCartesianMap, m_bcCorrection, Nektar::Extrapolate::m_bnd_dim, Nektar::Extrapolate::m_fields, m_implicitPressure, m_implicitViscous, Nektar::Extrapolate::m_intSteps, Nektar::Extrapolate::m_iprodnormvel, m_mapping, Nektar::Extrapolate::m_numHBCDof, Nektar::Extrapolate::m_PBndConds, Nektar::Extrapolate::m_PBndExp, Nektar::Extrapolate::m_pressureHBCs, m_pressureRelaxation, Nektar::Extrapolate::MountHOPBCs(), Vmath::Smul(), Nektar::Extrapolate::v_CalcNeumannPressureBCs(), Vmath::Vadd(), Vmath::Vcopy(), Vmath::Vdiv(), and Vmath::Vmul().

◆ v_CorrectPressureBCs()

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

Reimplemented from Nektar::Extrapolate.

Definition at line 75 of file MappingExtrapolate.cpp.

77 {
78  if (m_HBCnumber > 0)
79  {
80  int cnt, n;
81  int physTot = m_fields[0]->GetTotPoints();
82  int nvel = m_fields.size() - 1;
83 
84  Array<OneD, NekDouble> Vals;
85  // Remove previous correction
86  for (cnt = n = 0; n < m_PBndConds.size(); ++n)
87  {
88  if (m_PBndConds[n]->GetUserDefined() == "H")
89  {
90  int nq = m_PBndExp[n]->GetNcoeffs();
91  Vmath::Vsub(nq, &(m_PBndExp[n]->GetCoeffs()[0]), 1,
92  &(m_bcCorrection[cnt]), 1,
93  &(m_PBndExp[n]->UpdateCoeffs()[0]), 1);
94  cnt += nq;
95  }
96  }
97 
98  // Calculate new correction
99  Array<OneD, NekDouble> Jac(physTot, 0.0);
100  m_mapping->GetJacobian(Jac);
101 
102  Array<OneD, Array<OneD, NekDouble>> correction(nvel);
103  Array<OneD, Array<OneD, NekDouble>> gradP(nvel);
104  Array<OneD, Array<OneD, NekDouble>> wk(nvel);
105  Array<OneD, Array<OneD, NekDouble>> wk2(nvel);
106  for (int i = 0; i < nvel; i++)
107  {
108  wk[i] = Array<OneD, NekDouble>(physTot, 0.0);
109  gradP[i] = Array<OneD, NekDouble>(physTot, 0.0);
110  correction[i] = Array<OneD, NekDouble>(physTot, 0.0);
111  }
112 
113  // Calculate G(p)
114  for (int i = 0; i < nvel; ++i)
115  {
117  gradP[i]);
118  if (m_fields[0]->GetWaveSpace())
119  {
120  m_fields[0]->HomogeneousBwdTrans(gradP[i], wk[i]);
121  }
122  else
123  {
124  Vmath::Vcopy(physTot, gradP[i], 1, wk[i], 1);
125  }
126  }
127  m_mapping->RaiseIndex(wk, correction); // G(p)
128 
129  // alpha*J*(G(p))
130  if (!m_mapping->HasConstantJacobian())
131  {
132  for (int i = 0; i < nvel; ++i)
133  {
134  Vmath::Vmul(physTot, correction[i], 1, Jac, 1, correction[i],
135  1);
136  }
137  }
138  for (int i = 0; i < nvel; ++i)
139  {
140  Vmath::Smul(physTot, m_pressureRelaxation, correction[i], 1,
141  correction[i], 1);
142  }
143 
144  if (m_pressure->GetWaveSpace())
145  {
146  for (int i = 0; i < nvel; ++i)
147  {
148  m_pressure->HomogeneousFwdTrans(correction[i], correction[i]);
149  }
150  }
151  // p_i - alpha*J*div(G(p))
152  for (int i = 0; i < nvel; ++i)
153  {
154  Vmath::Vsub(physTot, gradP[i], 1, correction[i], 1, correction[i],
155  1);
156  }
157 
158  // Get value at boundary and calculate Inner product
159  Array<OneD, Array<OneD, NekDouble>> correctionElmt(m_bnd_dim);
160  Array<OneD, Array<OneD, NekDouble>> BndValues(m_bnd_dim);
162  for (n = cnt = 0; n < m_PBndConds.size(); ++n)
163  {
164  // High order boundary condition;
165  if (boost::iequals(m_PBndConds[n]->GetUserDefined(), "H"))
166  {
167  m_fields[0]->GetBndElmtExpansion(n, BndElmtExp);
168 
169  // Obtaining fields on BndElmtExp
170  for (int i = 0; i < m_bnd_dim; i++)
171  {
172  m_fields[0]->ExtractPhysToBndElmt(n, correction[i],
173  correctionElmt[i]);
174  }
175 
176  Vals = m_bcCorrection + cnt;
177  // Getting values on the edge and filling the correction
178  for (int i = 0; i < m_bnd_dim; i++)
179  {
180  m_fields[0]->ExtractElmtToBndPhys(n, correctionElmt[i],
181  BndValues[i]);
182  }
183  m_PBndExp[n]->NormVectorIProductWRTBase(BndValues, Vals);
184 
185  // Get offset for next terms
186  cnt += m_PBndExp[n]->GetNcoeffs();
187  }
188  }
189 
190  // Apply new correction
191  for (cnt = n = 0; n < m_PBndConds.size(); ++n)
192  {
193  if (m_PBndConds[n]->GetUserDefined() == "H")
194  {
195  int nq = m_PBndExp[n]->GetNcoeffs();
196  Vmath::Vadd(nq, &(m_PBndExp[n]->GetCoeffs()[0]), 1,
197  &(m_bcCorrection[cnt]), 1,
198  &(m_PBndExp[n]->UpdateCoeffs()[0]), 1);
199  cnt += nq;
200  }
201  }
202  }
203 }
MultiRegions::ExpListSharedPtr m_pressure
Pointer to field holding pressure field.
Definition: Extrapolate.h:201
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:419

References Nektar::MultiRegions::DirCartesianMap, m_bcCorrection, Nektar::Extrapolate::m_bnd_dim, Nektar::Extrapolate::m_fields, Nektar::Extrapolate::m_HBCnumber, m_mapping, Nektar::Extrapolate::m_PBndConds, Nektar::Extrapolate::m_PBndExp, Nektar::Extrapolate::m_pressure, m_pressureRelaxation, CG_Iterations::pressure, Vmath::Smul(), Vmath::Vadd(), Vmath::Vcopy(), Vmath::Vmul(), and Vmath::Vsub().

Member Data Documentation

◆ className

std::string Nektar::MappingExtrapolate::className
static
Initial value:
=
"Mapping", MappingExtrapolate::create, "Mapping")
tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, std::string pDesc="")
Register a class with the factory.
Definition: NekFactory.hpp:198
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.
ExtrapolateFactory & GetExtrapolateFactory()
Definition: Extrapolate.cpp:48

Name of class.

Registers the class with the Factory.

Definition at line 68 of file MappingExtrapolate.h.

◆ m_bcCorrection

Array<OneD, NekDouble> Nektar::MappingExtrapolate::m_bcCorrection
protected

Definition at line 88 of file MappingExtrapolate.h.

Referenced by v_CalcNeumannPressureBCs(), and v_CorrectPressureBCs().

◆ m_implicitPressure

bool Nektar::MappingExtrapolate::m_implicitPressure
protected

Definition at line 92 of file MappingExtrapolate.h.

Referenced by MappingExtrapolate(), and v_CalcNeumannPressureBCs().

◆ m_implicitViscous

bool Nektar::MappingExtrapolate::m_implicitViscous
protected

Definition at line 93 of file MappingExtrapolate.h.

Referenced by MappingExtrapolate(), and v_CalcNeumannPressureBCs().

◆ m_mapping

GlobalMapping::MappingSharedPtr Nektar::MappingExtrapolate::m_mapping
protected

◆ m_pressureRelaxation

NekDouble Nektar::MappingExtrapolate::m_pressureRelaxation
protected