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

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, NekDouble > m_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, 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
 

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 (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)
 
- Protected Member Functions inherited from Nektar::Extrapolate
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_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::Extrapolate
static NekDouble StifflyStable_Betaq_Coeffs [3][3]
 
static NekDouble StifflyStable_Alpha_Coeffs [3][3]
 
static NekDouble StifflyStable_Gamma0_Coeffs [3]
 

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.

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

53  : StandardExtrapolate(pSession, pFields, pPressure, pVel, advObject)
54 {
55  m_mapping = GlobalMapping::Mapping::Load(m_session, m_fields);
56 
57  // Load solve parameters related to the mapping
58  // Flags determining if pressure/viscous terms should be treated implicitly
59  m_session->MatchSolverInfo(
60  "MappingImplicitPressure", "True", m_implicitPressure, false);
61  m_session->MatchSolverInfo(
62  "MappingImplicitViscous", "True", m_implicitViscous, false);
63 
64  // Relaxation parameter for pressure system
65  m_session->LoadParameter(
66  "MappingPressureRelaxation", m_pressureRelaxation, 1.0);
67 }
Nektar::Extrapolate::m_session
LibUtilities::SessionReaderSharedPtr m_session
Definition: Extrapolate.h:210
Nektar::StandardExtrapolate::StandardExtrapolate
StandardExtrapolate(const LibUtilities::SessionReaderSharedPtr pSession, Array< OneD, MultiRegions::ExpListSharedPtr > pFields, MultiRegions::ExpListSharedPtr pPressure, const Array< OneD, int > pVel, const SolverUtils::AdvectionSharedPtr advObject)
Definition: StandardExtrapolate.cpp:48
Nektar::Extrapolate::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Velocity fields.
Definition: Extrapolate.h:218
Nektar::MappingExtrapolate::m_mapping
GlobalMapping::MappingSharedPtr m_mapping
Definition: MappingExtrapolate.h:88
Nektar::GlobalMapping::Mapping::Load
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:268

◆ ~MappingExtrapolate()

Nektar::MappingExtrapolate::~MappingExtrapolate ( )
virtual

Definition at line 69 of file MappingExtrapolate.cpp.

70 {
71 }

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.

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

61  {
62  ExtrapolateSharedPtr p =
63  MemoryManager<MappingExtrapolate>::AllocateSharedPtr(
64  pSession, pFields, pPressure, pVel, advObject);
65  return p;
66  }
Nektar::ExtrapolateSharedPtr
std::shared_ptr< Extrapolate > ExtrapolateSharedPtr
Definition: Extrapolate.h:59
CellMLToNektar.cellml_metadata.p
p
Definition: cellml_metadata.py:350
Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:161

◆ 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 218 of file MappingExtrapolate.cpp.

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

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

◆ v_CorrectPressureBCs()

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

Reimplemented from Nektar::Extrapolate.

Definition at line 76 of file MappingExtrapolate.cpp.

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, Vmath::Smul(), Vmath::Vadd(), Vmath::Vcopy(), Vmath::Vmul(), and Vmath::Vsub().

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

Member Data Documentation

◆ className

std::string Nektar::MappingExtrapolate::className
static
Initial value:
=
GetExtrapolateFactory().RegisterCreatorFunction(
"Mapping", MappingExtrapolate::create, "Mapping")

Name of class.

Registers the class with the Factory.

Definition at line 69 of file MappingExtrapolate.h.

◆ m_bcCorrection

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

Definition at line 90 of file MappingExtrapolate.h.

Referenced by v_CalcNeumannPressureBCs(), and v_CorrectPressureBCs().

◆ m_implicitPressure

bool Nektar::MappingExtrapolate::m_implicitPressure
protected

Definition at line 94 of file MappingExtrapolate.h.

Referenced by MappingExtrapolate(), and v_CalcNeumannPressureBCs().

◆ m_implicitViscous

bool Nektar::MappingExtrapolate::m_implicitViscous
protected

Definition at line 95 of file MappingExtrapolate.h.

Referenced by MappingExtrapolate(), and v_CalcNeumannPressureBCs().

◆ m_mapping

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

Definition at line 88 of file MappingExtrapolate.h.

Referenced by MappingExtrapolate(), v_CalcNeumannPressureBCs(), and v_CorrectPressureBCs().

◆ m_pressureRelaxation

NekDouble Nektar::MappingExtrapolate::m_pressureRelaxation
protected

Definition at line 98 of file MappingExtrapolate.h.

Referenced by MappingExtrapolate(), v_CalcNeumannPressureBCs(), and v_CorrectPressureBCs().

Generated on Wed Jan 20 2021 03:33:53 for Nektar++ by   doxygen 1.8.13