#include <DiffusionIP.h>

Inheritance diagram for Nektar::SolverUtils::DiffusionIP:

Public Member Functions
template<class T , typename = typename std::enable_if < std::is_floating_point<T>::value \|\| tinysimd::is_vector_floating_point<T>::value >::type>
void	ConsVarAve (const size_t nConvectiveFields, const T &Bweight, const std::vector< T > &vFwd, const std::vector< T > &vBwd, std::vector< T > &aver)
	Calculate the average of conservative variables on traces. More...

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

SOLVER_UTILS_EXPORT void	InitObject (LibUtilities::SessionReaderSharedPtr pSession, Array< OneD, MultiRegions::ExpListSharedPtr > pFields)

SOLVER_UTILS_EXPORT void	Diffuse (const std::size_t nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const Array< OneD, Array< OneD, NekDouble > > &pFwd=NullNekDoubleArrayOfArray, const Array< OneD, Array< OneD, NekDouble > > &pBwd=NullNekDoubleArrayOfArray)

SOLVER_UTILS_EXPORT void	DiffuseCoeffs (const std::size_t nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const Array< OneD, Array< OneD, NekDouble > > &pFwd=NullNekDoubleArrayOfArray, const Array< OneD, Array< OneD, NekDouble > > &pBwd=NullNekDoubleArrayOfArray)
	Similar with Diffusion::Diffuse(): calculate diffusion flux The difference is in the outarray: it is the coefficients of basis for DiffuseCoeffs() it is the physics on quadrature points for Diffuse() More...

SOLVER_UTILS_EXPORT void	Diffuse (const std::size_t nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, NekDouble time, const Array< OneD, Array< OneD, NekDouble > > &pFwd=NullNekDoubleArrayOfArray, const Array< OneD, Array< OneD, NekDouble > > &pBwd=NullNekDoubleArrayOfArray)

SOLVER_UTILS_EXPORT void	DiffuseCoeffs (const std::size_t nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const Array< OneD, Array< OneD, NekDouble > > &pFwd, const Array< OneD, Array< OneD, NekDouble > > &pBwd, TensorOfArray3D< NekDouble > &qfield, Array< OneD, int > &nonZeroIndex)

SOLVER_UTILS_EXPORT void	DiffuseCoeffs (const std::size_t nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, NekDouble time, const Array< OneD, Array< OneD, NekDouble > > &pFwd=NullNekDoubleArrayOfArray, const Array< OneD, Array< OneD, NekDouble > > &pBwd=NullNekDoubleArrayOfArray)

SOLVER_UTILS_EXPORT void	DiffuseCalcDerivative (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &inarray, TensorOfArray3D< NekDouble > &qfields, const Array< OneD, Array< OneD, NekDouble >> &pFwd=NullNekDoubleArrayOfArray, const Array< OneD, Array< OneD, NekDouble >> &pBwd=NullNekDoubleArrayOfArray)

SOLVER_UTILS_EXPORT void	DiffuseVolumeFlux (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &inarray, TensorOfArray3D< NekDouble > &qfields, TensorOfArray3D< NekDouble > &VolumeFlux, Array< OneD, int > &nonZeroIndex=NullInt1DArray)
	Diffusion Volume FLux. More...

SOLVER_UTILS_EXPORT void	DiffuseTraceFlux (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &inarray, TensorOfArray3D< NekDouble > &qfields, TensorOfArray3D< NekDouble > &VolumeFlux, Array< OneD, Array< OneD, NekDouble > > &TraceFlux, const Array< OneD, Array< OneD, NekDouble >> &pFwd=NullNekDoubleArrayOfArray, const Array< OneD, Array< OneD, NekDouble >> &pBwd=NullNekDoubleArrayOfArray, Array< OneD, int > &nonZeroIndex=NullInt1DArray)
	Diffusion term Trace Flux. More...

SOLVER_UTILS_EXPORT void	DiffuseTraceSymmFlux (const int nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &inarray, const TensorOfArray3D< NekDouble > &qfield, const TensorOfArray3D< NekDouble > &VolumeFlux, TensorOfArray3D< NekDouble > &SymmFlux, const Array< OneD, Array< OneD, NekDouble >> &pFwd, const Array< OneD, Array< OneD, NekDouble >> &pBwd, Array< OneD, int > &nonZeroIndex, Array< OneD, Array< OneD, NekDouble > > &solution_Aver=NullNekDoubleArrayOfArray, Array< OneD, Array< OneD, NekDouble > > &solution_jump=NullNekDoubleArrayOfArray)

SOLVER_UTILS_EXPORT void	AddDiffusionSymmFluxToCoeff (const std::size_t nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, TensorOfArray3D< NekDouble > &qfield, TensorOfArray3D< NekDouble > &VolumeFlux, Array< OneD, Array< OneD, NekDouble > > &outarray, const Array< OneD, Array< OneD, NekDouble > > &pFwd, const Array< OneD, Array< OneD, NekDouble > > &pBwd)
	Add symmetric flux to field in coeff space. More...

SOLVER_UTILS_EXPORT void	AddDiffusionSymmFluxToPhys (const std::size_t nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, TensorOfArray3D< NekDouble > &qfield, TensorOfArray3D< NekDouble > &VolumeFlux, Array< OneD, Array< OneD, NekDouble > > &outarray, const Array< OneD, Array< OneD, NekDouble > > &pFwd, const Array< OneD, Array< OneD, NekDouble > > &pBwd)
	Add symmetric flux to field in coeff physical space. More...

SOLVER_UTILS_EXPORT void	AddSymmFluxIntegralToOffDiag (const int nConvectiveFields, const int nDim, const int nPts, const int nTracePts, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, const int > &nonZeroIndex, TensorOfArray3D< NekDouble > &Fwdflux, TensorOfArray3D< NekDouble > &Bwdflux, Array< OneD, Array< OneD, NekDouble > > &outarray)

SOLVER_UTILS_EXPORT void	FluxVec (TensorOfArray3D< NekDouble > &fluxvector)

template<typename FuncPointerT , typename ObjectPointerT >
void	SetFluxVector (FuncPointerT func, ObjectPointerT obj)

SOLVER_UTILS_EXPORT void	SetFluxVector (DiffusionFluxVecCB fluxVector)

template<typename FuncPointerT , typename ObjectPointerT >
void	SetFluxVectorNS (FuncPointerT func, ObjectPointerT obj)

void	SetFluxVectorNS (DiffusionFluxVecCBNS fluxVector)

template<typename FuncPointerT , typename ObjectPointerT >
void	SetFluxPenaltyNS (FuncPointerT func, ObjectPointerT obj)

void	SetFluxPenaltyNS (DiffusionFluxPenaltyNS flux)

template<typename FuncPointerT , typename ObjectPointerT >
void	SetDiffusionFluxCons (FuncPointerT func, ObjectPointerT obj)

void	SetDiffusionFluxCons (DiffusionFluxCons flux)

template<typename FuncPointerT , typename ObjectPointerT >
void	SetDiffusionFluxConsTrace (FuncPointerT func, ObjectPointerT obj)

void	SetDiffusionFluxConsTrace (DiffusionFluxCons flux)

template<typename FuncPointerT , typename ObjectPointerT >
void	SetArtificialDiffusionVector (FuncPointerT func, ObjectPointerT obj)

template<typename FuncPointerT , typename ObjectPointerT >
void	SetSpecialBndTreat (FuncPointerT func, ObjectPointerT obj)

template<typename FuncPointerT , typename ObjectPointerT >
void	SetCalcViscosity (FuncPointerT func, ObjectPointerT obj)

template<typename FuncPointerT , typename ObjectPointerT >
void	SetDiffusionSymmFluxCons (FuncPointerT func, ObjectPointerT obj)

void	SetHomoDerivs (Array< OneD, Array< OneD, NekDouble > > &deriv)

virtual TensorOfArray3D< NekDouble > &	GetFluxTensor ()

SOLVER_UTILS_EXPORT void	GetAVmu (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, NekDouble > &muvar, Array< OneD, NekDouble > &MuVarTrace)
	Get the mu of artifical viscosity(AV) More...

SOLVER_UTILS_EXPORT void	ConsVarAveJump (const std::size_t nConvectiveFields, const size_t npnts, const Array< OneD, const Array< OneD, NekDouble > > &vFwd, const Array< OneD, const Array< OneD, NekDouble > > &vBwd, Array< OneD, Array< OneD, NekDouble > > &aver, Array< OneD, Array< OneD, NekDouble > > &jump)
	Get the average and jump value of conservative variables on trace. More...

SOLVER_UTILS_EXPORT const Array< OneD, const Array< OneD, NekDouble > > &	GetTraceNormal ()
	Get trace normal. More...

Static Public Member Functions
static DiffusionSharedPtr	create (std::string diffType)

Static Public Attributes
static std::string	type

Protected Member Functions
	DiffusionIP ()

void	GetPenaltyFactor (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, Array< OneD, NekDouble > &factor)
	Get IP penalty factor based on order. More...

void	GetPenaltyFactorConst (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, Array< OneD, NekDouble > &factor)
	Get a constant IP penalty factor. More...

void	AddSymmFluxIntegralToCoeff (const std::size_t nConvectiveFields, const size_t nDim, const size_t nPts, const size_t nTracePts, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, const int > &nonZeroIndex, TensorOfArray3D< NekDouble > &tracflux, Array< OneD, Array< OneD, NekDouble >> &outarray)
	Add symmetric flux integration to field (in coefficient space) More...

void	AddSymmFluxIntegralToPhys (const std::size_t nConvectiveFields, const size_t nDim, const size_t nPts, const size_t nTracePts, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, const int > &nonZeroIndex, TensorOfArray3D< NekDouble > &tracflux, Array< OneD, Array< OneD, NekDouble >> &outarray)
	Add symmetric flux integration to field (in physical space) More...

void	CalcTraceSymFlux (const std::size_t nConvectiveFields, const size_t nDim, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &solution_Aver, Array< OneD, Array< OneD, NekDouble >> &solution_jump, Array< OneD, int > &nonZeroIndexsymm, Array< OneD, Array< OneD, Array< OneD, NekDouble >>> &traceSymflux)
	Calculate symmetric flux on traces. More...

void	DiffuseTraceSymmFlux (const std::size_t nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &inarray, TensorOfArray3D< NekDouble > &qfield, TensorOfArray3D< NekDouble > &VolumeFlux, TensorOfArray3D< NekDouble > &SymmFlux, const Array< OneD, Array< OneD, NekDouble >> &pFwd, const Array< OneD, Array< OneD, NekDouble >> &pBwd, Array< OneD, int > &nonZeroIndex)
	Calculate symmetric flux on traces interface. More...

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

virtual void	v_Diffuse (const std::size_t nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const Array< OneD, Array< OneD, NekDouble >> &pFwd, const Array< OneD, Array< OneD, NekDouble >> &pBwd)

virtual void	v_DiffuseCoeffs (const std::size_t nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const Array< OneD, Array< OneD, NekDouble >> &pFwd, const Array< OneD, Array< OneD, NekDouble >> &pBwd)

virtual void	v_DiffuseCoeffs (const std::size_t nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const Array< OneD, Array< OneD, NekDouble >> &pFwd, const Array< OneD, Array< OneD, NekDouble >> &pBwd, TensorOfArray3D< NekDouble > &qfield, Array< OneD, int > &nonZeroIndex)

virtual void	v_DiffuseVolumeFlux (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &inarray, TensorOfArray3D< NekDouble > &qfields, TensorOfArray3D< NekDouble > &VolumeFlux, Array< OneD, int > &nonZeroIndex)
	Diffusion Volume Flux. More...

virtual void	v_DiffuseTraceFlux (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &inarray, TensorOfArray3D< NekDouble > &qfields, TensorOfArray3D< NekDouble > &VolumeFlux, Array< OneD, Array< OneD, NekDouble >> &TraceFlux, const Array< OneD, Array< OneD, NekDouble >> &pFwd, const Array< OneD, Array< OneD, NekDouble >> &pBwd, Array< OneD, int > &nonZeroIndex)

void	v_DiffuseTraceFlux (const int nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &inarray, const Array< OneD, const Array< OneD, Array< OneD, NekDouble > > > &qfield, Array< OneD, Array< OneD, NekDouble > > &TraceFlux, const Array< OneD, Array< OneD, NekDouble >> &pFwd, const Array< OneD, Array< OneD, NekDouble >> &pBwd, const Array< OneD, const Array< OneD, Array< OneD, NekDouble > > > &qFwd, const Array< OneD, const Array< OneD, Array< OneD, NekDouble > > > &qBwd, const Array< OneD, NekDouble > &MuAVTrace, Array< OneD, int > &nonZeroIndex, const Array< OneD, Array< OneD, NekDouble >> &Aver, const Array< OneD, Array< OneD, NekDouble >> &Jump)

virtual void	v_AddDiffusionSymmFluxToCoeff (const std::size_t nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &inarray, TensorOfArray3D< NekDouble > &qfield, TensorOfArray3D< NekDouble > &VolumeFlux, Array< OneD, Array< OneD, NekDouble >> &outarray, const Array< OneD, Array< OneD, NekDouble >> &pFwd, const Array< OneD, Array< OneD, NekDouble >> &pBwd)

virtual void	v_AddDiffusionSymmFluxToPhys (const std::size_t nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &inarray, TensorOfArray3D< NekDouble > &qfield, TensorOfArray3D< NekDouble > &VolumeFlux, Array< OneD, Array< OneD, NekDouble >> &outarray, const Array< OneD, Array< OneD, NekDouble >> &pFwd, const Array< OneD, Array< OneD, NekDouble >> &pBwd)

virtual void	v_DiffuseCalcDerivative (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &inarray, TensorOfArray3D< NekDouble > &qfield, const Array< OneD, Array< OneD, NekDouble >> &pFwd, const Array< OneD, Array< OneD, NekDouble >> &pBwd)

virtual void	v_ConsVarAveJump (const std::size_t nConvectiveFields, const size_t npnts, const Array< OneD, const Array< OneD, NekDouble >> &vFwd, const Array< OneD, const Array< OneD, NekDouble >> &vBwd, Array< OneD, Array< OneD, NekDouble >> &aver, Array< OneD, Array< OneD, NekDouble >> &jump)

virtual const Array< OneD, const Array< OneD, NekDouble > > &	v_GetTraceNormal ()

void	CalcTraceNumFlux (const NekDouble PenaltyFactor2, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &inarray, const TensorOfArray3D< NekDouble > &qfield, const Array< OneD, Array< OneD, NekDouble >> &vFwd, const Array< OneD, Array< OneD, NekDouble >> &vBwd, const Array< OneD, NekDouble > &MuVarTrace, Array< OneD, int > &nonZeroIndexflux, TensorOfArray3D< NekDouble > &traceflux, Array< OneD, Array< OneD, NekDouble >> &solution_Aver, Array< OneD, Array< OneD, NekDouble >> &solution_jump)
	Calculate numerical flux on traces. More...

void	AddSecondDerivToTrace (const std::size_t nConvectiveFields, const size_t nDim, const size_t nPts, const size_t nTracePts, const NekDouble PenaltyFactor2, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const TensorOfArray3D< NekDouble > &qfield, TensorOfArray3D< NekDouble > &numDerivFwd, TensorOfArray3D< NekDouble > &numDerivBwd)
	Add second derivative term to trace jump (for DDG scheme) More...

void	ApplyFluxBndConds (const int nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, Array< OneD, Array< OneD, NekDouble > > &flux)
	aplly Neuman boundary conditions on flux Currently only consider WallAdiabatic More...

Protected Member Functions inherited from Nektar::SolverUtils::Diffusion
virtual SOLVER_UTILS_EXPORT void	v_Diffuse (const std::size_t nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const Array< OneD, Array< OneD, NekDouble > > &pFwd, const Array< OneD, Array< OneD, NekDouble > > &pBwd)

virtual SOLVER_UTILS_EXPORT void	v_DiffuseCoeffs (const std::size_t nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const Array< OneD, Array< OneD, NekDouble > > &pFwd, const Array< OneD, Array< OneD, NekDouble > > &pBwd)

virtual SOLVER_UTILS_EXPORT void	v_DiffuseCoeffs (const std::size_t nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const Array< OneD, Array< OneD, NekDouble > > &vFwd, const Array< OneD, Array< OneD, NekDouble > > &vBwd, TensorOfArray3D< NekDouble > &qfield, Array< OneD, int > &nonZeroIndex)

virtual SOLVER_UTILS_EXPORT void	v_ConsVarAveJump (const std::size_t nConvectiveFields, const size_t npnts, const Array< OneD, const Array< OneD, NekDouble > > &vFwd, const Array< OneD, const Array< OneD, NekDouble > > &vBwd, Array< OneD, Array< OneD, NekDouble > > &aver, Array< OneD, Array< OneD, NekDouble > > &jump)

virtual SOLVER_UTILS_EXPORT void	v_DiffuseCalcDerivative (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, TensorOfArray3D< NekDouble > &qfields, const Array< OneD, Array< OneD, NekDouble > > &pFwd, const Array< OneD, Array< OneD, NekDouble > > &pBwd)
	Diffusion Flux, calculate the physical derivatives. More...

virtual SOLVER_UTILS_EXPORT void	v_DiffuseTraceFlux (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &inarray, TensorOfArray3D< NekDouble > &Qfields, TensorOfArray3D< NekDouble > &VolumeFlux, Array< OneD, Array< OneD, NekDouble > > &TraceFlux, const Array< OneD, Array< OneD, NekDouble >> &pFwd, const Array< OneD, Array< OneD, NekDouble >> &pBwd, Array< OneD, int > &nonZeroIndex)
	Diffusion term Trace Flux. More...

virtual SOLVER_UTILS_EXPORT void	v_DiffuseTraceSymmFlux (const int nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &inarray, const TensorOfArray3D< NekDouble > &qfield, const TensorOfArray3D< NekDouble > &VolumeFlux, TensorOfArray3D< NekDouble > &SymmFlux, const Array< OneD, Array< OneD, NekDouble >> &pFwd, const Array< OneD, Array< OneD, NekDouble >> &pBwd, Array< OneD, int > &nonZeroIndex, Array< OneD, Array< OneD, NekDouble > > &solution_Aver, Array< OneD, Array< OneD, NekDouble > > &solution_jump)

virtual SOLVER_UTILS_EXPORT void	v_AddDiffusionSymmFluxToCoeff (const std::size_t nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, TensorOfArray3D< NekDouble > &qfield, TensorOfArray3D< NekDouble > &VolumeFlux, Array< OneD, Array< OneD, NekDouble > > &outarray, const Array< OneD, Array< OneD, NekDouble > > &pFwd, const Array< OneD, Array< OneD, NekDouble > > &pBwd)

virtual SOLVER_UTILS_EXPORT void	v_AddDiffusionSymmFluxToPhys (const std::size_t nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, TensorOfArray3D< NekDouble > &qfield, TensorOfArray3D< NekDouble > &VolumeFlux, Array< OneD, Array< OneD, NekDouble > > &outarray, const Array< OneD, Array< OneD, NekDouble > > &pFwd, const Array< OneD, Array< OneD, NekDouble > > &pBwd)

virtual void	v_SetHomoDerivs (Array< OneD, Array< OneD, NekDouble > > &deriv)

virtual TensorOfArray3D< NekDouble > &	v_GetFluxTensor ()

virtual SOLVER_UTILS_EXPORT void	v_GetPrimVar (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &primVar)
	Compute primary derivatives. More...

SOLVER_UTILS_EXPORT void	GetDivCurl (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const TensorOfArray3D< NekDouble > &pVarDer)
	Compute divergence and curl squared. More...

Protected Attributes
std::string	m_shockCaptureType

NekDouble	m_IPSymmFluxCoeff

NekDouble	m_IP2ndDervCoeff

NekDouble	m_IPPenaltyCoeff

Array< OneD, NekDouble >	m_MuVarTrace

Array< OneD, Array< OneD, NekDouble > >	m_traceNormals

Array< OneD, Array< OneD, NekDouble > >	m_traceAver

Array< OneD, Array< OneD, NekDouble > >	m_traceJump

Array< OneD, Array< OneD, NekDouble > >	m_wspDiff
	Workspace for v_Diffusion. More...

TensorOfArray3D< NekDouble >	m_wspNumDerivBwd
	Workspace for CallTraceNumFlux. More...

TensorOfArray3D< NekDouble >	m_wspNumDerivFwd

Array< OneD, NekDouble >	m_tracBwdWeightAver

Array< OneD, NekDouble >	m_tracBwdWeightJump

Array< OneD, NekDouble >	m_traceNormDirctnElmtLength

Array< OneD, NekDouble >	m_traceNormDirctnElmtLengthRecip

LibUtilities::SessionReaderSharedPtr	m_session

Protected Attributes inherited from Nektar::SolverUtils::Diffusion
DiffusionFluxVecCB	m_fluxVector

DiffusionFluxVecCBNS	m_fluxVectorNS

DiffusionFluxPenaltyNS	m_fluxPenaltyNS

DiffusionArtificialDiffusion	m_ArtificialDiffusionVector

DiffusionFluxCons	m_FunctorDiffusionfluxCons

DiffusionFluxCons	m_FunctorDiffusionfluxConsTrace

SpecialBndTreat	m_SpecialBndTreat

CalcViscosity	m_CalcViscosity

DiffusionSymmFluxCons	m_FunctorSymmetricfluxCons

NekDouble	m_time =0.0

Additional Inherited Members
Public Attributes inherited from Nektar::SolverUtils::Diffusion
Array< OneD, NekDouble >	m_divVel
	Params for Ducros sensor. More...

Array< OneD, NekDouble >	m_divVelSquare

Array< OneD, NekDouble >	m_curlVelSquare

Detailed Description

Definition at line 45 of file DiffusionIP.h.

Constructor & Destructor Documentation

◆ DiffusionIP()

Nektar::SolverUtils::DiffusionIP::DiffusionIP ( )

protected

Definition at line 49 of file DiffusionIP.cpp.

50 {

51 }

Referenced by create().

Member Function Documentation

◆ AddSecondDerivToTrace()

void Nektar::SolverUtils::DiffusionIP::AddSecondDerivToTrace	(	const std::size_t	nConvectiveFields,
		const size_t	nDim,
		const size_t	nPts,
		const size_t	nTracePts,
		const NekDouble	PenaltyFactor2,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const TensorOfArray3D< NekDouble > &	qfield,
		TensorOfArray3D< NekDouble > &	numDerivFwd,
		TensorOfArray3D< NekDouble > &	numDerivBwd
	)

protected

Add second derivative term to trace jump (for DDG scheme)

Definition at line 856 of file DiffusionIP.cpp.

 {
     Array<OneD, NekDouble> Fwd{nTracePts, 0.0};
     Array<OneD, NekDouble> Bwd{nTracePts, 0.0};
     Array<OneD, NekDouble> tmp{nTracePts, 0.0};
  
     Array<OneD, Array<OneD, NekDouble>> elmt2ndDerv{nDim};
     for (int nd1 = 0; nd1 < nDim; ++nd1)
     {
         elmt2ndDerv[nd1] = Array<OneD, NekDouble>{nPts, 0.0};
     }
  
     Array<OneD, Array<OneD, NekDouble>> qtmp{3};
     for (int nd = 0; nd < 3; ++nd)
     {
         qtmp[nd] = NullNekDouble1DArray;
     }
     for (int nd2 = 0; nd2 < nDim; ++nd2)
     {
         qtmp[nd2] = elmt2ndDerv[nd2];
     }
  
     Vmath::Smul(nTracePts, PenaltyFactor2, m_traceNormDirctnElmtLength, 1, tmp,
                 1);
     // the derivatives are assumed to be exchangable
     for (int nd1 = 0; nd1 < nDim; ++nd1)
     {
         for (int i = 0; i < nConvectiveFields; ++i)
         {
             fields[i]->PhysDeriv(qfield[nd1][i], qtmp[0], qtmp[1], qtmp[2]);
  
             for (int nd2 = nd1; nd2 < nDim; ++nd2)
             {
                 Vmath::Zero(nTracePts, Bwd, 1);
                 fields[i]->GetFwdBwdTracePhys(elmt2ndDerv[nd2], Fwd, Bwd,
                                               true, true, false);
                 Vmath::Vmul(nTracePts, tmp, 1, Bwd, 1, Bwd, 1);
                 Vmath::Vvtvp(nTracePts, m_traceNormals[nd2], 1, Bwd, 1,
                              numDerivBwd[nd1][i], 1, numDerivBwd[nd1][i], 1);
                 Vmath::Vmul(nTracePts, tmp, 1, Fwd, 1, Fwd, 1);
                 Vmath::Vvtvm(nTracePts, m_traceNormals[nd2], 1, Fwd, 1,
                              numDerivFwd[nd1][i], 1, numDerivFwd[nd1][i], 1);
                 Vmath::Neg(nTracePts, numDerivFwd[nd1][i], 1);
  
                 if (nd2 != nd1)
                 {
                     Vmath::Vvtvp(nTracePts, m_traceNormals[nd1], 1, Bwd, 1,
                                  numDerivBwd[nd2][i], 1, numDerivBwd[nd2][i],
                                  1);
                     Vmath::Vvtvm(nTracePts, m_traceNormals[nd1], 1, Fwd, 1,
                                  numDerivFwd[nd2][i], 1, numDerivFwd[nd2][i],
                                  1);
                     Vmath::Neg(nTracePts, numDerivFwd[nd2][i], 1);
                 }
             }
         }
     }
 }

References m_traceNormals, m_traceNormDirctnElmtLength, Vmath::Neg(), Nektar::NullNekDouble1DArray, Vmath::Smul(), Vmath::Vmul(), Vmath::Vvtvm(), Vmath::Vvtvp(), and Vmath::Zero().

Referenced by CalcTraceNumFlux().

◆ AddSymmFluxIntegralToCoeff()

void Nektar::SolverUtils::DiffusionIP::AddSymmFluxIntegralToCoeff	(	const std::size_t	nConvectiveFields,
		const size_t	nDim,
		const size_t	nPts,
		const size_t	nTracePts,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, const int > &	nonZeroIndex,
		TensorOfArray3D< NekDouble > &	tracflux,
		Array< OneD, Array< OneD, NekDouble >> &	outarray
	)

protected

Add symmetric flux integration to field (in coefficient space)

Definition at line 565 of file DiffusionIP.cpp.

 {
     boost::ignore_unused(nTracePts);
  
     size_t nCoeffs = outarray[nConvectiveFields - 1].size();
     Array<OneD, NekDouble> tmpCoeff{nCoeffs, 0.0};
     Array<OneD, Array<OneD, NekDouble>> tmpfield(nDim);
     for (int i = 0; i < nDim; ++i)
     {
         tmpfield[i] = Array<OneD, NekDouble>{nPts, 0.0};
     }
     int nv = 0;
     for (int j = 0; j < nonZeroIndex.size(); ++j)
     {
         nv = nonZeroIndex[j];
         for (int nd = 0; nd < nDim; ++nd)
         {
             Vmath::Zero(nPts, tmpfield[nd], 1);
  
             fields[nv]->AddTraceQuadPhysToField(tracflux[nd][nv],
                                                 tracflux[nd][nv], tmpfield[nd]);
             fields[nv]->DivideByQuadratureMetric(tmpfield[nd], tmpfield[nd]);
         }
         fields[nv]->IProductWRTDerivBase(tmpfield, tmpCoeff);
         Vmath::Vadd(nCoeffs, tmpCoeff, 1, outarray[nv], 1, outarray[nv], 1);
     }
 }

References Vmath::Vadd(), and Vmath::Zero().

Referenced by v_AddDiffusionSymmFluxToCoeff().

◆ AddSymmFluxIntegralToPhys()

void Nektar::SolverUtils::DiffusionIP::AddSymmFluxIntegralToPhys	(	const std::size_t	nConvectiveFields,
		const size_t	nDim,
		const size_t	nPts,
		const size_t	nTracePts,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, const int > &	nonZeroIndex,
		TensorOfArray3D< NekDouble > &	tracflux,
		Array< OneD, Array< OneD, NekDouble >> &	outarray
	)

protected

Add symmetric flux integration to field (in physical space)

Definition at line 599 of file DiffusionIP.cpp.

 {
     boost::ignore_unused(nTracePts);
  
     size_t nCoeffs = outarray[nConvectiveFields - 1].size();
     Array<OneD, NekDouble> tmpCoeff{nCoeffs, 0.0};
     Array<OneD, NekDouble> tmpPhysi{nPts, 0.0};
     Array<OneD, Array<OneD, NekDouble>> tmpfield{nDim};
     for (int i = 0; i < nDim; ++i)
     {
         tmpfield[i] = Array<OneD, NekDouble>{nPts, 0.0};
     }
     for (int j = 0; j < nonZeroIndex.size(); ++j)
     {
         int nv = nonZeroIndex[j];
         for (int nd = 0; nd < nDim; ++nd)
         {
             Vmath::Zero(nPts, tmpfield[nd], 1);
  
             fields[nv]->AddTraceQuadPhysToField(tracflux[nd][nv],
                                                 tracflux[nd][nv], tmpfield[nd]);
             fields[nv]->DivideByQuadratureMetric(tmpfield[nd], tmpfield[nd]);
         }
         fields[nv]->IProductWRTDerivBase(tmpfield, tmpCoeff);
         fields[nv]->BwdTrans(tmpCoeff, tmpPhysi);
         Vmath::Vadd(nPts, tmpPhysi, 1, outarray[nv], 1, outarray[nv], 1);
     }
 }

References Vmath::Vadd(), and Vmath::Zero().

Referenced by v_AddDiffusionSymmFluxToPhys().

◆ ApplyFluxBndConds()

void Nektar::SolverUtils::DiffusionIP::ApplyFluxBndConds	(	const int	nConvectiveFields,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		Array< OneD, Array< OneD, NekDouble > > &	flux
	)

protected

aplly Neuman boundary conditions on flux Currently only consider WallAdiabatic

Definition at line 927 of file DiffusionIP.cpp.

 {            
     int nengy       = nConvectiveFields-1;
     int cnt;
     // Compute boundary conditions  for Energy
     cnt = 0;
     size_t nBndRegions = fields[nengy]->
     GetBndCondExpansions().size();
     for (size_t j = 0; j < nBndRegions; ++j)
     {
         if (fields[nengy]->GetBndConditions()[j]->
             GetBoundaryConditionType() ==
             SpatialDomains::ePeriodic)
         {
             continue;
         }
  
         size_t nBndEdges = fields[nengy]->
         GetBndCondExpansions()[j]->GetExpSize();
         for (size_t e = 0; e < nBndEdges; ++e)
         {
             size_t nBndEdgePts = fields[nengy]->
             GetBndCondExpansions()[j]->GetExp(e)->GetTotPoints();
  
             std::size_t id2 = fields[0]->GetTrace()->
                 GetPhys_Offset(fields[0]->GetTraceMap()->
                                 GetBndCondIDToGlobalTraceID(cnt++));
  
             if (fields[0]->GetBndConditions()[j]->
                 GetUserDefined() =="WallAdiabatic")
             {
                 Vmath::Zero(nBndEdgePts, &flux[nengy][id2], 1);
             }                    
         }
     }
 }

References Nektar::SpatialDomains::ePeriodic, and Vmath::Zero().

Referenced by v_DiffuseTraceFlux().

◆ CalcTraceNumFlux()

void Nektar::SolverUtils::DiffusionIP::CalcTraceNumFlux	(	const NekDouble	PenaltyFactor2,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		const TensorOfArray3D< NekDouble > &	qfield,
		const Array< OneD, Array< OneD, NekDouble >> &	vFwd,
		const Array< OneD, Array< OneD, NekDouble >> &	vBwd,
		const Array< OneD, NekDouble > &	MuVarTrace,
		Array< OneD, int > &	nonZeroIndexflux,
		TensorOfArray3D< NekDouble > &	traceflux,
		Array< OneD, Array< OneD, NekDouble >> &	solution_Aver,
		Array< OneD, Array< OneD, NekDouble >> &	solution_jump
	)

protected

Calculate numerical flux on traces.

Definition at line 744 of file DiffusionIP.cpp.

 {
     size_t nDim      = fields[0]->GetCoordim(0);
     size_t nPts      = fields[0]->GetTotPoints();
     size_t nTracePts = fields[0]->GetTrace()->GetTotPoints();
     size_t nConvectiveFields = fields.size();
  
     boost::ignore_unused(inarray);
     const MultiRegions::AssemblyMapDGSharedPtr TraceMap =
         fields[0]->GetTraceMap();
  
  
     LibUtilities::Timer timer;
     timer.Start();
     // with further restructuring this iniziatilization could be eliminated
     for (int nd = 0; nd < nDim; ++nd)
     {
         for (int i = 0; i < nConvectiveFields; ++i)
         {
             Vmath::Zero(nTracePts, m_wspNumDerivBwd[nd][i], 1);
             Vmath::Zero(nTracePts, m_wspNumDerivFwd[nd][i], 1);
         }
     }
  
     // could this be pre-allocated?
     Array<OneD, NekDouble> Fwd{nTracePts, 0.0};
     Array<OneD, NekDouble> Bwd{nTracePts, 0.0};
  
     timer.Stop();
     timer.AccumulateRegion("DiffIP:_CalcTraceNumFlux_alloc",1);
  
  
     timer.Start();
     if (fabs(PenaltyFactor2) > 1.0E-12)
     {
         AddSecondDerivToTrace(nConvectiveFields, nDim, nPts, nTracePts,
                               PenaltyFactor2, fields, qfield, m_wspNumDerivFwd,
                               m_wspNumDerivBwd);
     }
  
     timer.Stop();
     timer.AccumulateRegion("DiffIP:_AddSecondDerivToTrace",1);
  
     for (int nd = 0; nd < nDim; ++nd)
     {
         for (int i = 0; i < nConvectiveFields; ++i)
         {
             // this sequence of operations is really exepensive,
             // it should be done collectively for all fields together instead of
             // one by one
             timer.Start();
             fields[i]->GetFwdBwdTracePhys(qfield[nd][i], Fwd, Bwd, true, true,
                 false);
             timer.Stop();
             timer.AccumulateRegion("DiffIP:_GetFwdBwdTracePhys",1);
  
             for (size_t p = 0; p < nTracePts; ++p)
             {
                 m_wspNumDerivBwd[nd][i][p] += 0.5 * Bwd[p];
                 m_wspNumDerivFwd[nd][i][p] += 0.5 * Fwd[p];
             }
  
             timer.Start();
             TraceMap->GetAssemblyCommDG()->PerformExchange(m_wspNumDerivFwd[nd][i],
                                                            m_wspNumDerivBwd[nd][i]);
             timer.Stop();
             timer.AccumulateRegion("DiffIP:_PerformExchange",1);
  
             Vmath::Vadd(nTracePts, m_wspNumDerivFwd[nd][i], 1, m_wspNumDerivBwd[nd][i], 1,
                         m_wspNumDerivFwd[nd][i], 1);
         }
     }
  
     timer.Start();
     ConsVarAveJump(nConvectiveFields, nTracePts, vFwd, vBwd, solution_Aver,
                    solution_jump);
     timer.Stop();
     timer.AccumulateRegion("DiffIP:_ConsVarAveJump",1);
  
     for (size_t p = 0; p < nTracePts; ++p)
     {
         NekDouble PenaltyFactor = m_IPPenaltyCoeff * m_traceNormDirctnElmtLengthRecip[p]; // load 1x
  
         for (size_t f = 0; f < nConvectiveFields; ++f)
         {
             NekDouble jumpTmp = solution_jump[f][p] * PenaltyFactor; // load 1x
             for (size_t d = 0; d < nDim; ++d)
             {
                 NekDouble tmp = m_traceNormals[d][p] * jumpTmp + m_wspNumDerivFwd[d][f][p]; // load 2x
                 m_wspNumDerivFwd[d][f][p] = tmp; // store 1x
             }
         }
     }
  
     timer.Start();
     // Calculate normal viscous flux
     m_FunctorDiffusionfluxConsTrace(nDim, solution_Aver, m_wspNumDerivFwd, traceflux,
                                nonZeroIndexflux, m_traceNormals, MuVarTrace);
     timer.Stop();
     timer.AccumulateRegion("DiffIP:_FunctorDiffFluxConsTrace",1);
 }

References Nektar::LibUtilities::Timer::AccumulateRegion(), AddSecondDerivToTrace(), Nektar::SolverUtils::Diffusion::ConsVarAveJump(), Nektar::SolverUtils::Diffusion::m_FunctorDiffusionfluxConsTrace, m_IPPenaltyCoeff, m_traceNormals, m_traceNormDirctnElmtLengthRecip, m_wspNumDerivBwd, m_wspNumDerivFwd, CellMLToNektar.cellml_metadata::p, Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), Vmath::Vadd(), and Vmath::Zero().

Referenced by v_DiffuseTraceFlux().

◆ CalcTraceSymFlux()

void Nektar::SolverUtils::DiffusionIP::CalcTraceSymFlux	(	const std::size_t	nConvectiveFields,
		const size_t	nDim,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, Array< OneD, NekDouble >> &	solution_Aver,
		Array< OneD, Array< OneD, NekDouble >> &	solution_jump,
		Array< OneD, int > &	nonZeroIndexsymm,
		Array< OneD, Array< OneD, Array< OneD, NekDouble >>> &	traceSymflux
	)

protected

Calculate symmetric flux on traces.

Definition at line 535 of file DiffusionIP.cpp.

 {
     size_t nTracePts = solution_jump[nConvectiveFields - 1].size();
     
     for (int i = 0; i < nConvectiveFields; ++i)
     {
         Vmath::Smul(nTracePts, m_IPSymmFluxCoeff, solution_jump[i], 1,
                     solution_jump[i], 1);
     }
  
     m_FunctorSymmetricfluxCons(nDim, solution_Aver, solution_jump, traceSymflux,
                                nonZeroIndexsymm, m_traceNormals);
  
     for (int i = 0; i < nConvectiveFields; ++i)
     {
         MultiRegions::ExpListSharedPtr tracelist = fields[i]->GetTrace();
         for (int nd = 0; nd < nDim; ++nd)
         {
             tracelist->MultiplyByQuadratureMetric(traceSymflux[nd][i],
                                                   traceSymflux[nd][i]);
         }
     }
 }

References Nektar::SolverUtils::Diffusion::m_FunctorSymmetricfluxCons, m_IPSymmFluxCoeff, m_traceNormals, and Vmath::Smul().

Referenced by DiffuseTraceSymmFlux().

◆ ConsVarAve()

template<class T , typename = typename std::enable_if < std::is_floating_point<T>::value || tinysimd::is_vector_floating_point<T>::value >::type>

void Nektar::SolverUtils::DiffusionIP::ConsVarAve	(	const size_t	nConvectiveFields,
		const T &	Bweight,
		const std::vector< T > &	vFwd,
		const std::vector< T > &	vBwd,
		std::vector< T > &	aver
	)

inline

Calculate the average of conservative variables on traces.

Definition at line 63 of file DiffusionIP.h.

     {
         constexpr int nvelst = 1;
         int nEngy  = nConvectiveFields - 1;
         int nveled = nEngy;
  
         T Fweight = 1.0 - Bweight;
         for (size_t v = 0; v < nEngy; ++v)
         {
             aver[v] = Fweight * vFwd[v] + Bweight * vBwd[v];
         }
  
         T LinternalEngy{};
         T RinternalEngy{};
         T AinternalEngy{};
         for (size_t j = nvelst; j < nveled; ++j)
         {
             LinternalEngy += vFwd[j] * vFwd[j];
             RinternalEngy += vBwd[j] * vBwd[j];
             AinternalEngy += aver[j] * aver[j];
         }
         LinternalEngy *= -0.5 / vFwd[0];
         RinternalEngy *= -0.5 / vBwd[0];
         LinternalEngy += vFwd[nEngy];
         RinternalEngy += vBwd[nEngy];
  
         aver[nEngy] = Fweight * LinternalEngy + Bweight * RinternalEngy;
         aver[nEngy] += AinternalEngy * (0.5 / aver[0]);
  
     }

Referenced by v_ConsVarAveJump().

◆ create()

static DiffusionSharedPtr Nektar::SolverUtils::DiffusionIP::create ( std::string diffType )

inlinestatic

Definition at line 48 of file DiffusionIP.h.

     {
         boost::ignore_unused(diffType);
         return DiffusionSharedPtr(new DiffusionIP());
     }

References DiffusionIP().

◆ DiffuseTraceSymmFlux()

void Nektar::SolverUtils::DiffusionIP::DiffuseTraceSymmFlux	(	const std::size_t	nConvectiveFields,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		TensorOfArray3D< NekDouble > &	qfield,
		TensorOfArray3D< NekDouble > &	VolumeFlux,
		TensorOfArray3D< NekDouble > &	SymmFlux,
		const Array< OneD, Array< OneD, NekDouble >> &	pFwd,
		const Array< OneD, Array< OneD, NekDouble >> &	pBwd,
		Array< OneD, int > &	nonZeroIndex
	)

protected

Calculate symmetric flux on traces interface.

Definition at line 518 of file DiffusionIP.cpp.

 {
     boost::ignore_unused(inarray, qfield, VolumeFlux, pFwd, pBwd);
     size_t nDim = fields[0]->GetCoordim(0);
  
     CalcTraceSymFlux(nConvectiveFields, nDim, fields, m_traceAver, m_traceJump,
                     nonZeroIndex, SymmFlux);
 }

References CalcTraceSymFlux(), m_traceAver, and m_traceJump.

Referenced by v_AddDiffusionSymmFluxToCoeff(), and v_AddDiffusionSymmFluxToPhys().

◆ GetPenaltyFactor()

void Nektar::SolverUtils::DiffusionIP::GetPenaltyFactor	(	const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		Array< OneD, NekDouble > &	factor
	)

protected

Get IP penalty factor based on order.

Definition at line 634 of file DiffusionIP.cpp.

 {
     MultiRegions::ExpListSharedPtr tracelist = fields[0]->GetTrace();
     std::shared_ptr<LocalRegions::ExpansionVector> traceExp =
         tracelist->GetExp();
     size_t ntotTrac = (*traceExp).size();
     int nTracPnt, noffset;
  
     const MultiRegions::LocTraceToTraceMapSharedPtr locTraceToTraceMap =
         fields[0]->GetLocTraceToTraceMap();
  
     const Array<OneD, const Array<OneD, int>> LRAdjExpid =
         locTraceToTraceMap->GetLeftRightAdjacentExpId();
     const Array<OneD, const Array<OneD, bool>> LRAdjflag =
         locTraceToTraceMap->GetLeftRightAdjacentExpFlag();
  
     std::shared_ptr<LocalRegions::ExpansionVector> fieldExp =
         fields[0]->GetExp();
  
     Array<OneD, NekDouble> factorFwdBwd{2, 0.0};
  
     NekDouble spaceDim = NekDouble(fields[0]->GetCoordim(0));
  
     for (int ntrace = 0; ntrace < ntotTrac; ++ntrace)
     {
         noffset  = tracelist->GetPhys_Offset(ntrace);
         nTracPnt = tracelist->GetTotPoints(ntrace);
  
         factorFwdBwd[0] = 0.0;
         factorFwdBwd[1] = 0.0;
  
         for (int nlr = 0; nlr < 2; ++nlr)
         {
             if (LRAdjflag[nlr][ntrace])
             {
                 int numModes = fields[0]->GetNcoeffs(LRAdjExpid[nlr][ntrace]);
                 NekDouble numModesdir =
                     pow(NekDouble(numModes), (1.0 / spaceDim));
                 factorFwdBwd[nlr] = 1.0 * numModesdir * (numModesdir + 1.0);
             }
         }
  
         for (int np = 0; np < nTracPnt; ++np)
         {
             factor[noffset + np] = std::max(factorFwdBwd[0], factorFwdBwd[1]);
         }
     }
 }

◆ GetPenaltyFactorConst()

void Nektar::SolverUtils::DiffusionIP::GetPenaltyFactorConst	(	const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		Array< OneD, NekDouble > &	factor
	)

protected

Get a constant IP penalty factor.

Definition at line 685 of file DiffusionIP.cpp.

 {
     boost::ignore_unused(fields);
     Vmath::Fill(factor.size(), m_IPPenaltyCoeff, factor, 1);
 }

References Vmath::Fill(), and m_IPPenaltyCoeff.

◆ v_AddDiffusionSymmFluxToCoeff()

void Nektar::SolverUtils::DiffusionIP::v_AddDiffusionSymmFluxToCoeff	(	const std::size_t	nConvectiveFields,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		TensorOfArray3D< NekDouble > &	qfield,
		TensorOfArray3D< NekDouble > &	VolumeFlux,
		Array< OneD, Array< OneD, NekDouble >> &	outarray,
		const Array< OneD, Array< OneD, NekDouble >> &	pFwd,
		const Array< OneD, Array< OneD, NekDouble >> &	pBwd
	)

protectedvirtual

Definition at line 448 of file DiffusionIP.cpp.

 {
     if (fabs(m_IPSymmFluxCoeff) > 1.0E-12)
     {
         size_t nDim      = fields[0]->GetCoordim(0);
         size_t nPts      = fields[0]->GetTotPoints();
         size_t nTracePts = fields[0]->GetTrace()->GetTotPoints();
         TensorOfArray3D<NekDouble> traceSymflux{nDim};
         for (int nd = 0; nd < nDim; ++nd)
         {
             traceSymflux[nd] =
                 Array<OneD, Array<OneD, NekDouble>>{nConvectiveFields};
             for (int j = 0; j < nConvectiveFields; ++j)
             {
                 traceSymflux[nd][j] = Array<OneD, NekDouble>{nTracePts, 0.0};
             }
         }
         Array<OneD, int> nonZeroIndex;
         DiffuseTraceSymmFlux(nConvectiveFields, fields, inarray, qfield,
                              VolumeFlux, traceSymflux, pFwd, pBwd,
                              nonZeroIndex);
  
         AddSymmFluxIntegralToCoeff(nConvectiveFields, nDim, nPts, nTracePts,
                                    fields, nonZeroIndex, traceSymflux,
                                    outarray);
     }
 }

References AddSymmFluxIntegralToCoeff(), DiffuseTraceSymmFlux(), and m_IPSymmFluxCoeff.

◆ v_AddDiffusionSymmFluxToPhys()

void Nektar::SolverUtils::DiffusionIP::v_AddDiffusionSymmFluxToPhys	(	const std::size_t	nConvectiveFields,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		TensorOfArray3D< NekDouble > &	qfield,
		TensorOfArray3D< NekDouble > &	VolumeFlux,
		Array< OneD, Array< OneD, NekDouble >> &	outarray,
		const Array< OneD, Array< OneD, NekDouble >> &	pFwd,
		const Array< OneD, Array< OneD, NekDouble >> &	pBwd
	)

protectedvirtual

Definition at line 483 of file DiffusionIP.cpp.

 {
     if (fabs(m_IPSymmFluxCoeff) > 1.0E-12)
     {
         size_t nDim      = fields[0]->GetCoordim(0);
         size_t nPts      = fields[0]->GetTotPoints();
         size_t nTracePts = fields[0]->GetTrace()->GetTotPoints();
         TensorOfArray3D<NekDouble> traceSymflux{nDim};
         for (int nd = 0; nd < nDim; ++nd)
         {
             traceSymflux[nd] =
                 Array<OneD, Array<OneD, NekDouble>>{nConvectiveFields};
             for (int j = 0; j < nConvectiveFields; ++j)
             {
                 traceSymflux[nd][j] = Array<OneD, NekDouble>{nTracePts, 0.0};
             }
         }
         Array<OneD, int> nonZeroIndex;
         DiffuseTraceSymmFlux(nConvectiveFields, fields, inarray, qfield,
                              VolumeFlux, traceSymflux, pFwd, pBwd,
                              nonZeroIndex);
  
         AddSymmFluxIntegralToPhys(nConvectiveFields, nDim, nPts, nTracePts,
                                   fields, nonZeroIndex, traceSymflux, outarray);
     }
 }

References AddSymmFluxIntegralToPhys(), DiffuseTraceSymmFlux(), and m_IPSymmFluxCoeff.

◆ v_ConsVarAveJump()

void Nektar::SolverUtils::DiffusionIP::v_ConsVarAveJump	(	const std::size_t	nConvectiveFields,
		const size_t	npnts,
		const Array< OneD, const Array< OneD, NekDouble >> &	vFwd,
		const Array< OneD, const Array< OneD, NekDouble >> &	vBwd,
		Array< OneD, Array< OneD, NekDouble >> &	aver,
		Array< OneD, Array< OneD, NekDouble >> &	jump
	)

protectedvirtual

Definition at line 693 of file DiffusionIP.cpp.

 {
     // ConsVarAve(nConvectiveFields, nPts, vFwd, vBwd, aver);
  
     std::vector<NekDouble> vFwdTmp(nConvectiveFields),
         vBwdTmp(nConvectiveFields), averTmp(nConvectiveFields) ;
     for (size_t p = 0; p < nPts; ++p)
     {
         // re-arrange data
         for (size_t f = 0; f < nConvectiveFields; ++f)
         {
             vFwdTmp[f] = vFwd[f][p];
             vBwdTmp[f] = vBwd[f][p];
         }
  
         ConsVarAve(nConvectiveFields, m_tracBwdWeightAver[p], vFwdTmp, vBwdTmp,
             averTmp);
  
         // store
         for (size_t f = 0; f < nConvectiveFields; ++f)
         {
             aver[f][p] = averTmp[f];
         }
     }
  
     // if this can be make function of points, the nPts loop can be lifted more
     m_SpecialBndTreat(aver);
  
     // note: here the jump is 2.0*(aver-vFwd)
     //       because Viscous wall use a symmetry value as the Bwd,
     //       not the target one
  
     for (size_t f = 0; f < nConvectiveFields; ++f)
     {
         for (size_t p = 0; p < nPts; ++p)
         {
             NekDouble Bweight = m_tracBwdWeightJump[p];
             NekDouble Fweight = 2.0 - Bweight;
  
             NekDouble tmpF = aver[f][p] - vFwd[f][p];
             NekDouble tmpB = vBwd[f][p] - aver[f][p];
             jump[f][p] = tmpF * Fweight + tmpB * Bweight;
         }
     }
 }

References ConsVarAve(), Nektar::SolverUtils::Diffusion::m_SpecialBndTreat, m_tracBwdWeightAver, m_tracBwdWeightJump, and CellMLToNektar.cellml_metadata::p.

◆ v_Diffuse()

void Nektar::SolverUtils::DiffusionIP::v_Diffuse	(	const std::size_t	nConvectiveFields,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		Array< OneD, Array< OneD, NekDouble >> &	outarray,
		const Array< OneD, Array< OneD, NekDouble >> &	pFwd,
		const Array< OneD, Array< OneD, NekDouble >> &	pBwd
	)

protectedvirtual

Definition at line 154 of file DiffusionIP.cpp.

 {
  
     LibUtilities::Timer timer;
     timer.Start();
     DiffusionIP::v_DiffuseCoeffs(nConvectiveFields, fields, inarray, m_wspDiff,
         pFwd, pBwd);
     for (int i = 0; i < nConvectiveFields; ++i)
     {
         fields[i]->BwdTrans(m_wspDiff[i], outarray[i]);
     }
     timer.Stop();
     timer.AccumulateRegion("Diffusion IP");
 }

References Nektar::LibUtilities::Timer::AccumulateRegion(), m_wspDiff, Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), and v_DiffuseCoeffs().

◆ v_DiffuseCalcDerivative()

void Nektar::SolverUtils::DiffusionIP::v_DiffuseCalcDerivative	(	const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		TensorOfArray3D< NekDouble > &	qfield,
		const Array< OneD, Array< OneD, NekDouble >> &	pFwd,
		const Array< OneD, Array< OneD, NekDouble >> &	pBwd
	)

protectedvirtual

Definition at line 368 of file DiffusionIP.cpp.

 {
     size_t nConvectiveFields = fields.size();
     boost::ignore_unused(pFwd, pBwd);
  
     size_t nDim = fields[0]->GetCoordim(0);
  
     Array<OneD, Array<OneD, NekDouble>> qtmp{3};
     for (int nd = 0; nd < 3; ++nd)
     {
         qtmp[nd] = NullNekDouble1DArray;
     }
     for (int i = 0; i < nConvectiveFields; ++i)
     {
         for (int nd = 0; nd < nDim; ++nd)
         {
             qtmp[nd] = qfield[nd][i];
         }
         fields[i]->PhysDeriv(inarray[i], qtmp[0], qtmp[1], qtmp[2]);
     }
 }

References Nektar::NullNekDouble1DArray.

◆ v_DiffuseCoeffs() [1/2]

virtual void Nektar::SolverUtils::DiffusionIP::v_DiffuseCoeffs	(	const std::size_t	nConvectiveFields,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		Array< OneD, Array< OneD, NekDouble >> &	outarray,
		const Array< OneD, Array< OneD, NekDouble >> &	pFwd,
		const Array< OneD, Array< OneD, NekDouble >> &	pBwd
	)

protectedvirtual

Referenced by v_Diffuse().

◆ v_DiffuseCoeffs() [2/2]

void Nektar::SolverUtils::DiffusionIP::v_DiffuseCoeffs	(	const std::size_t	nConvectiveFields,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		Array< OneD, Array< OneD, NekDouble >> &	outarray,
		const Array< OneD, Array< OneD, NekDouble >> &	pFwd,
		const Array< OneD, Array< OneD, NekDouble >> &	pBwd,
		TensorOfArray3D< NekDouble > &	qfield,
		Array< OneD, int > &	nonZeroIndex
	)

protectedvirtual

Definition at line 300 of file DiffusionIP.cpp.

 {
     int i, j;
     int nDim      = fields[0]->GetCoordim(0);
     int nPts      = fields[0]->GetTotPoints();
     int nCoeffs   = fields[0]->GetNcoeffs();
     int nTracePts = fields[0]->GetTrace()->GetTotPoints();
     
     TensorOfArray3D<NekDouble> elmtFlux(nDim);
     for (j = 0; j < nDim; ++j)
     {
         elmtFlux[j] = Array<OneD, Array<OneD, NekDouble>>(nConvectiveFields);
         for (i = 0; i < nConvectiveFields; ++i)
         {
             elmtFlux[j][i] = Array<OneD, NekDouble>(nPts, 0.0);
         }
     }
     
     DiffuseVolumeFlux(fields,inarray,qfield,elmtFlux,nonZeroIndex);
     
     Array<OneD, Array<OneD, NekDouble>> tmpFluxIprdct(nDim);
     // volume intergration: the nonZeroIndex indicates which flux is nonzero
     for(i = 0; i < nonZeroIndex.size(); ++i)
     {
         int j = nonZeroIndex[i];
         for (int k = 0; k < nDim; ++k)
         {
             tmpFluxIprdct[k] = elmtFlux[k][j];
         }
         fields[j]->IProductWRTDerivBase(tmpFluxIprdct,outarray[j]);
         Vmath::Neg                      (nCoeffs, outarray[j], 1);
     }
     
     Array<OneD, Array<OneD, NekDouble > > Traceflux(nConvectiveFields);
     for (int j = 0; j < nConvectiveFields; ++j)
     {
         Traceflux[j]   = Array<OneD, NekDouble>(nTracePts, 0.0);
     }
     
     DiffuseTraceFlux(fields,inarray,qfield,elmtFlux,
                      Traceflux,vFwd,vBwd,nonZeroIndex);
     
     // release qfield, elmtFlux and muvar;
     for (j = 0; j < nDim; ++j)
     {
         elmtFlux[j]     = NullNekDoubleArrayOfArray;
     }
     
     for(i = 0; i < nonZeroIndex.size(); ++i)
     {
         int j = nonZeroIndex[i];
         
         fields[j]->AddTraceIntegral     (Traceflux[j], outarray[j]);
         fields[j]->SetPhysState         (false);
     }
  
     AddDiffusionSymmFluxToCoeff(nConvectiveFields, fields, inarray,qfield,
                                 elmtFlux, outarray, vFwd, vBwd);    
 }

References Nektar::SolverUtils::Diffusion::AddDiffusionSymmFluxToCoeff(), Nektar::SolverUtils::Diffusion::DiffuseTraceFlux(), Nektar::SolverUtils::Diffusion::DiffuseVolumeFlux(), Vmath::Neg(), and Nektar::NullNekDoubleArrayOfArray.

◆ v_DiffuseTraceFlux() [1/2]

void Nektar::SolverUtils::DiffusionIP::v_DiffuseTraceFlux	(	const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		TensorOfArray3D< NekDouble > &	qfields,
		TensorOfArray3D< NekDouble > &	VolumeFlux,
		Array< OneD, Array< OneD, NekDouble >> &	TraceFlux,
		const Array< OneD, Array< OneD, NekDouble >> &	pFwd,
		const Array< OneD, Array< OneD, NekDouble >> &	pBwd,
		Array< OneD, int > &	nonZeroIndex
	)

protectedvirtual

Definition at line 421 of file DiffusionIP.cpp.

 {
     boost::ignore_unused(VolumeFlux);
  
     TensorOfArray3D<NekDouble> traceflux3D(1);
     traceflux3D[0] = TraceFlux;
  
     size_t nConvectiveFields = fields.size();
  
     LibUtilities::Timer timer;
     timer.Start();
     CalcTraceNumFlux(m_IP2ndDervCoeff,
                     fields, inarray, qfield, pFwd, pBwd, m_MuVarTrace,
                     nonZeroIndex, traceflux3D, m_traceAver, m_traceJump);
     timer.Stop();
     timer.AccumulateRegion("DiffIP:_CalcTraceNumFlux",1);
  
     ApplyFluxBndConds(nConvectiveFields, fields, TraceFlux);
 }

References Nektar::LibUtilities::Timer::AccumulateRegion(), ApplyFluxBndConds(), CalcTraceNumFlux(), m_IP2ndDervCoeff, m_MuVarTrace, m_traceAver, m_traceJump, Nektar::LibUtilities::Timer::Start(), and Nektar::LibUtilities::Timer::Stop().

◆ v_DiffuseTraceFlux() [2/2]

void Nektar::SolverUtils::DiffusionIP::v_DiffuseTraceFlux	(	const int	nConvectiveFields,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		const Array< OneD, const Array< OneD, Array< OneD, NekDouble > > > &	qfield,
		Array< OneD, Array< OneD, NekDouble > > &	TraceFlux,
		const Array< OneD, Array< OneD, NekDouble >> &	pFwd,
		const Array< OneD, Array< OneD, NekDouble >> &	pBwd,
		const Array< OneD, const Array< OneD, Array< OneD, NekDouble > > > &	qFwd,
		const Array< OneD, const Array< OneD, Array< OneD, NekDouble > > > &	qBwd,
		const Array< OneD, NekDouble > &	MuAVTrace,
		Array< OneD, int > &	nonZeroIndex,
		const Array< OneD, Array< OneD, NekDouble >> &	Aver,
		const Array< OneD, Array< OneD, NekDouble >> &	Jump
	)

protected

◆ v_DiffuseVolumeFlux()

void Nektar::SolverUtils::DiffusionIP::v_DiffuseVolumeFlux	(	const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		TensorOfArray3D< NekDouble > &	qfields,
		TensorOfArray3D< NekDouble > &	VolumeFlux,
		Array< OneD, int > &	nonZeroIndex
	)

protectedvirtual

Diffusion Volume Flux.

Reimplemented from Nektar::SolverUtils::Diffusion.

Definition at line 395 of file DiffusionIP.cpp.

 {
     size_t nDim = fields[0]->GetCoordim(0);
     size_t nPts = fields[0]->GetTotPoints();
  
     Array<OneD, NekDouble> muvar = NullNekDouble1DArray;
     if (m_ArtificialDiffusionVector)
     {
         muvar = Array<OneD, NekDouble>{nPts, 0.0};
         GetAVmu(fields, inarray, muvar, m_MuVarTrace);
     }
  
     Array<OneD, Array<OneD, NekDouble>> tmparray2D = NullNekDoubleArrayOfArray;
  
     LibUtilities::Timer timer;
     timer.Start();
     m_FunctorDiffusionfluxCons(nDim, inarray, qfield, VolumeFlux, nonZeroIndex,
                                tmparray2D, muvar);
     timer.Stop();
     timer.AccumulateRegion("DiffIP:_FunctorDiffFluxCons",1);
 }

References Nektar::LibUtilities::Timer::AccumulateRegion(), Nektar::SolverUtils::Diffusion::GetAVmu(), Nektar::SolverUtils::Diffusion::m_ArtificialDiffusionVector, Nektar::SolverUtils::Diffusion::m_FunctorDiffusionfluxCons, m_MuVarTrace, Nektar::NullNekDouble1DArray, Nektar::NullNekDoubleArrayOfArray, Nektar::LibUtilities::Timer::Start(), and Nektar::LibUtilities::Timer::Stop().

◆ v_GetTraceNormal()

virtual const Array<OneD, const Array<OneD, NekDouble> >& Nektar::SolverUtils::DiffusionIP::v_GetTraceNormal ( )

inlineprotectedvirtual

Reimplemented from Nektar::SolverUtils::Diffusion.

Definition at line 268 of file DiffusionIP.h.

     {
         return m_traceNormals;
     }

References m_traceNormals.

◆ v_InitObject()

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

protectedvirtual

Reimplemented from Nektar::SolverUtils::Diffusion.

Definition at line 53 of file DiffusionIP.cpp.

 {
     m_session = pSession;
  
     m_session->LoadSolverInfo("ShockCaptureType", m_shockCaptureType, "Off");
  
     m_session->LoadParameter("IPSymmFluxCoeff", m_IPSymmFluxCoeff, 0.0); // 0.5
  
     m_session->LoadParameter("IP2ndDervCoeff", m_IP2ndDervCoeff,
                              0.0); // 1.0/12.0
  
     m_session->LoadParameter("IPPenaltyCoeff", m_IPPenaltyCoeff,
                              4.0); // 1.0/12.0
  
     // Setting up the normals
     size_t nDim      = pFields[0]->GetCoordim(0);
     size_t nVariable = pFields.size();
     size_t nTracePts = pFields[0]->GetTrace()->GetTotPoints();
  
     m_traceNormals = Array<OneD, Array<OneD, NekDouble>>{nDim};
     for (int i = 0; i < nDim; ++i)
     {
         m_traceNormals[i] = Array<OneD, NekDouble>{nTracePts, 0.0};
     }
     m_traceAver = Array<OneD, Array<OneD, NekDouble>>{nVariable};
     m_traceJump = Array<OneD, Array<OneD, NekDouble>>{nVariable};
     for (int i = 0; i < nVariable; ++i)
     {
         m_traceAver[i] = Array<OneD, NekDouble>{nTracePts, 0.0};
         m_traceJump[i] = Array<OneD, NekDouble>{nTracePts, 0.0};
     }
  
     pFields[0]->GetTrace()->GetNormals(m_traceNormals);
     Array<OneD, NekDouble> lengthFwd{nTracePts, 0.0};
     Array<OneD, NekDouble> lengthBwd{nTracePts, 0.0};
     pFields[0]->GetTrace()->GetElmtNormalLength(lengthFwd, lengthBwd);
     pFields[0]->PeriodicBwdCopy(lengthFwd, lengthBwd);
  
     const MultiRegions::AssemblyMapDGSharedPtr TraceMap =
         pFields[0]->GetTraceMap();
     TraceMap->GetAssemblyCommDG()->PerformExchange(lengthFwd, lengthBwd);
  
     Vmath::Vadd(nTracePts, lengthBwd, 1, lengthFwd, 1, lengthFwd, 1);
     m_traceNormDirctnElmtLength      = lengthFwd;
     m_traceNormDirctnElmtLengthRecip = lengthBwd;
     Vmath::Sdiv(nTracePts, 1.0, m_traceNormDirctnElmtLength, 1,
                 m_traceNormDirctnElmtLengthRecip, 1);
  
     m_tracBwdWeightAver = Array<OneD, NekDouble>{nTracePts, 0.0};
     m_tracBwdWeightJump = Array<OneD, NekDouble>{nTracePts, 0.0};
     pFields[0]->GetBwdWeight(m_tracBwdWeightAver, m_tracBwdWeightJump);
     Array<OneD, NekDouble> tmpBwdWeight{nTracePts, 0.0};
     Array<OneD, NekDouble> tmpBwdWeightJump{nTracePts, 0.0};
     for (int i = 1; i < nVariable; ++i)
     {
         pFields[i]->GetBwdWeight(tmpBwdWeight, tmpBwdWeightJump);
         Vmath::Vsub(nTracePts, tmpBwdWeight, 1, m_tracBwdWeightAver, 1,
                     tmpBwdWeight, 1);
         Vmath::Vabs(nTracePts, tmpBwdWeight, 1, tmpBwdWeight, 1);
         NekDouble norm = 0.0;
         for (int j = 0; j < nTracePts; ++j)
         {
             norm += tmpBwdWeight[j];
         }
         ASSERTL0(norm < 1.0E-11,
                  "different BWD for different variable not coded yet");
     }
  
     m_MuVarTrace = NullNekDouble1DArray;
     if (m_ArtificialDiffusionVector)
     {
         m_MuVarTrace = Array<OneD, NekDouble>{nTracePts, 0.0};
     }
  
     // workspace for v_diffuse
     size_t nCoeffs = pFields[0]->GetNcoeffs();
     m_wspDiff = Array<OneD, Array<OneD, NekDouble>>{nVariable};
     for (int i = 0; i < nVariable; ++i)
     {
         m_wspDiff[i] = Array<OneD, NekDouble>{nCoeffs, 0.0};
     }
  
     // workspace for callnumtraceflux
     m_wspNumDerivBwd = TensorOfArray3D<NekDouble>{nDim};
     m_wspNumDerivFwd = TensorOfArray3D<NekDouble>{nDim};
     for (int nd = 0; nd < nDim; ++nd)
     {
         m_wspNumDerivBwd[nd] =
             Array<OneD, Array<OneD, NekDouble>>{nVariable};
         m_wspNumDerivFwd[nd] =
             Array<OneD, Array<OneD, NekDouble>>{nVariable};
         for (int i = 0; i < nVariable; ++i)
         {
             m_wspNumDerivBwd[nd][i] = Array<OneD, NekDouble>{nTracePts, 0.0};
             m_wspNumDerivFwd[nd][i] = Array<OneD, NekDouble>{nTracePts, 0.0};
         }
     }
 }

References ASSERTL0, Nektar::SolverUtils::Diffusion::m_ArtificialDiffusionVector, m_IP2ndDervCoeff, m_IPPenaltyCoeff, m_IPSymmFluxCoeff, m_MuVarTrace, m_session, m_shockCaptureType, m_tracBwdWeightAver, m_tracBwdWeightJump, m_traceAver, m_traceJump, m_traceNormals, m_traceNormDirctnElmtLength, m_traceNormDirctnElmtLengthRecip, m_wspDiff, m_wspNumDerivBwd, m_wspNumDerivFwd, Nektar::NullNekDouble1DArray, Vmath::Sdiv(), Vmath::Vabs(), Vmath::Vadd(), and Vmath::Vsub().

Member Data Documentation

◆ m_IP2ndDervCoeff

NekDouble Nektar::SolverUtils::DiffusionIP::m_IP2ndDervCoeff

protected

Definition at line 105 of file DiffusionIP.h.

Referenced by v_DiffuseTraceFlux(), and v_InitObject().

◆ m_IPPenaltyCoeff

NekDouble Nektar::SolverUtils::DiffusionIP::m_IPPenaltyCoeff

protected

Definition at line 106 of file DiffusionIP.h.

Referenced by CalcTraceNumFlux(), GetPenaltyFactorConst(), and v_InitObject().

◆ m_IPSymmFluxCoeff

NekDouble Nektar::SolverUtils::DiffusionIP::m_IPSymmFluxCoeff

protected

Definition at line 104 of file DiffusionIP.h.

Referenced by CalcTraceSymFlux(), v_AddDiffusionSymmFluxToCoeff(), v_AddDiffusionSymmFluxToPhys(), and v_InitObject().

◆ m_MuVarTrace

Array<OneD, NekDouble> Nektar::SolverUtils::DiffusionIP::m_MuVarTrace

protected

Definition at line 108 of file DiffusionIP.h.

Referenced by v_DiffuseTraceFlux(), v_DiffuseVolumeFlux(), and v_InitObject().

◆ m_session

LibUtilities::SessionReaderSharedPtr Nektar::SolverUtils::DiffusionIP::m_session

protected

Definition at line 122 of file DiffusionIP.h.

Referenced by v_InitObject().

◆ m_shockCaptureType

std::string Nektar::SolverUtils::DiffusionIP::m_shockCaptureType

protected

Definition at line 103 of file DiffusionIP.h.

Referenced by v_InitObject().

◆ m_tracBwdWeightAver

Array<OneD, NekDouble> Nektar::SolverUtils::DiffusionIP::m_tracBwdWeightAver

protected

Definition at line 118 of file DiffusionIP.h.

Referenced by v_ConsVarAveJump(), and v_InitObject().

◆ m_tracBwdWeightJump

Array<OneD, NekDouble> Nektar::SolverUtils::DiffusionIP::m_tracBwdWeightJump

protected

Definition at line 119 of file DiffusionIP.h.

Referenced by v_ConsVarAveJump(), and v_InitObject().

◆ m_traceAver

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::DiffusionIP::m_traceAver

protected

Definition at line 110 of file DiffusionIP.h.

Referenced by DiffuseTraceSymmFlux(), v_DiffuseTraceFlux(), and v_InitObject().

◆ m_traceJump

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::DiffusionIP::m_traceJump

protected

Definition at line 111 of file DiffusionIP.h.

Referenced by DiffuseTraceSymmFlux(), v_DiffuseTraceFlux(), and v_InitObject().

◆ m_traceNormals

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::DiffusionIP::m_traceNormals

protected

Definition at line 109 of file DiffusionIP.h.

Referenced by AddSecondDerivToTrace(), CalcTraceNumFlux(), CalcTraceSymFlux(), v_GetTraceNormal(), and v_InitObject().

◆ m_traceNormDirctnElmtLength

Array<OneD, NekDouble> Nektar::SolverUtils::DiffusionIP::m_traceNormDirctnElmtLength

protected

Definition at line 120 of file DiffusionIP.h.

Referenced by AddSecondDerivToTrace(), and v_InitObject().

◆ m_traceNormDirctnElmtLengthRecip

Array<OneD, NekDouble> Nektar::SolverUtils::DiffusionIP::m_traceNormDirctnElmtLengthRecip

protected

Definition at line 121 of file DiffusionIP.h.

Referenced by CalcTraceNumFlux(), and v_InitObject().

◆ m_wspDiff

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::DiffusionIP::m_wspDiff

protected

Workspace for v_Diffusion.

Definition at line 113 of file DiffusionIP.h.

Referenced by v_Diffuse(), and v_InitObject().

◆ m_wspNumDerivBwd

TensorOfArray3D<NekDouble> Nektar::SolverUtils::DiffusionIP::m_wspNumDerivBwd

protected

Workspace for CallTraceNumFlux.

Definition at line 115 of file DiffusionIP.h.

Referenced by CalcTraceNumFlux(), and v_InitObject().

◆ m_wspNumDerivFwd

TensorOfArray3D<NekDouble> Nektar::SolverUtils::DiffusionIP::m_wspNumDerivFwd

protected

Definition at line 116 of file DiffusionIP.h.

Referenced by CalcTraceNumFlux(), and v_InitObject().

◆ type

std::string Nektar::SolverUtils::DiffusionIP::type

static

Initial value:

= GetDiffusionFactory().RegisterCreatorFunction(

"InteriorPenalty", DiffusionIP::create)

Nektar::LibUtilities::NekFactory::RegisterCreatorFunction

tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, std::string pDesc="")

Register a class with the factory.

Definition: NekFactory.hpp:200

Nektar::SolverUtils::DiffusionIP::create

static DiffusionSharedPtr create(std::string diffType)

Definition: DiffusionIP.h:48

Nektar::SolverUtils::GetDiffusionFactory

DiffusionFactory & GetDiffusionFactory()

Definition: Diffusion.cpp:41

Definition at line 54 of file DiffusionIP.h.

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DiffusionIP()

Member Function Documentation

◆ AddSecondDerivToTrace()

◆ AddSymmFluxIntegralToCoeff()

◆ AddSymmFluxIntegralToPhys()

◆ ApplyFluxBndConds()

◆ CalcTraceNumFlux()

◆ CalcTraceSymFlux()

◆ ConsVarAve()

◆ create()

◆ DiffuseTraceSymmFlux()

◆ GetPenaltyFactor()

◆ GetPenaltyFactorConst()

◆ v_AddDiffusionSymmFluxToCoeff()

◆ v_AddDiffusionSymmFluxToPhys()

◆ v_ConsVarAveJump()

◆ v_Diffuse()

◆ v_DiffuseCalcDerivative()

◆ v_DiffuseCoeffs() [1/2]

◆ v_DiffuseCoeffs() [2/2]

◆ v_DiffuseTraceFlux() [1/2]

◆ v_DiffuseTraceFlux() [2/2]

◆ v_DiffuseVolumeFlux()

◆ v_GetTraceNormal()

◆ v_InitObject()

Member Data Documentation

◆ m_IP2ndDervCoeff

◆ m_IPPenaltyCoeff

◆ m_IPSymmFluxCoeff

◆ m_MuVarTrace

◆ m_session

◆ m_shockCaptureType

◆ m_tracBwdWeightAver

◆ m_tracBwdWeightJump

◆ m_traceAver

◆ m_traceJump

◆ m_traceNormals

◆ m_traceNormDirctnElmtLength

◆ m_traceNormDirctnElmtLengthRecip

◆ m_wspDiff

◆ m_wspNumDerivBwd

◆ m_wspNumDerivFwd

◆ type