#include <NavierStokesAdvection.h>

Inheritance diagram for Nektar::NavierStokesAdvection:

Public Member Functions
void	SetSpecHPDealiasing (bool value)

Public Member Functions inherited from Nektar::SolverUtils::Advection
virtual SOLVER_UTILS_EXPORT	~Advection ()

SOLVER_UTILS_EXPORT void	InitObject (LibUtilities::SessionReaderSharedPtr pSession, Array< OneD, MultiRegions::ExpListSharedPtr > pFields)
	Interface function to initialise the advection object. More...

SOLVER_UTILS_EXPORT void	Advect (const int nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &advVel, const Array< OneD, Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const NekDouble &time, const Array< OneD, Array< OneD, NekDouble >> &pFwd=NullNekDoubleArrayOfArray, const Array< OneD, Array< OneD, NekDouble >> &pBwd=NullNekDoubleArrayOfArray)
	Interface function to advect the vector field. More...

SOLVER_UTILS_EXPORT void	AdvectVolumeFlux (const int nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const Array< OneD, Array< OneD, NekDouble >> &pAdvVel, const Array< OneD, Array< OneD, NekDouble >> &pInarray, TensorOfArray3D< NekDouble > &pVolumeFlux, const NekDouble &pTime)
	Interface function to advect the Volume field. More...

SOLVER_UTILS_EXPORT void	AdvectTraceFlux (const int nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const Array< OneD, Array< OneD, NekDouble >> &pAdvVel, const Array< OneD, Array< OneD, NekDouble >> &pInarray, Array< OneD, Array< OneD, NekDouble >> &pTraceFlux, const NekDouble &pTime, const Array< OneD, Array< OneD, NekDouble >> &pFwd=NullNekDoubleArrayOfArray, const Array< OneD, Array< OneD, NekDouble >> &pBwd=NullNekDoubleArrayOfArray)
	Interface function to advect the Trace field. More...

SOLVER_UTILS_EXPORT void	AdvectCoeffs (const int nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &advVel, const Array< OneD, Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const NekDouble &time, const Array< OneD, Array< OneD, NekDouble >> &pFwd=NullNekDoubleArrayOfArray, const Array< OneD, Array< OneD, NekDouble >> &pBwd=NullNekDoubleArrayOfArray)
	Similar with Advection::Advect(): calculate the advection flux The difference is in the outarray: it is the coefficients of basis for AdvectCoeffs() it is the physics on quadrature points for Advect() More...

template<typename FuncPointerT , typename ObjectPointerT >
void	SetFluxVector (FuncPointerT func, ObjectPointerT obj)
	Set the flux vector callback function. More...

void	SetRiemannSolver (RiemannSolverSharedPtr riemann)
	Set a Riemann solver object for this advection object. More...

void	SetFluxVector (AdvectionFluxVecCB fluxVector)
	Set the flux vector callback function. More...

void	SetBaseFlow (const Array< OneD, Array< OneD, NekDouble >> &inarray, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields)
	Set the base flow used for linearised advection objects. More...

template<typename DataType , typename TypeNekBlkMatSharedPtr >
SOLVER_UTILS_EXPORT void	AddTraceJacToMat (const int nConvectiveFields, const int nSpaceDim, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const Array< OneD, TypeNekBlkMatSharedPtr > &TracePntJacCons, Array< OneD, Array< OneD, TypeNekBlkMatSharedPtr >> &gmtxarray, const Array< OneD, TypeNekBlkMatSharedPtr > &TracePntJacGrad, const Array< OneD, Array< OneD, DataType >> &TracePntJacGradSign)

template<typename DataType , typename TypeNekBlkMatSharedPtr >
void	CalcJacobTraceInteg (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const int m, const int n, const Array< OneD, const TypeNekBlkMatSharedPtr > &PntJac, const Array< OneD, const Array< OneD, DataType >> &PntJacSign, Array< OneD, DNekMatSharedPtr > &TraceJacFwd, Array< OneD, DNekMatSharedPtr > &TraceJacBwd)

SOLVER_UTILS_EXPORT void	AddVolumJacToMat (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const int &nConvectiveFields, const TensorOfArray5D< NekDouble > &ElmtJacArray, Array< OneD, Array< OneD, SNekBlkMatSharedPtr >> &gmtxarray)

template<typename DataType , typename TypeNekBlkMatSharedPtr >
void	AddTraceJacToMat (const int nConvectiveFields, const int nSpaceDim, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const Array< OneD, TypeNekBlkMatSharedPtr > &TracePntJacCons, Array< OneD, Array< OneD, TypeNekBlkMatSharedPtr >> &gmtxarray, const Array< OneD, TypeNekBlkMatSharedPtr > &TracePntJacGrad, const Array< OneD, Array< OneD, DataType >> &TracePntJacGradSign)

Static Public Member Functions
static SolverUtils::AdvectionSharedPtr	create (std::string)
	Creates an instance of this class. More...

Static Public Attributes
static std::string	className
	Name of class. More...

static std::string	className2

Protected Member Functions
	NavierStokesAdvection ()

virtual	~NavierStokesAdvection ()

virtual void	v_InitObject (LibUtilities::SessionReaderSharedPtr pSession, Array< OneD, MultiRegions::ExpListSharedPtr > pFields) override
	Initialises the advection object. More...

virtual void	v_Advect (const int nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &advVel, const Array< OneD, Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const NekDouble &time, const Array< OneD, Array< OneD, NekDouble >> &pFwd=NullNekDoubleArrayOfArray, const Array< OneD, Array< OneD, NekDouble >> &pBwd=NullNekDoubleArrayOfArray) override
	Advects a vector field. More...

Protected Member Functions inherited from Nektar::SolverUtils::Advection
virtual SOLVER_UTILS_EXPORT void	v_AdvectVolumeFlux (const int nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &advVel, const Array< OneD, Array< OneD, NekDouble >> &inarray, TensorOfArray3D< NekDouble > &pVolumeFlux, const NekDouble &time)
	Advects Volume Flux. More...

virtual SOLVER_UTILS_EXPORT void	v_AdvectTraceFlux (const int nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &advVel, const Array< OneD, Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &pTraceFlux, const NekDouble &time, const Array< OneD, Array< OneD, NekDouble >> &pFwd=NullNekDoubleArrayOfArray, const Array< OneD, Array< OneD, NekDouble >> &pBwd=NullNekDoubleArrayOfArray)
	Advects Trace Flux. More...

virtual SOLVER_UTILS_EXPORT void	v_AdvectCoeffs (const int nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &advVel, const Array< OneD, Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const NekDouble &time, const Array< OneD, Array< OneD, NekDouble >> &pFwd=NullNekDoubleArrayOfArray, const Array< OneD, Array< OneD, NekDouble >> &pBwd=NullNekDoubleArrayOfArray)

virtual SOLVER_UTILS_EXPORT void	v_SetBaseFlow (const Array< OneD, Array< OneD, NekDouble >> &inarray, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields)
	Overrides the base flow used during linearised advection. More...

virtual SOLVER_UTILS_EXPORT void	v_AddVolumJacToMat (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const int &nConvectiveFields, const TensorOfArray5D< NekDouble > &ElmtJacArray, Array< OneD, Array< OneD, SNekBlkMatSharedPtr >> &gmtxarray)

Static Protected Attributes
static std::string	navierStokesAdvectionTypeLookupIds []

Private Attributes
bool	m_specHP_dealiasing

bool	m_homogen_dealiasing

bool	m_SingleMode

bool	m_HalfMode

Friends
class	MemoryManager< NavierStokesAdvection >

Additional Inherited Members
Protected Attributes inherited from Nektar::SolverUtils::Advection
AdvectionFluxVecCB	m_fluxVector
	Callback function to the flux vector (set when advection is in conservative form). More...

RiemannSolverSharedPtr	m_riemann
	Riemann solver for DG-type schemes. More...

int	m_spaceDim
	Storage for space dimension. Used for homogeneous extension. More...

Detailed Description

Definition at line 43 of file NavierStokesAdvection.h.

Constructor & Destructor Documentation

◆ NavierStokesAdvection()

Nektar::NavierStokesAdvection::NavierStokesAdvection ( )

protected

Constructor. Creates ...

Parameters

Definition at line 63 of file NavierStokesAdvection.cpp.

                                              : Advection()
  
 {
 }

◆ ~NavierStokesAdvection()

Nektar::NavierStokesAdvection::~NavierStokesAdvection ( )

protectedvirtual

Definition at line 68 of file NavierStokesAdvection.cpp.

69 {

70 }

Member Function Documentation

◆ create()

static SolverUtils::AdvectionSharedPtr Nektar::NavierStokesAdvection::create ( std::string )

inlinestatic

Creates an instance of this class.

Definition at line 50 of file NavierStokesAdvection.h.

     {
         return MemoryManager<NavierStokesAdvection>::AllocateSharedPtr();
     }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr().

◆ SetSpecHPDealiasing()

void Nektar::NavierStokesAdvection::SetSpecHPDealiasing ( bool value )

inline

Definition at line 59 of file NavierStokesAdvection.h.

     {
         m_specHP_dealiasing = value;
     }

References m_specHP_dealiasing.

◆ v_Advect()

void Nektar::NavierStokesAdvection::v_Advect	(	const int	nConvectiveFields,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, Array< OneD, NekDouble >> &	advVel,
		const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		Array< OneD, Array< OneD, NekDouble >> &	outarray,
		const NekDouble &	time,
		const Array< OneD, Array< OneD, NekDouble >> &	pFwd = `NullNekDoubleArrayOfArray`,
		const Array< OneD, Array< OneD, NekDouble >> &	pBwd = `NullNekDoubleArrayOfArray`
	)

overrideprotectedvirtual

Advects a vector field.

Implements Nektar::SolverUtils::Advection.

Definition at line 86 of file NavierStokesAdvection.cpp.

 {
     boost::ignore_unused(time, pFwd, pBwd);
  
     int nqtot = fields[0]->GetTotPoints();
     ASSERTL1(nConvectiveFields == inarray.size(),
              "Number of convective fields and Inarray are not compatible");
  
     // use dimension of Velocity vector to dictate dimension of operation
     int ndim = advVel.size();
     Array<OneD, Array<OneD, NekDouble>> AdvVel(advVel.size());
  
     Array<OneD, Array<OneD, NekDouble>> velocity(ndim);
  
     LibUtilities::Timer timer;
  
     for (int i = 0; i < ndim; ++i)
     {
         if (fields[i]->GetWaveSpace() && !m_SingleMode && !m_HalfMode &&
             !m_homogen_dealiasing)
         {
             velocity[i] = Array<OneD, NekDouble>(nqtot, 0.0);
             fields[i]->HomogeneousBwdTrans(nqtot, advVel[i], velocity[i]);
         }
         else
         {
             velocity[i] = advVel[i];
         }
     }
  
     int nPointsTot = fields[0]->GetNpoints();
     Array<OneD, NekDouble> grad0, grad1, grad2, wkSp;
  
     NekDouble OneDptscale = 1.5; // factor to rescale 1d points in dealiasing
  
     if (m_specHP_dealiasing)
     {
         // Get number of points to dealias a quadratic non-linearity
         nPointsTot = fields[0]->Get1DScaledTotPoints(OneDptscale);
     }
  
     // interpolate Advection velocity
     if (m_specHP_dealiasing) // interpolate advection field to higher space.
     {
         for (int i = 0; i < ndim; ++i)
         {
             AdvVel[i] = Array<OneD, NekDouble>(nPointsTot);
             // interpolate infield to 3/2 dimension
             timer.Start();
             fields[0]->PhysInterp1DScaled(OneDptscale, velocity[i], AdvVel[i]);
             timer.Stop();
             timer.AccumulateRegion("Interp1DScaled");
         }
     }
     else
     {
         for (int i = 0; i < ndim; ++i)
         {
             AdvVel[i] = velocity[i];
         }
     }
  
     wkSp = Array<OneD, NekDouble>(nPointsTot);
  
     // Evaluate V\cdot Grad(u)
     switch (ndim)
     {
         case 1:
             grad0 = Array<OneD, NekDouble>(fields[0]->GetNpoints());
             for (int n = 0; n < nConvectiveFields; ++n)
             {
                 fields[0]->PhysDeriv(inarray[n], grad0);
                 if (m_specHP_dealiasing) // interpolate gradient field
                 {
                     Array<OneD, NekDouble> Outarray(nPointsTot);
                     fields[0]->PhysInterp1DScaled(OneDptscale, grad0, wkSp);
                     Vmath::Vmul(nPointsTot, wkSp, 1, AdvVel[0], 1, Outarray, 1);
                     // Galerkin project solution back to origianl spac
                     timer.Start();
                     fields[0]->PhysGalerkinProjection1DScaled(
                         OneDptscale, Outarray, outarray[n]);
                     timer.Stop();
                     timer.AccumulateRegion("GalerinProject");
                 }
                 else
                 {
                     Vmath::Vmul(nPointsTot, grad0, 1, AdvVel[0], 1, outarray[n],
                                 1);
                 }
             }
             break;
         case 2:
             grad0 = Array<OneD, NekDouble>(nqtot);
             grad1 = Array<OneD, NekDouble>(nqtot);
             for (int n = 0; n < nConvectiveFields; ++n)
             {
                 fields[0]->PhysDeriv(inarray[n], grad0, grad1);
  
                 if (m_specHP_dealiasing) // interpolate gradient field
                 {
                     Array<OneD, NekDouble> Outarray(nPointsTot);
                     fields[0]->PhysInterp1DScaled(OneDptscale, grad0, wkSp);
                     Vmath::Vmul(nPointsTot, wkSp, 1, AdvVel[0], 1, Outarray, 1);
                     timer.Start();
                     fields[0]->PhysInterp1DScaled(OneDptscale, grad1, wkSp);
                     timer.Stop();
                     timer.AccumulateRegion("Interp1DScaled");
                     Vmath::Vvtvp(nPointsTot, wkSp, 1, AdvVel[1], 1, Outarray, 1,
                                  Outarray, 1);
                     // Galerkin project solution back to original space
                     timer.Start();
                     fields[0]->PhysGalerkinProjection1DScaled(
                         OneDptscale, Outarray, outarray[n]);
                     timer.Stop();
                     timer.AccumulateRegion("GalerinProject");
                 }
                 else
                 {
                     Vmath::Vmul(nPointsTot, grad0, 1, AdvVel[0], 1, outarray[n],
                                 1);
                     Vmath::Vvtvp(nPointsTot, grad1, 1, AdvVel[1], 1,
                                  outarray[n], 1, outarray[n], 1);
                 }
             }
             break;
         case 3:
             if (m_homogen_dealiasing == true && m_specHP_dealiasing == true)
             {
                 Array<OneD, Array<OneD, NekDouble>> grad(ndim);
                 Array<OneD, Array<OneD, NekDouble>> gradScaled(
                     ndim * nConvectiveFields);
                 Array<OneD, Array<OneD, NekDouble>> Outarray(nConvectiveFields);
                 for (int i = 0; i < ndim; i++)
                 {
                     grad[i] = Array<OneD, NekDouble>(nqtot);
                 }
                 for (int i = 0; i < ndim * nConvectiveFields; i++)
                 {
                     gradScaled[i] = Array<OneD, NekDouble>(nPointsTot);
                 }
                 for (int i = 0; i < nConvectiveFields; i++)
                 {
                     Outarray[i] = Array<OneD, NekDouble>(nPointsTot);
                 }
  
                 for (int n = 0; n < nConvectiveFields; n++)
                 {
                     fields[0]->PhysDeriv(inarray[n], grad[0], grad[1], grad[2]);
                     for (int i = 0; i < ndim; i++)
                     {
                         timer.Start();
                         fields[0]->PhysInterp1DScaled(OneDptscale, grad[i],
                                                       gradScaled[n * ndim + i]);
                         timer.Stop();
                         timer.AccumulateRegion("Interp1DScaled");
                     }
                 }
  
                 fields[0]->DealiasedDotProd(nPointsTot, AdvVel, gradScaled,
                                             Outarray);
  
                 timer.Start();
                 for (int n = 0; n < nConvectiveFields; n++)
                 {
                     fields[0]->PhysGalerkinProjection1DScaled(
                         OneDptscale, Outarray[n], outarray[n]);
                 }
                 timer.Stop();
                 timer.AccumulateRegion("GalerinProject");
             }
             else if (m_homogen_dealiasing == true &&
                      m_specHP_dealiasing == false)
             {
                 Array<OneD, Array<OneD, NekDouble>> grad(ndim *
                                                          nConvectiveFields);
                 Array<OneD, Array<OneD, NekDouble>> Outarray(nConvectiveFields);
                 for (int i = 0; i < ndim * nConvectiveFields; i++)
                 {
                     grad[i] = Array<OneD, NekDouble>(nPointsTot);
                 }
                 for (int i = 0; i < nConvectiveFields; i++)
                 {
                     Outarray[i] = Array<OneD, NekDouble>(nPointsTot);
                 }
  
                 for (int n = 0; n < nConvectiveFields; n++)
                 {
                     fields[0]->PhysDeriv(inarray[n], grad[n * ndim + 0],
                                          grad[n * ndim + 1],
                                          grad[n * ndim + 2]);
                 }
  
                 fields[0]->DealiasedDotProd(nPointsTot, AdvVel, grad, outarray);
             }
             else
             {
                 grad0                      = Array<OneD, NekDouble>(nqtot);
                 grad1                      = Array<OneD, NekDouble>(nqtot);
                 grad2                      = Array<OneD, NekDouble>(nqtot);
                 Array<OneD, NekDouble> tmp = grad2;
                 for (int n = 0; n < nConvectiveFields; ++n)
                 {
                     if (fields[0]->GetWaveSpace() == true &&
                         fields[0]->GetExpType() == MultiRegions::e3DH1D)
                     {
                         fields[0]->HomogeneousBwdTrans(nqtot, inarray[n], tmp);
                         fields[0]->PhysDeriv(tmp, grad0, grad1);
                         // Take d/dz derivative using wave space field
                         fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[2],
                                              inarray[n], outarray[n]);
                         fields[0]->HomogeneousBwdTrans(nqtot, outarray[n],
                                                        grad2);
                     }
                     else if (fields[0]->GetWaveSpace() == true &&
                              fields[0]->GetExpType() == MultiRegions::e3DH2D)
                     {
                         fields[0]->HomogeneousBwdTrans(nqtot, inarray[n], tmp);
                         fields[0]->PhysDeriv(tmp, grad0);
                         // Take d/dy derivative using wave space field
                         fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[1],
                                              inarray[n], outarray[n]);
                         fields[0]->HomogeneousBwdTrans(nqtot, outarray[n],
                                                        grad1);
                         // Take d/dz derivative using wave space field
                         fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[2],
                                              inarray[n], outarray[n]);
                         fields[0]->HomogeneousBwdTrans(nqtot, outarray[n],
                                                        grad2);
                     }
                     else
                     {
                         fields[0]->PhysDeriv(inarray[n], grad0, grad1, grad2);
                     }
                     if (m_specHP_dealiasing) // interpolate spectral/hp gradient
                                              // field
                     {
                         Array<OneD, NekDouble> Outarray(nPointsTot);
                         timer.Start();
                         fields[0]->PhysInterp1DScaled(OneDptscale, grad0, wkSp);
                         timer.Stop();
                         timer.AccumulateRegion("Interp1DScaled");
                         Vmath::Vmul(nPointsTot, wkSp, 1, AdvVel[0], 1, Outarray,
                                     1);
  
                         timer.Start();
                         fields[0]->PhysInterp1DScaled(OneDptscale, grad1, wkSp);
                         timer.Stop();
                         timer.AccumulateRegion("Interp1DScaled");
                         Vmath::Vvtvp(nPointsTot, wkSp, 1, AdvVel[1], 1,
                                      Outarray, 1, Outarray, 1);
  
                         timer.Start();
                         fields[0]->PhysInterp1DScaled(OneDptscale, grad2, wkSp);
                         timer.Stop();
                         timer.AccumulateRegion("Interp1DScaled");
                         Vmath::Vvtvp(nPointsTot, wkSp, 1, AdvVel[2], 1,
                                      Outarray, 1, Outarray, 1);
                         timer.Start();
                         fields[0]->PhysGalerkinProjection1DScaled(
                             OneDptscale, Outarray, outarray[n]);
                         timer.Stop();
                         timer.AccumulateRegion("GalerinProject");
                     }
                     else
                     {
                         Vmath::Vmul(nPointsTot, grad0, 1, AdvVel[0], 1,
                                     outarray[n], 1);
                         Vmath::Vvtvp(nPointsTot, grad1, 1, AdvVel[1], 1,
                                      outarray[n], 1, outarray[n], 1);
                         Vmath::Vvtvp(nPointsTot, grad2, 1, AdvVel[2], 1,
                                      outarray[n], 1, outarray[n], 1);
                     }
  
                     if (fields[0]->GetWaveSpace() == true)
                     {
                         fields[0]->HomogeneousFwdTrans(nqtot, outarray[n],
                                                        outarray[n]);
                     }
                 }
             }
             break;
         default:
             ASSERTL0(false, "dimension unknown");
     }
  
     for (int n = 0; n < nConvectiveFields; ++n)
     {
         Vmath::Neg(nqtot, outarray[n], 1);
     }
 }

References Nektar::LibUtilities::Timer::AccumulateRegion(), ASSERTL0, ASSERTL1, Nektar::MultiRegions::DirCartesianMap, Nektar::MultiRegions::e3DH1D, Nektar::MultiRegions::e3DH2D, m_HalfMode, m_homogen_dealiasing, m_SingleMode, m_specHP_dealiasing, Vmath::Neg(), Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), Vmath::Vmul(), and Vmath::Vvtvp().

◆ v_InitObject()

void Nektar::NavierStokesAdvection::v_InitObject	(	LibUtilities::SessionReaderSharedPtr	pSession,
		Array< OneD, MultiRegions::ExpListSharedPtr >	pFields
	)

overrideprotectedvirtual

Initialises the advection object.

This function should be overridden in derived classes to initialise the specific advection data members. However, this base class function should be called as the first statement of the overridden function to ensure the base class is correctly initialised in order.

Parameters

pSession	Session information.
pFields	Expansion lists for scalar fields.

Reimplemented from Nektar::SolverUtils::Advection.

Definition at line 72 of file NavierStokesAdvection.cpp.

 {
     m_homogen_dealiasing = pSession->DefinesSolverInfo("dealiasing");
  
     pSession->MatchSolverInfo("SPECTRALHPDEALIASING", "True",
                               m_specHP_dealiasing, false);
     pSession->MatchSolverInfo("ModeType", "SingleMode", m_SingleMode, false);
     pSession->MatchSolverInfo("ModeType", "HalfMode", m_HalfMode, false);
  
     Advection::v_InitObject(pSession, pFields);
 }

References m_HalfMode, m_homogen_dealiasing, m_SingleMode, m_specHP_dealiasing, and Nektar::SolverUtils::Advection::v_InitObject().

Friends And Related Function Documentation

◆ MemoryManager< NavierStokesAdvection >

friend class MemoryManager< NavierStokesAdvection >

friend

Definition at line 1 of file NavierStokesAdvection.h.

Member Data Documentation

◆ className

string Nektar::NavierStokesAdvection::className

static

Initial value:

=
    SolverUtils::GetAdvectionFactory().RegisterCreatorFunction(
        "Convective", NavierStokesAdvection::create, "Convective")

Name of class.

Definition at line 56 of file NavierStokesAdvection.h.

◆ className2

string Nektar::NavierStokesAdvection::className2

static

Initial value:

=
    SolverUtils::GetAdvectionFactory().RegisterCreatorFunction(
        "NonConservative", NavierStokesAdvection::create, "NonConserviative")

Definition at line 57 of file NavierStokesAdvection.h.

◆ m_HalfMode

bool Nektar::NavierStokesAdvection::m_HalfMode

private

Definition at line 90 of file NavierStokesAdvection.h.

Referenced by v_Advect(), and v_InitObject().

◆ m_homogen_dealiasing

bool Nektar::NavierStokesAdvection::m_homogen_dealiasing

private

Definition at line 88 of file NavierStokesAdvection.h.

Referenced by v_Advect(), and v_InitObject().

◆ m_SingleMode

bool Nektar::NavierStokesAdvection::m_SingleMode

private

Definition at line 89 of file NavierStokesAdvection.h.

Referenced by v_Advect(), and v_InitObject().

◆ m_specHP_dealiasing

bool Nektar::NavierStokesAdvection::m_specHP_dealiasing

private

Definition at line 87 of file NavierStokesAdvection.h.

Referenced by SetSpecHPDealiasing(), v_Advect(), and v_InitObject().

◆ navierStokesAdvectionTypeLookupIds

std::string Nektar::NavierStokesAdvection::navierStokesAdvectionTypeLookupIds

staticprotected

Initial value:

= {
    LibUtilities::SessionReader::RegisterEnumValue("SPECTRALHPDEALIASING",
                                                   "True", 0),
    LibUtilities::SessionReader::RegisterEnumValue("SPECTRALHPDEALIASING",
                                                   "False", 1)}

Definition at line 84 of file NavierStokesAdvection.h.

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Static Protected Attributes

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ NavierStokesAdvection()

◆ ~NavierStokesAdvection()

Member Function Documentation

◆ create()

◆ SetSpecHPDealiasing()

◆ v_Advect()

◆ v_InitObject()

Friends And Related Function Documentation

◆ MemoryManager< NavierStokesAdvection >

Member Data Documentation

◆ className

◆ className2

◆ m_HalfMode

◆ m_homogen_dealiasing

◆ m_SingleMode

◆ m_specHP_dealiasing

◆ navierStokesAdvectionTypeLookupIds