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, 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)
 
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, 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
 
std::vector< SolverUtils::ForcingSharedPtr > m_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::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) override
 
virtual void v_SubSteppingTimeIntegration (const LibUtilities::TimeIntegrationSchemeSharedPtr &IntegrationScheme) override
 
virtual void v_SubStepSaveFields (int nstep) override
 
virtual void v_SubStepSetPressureBCs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, NekDouble Aii_DT, NekDouble kinvis) override
 
virtual void v_SubStepAdvance (int nstep, NekDouble time) override
 
virtual void v_MountHOPBCs (int HBCdata, NekDouble kinvis, Array< OneD, NekDouble > &Q, Array< OneD, const NekDouble > &Advection) override
 
virtual void v_AccelerationBDF (Array< OneD, Array< OneD, NekDouble > > &array) override
 
- Protected Member Functions inherited from Nektar::Extrapolate
virtual void v_EvaluatePressureBCs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, const Array< OneD, const Array< OneD, NekDouble > > &N, NekDouble kinvis)=0
 
virtual void v_SubSteppingTimeIntegration (const LibUtilities::TimeIntegrationSchemeSharedPtr &IntegrationScheme)=0
 
virtual void v_SubStepSaveFields (int nstep)=0
 
virtual void v_SubStepSetPressureBCs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, NekDouble Aii_DT, NekDouble kinvis)=0
 
virtual void v_SubStepAdvance (int nstep, NekDouble time)=0
 
virtual void v_MountHOPBCs (int HBCdata, NekDouble kinvis, Array< OneD, NekDouble > &Q, Array< OneD, const NekDouble > &Advection)=0
 
virtual std::string v_GetSubStepName (void)
 
virtual void v_AccelerationBDF (Array< OneD, Array< OneD, NekDouble > > &array)
 
void CalcNeumannPressureBCs (const Array< OneD, const Array< OneD, NekDouble > > &fields, const Array< OneD, const Array< OneD, NekDouble > > &N, NekDouble kinvis)
 
virtual void v_CalcNeumannPressureBCs (const Array< OneD, const Array< OneD, NekDouble > > &fields, const Array< OneD, const Array< OneD, NekDouble > > &N, NekDouble kinvis)
 
virtual void v_CorrectPressureBCs (const Array< OneD, NekDouble > &pressure)
 
virtual void v_AddNormVelOnOBC (const int nbcoeffs, const int nreg, Array< OneD, Array< OneD, NekDouble > > &u)
 
void CalcOutflowBCs (const Array< OneD, const Array< OneD, NekDouble > > &fields, NekDouble kinvis)
 
void RollOver (Array< OneD, Array< OneD, NekDouble > > &input)
 
- 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{
54 m_mapping = GlobalMapping::Mapping::Load(m_session, m_fields);
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}
Nektar::Extrapolate::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Velocity fields.
Definition: Extrapolate.h:199
Nektar::Extrapolate::m_session
LibUtilities::SessionReaderSharedPtr m_session
Definition: Extrapolate.h:191
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:272
Nektar::MappingExtrapolate::m_mapping
GlobalMapping::MappingSharedPtr m_mapping
Definition: MappingExtrapolate.h:86
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:52

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

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

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

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 size_t cnt, n;
81 size_t physTot = m_fields[0]->GetTotPoints();
82 size_t 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 size_t 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 (size_t 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 (size_t i = 0; i < nvel; ++i)
115 {
116 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[i], pressure,
117 gradP[i]);
118 if (m_fields[0]->GetWaveSpace())
119 {
120 m_fields[0]->HomogeneousBwdTrans(physTot, 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 (size_t i = 0; i < nvel; ++i)
133 {
134 Vmath::Vmul(physTot, correction[i], 1, Jac, 1, correction[i],
135 1);
136 }
137 }
138 for (size_t 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 (size_t i = 0; i < nvel; ++i)
147 {
148 m_pressure->HomogeneousFwdTrans(physTot, correction[i],
149 correction[i]);
150 }
151 }
152 // p_i - alpha*J*div(G(p))
153 for (size_t i = 0; i < nvel; ++i)
154 {
155 Vmath::Vsub(physTot, gradP[i], 1, correction[i], 1, correction[i],
156 1);
157 }
158
159 // Get value at boundary and calculate Inner product
160 Array<OneD, Array<OneD, NekDouble>> correctionElmt(m_bnd_dim);
161 Array<OneD, Array<OneD, NekDouble>> BndValues(m_bnd_dim);
162 MultiRegions::ExpListSharedPtr BndElmtExp;
163 for (n = cnt = 0; n < m_PBndConds.size(); ++n)
164 {
165 // High order boundary condition;
166 if (boost::iequals(m_PBndConds[n]->GetUserDefined(), "H"))
167 {
168 m_fields[0]->GetBndElmtExpansion(n, BndElmtExp);
169
170 // Obtaining fields on BndElmtExp
171 for (int i = 0; i < m_bnd_dim; i++)
172 {
173 m_fields[0]->ExtractPhysToBndElmt(n, correction[i],
174 correctionElmt[i]);
175 }
176
177 Vals = m_bcCorrection + cnt;
178 // Getting values on the edge and filling the correction
179 for (int i = 0; i < m_bnd_dim; i++)
180 {
181 m_fields[0]->ExtractElmtToBndPhys(n, correctionElmt[i],
182 BndValues[i]);
183 }
184 m_PBndExp[n]->NormVectorIProductWRTBase(BndValues, Vals);
185
186 // Get offset for next terms
187 cnt += m_PBndExp[n]->GetNcoeffs();
188 }
189 }
190
191 // Apply new correction
192 for (size_t cnt = n = 0; n < m_PBndConds.size(); ++n)
193 {
194 if (m_PBndConds[n]->GetUserDefined() == "H")
195 {
196 size_t nq = m_PBndExp[n]->GetNcoeffs();
197 Vmath::Vadd(nq, &(m_PBndExp[n]->GetCoeffs()[0]), 1,
198 &(m_bcCorrection[cnt]), 1,
199 &(m_PBndExp[n]->UpdateCoeffs()[0]), 1);
200 cnt += nq;
201 }
202 }
203 }
204}
Nektar::Extrapolate::m_pressure
MultiRegions::ExpListSharedPtr m_pressure
Pointer to field holding pressure field.
Definition: Extrapolate.h:202
CG_Iterations.pressure
pressure
Definition: CG_Iterations.py:229
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:414

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:
=
GetExtrapolateFactory().RegisterCreatorFunction(
"Mapping", MappingExtrapolate::create, "Mapping")
Nektar::LibUtilities::NekFactory::RegisterCreatorFunction
tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, std::string pDesc="")
Register a class with the factory.
Definition: NekFactory.hpp:198
Nektar::MappingExtrapolate::create
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.
Definition: MappingExtrapolate.h:55
Nektar::GetExtrapolateFactory
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

Definition at line 86 of file MappingExtrapolate.h.

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

◆ m_pressureRelaxation

NekDouble Nektar::MappingExtrapolate::m_pressureRelaxation
protected

Definition at line 96 of file MappingExtrapolate.h.

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

Generated on Wed Jan 31 2024 08:26:53 for Nektar++ by doxygen 1.9.4