A base class for PDEs which include an advection component. More...

#include <MMFSystem.h>

Inheritance diagram for Nektar::SolverUtils::MMFSystem:

Public Member Functions
SOLVER_UTILS_EXPORT	MMFSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)

SOLVER_UTILS_EXPORT	~MMFSystem () override

SOLVER_UTILS_EXPORT void	v_GenerateSummary (SummaryList &s) override
	Virtual function for generating summary information. More...

SOLVER_UTILS_EXPORT void	MMFInitObject (const Array< OneD, const Array< OneD, NekDouble > > &Anisotropy, const int TangentXelem=-1)

SOLVER_UTILS_EXPORT void	CopyBoundaryTrace (const Array< OneD, const NekDouble > &Fwd, Array< OneD, NekDouble > &Bwd, const BoundaryCopyType BDCopyType, const int var=0, const std::string btype="NoUserDefined")

Public Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
SOLVER_UTILS_EXPORT	~UnsteadySystem () override
	Destructor. More...

SOLVER_UTILS_EXPORT NekDouble	GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray)
	Calculate the larger time-step mantaining the problem stable. More...

SOLVER_UTILS_EXPORT NekDouble	GetTimeStep ()

SOLVER_UTILS_EXPORT void	SetTimeStep (const NekDouble timestep)

SOLVER_UTILS_EXPORT void	SteadyStateResidual (int step, Array< OneD, NekDouble > &L2)

SOLVER_UTILS_EXPORT LibUtilities::TimeIntegrationSchemeSharedPtr &	GetTimeIntegrationScheme ()
	Returns the time integration scheme. More...

SOLVER_UTILS_EXPORT LibUtilities::TimeIntegrationSchemeOperators &	GetTimeIntegrationSchemeOperators ()
	Returns the time integration scheme operators. More...

Public Member Functions inherited from Nektar::SolverUtils::EquationSystem
virtual SOLVER_UTILS_EXPORT	~EquationSystem ()
	Destructor. More...

SOLVER_UTILS_EXPORT void	InitObject (bool DeclareField=true)
	Initialises the members of this object. More...

SOLVER_UTILS_EXPORT void	DoInitialise (bool dumpInitialConditions=true)
	Perform any initialisation necessary before solving the problem. More...

SOLVER_UTILS_EXPORT void	DoSolve ()
	Solve the problem. More...

SOLVER_UTILS_EXPORT void	TransCoeffToPhys ()
	Transform from coefficient to physical space. More...

SOLVER_UTILS_EXPORT void	TransPhysToCoeff ()
	Transform from physical to coefficient space. More...

SOLVER_UTILS_EXPORT void	Output ()
	Perform output operations after solve. More...

SOLVER_UTILS_EXPORT std::string	GetSessionName ()
	Get Session name. More...

template<class T >
std::shared_ptr< T >	as ()

SOLVER_UTILS_EXPORT void	ResetSessionName (std::string newname)
	Reset Session name. More...

SOLVER_UTILS_EXPORT LibUtilities::SessionReaderSharedPtr	GetSession ()
	Get Session name. More...

SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr	GetPressure ()
	Get pressure field if available. More...

SOLVER_UTILS_EXPORT void	ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)

SOLVER_UTILS_EXPORT void	PrintSummary (std::ostream &out)
	Print a summary of parameters and solver characteristics. More...

SOLVER_UTILS_EXPORT void	SetLambda (NekDouble lambda)
	Set parameter m_lambda. More...

SOLVER_UTILS_EXPORT SessionFunctionSharedPtr	GetFunction (std::string name, const MultiRegions::ExpListSharedPtr &field=MultiRegions::NullExpListSharedPtr, bool cache=false)
	Get a SessionFunction by name. More...

SOLVER_UTILS_EXPORT void	SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
	Initialise the data in the dependent fields. More...

SOLVER_UTILS_EXPORT void	EvaluateExactSolution (int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
	Evaluates an exact solution. More...

SOLVER_UTILS_EXPORT NekDouble	L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln, bool Normalised=false)
	Compute the L2 error between fields and a given exact solution. More...

SOLVER_UTILS_EXPORT NekDouble	L2Error (unsigned int field, bool Normalised=false)
	Compute the L2 error of the fields. More...

SOLVER_UTILS_EXPORT NekDouble	LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
	Linf error computation. More...

SOLVER_UTILS_EXPORT Array< OneD, NekDouble >	ErrorExtraPoints (unsigned int field)
	Compute error (L2 and L_inf) over an larger set of quadrature points return [L2 Linf]. More...

SOLVER_UTILS_EXPORT void	Checkpoint_Output (const int n)
	Write checkpoint file of m_fields. More...

SOLVER_UTILS_EXPORT void	Checkpoint_Output (const int n, MultiRegions::ExpListSharedPtr &field, std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
	Write checkpoint file of custom data fields. More...

SOLVER_UTILS_EXPORT void	Checkpoint_BaseFlow (const int n)
	Write base flow file of m_fields. More...

SOLVER_UTILS_EXPORT void	WriteFld (const std::string &outname)
	Write field data to the given filename. More...

SOLVER_UTILS_EXPORT void	WriteFld (const std::string &outname, MultiRegions::ExpListSharedPtr &field, std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
	Write input fields to the given filename. More...

SOLVER_UTILS_EXPORT void	ImportFld (const std::string &infile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)
	Input field data from the given file. More...

SOLVER_UTILS_EXPORT void	ImportFldToMultiDomains (const std::string &infile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const int ndomains)
	Input field data from the given file to multiple domains. More...

SOLVER_UTILS_EXPORT void	ImportFld (const std::string &infile, std::vector< std::string > &fieldStr, Array< OneD, Array< OneD, NekDouble > > &coeffs)
	Output a field. Input field data into array from the given file. More...

SOLVER_UTILS_EXPORT void	ImportFld (const std::string &infile, MultiRegions::ExpListSharedPtr &pField, std::string &pFieldName)
	Output a field. Input field data into ExpList from the given file. More...

SOLVER_UTILS_EXPORT void	SessionSummary (SummaryList &vSummary)
	Write out a session summary. More...

SOLVER_UTILS_EXPORT Array< OneD, MultiRegions::ExpListSharedPtr > &	UpdateFields ()

SOLVER_UTILS_EXPORT LibUtilities::FieldMetaDataMap &	UpdateFieldMetaDataMap ()
	Get hold of FieldInfoMap so it can be updated. More...

SOLVER_UTILS_EXPORT NekDouble	GetTime ()
	Return final time. More...

SOLVER_UTILS_EXPORT int	GetNcoeffs ()

SOLVER_UTILS_EXPORT int	GetNcoeffs (const int eid)

SOLVER_UTILS_EXPORT int	GetNumExpModes ()

SOLVER_UTILS_EXPORT const Array< OneD, int >	GetNumExpModesPerExp ()

SOLVER_UTILS_EXPORT int	GetNvariables ()

SOLVER_UTILS_EXPORT const std::string	GetVariable (unsigned int i)

SOLVER_UTILS_EXPORT int	GetTraceTotPoints ()

SOLVER_UTILS_EXPORT int	GetTraceNpoints ()

SOLVER_UTILS_EXPORT int	GetExpSize ()

SOLVER_UTILS_EXPORT int	GetPhys_Offset (int n)

SOLVER_UTILS_EXPORT int	GetCoeff_Offset (int n)

SOLVER_UTILS_EXPORT int	GetTotPoints ()

SOLVER_UTILS_EXPORT int	GetTotPoints (int n)

SOLVER_UTILS_EXPORT int	GetNpoints ()

SOLVER_UTILS_EXPORT int	GetSteps ()

SOLVER_UTILS_EXPORT NekDouble	GetTimeStep ()

SOLVER_UTILS_EXPORT void	CopyFromPhysField (const int i, Array< OneD, NekDouble > &output)

SOLVER_UTILS_EXPORT void	CopyToPhysField (const int i, const Array< OneD, const NekDouble > &input)

SOLVER_UTILS_EXPORT Array< OneD, NekDouble > &	UpdatePhysField (const int i)

SOLVER_UTILS_EXPORT void	SetSteps (const int steps)

SOLVER_UTILS_EXPORT void	ZeroPhysFields ()

SOLVER_UTILS_EXPORT void	FwdTransFields ()

SOLVER_UTILS_EXPORT void	SetModifiedBasis (const bool modbasis)

SOLVER_UTILS_EXPORT int	GetCheckpointNumber ()

SOLVER_UTILS_EXPORT void	SetCheckpointNumber (int num)

SOLVER_UTILS_EXPORT int	GetCheckpointSteps ()

SOLVER_UTILS_EXPORT void	SetCheckpointSteps (int num)

SOLVER_UTILS_EXPORT int	GetInfoSteps ()

SOLVER_UTILS_EXPORT void	SetInfoSteps (int num)

SOLVER_UTILS_EXPORT void	SetIterationNumberPIT (int num)

SOLVER_UTILS_EXPORT void	SetWindowNumberPIT (int num)

SOLVER_UTILS_EXPORT Array< OneD, const Array< OneD, NekDouble > >	GetTraceNormals ()

SOLVER_UTILS_EXPORT void	SetTime (const NekDouble time)

SOLVER_UTILS_EXPORT void	SetTimeStep (const NekDouble timestep)

SOLVER_UTILS_EXPORT void	SetInitialStep (const int step)

SOLVER_UTILS_EXPORT void	SetBoundaryConditions (NekDouble time)
	Evaluates the boundary conditions at the given time. More...

SOLVER_UTILS_EXPORT bool	NegatedOp ()
	Identify if operator is negated in DoSolve. More...

Public Member Functions inherited from Nektar::SolverUtils::ALEHelper
virtual	~ALEHelper ()=default

virtual SOLVER_UTILS_EXPORT void	v_ALEInitObject (int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields)

SOLVER_UTILS_EXPORT void	InitObject (int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields)

virtual SOLVER_UTILS_EXPORT void	v_UpdateGridVelocity (const NekDouble &time)

virtual SOLVER_UTILS_EXPORT void	v_ALEPreMultiplyMass (Array< OneD, Array< OneD, NekDouble > > &fields)

SOLVER_UTILS_EXPORT void	ALEDoElmtInvMass (Array< OneD, Array< OneD, NekDouble > > &traceNormals, Array< OneD, Array< OneD, NekDouble > > &fields, NekDouble time)
	Update m_fields with u^n by multiplying by inverse mass matrix. That's then used in e.g. checkpoint output and L^2 error calculation. More...

SOLVER_UTILS_EXPORT void	ALEDoElmtInvMassBwdTrans (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)

SOLVER_UTILS_EXPORT void	MoveMesh (const NekDouble &time, Array< OneD, Array< OneD, NekDouble > > &traceNormals)

const Array< OneD, const Array< OneD, NekDouble > > &	GetGridVelocity ()

SOLVER_UTILS_EXPORT const Array< OneD, const Array< OneD, NekDouble > > &	GetGridVelocityTrace ()

SOLVER_UTILS_EXPORT void	ExtraFldOutputGridVelocity (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)

Public Attributes
NekDouble	m_pi

int	m_shapedim

SurfaceType	m_surfaceType

UpwindType	m_upwindType

TestMaxwellType	m_TestMaxwellType

PolType	m_PolType

IncType	m_IncType

Array< OneD, NekDouble >	m_MMFfactors

Protected Member Functions
void	SetUpMovingFrames (const Array< OneD, const Array< OneD, NekDouble > > &Anisotropy, const int TangentXelem)

void	CheckMovingFrames (const Array< OneD, const Array< OneD, NekDouble > > &movingframes)

SOLVER_UTILS_EXPORT void	ComputencdotMF ()

SOLVER_UTILS_EXPORT void	ComputeDivCurlMF ()

SOLVER_UTILS_EXPORT void	ComputeMFtrace ()

SOLVER_UTILS_EXPORT void	VectorDotProd (const Array< OneD, const Array< OneD, NekDouble > > &v1, const Array< OneD, const Array< OneD, NekDouble > > &v2, Array< OneD, NekDouble > &v3)

SOLVER_UTILS_EXPORT void	VectorCrossProd (const Array< OneD, const Array< OneD, NekDouble > > &v1, const Array< OneD, const Array< OneD, NekDouble > > &v2, Array< OneD, Array< OneD, NekDouble > > &v3)

SOLVER_UTILS_EXPORT void	VectorCrossProd (const Array< OneD, NekDouble > &v1, const Array< OneD, NekDouble > &v2, Array< OneD, NekDouble > &v3)

SOLVER_UTILS_EXPORT void	ComputeCurl (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)

SOLVER_UTILS_EXPORT Array< OneD, NekDouble >	CartesianToMovingframes (const Array< OneD, const Array< OneD, NekDouble > > &uvec, unsigned int field)

SOLVER_UTILS_EXPORT void	DeriveCrossProductMF (Array< OneD, Array< OneD, NekDouble > > &CrossProductMF)

SOLVER_UTILS_EXPORT void	ComputeNtimesMF ()

SOLVER_UTILS_EXPORT void	ComputeNtimesFz (const int dir, const Array< OneD, Array< OneD, NekDouble > > &Fwd, const Array< OneD, Array< OneD, NekDouble > > &Bwd, const Array< OneD, const NekDouble > &imFwd, const Array< OneD, const NekDouble > &imBwd, Array< OneD, NekDouble > &outarrayFwd, Array< OneD, NekDouble > &outarrayBwd)

SOLVER_UTILS_EXPORT void	ComputeNtimesF12 (const Array< OneD, Array< OneD, NekDouble > > &Fwd, const Array< OneD, Array< OneD, NekDouble > > &Bwd, const Array< OneD, const NekDouble > &im1Fwd, const Array< OneD, const NekDouble > &im1Bwd, const Array< OneD, const NekDouble > &im2Fwd, const Array< OneD, const NekDouble > &im2Bwd, Array< OneD, NekDouble > &outarrayFwd, Array< OneD, NekDouble > &outarrayBwd)

SOLVER_UTILS_EXPORT void	ComputeNtimestimesdFz (const int dir, const Array< OneD, Array< OneD, NekDouble > > &Fwd, const Array< OneD, Array< OneD, NekDouble > > &Bwd, const Array< OneD, const NekDouble > &imFwd, const Array< OneD, const NekDouble > &imBwd, Array< OneD, NekDouble > &outarrayFwd, Array< OneD, NekDouble > &outarrayBwd)

SOLVER_UTILS_EXPORT void	ComputeNtimestimesdF12 (const Array< OneD, Array< OneD, NekDouble > > &Fwd, const Array< OneD, Array< OneD, NekDouble > > &Bwd, const Array< OneD, const NekDouble > &im1Fwd, const Array< OneD, const NekDouble > &im1Bwd, const Array< OneD, const NekDouble > &im2Fwd, const Array< OneD, const NekDouble > &im2Bwd, Array< OneD, NekDouble > &outarrayFwd, Array< OneD, NekDouble > &outarrayBwd)

SOLVER_UTILS_EXPORT void	CartesianToSpherical (const NekDouble x0j, const NekDouble x1j, const NekDouble x2j, NekDouble &sin_varphi, NekDouble &cos_varphi, NekDouble &sin_theta, NekDouble &cos_theta)

SOLVER_UTILS_EXPORT void	ComputeZimYim (Array< OneD, Array< OneD, NekDouble > > &epsvec, Array< OneD, Array< OneD, NekDouble > > &muvec)

SOLVER_UTILS_EXPORT void	AdddedtMaxwell (const Array< OneD, const Array< OneD, NekDouble > > &physarray, Array< OneD, Array< OneD, NekDouble > > &outarray)

SOLVER_UTILS_EXPORT void	GetMaxwellFluxVector (const int var, const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &flux)

SOLVER_UTILS_EXPORT void	GetMaxwellFlux1D (const int var, const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &flux)

SOLVER_UTILS_EXPORT void	GetMaxwellFlux2D (const int var, const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &flux)

SOLVER_UTILS_EXPORT void	LaxFriedrichMaxwellFlux1D (Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &numfluxFwd, Array< OneD, Array< OneD, NekDouble > > &numfluxBwd)

SOLVER_UTILS_EXPORT void	UpwindMaxwellFlux1D (Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &numfluxFwd, Array< OneD, Array< OneD, NekDouble > > &numfluxBwd)

SOLVER_UTILS_EXPORT void	AverageMaxwellFlux1D (Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &numfluxFwd, Array< OneD, Array< OneD, NekDouble > > &numfluxBwd)

SOLVER_UTILS_EXPORT void	NumericalMaxwellFlux (Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &numfluxFwd, Array< OneD, Array< OneD, NekDouble > > &numfluxBwd, const NekDouble time=0.0)

SOLVER_UTILS_EXPORT void	NumericalMaxwellFluxTM (Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &numfluxFwd, Array< OneD, Array< OneD, NekDouble > > &numfluxBwd, const NekDouble time)

SOLVER_UTILS_EXPORT void	NumericalMaxwellFluxTE (Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &numfluxFwd, Array< OneD, Array< OneD, NekDouble > > &numfluxBwd, const NekDouble time)

SOLVER_UTILS_EXPORT Array< OneD, NekDouble >	GetIncidentField (const int var, const NekDouble time)

SOLVER_UTILS_EXPORT void	Computedemdxicdote ()

SOLVER_UTILS_EXPORT NekDouble	AvgInt (const Array< OneD, const NekDouble > &inarray)

SOLVER_UTILS_EXPORT NekDouble	AvgAbsInt (const Array< OneD, const NekDouble > &inarray)

SOLVER_UTILS_EXPORT NekDouble	AbsIntegral (const Array< OneD, const NekDouble > &inarray)

SOLVER_UTILS_EXPORT NekDouble	RootMeanSquare (const Array< OneD, const NekDouble > &inarray)

SOLVER_UTILS_EXPORT NekDouble	VectorAvgMagnitude (const Array< OneD, const Array< OneD, NekDouble > > &inarray)

SOLVER_UTILS_EXPORT void	GramSchumitz (const Array< OneD, const Array< OneD, NekDouble > > &v1, const Array< OneD, const Array< OneD, NekDouble > > &v2, Array< OneD, Array< OneD, NekDouble > > &outarray, bool KeepTheMagnitude=true)

SOLVER_UTILS_EXPORT void	BubbleSort (Array< OneD, NekDouble > &refarray, Array< OneD, NekDouble > &sortarray)

Protected Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
SOLVER_UTILS_EXPORT	UnsteadySystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
	Initialises UnsteadySystem class members. More...

SOLVER_UTILS_EXPORT void	v_InitObject (bool DeclareField=true) override
	Init object for UnsteadySystem class. More...

SOLVER_UTILS_EXPORT void	v_DoSolve () override
	Solves an unsteady problem. More...

virtual SOLVER_UTILS_EXPORT void	v_PrintStatusInformation (const int step, const NekDouble cpuTime)
	Print Status Information. More...

virtual SOLVER_UTILS_EXPORT void	v_PrintSummaryStatistics (const NekDouble intTime)
	Print Summary Statistics. More...

SOLVER_UTILS_EXPORT void	v_DoInitialise (bool dumpInitialConditions=true) override
	Sets up initial conditions. More...

SOLVER_UTILS_EXPORT void	v_GenerateSummary (SummaryList &s) override
	Print a summary of time stepping parameters. More...

virtual SOLVER_UTILS_EXPORT NekDouble	v_GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray)
	Return the timestep to be used for the next step in the time-marching loop. More...

virtual SOLVER_UTILS_EXPORT bool	v_PreIntegrate (int step)

virtual SOLVER_UTILS_EXPORT bool	v_PostIntegrate (int step)

virtual SOLVER_UTILS_EXPORT bool	v_RequireFwdTrans ()

virtual SOLVER_UTILS_EXPORT void	v_SteadyStateResidual (int step, Array< OneD, NekDouble > &L2)

virtual SOLVER_UTILS_EXPORT bool	v_UpdateTimeStepCheck ()

SOLVER_UTILS_EXPORT NekDouble	MaxTimeStepEstimator ()
	Get the maximum timestep estimator for cfl control. More...

SOLVER_UTILS_EXPORT void	CheckForRestartTime (NekDouble &time, int &nchk)

SOLVER_UTILS_EXPORT void	SVVVarDiffCoeff (const Array< OneD, Array< OneD, NekDouble > > vel, StdRegions::VarCoeffMap &varCoeffMap)
	Evaluate the SVV diffusion coefficient according to Moura's paper where it should proportional to h time velocity. More...

SOLVER_UTILS_EXPORT void	DoDummyProjection (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
	Perform dummy projection. More...

Protected Member Functions inherited from Nektar::SolverUtils::EquationSystem
SOLVER_UTILS_EXPORT	EquationSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
	Initialises EquationSystem class members. More...

virtual SOLVER_UTILS_EXPORT void	v_InitObject (bool DeclareFeld=true)
	Initialisation object for EquationSystem. More...

virtual SOLVER_UTILS_EXPORT void	v_DoInitialise (bool dumpInitialConditions=true)
	Virtual function for initialisation implementation. More...

virtual SOLVER_UTILS_EXPORT void	v_DoSolve ()
	Virtual function for solve implementation. More...

virtual SOLVER_UTILS_EXPORT NekDouble	v_LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
	Virtual function for the L_inf error computation between fields and a given exact solution. More...

virtual SOLVER_UTILS_EXPORT NekDouble	v_L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray, bool Normalised=false)
	Virtual function for the L_2 error computation between fields and a given exact solution. More...

virtual SOLVER_UTILS_EXPORT void	v_TransCoeffToPhys ()
	Virtual function for transformation to physical space. More...

virtual SOLVER_UTILS_EXPORT void	v_TransPhysToCoeff ()
	Virtual function for transformation to coefficient space. More...

virtual SOLVER_UTILS_EXPORT void	v_GenerateSummary (SummaryList &l)
	Virtual function for generating summary information. More...

virtual SOLVER_UTILS_EXPORT void	v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)

virtual SOLVER_UTILS_EXPORT void	v_EvaluateExactSolution (unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time)

virtual SOLVER_UTILS_EXPORT void	v_Output (void)

virtual SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr	v_GetPressure (void)

virtual SOLVER_UTILS_EXPORT bool	v_NegatedOp (void)
	Virtual function to identify if operator is negated in DoSolve. More...

virtual SOLVER_UTILS_EXPORT void	v_ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)

Protected Attributes
NekDouble	m_alpha

NekDouble	m_Incfreq

int	m_SmoothFactor

NekDouble	m_SFinit

Array< OneD, Array< OneD, NekDouble > >	m_movingframes

Array< OneD, Array< OneD, NekDouble > >	m_surfaceNormal

Array< OneD, Array< OneD, NekDouble > >	m_ncdotMFFwd

Array< OneD, Array< OneD, NekDouble > >	m_ncdotMFBwd

Array< OneD, Array< OneD, NekDouble > >	m_nperpcdotMFFwd

Array< OneD, Array< OneD, NekDouble > >	m_nperpcdotMFBwd

Array< OneD, Array< OneD, NekDouble > >	m_DivMF

Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	m_CurlMF

Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	m_MFtraceFwd

Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	m_MFtraceBwd

Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	m_ntimesMFFwd

Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	m_ntimesMFBwd

Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	m_ntimes_ntimesMFFwd

Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	m_ntimes_ntimesMFBwd

Array< OneD, Array< OneD, NekDouble > >	m_ZimFwd

Array< OneD, Array< OneD, NekDouble > >	m_ZimBwd

Array< OneD, Array< OneD, NekDouble > >	m_YimFwd

Array< OneD, Array< OneD, NekDouble > >	m_YimBwd

Array< OneD, Array< OneD, NekDouble > >	m_epsvec

Array< OneD, Array< OneD, NekDouble > >	m_muvec

Array< OneD, Array< OneD, NekDouble > >	m_negepsvecminus1

Array< OneD, Array< OneD, NekDouble > >	m_negmuvecminus1

Array< OneD, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > >	m_dedxi_cdot_e

SpatialDomains::GeomMMF	m_MMFdir

Protected Attributes inherited from Nektar::SolverUtils::UnsteadySystem
LibUtilities::TimeIntegrationSchemeSharedPtr	m_intScheme
	Wrapper to the time integration scheme. More...

LibUtilities::TimeIntegrationSchemeOperators	m_ode
	The time integration scheme operators to use. More...

Array< OneD, Array< OneD, NekDouble > >	m_previousSolution
	Storage for previous solution for steady-state check. More...

std::vector< int >	m_intVariables

NekDouble	m_cflSafetyFactor
	CFL safety factor (comprise between 0 to 1). More...

NekDouble	m_CFLGrowth
	CFL growth rate. More...

NekDouble	m_CFLEnd
	Maximun cfl in cfl growth. More...

int	m_abortSteps
	Number of steps between checks for abort conditions. More...

bool	m_explicitDiffusion
	Indicates if explicit or implicit treatment of diffusion is used. More...

bool	m_explicitAdvection
	Indicates if explicit or implicit treatment of advection is used. More...

bool	m_explicitReaction
	Indicates if explicit or implicit treatment of reaction is used. More...

int	m_steadyStateSteps
	Check for steady state at step interval. More...

NekDouble	m_steadyStateTol
	Tolerance to which steady state should be evaluated at. More...

int	m_filtersInfosteps
	Number of time steps between outputting filters information. More...

std::vector< std::pair< std::string, FilterSharedPtr > >	m_filters

bool	m_homoInitialFwd
	Flag to determine if simulation should start in homogeneous forward transformed state. More...

std::ofstream	m_errFile

NekDouble	m_epsilon
	Diffusion coefficient. More...

Protected Attributes inherited from Nektar::SolverUtils::EquationSystem
LibUtilities::CommSharedPtr	m_comm
	Communicator. More...

bool	m_verbose

LibUtilities::SessionReaderSharedPtr	m_session
	The session reader. More...

std::map< std::string, SolverUtils::SessionFunctionSharedPtr >	m_sessionFunctions
	Map of known SessionFunctions. More...

LibUtilities::FieldIOSharedPtr	m_fld
	Field input/output. More...

Array< OneD, MultiRegions::ExpListSharedPtr >	m_fields
	Array holding all dependent variables. More...

SpatialDomains::BoundaryConditionsSharedPtr	m_boundaryConditions
	Pointer to boundary conditions object. More...

SpatialDomains::MeshGraphSharedPtr	m_graph
	Pointer to graph defining mesh. More...

std::string	m_sessionName
	Name of the session. More...

NekDouble	m_time
	Current time of simulation. More...

int	m_initialStep
	Number of the step where the simulation should begin. More...

NekDouble	m_fintime
	Finish time of the simulation. More...

NekDouble	m_timestep
	Time step size. More...

NekDouble	m_lambda
	Lambda constant in real system if one required. More...

NekDouble	m_checktime
	Time between checkpoints. More...

NekDouble	m_lastCheckTime

NekDouble	m_TimeIncrementFactor

int	m_nchk
	Number of checkpoints written so far. More...

int	m_steps
	Number of steps to take. More...

int	m_checksteps
	Number of steps between checkpoints. More...

int	m_infosteps
	Number of time steps between outputting status information. More...

int	m_iterPIT = 0
	Number of parallel-in-time time iteration. More...

int	m_windowPIT = 0
	Index of windows for parallel-in-time time iteration. More...

int	m_spacedim
	Spatial dimension (>= expansion dim). More...

int	m_expdim
	Expansion dimension. More...

bool	m_singleMode
	Flag to determine if single homogeneous mode is used. More...

bool	m_halfMode
	Flag to determine if half homogeneous mode is used. More...

bool	m_multipleModes
	Flag to determine if use multiple homogenenous modes are used. More...

bool	m_useFFT
	Flag to determine if FFT is used for homogeneous transform. More...

bool	m_homogen_dealiasing
	Flag to determine if dealiasing is used for homogeneous simulations. More...

bool	m_specHP_dealiasing
	Flag to determine if dealisising is usde for the Spectral/hp element discretisation. More...

enum MultiRegions::ProjectionType	m_projectionType
	Type of projection; e.g continuous or discontinuous. More...

Array< OneD, Array< OneD, NekDouble > >	m_traceNormals
	Array holding trace normals for DG simulations in the forwards direction. More...

Array< OneD, bool >	m_checkIfSystemSingular
	Flag to indicate if the fields should be checked for singularity. More...

LibUtilities::FieldMetaDataMap	m_fieldMetaDataMap
	Map to identify relevant solver info to dump in output fields. More...

Array< OneD, NekDouble >	m_movingFrameData
	Moving reference frame status in the inertial frame X, Y, Z, Theta_x, Theta_y, Theta_z, U, V, W, Omega_x, Omega_y, Omega_z, A_x, A_y, A_z, DOmega_x, DOmega_y, DOmega_z, pivot_x, pivot_y, pivot_z. More...

std::vector< std::string >	m_strFrameData
	variable name in m_movingFrameData More...

int	m_NumQuadPointsError
	Number of Quadrature points used to work out the error. More...

enum HomogeneousType	m_HomogeneousType

NekDouble	m_LhomX
	physical length in X direction (if homogeneous) More...

NekDouble	m_LhomY
	physical length in Y direction (if homogeneous) More...

NekDouble	m_LhomZ
	physical length in Z direction (if homogeneous) More...

int	m_npointsX
	number of points in X direction (if homogeneous) More...

int	m_npointsY
	number of points in Y direction (if homogeneous) More...

int	m_npointsZ
	number of points in Z direction (if homogeneous) More...

int	m_HomoDirec
	number of homogenous directions More...

Protected Attributes inherited from Nektar::SolverUtils::ALEHelper
Array< OneD, MultiRegions::ExpListSharedPtr >	m_fieldsALE

Array< OneD, Array< OneD, NekDouble > >	m_gridVelocity

Array< OneD, Array< OneD, NekDouble > >	m_gridVelocityTrace

std::vector< ALEBaseShPtr >	m_ALEs

bool	m_ALESolver = false

bool	m_ImplicitALESolver = false

NekDouble	m_prevStageTime = 0.0

int	m_spaceDim

Additional Inherited Members
Static Public Attributes inherited from Nektar::SolverUtils::UnsteadySystem
static std::string	cmdSetStartTime

static std::string	cmdSetStartChkNum

Protected Types inherited from Nektar::SolverUtils::EquationSystem
enum	HomogeneousType { eHomogeneous1D , eHomogeneous2D , eHomogeneous3D , eNotHomogeneous }
	Parameter for homogeneous expansions. More...

Static Protected Attributes inherited from Nektar::SolverUtils::EquationSystem
static std::string	equationSystemTypeLookupIds []

static std::string	projectionTypeLookupIds []

Detailed Description

A base class for PDEs which include an advection component.

Definition at line 143 of file MMFSystem.h.

Constructor & Destructor Documentation

◆ MMFSystem()

Nektar::SolverUtils::MMFSystem::MMFSystem	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const SpatialDomains::MeshGraphSharedPtr &	pGraph
	)

Definition at line 41 of file MMFSystem.cpp.

    : UnsteadySystem(pSession, pGraph)
{
}

◆ ~MMFSystem()

Nektar::SolverUtils::MMFSystem::~MMFSystem ( )

override

Definition at line 47 of file MMFSystem.cpp.

48{

49}

Member Function Documentation

◆ AbsIntegral()

NekDouble Nektar::SolverUtils::MMFSystem::AbsIntegral ( const Array< OneD, const NekDouble > & inarray )

protected

Definition at line 2324 of file MMFSystem.cpp.

{
    int nq = m_fields[0]->GetNpoints();
    Array<OneD, NekDouble> tmp(nq);
 
    if (inarray.size() != nq)
    {
        ASSERTL0(false, "AbsIntegral Error: Vector size is not correct");
    }
 
    Vmath::Vabs(nq, inarray, 1, tmp, 1);
    return m_fields[0]->Integral(tmp);
}

References ASSERTL0, Nektar::SolverUtils::EquationSystem::m_fields, and Vmath::Vabs().

◆ AdddedtMaxwell()

void Nektar::SolverUtils::MMFSystem::AdddedtMaxwell	(	const Array< OneD, const Array< OneD, NekDouble > > &	physarray,
		Array< OneD, Array< OneD, NekDouble > > &	outarray
	)

protected

Definition at line 1364 of file MMFSystem.cpp.

{
    int nq = GetTotPoints();
 
    // m_dedxi_cdot_e[m][j][n][] = de^m / d \xi^j \cdot e^n
    Array<OneD, NekDouble> dedtej(nq);
    Array<OneD, NekDouble> de1dtcdotej(nq);
    Array<OneD, NekDouble> de2dtcdotej(nq);
 
    Array<OneD, NekDouble> normH(nq);
    Array<OneD, NekDouble> NormedH1(nq, 0.0);
    Array<OneD, NekDouble> NormednegH2(nq, 0.0);
 
    Vmath::Vmul(nq, &physarray[0][0], 1, &physarray[0][0], 1, &normH[0], 1);
    Vmath::Vvtvp(nq, &physarray[1][0], 1, &physarray[1][0], 1, &normH[0], 1,
                 &normH[0], 1);
    Vmath::Vsqrt(nq, normH, 1, normH, 1);
 
    NekDouble Tol = 0.001;
    for (int i = 0; i < nq; ++i)
    {
        if (normH[i] > Tol)
        {
            NormedH1[i]    = physarray[0][i] / normH[i];
            NormednegH2[i] = -1.0 * physarray[1][i] / normH[i];
        }
    }
 
    for (int j = 0; j < m_shapedim; ++j)
    {
        // Compute de1 / dt \cdot ej = (-H2 de^1/d\xi1 \cdot e^j + H1 de^1/d\xi2
        // \cdot e^j) / sqrt{ H1^2 + H2^2 }
        Vmath::Vmul(nq, &NormednegH2[0], 1, &m_dedxi_cdot_e[0][0][j][0], 1,
                    &de1dtcdotej[0], 1);
        Vmath::Vvtvp(nq, &NormedH1[0], 1, &m_dedxi_cdot_e[0][1][j][0], 1,
                     &de1dtcdotej[0], 1, &de1dtcdotej[0], 1);
 
        // Compute de2 / dt \cdot ej = (-H2 de2/d\xi1 \cdot e^j + H1 de2/d\xi2
        // \cdot e^j) / sqrt{ H1^2 + H2^2 }
        Vmath::Vmul(nq, &NormednegH2[0], 1, &m_dedxi_cdot_e[1][0][j][0], 1,
                    &de2dtcdotej[0], 1);
        Vmath::Vvtvp(nq, &NormedH1[0], 1, &m_dedxi_cdot_e[1][1][j][0], 1,
                     &de2dtcdotej[0], 1, &de2dtcdotej[0], 1);
 
        // Add dedt component: (H1 (de1/dt) + H2 (de2/dt) ) \cdot ej
        Vmath::Vmul(nq, &physarray[0][0], 1, &de1dtcdotej[0], 1, &dedtej[0], 1);
        Vmath::Vvtvp(nq, &physarray[1][0], 1, &de2dtcdotej[0], 1, &dedtej[0], 1,
                     &dedtej[0], 1);
 
        Vmath::Neg(nq, dedtej, 1);
 
        switch (m_PolType)
        {
            case SolverUtils::eTransMagnetic:
            {
                if (j == 0)
                {
                    Vmath::Vmul(nq, m_muvec[0], 1, dedtej, 1, dedtej, 1);
                }
 
                else if (j == 1)
                {
                    Vmath::Vmul(nq, m_muvec[1], 1, dedtej, 1, dedtej, 1);
                }
            }
            break;
 
            case SolverUtils::eTransElectric:
            {
                if (j == 0)
                {
                    Vmath::Vmul(nq, m_epsvec[0], 1, dedtej, 1, dedtej, 1);
                }
 
                else if (j == 1)
                {
                    Vmath::Vmul(nq, m_epsvec[1], 1, dedtej, 1, dedtej, 1);
                }
            }
            break;
 
            default:
                break;
        }
 
        Vmath::Vadd(nq, &dedtej[0], 1, &outarray[j][0], 1, &outarray[j][0], 1);
    }
}

References Nektar::SolverUtils::eTransElectric, Nektar::SolverUtils::eTransMagnetic, Nektar::SolverUtils::EquationSystem::GetTotPoints(), m_dedxi_cdot_e, m_epsvec, m_muvec, m_PolType, m_shapedim, Vmath::Neg(), Vmath::Vadd(), Vmath::Vmul(), Vmath::Vsqrt(), and Vmath::Vvtvp().

Referenced by Nektar::MMFMaxwell::DoOdeRhs().

◆ AverageMaxwellFlux1D()

void Nektar::SolverUtils::MMFSystem::AverageMaxwellFlux1D	(	Array< OneD, Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	numfluxFwd,
		Array< OneD, Array< OneD, NekDouble > > &	numfluxBwd
	)

protected

Definition at line 1562 of file MMFSystem.cpp.

{
    int i;
    int nTraceNumPoints = GetTraceTotPoints();
    int nvar            = 2;
 
    // get temporary arrays
    Array<OneD, Array<OneD, NekDouble>> Fwd(nvar);
    Array<OneD, Array<OneD, NekDouble>> Bwd(nvar);
 
    for (i = 0; i < nvar; ++i)
    {
        Fwd[i] = Array<OneD, NekDouble>(nTraceNumPoints);
        Bwd[i] = Array<OneD, NekDouble>(nTraceNumPoints);
    }
 
    // get the physical values at the trace from the dependent variables
    for (i = 0; i < nvar; ++i)
    {
        m_fields[i]->GetFwdBwdTracePhys(physfield[i], Fwd[i], Bwd[i]);
    }
 
    // E = 0 at the boundaries
    CopyBoundaryTrace(Fwd[0], Bwd[0], SolverUtils::eFwdEQNegBwd, 0, "PEC");
 
    // d H / d n = 0 at the boundaries
    CopyBoundaryTrace(Fwd[1], Bwd[1], SolverUtils::eFwdEQBwd, 1, "PEC");
 
    for (i = 0; i < nTraceNumPoints; ++i)
    {
        numfluxFwd[0][i] = 0.5 * m_traceNormals[0][i] * (Fwd[1][i] + Bwd[1][i]);
        numfluxFwd[1][i] = 0.5 * m_traceNormals[0][i] * (Fwd[0][i] + Bwd[0][i]);
 
        numfluxBwd[0][i] = 0.5 * m_traceNormals[0][i] * (Fwd[1][i] + Bwd[1][i]);
        numfluxBwd[1][i] = 0.5 * m_traceNormals[0][i] * (Fwd[0][i] + Bwd[0][i]);
    }
}

References CopyBoundaryTrace(), Nektar::SolverUtils::eFwdEQBwd, Nektar::SolverUtils::eFwdEQNegBwd, Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, and Nektar::SolverUtils::EquationSystem::m_traceNormals.

Referenced by NumericalMaxwellFlux().

◆ AvgAbsInt()

NekDouble Nektar::SolverUtils::MMFSystem::AvgAbsInt ( const Array< OneD, const NekDouble > & inarray )

protected

Definition at line 2307 of file MMFSystem.cpp.

{
    int nq = m_fields[0]->GetNpoints();
    Array<OneD, NekDouble> Ones(nq, 1.0);
    Array<OneD, NekDouble> tmp(nq);
 
    if (inarray.size() != nq)
    {
        ASSERTL0(false, "AvgAbsInt Error: Vector size is not correct");
    }
 
    NekDouble jac = m_fields[0]->Integral(Ones);
 
    Vmath::Vabs(nq, inarray, 1, tmp, 1);
    return (m_fields[0]->Integral(tmp)) / jac;
}

References ASSERTL0, Nektar::SolverUtils::EquationSystem::m_fields, and Vmath::Vabs().

Referenced by CheckMovingFrames(), Nektar::MMFSWE::EvaluateWaterDepth(), and Nektar::MMFSWE::TestVorticityComputation().

◆ AvgInt()

NekDouble Nektar::SolverUtils::MMFSystem::AvgInt ( const Array< OneD, const NekDouble > & inarray )

protected

Definition at line 2292 of file MMFSystem.cpp.

{
    int nq = m_fields[0]->GetNpoints();
    Array<OneD, NekDouble> Ones(nq, 1.0);
 
    if (inarray.size() != nq)
    {
        ASSERTL0(false, "AvgInt Error: Vector size is not correct");
    }
 
    NekDouble jac = m_fields[0]->Integral(Ones);
 
    return (m_fields[0]->Integral(inarray)) / jac;
}

References ASSERTL0, and Nektar::SolverUtils::EquationSystem::m_fields.

Referenced by ComputeDivCurlMF(), and Nektar::MMFAdvection::v_InitObject().

◆ BubbleSort()

void Nektar::SolverUtils::MMFSystem::BubbleSort	(	Array< OneD, NekDouble > &	refarray,
		Array< OneD, NekDouble > &	sortarray
	)

protected

Definition at line 2368 of file MMFSystem.cpp.

{
    int nq = refarray.size();
 
    bool swapped = true;
    int j        = 0;
    NekDouble tmp;
 
    while (swapped)
    {
        swapped = false;
        j++;
        for (int i = 0; i < nq - j; i++)
        {
            if (refarray[i] > refarray[i + 1])
            {
                tmp             = refarray[i];
                refarray[i]     = refarray[i + 1];
                refarray[i + 1] = tmp;
 
                tmp              = sortarray[i];
                sortarray[i]     = sortarray[i + 1];
                sortarray[i + 1] = tmp;
 
                swapped = true;
            }
        }
    }
}

◆ CartesianToMovingframes()

Array< OneD, NekDouble > Nektar::SolverUtils::MMFSystem::CartesianToMovingframes	(	const Array< OneD, const Array< OneD, NekDouble > > &	uvec,
		unsigned int	field
	)

protected

Definition at line 771 of file MMFSystem.cpp.

{
    int nq = m_fields[0]->GetNpoints();
 
    Array<OneD, NekDouble> outarray(nq, 0.0);
 
    // new u0 = ( [u v] \cdot e^1 )/ |e^1|^2
    Vmath::Vmul(nq, &m_movingframes[field][0], 1, &uvec[0][0], 1, &outarray[0],
                1);
    Vmath::Vvtvp(nq, &m_movingframes[field][nq], 1, &uvec[1][0], 1,
                 &outarray[0], 1, &outarray[0], 1);
    Vmath::Vvtvp(nq, &m_movingframes[field][2 * nq], 1, &uvec[2][0], 1,
                 &outarray[0], 1, &outarray[0], 1);
 
    return outarray;
}

References FilterPython_Function::field, Nektar::SolverUtils::EquationSystem::m_fields, m_movingframes, Vmath::Vmul(), and Vmath::Vvtvp().

Referenced by Nektar::MMFSWE::IsolatedMountainFlow(), Nektar::MMFSWE::RossbyWave(), Nektar::MMFSWE::SteadyZonalFlow(), Nektar::MMFMaxwell::TestMaxwellSphere(), Nektar::MMFSWE::TestSWE2Dproblem(), Nektar::MMFSWE::TestVorticityComputation(), Nektar::MMFSWE::UnstableJetFlow(), and Nektar::MMFSWE::UnsteadyZonalFlow().

◆ CartesianToSpherical()

void Nektar::SolverUtils::MMFSystem::CartesianToSpherical	(	const NekDouble	x0j,
		const NekDouble	x1j,
		const NekDouble	x2j,
		NekDouble &	sin_varphi,
		NekDouble &	cos_varphi,
		NekDouble &	sin_theta,
		NekDouble &	cos_theta
	)

protected

Definition at line 792 of file MMFSystem.cpp.

{
    NekDouble radius;
    NekDouble radxy;
    NekDouble Tol = 0.0000001;
 
    NekDouble m_Xscale = 1.0;
    NekDouble m_Yscale = 1.0;
    NekDouble m_Zscale = 1.0;
 
    radius = sqrt(x0j * x0j / (m_Xscale * m_Xscale) +
                  x1j * x1j / (m_Yscale * m_Yscale) +
                  x2j * x2j / (m_Zscale * m_Zscale));
    radxy  = sqrt(x0j * x0j / (m_Xscale * m_Xscale) +
                  x1j * x1j / (m_Yscale * m_Yscale));
 
    if (radxy > Tol)
    {
        sin_varphi = x1j / (radxy * m_Yscale);
        cos_varphi = x0j / (radxy * m_Xscale);
    }
 
    else
    {
        sin_varphi = 0.0;
        if (x2j > 0)
        {
            cos_varphi = 1.0;
        }
 
        else
        {
            cos_varphi = -1.0;
        }
    }
 
    sin_theta = x2j / (radius * m_Zscale);
    cos_theta = radxy / radius;
}

References tinysimd::sqrt().

Referenced by Nektar::MMFAdvection::EvaluateAdvectionVelocity(), Nektar::MMFMaxwell::EvaluateCoriolis(), Nektar::MMFSWE::EvaluateCoriolisForZonalFlow(), Nektar::MMFSWE::EvaluateStandardCoriolis(), Nektar::MMFSWE::EvaluateWaterDepth(), Nektar::MMFSWE::IsolatedMountainFlow(), Nektar::MMFSWE::RossbyWave(), Nektar::MMFSWE::SteadyZonalFlow(), Nektar::MMFMaxwell::TestMaxwellSphere(), Nektar::MMFSWE::TestVorticityComputation(), Nektar::MMFSWE::UnstableJetFlow(), and Nektar::MMFSWE::UnsteadyZonalFlow().

◆ CheckMovingFrames()

void Nektar::SolverUtils::MMFSystem::CheckMovingFrames ( const Array< OneD, const Array< OneD, NekDouble > > & movingframes )

protected

Definition at line 230 of file MMFSystem.cpp.

{
    NekDouble t1x, t1y, t1z, t2x, t2y, t2z, t3x, t3y, t3z;
    NekDouble dot12 = 0.0, dot23 = 0.0, dot31 = 0.0;
    NekDouble Tol = 0.0001;
 
    int nq = m_fields[0]->GetNpoints();
 
    for (int i = 0; i < nq; ++i)
    {
        t1x = movingframes[0][i];
        t1y = movingframes[0][i + nq];
        t1z = movingframes[0][i + 2 * nq];
 
        t2x = movingframes[1][i];
        t2y = movingframes[1][i + nq];
        t2z = movingframes[1][i + 2 * nq];
 
        t3x = movingframes[2][i];
        t3y = movingframes[2][i + nq];
        t3z = movingframes[2][i + 2 * nq];
 
        dot12 = t1x * t2x + t1y * t2y + t1z * t2z;
        dot23 = t2x * t3x + t2y * t3y + t2z * t3z;
        dot31 = t3x * t1x + t3y * t1y + t3z * t1z;
    }
 
    std::cout << "======================================================"
              << std::endl;
    std::cout << "======================================================"
              << std::endl;
    std::cout << "*** The first moving frame is alinged along"
              << SpatialDomains::GeomMMFMap[m_MMFdir] << std::endl;
 
    Array<OneD, NekDouble> tmpx(nq), tmpy(nq), tmpz(nq);
 
    Vmath::Vcopy(nq, &movingframes[0][0], 1, &tmpx[0], 1);
    Vmath::Vcopy(nq, &movingframes[0][nq], 1, &tmpy[0], 1);
    Vmath::Vcopy(nq, &movingframes[0][2 * nq], 1, &tmpz[0], 1);
    std::cout << nq << " , "
              << "*** Avg MF1 = ( " << AvgAbsInt(tmpx) << " , "
              << AvgAbsInt(tmpy) << " , " << AvgAbsInt(tmpz) << " ) "
              << std::endl;
 
    Vmath::Vcopy(nq, &movingframes[1][0], 1, &tmpx[0], 1);
    Vmath::Vcopy(nq, &movingframes[1][nq], 1, &tmpy[0], 1);
    Vmath::Vcopy(nq, &movingframes[1][2 * nq], 1, &tmpz[0], 1);
    std::cout << "*** Avg MF2 = ( " << AvgAbsInt(tmpx) << " , "
              << AvgAbsInt(tmpy) << " , " << AvgAbsInt(tmpz) << " ) "
              << std::endl;
 
    if (m_shapedim == 3)
    {
        Vmath::Vcopy(nq, &movingframes[2][0], 1, &tmpx[0], 1);
        Vmath::Vcopy(nq, &movingframes[2][nq], 1, &tmpy[0], 1);
        Vmath::Vcopy(nq, &movingframes[2][2 * nq], 1, &tmpz[0], 1);
        std::cout << "*** Avg MF3 = ( " << AvgAbsInt(tmpx) << " , "
                  << AvgAbsInt(tmpy) << " , " << AvgAbsInt(tmpz) << " ) "
                  << std::endl;
    }
 
    if ((fabs(dot12) + fabs(dot23) + fabs(dot31)) < Tol)
    {
        std::cout << "*** Moving frames are Orthogonal" << std::endl;
    }
 
    else
    {
        std::cout << "*** Moving frames are NOT Orthogonal" << std::endl;
    }
 
    Array<OneD, NekDouble> tmp;
    for (int j = 0; j < m_shapedim; ++j)
    {
        tmp = Array<OneD, NekDouble>(nq, 0.0);
        for (int k = 0; k < m_spacedim; ++k)
        {
            Vmath::Vvtvp(nq, &movingframes[j][k * nq], 1,
                         &movingframes[j][k * nq], 1, &tmp[0], 1, &tmp[0], 1);
        }
        Vmath::Vsqrt(nq, tmp, 1, tmp, 1);
        std::cout << "*** Avg. Magnitude of MF" << j << " = " << AvgAbsInt(tmp)
                  << std::endl;
    }
}

References AvgAbsInt(), Nektar::SpatialDomains::GeomMMFMap, Nektar::SolverUtils::EquationSystem::m_fields, m_MMFdir, m_shapedim, Nektar::SolverUtils::EquationSystem::m_spacedim, Vmath::Vcopy(), Vmath::Vsqrt(), and Vmath::Vvtvp().

Referenced by SetUpMovingFrames().

◆ ComputeCurl()

void Nektar::SolverUtils::MMFSystem::ComputeCurl	(	const Array< OneD, const Array< OneD, NekDouble > > &	inarray,
		Array< OneD, Array< OneD, NekDouble > > &	outarray
	)

protected

Definition at line 731 of file MMFSystem.cpp.

{
    int nq = inarray[0].size();
 
    Array<OneD, NekDouble> tmpx, tmpy, tmpz;
    Array<OneD, NekDouble> Dtmpzdx, Dtmpydx, Dtmpxdy, Dtmpzdy, Dtmpxdz, Dtmpydz;
 
    tmpx = Array<OneD, NekDouble>(nq);
    tmpy = Array<OneD, NekDouble>(nq);
    tmpz = Array<OneD, NekDouble>(nq);
 
    Dtmpzdx = Array<OneD, NekDouble>(nq);
    Dtmpydx = Array<OneD, NekDouble>(nq);
    Dtmpxdy = Array<OneD, NekDouble>(nq);
    Dtmpzdy = Array<OneD, NekDouble>(nq);
    Dtmpxdz = Array<OneD, NekDouble>(nq);
    Dtmpydz = Array<OneD, NekDouble>(nq);
 
    for (int k = 0; k < m_spacedim; ++k)
    {
        Vmath::Vcopy(nq, &inarray[0][0], 1, &tmpx[0], 1);
        Vmath::Vcopy(nq, &inarray[1][0], 1, &tmpy[0], 1);
        Vmath::Vcopy(nq, &inarray[2][0], 1, &tmpz[0], 1);
 
        m_fields[0]->PhysDeriv(0, tmpz, Dtmpzdx);
        m_fields[0]->PhysDeriv(0, tmpy, Dtmpydx);
        m_fields[0]->PhysDeriv(1, tmpx, Dtmpxdy);
        m_fields[0]->PhysDeriv(1, tmpz, Dtmpzdy);
        m_fields[0]->PhysDeriv(2, tmpx, Dtmpxdz);
        m_fields[0]->PhysDeriv(2, tmpy, Dtmpydz);
 
        Vmath::Vsub(nq, &Dtmpzdy[0], 1, &Dtmpydz[0], 1, &outarray[0][0], 1);
        Vmath::Vsub(nq, &Dtmpxdz[0], 1, &Dtmpzdx[0], 1, &outarray[1][0], 1);
        Vmath::Vsub(nq, &Dtmpydx[0], 1, &Dtmpxdy[0], 1, &outarray[2][0], 1);
    }
}

References Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_spacedim, Vmath::Vcopy(), and Vmath::Vsub().

Referenced by ComputeDivCurlMF().

◆ Computedemdxicdote()

void Nektar::SolverUtils::MMFSystem::Computedemdxicdote ( )

protected

Definition at line 1274 of file MMFSystem.cpp.

{
    int MFdim = 3;
    int nq    = GetTotPoints();
 
    // Initialization
    m_dedxi_cdot_e =
        Array<OneD, Array<OneD, Array<OneD, Array<OneD, NekDouble>>>>(MFdim);
    for (int indm = 0; indm < MFdim; ++indm)
    {
        m_dedxi_cdot_e[indm] =
            Array<OneD, Array<OneD, Array<OneD, NekDouble>>>(MFdim);
        for (int indj = 0; indj < MFdim; ++indj)
        {
            m_dedxi_cdot_e[indm][indj] =
                Array<OneD, Array<OneD, NekDouble>>(MFdim);
            for (int indn = 0; indn < MFdim; ++indn)
            {
                m_dedxi_cdot_e[indm][indj][indn] =
                    Array<OneD, NekDouble>(nq, 0.0);
            }
        }
    }
 
    Array<OneD, NekDouble> tmp(nq);
    Array<OneD, NekDouble> tmpderiv(nq);
    Array<OneD, NekDouble> dedt;
    for (int indm = 0; indm < MFdim; ++indm)
    {
        for (int indj = 0; indj < MFdim; ++indj)
        {
            for (int indn = 0; indn < MFdim; ++indn)
            {
                dedt = Array<OneD, NekDouble>(nq, 0.0);
                for (int k = 0; k < m_spacedim; ++k)
                {
                    // Compute d e^m / d \xi_j cdot e^n
                    Vmath::Vcopy(nq, &m_movingframes[indm][k * nq], 1, &tmp[0],
                                 1);
                    m_fields[0]->PhysDirectionalDeriv(m_movingframes[indj], tmp,
                                                      tmpderiv);
 
                    Vmath::Vvtvp(nq, &tmpderiv[0], 1,
                                 &m_movingframes[indn][k * nq], 1, &dedt[0], 1,
                                 &dedt[0], 1);
                }
 
                Vmath::Vcopy(nq, &dedt[0], 1,
                             &m_dedxi_cdot_e[indm][indj][indn][0], 1);
            }
        }
    }
 
    int indx = 0;
    std::cout << "*** m_dedxi_cdot_e[0]/dxi1 = ( "
              << RootMeanSquare(m_dedxi_cdot_e[indx][0][0]) << " , "
              << RootMeanSquare(m_dedxi_cdot_e[indx][0][1]) << " , "
              << RootMeanSquare(m_dedxi_cdot_e[indx][0][2]) << " )_1, "
              << std::endl;
    std::cout << "*** m_dedxi_cdot_e[0]/dxi2 = ( "
              << RootMeanSquare(m_dedxi_cdot_e[indx][1][0]) << " , "
              << RootMeanSquare(m_dedxi_cdot_e[indx][1][1]) << " , "
              << RootMeanSquare(m_dedxi_cdot_e[indx][1][2]) << " )_2 "
              << std::endl;
 
    indx = 1;
    std::cout << "*** m_dedxi_cdot_e[1]/dxi1 = ( "
              << RootMeanSquare(m_dedxi_cdot_e[indx][0][0]) << " , "
              << RootMeanSquare(m_dedxi_cdot_e[indx][0][1]) << " , "
              << RootMeanSquare(m_dedxi_cdot_e[indx][0][2]) << " )_1, "
              << std::endl;
    std::cout << "*** m_dedxi_cdot_e[1]/dxi2 = ( "
              << RootMeanSquare(m_dedxi_cdot_e[indx][1][0]) << " , "
              << RootMeanSquare(m_dedxi_cdot_e[indx][1][1]) << " , "
              << RootMeanSquare(m_dedxi_cdot_e[indx][1][2]) << " )_2 "
              << std::endl;
 
    indx = 2;
    std::cout << "*** m_dedxi_cdot_e[2]/dxi1 = ( "
              << RootMeanSquare(m_dedxi_cdot_e[indx][0][0]) << " , "
              << RootMeanSquare(m_dedxi_cdot_e[indx][0][1]) << " , "
              << RootMeanSquare(m_dedxi_cdot_e[indx][0][2]) << " )_1, "
              << std::endl;
    std::cout << "*** m_dedxi_cdot_e[2]/dxi2 = ( "
              << RootMeanSquare(m_dedxi_cdot_e[indx][1][0]) << " , "
              << RootMeanSquare(m_dedxi_cdot_e[indx][1][1]) << " , "
              << RootMeanSquare(m_dedxi_cdot_e[indx][1][2]) << " )_2 "
              << std::endl;
}

References Nektar::SolverUtils::EquationSystem::GetTotPoints(), m_dedxi_cdot_e, Nektar::SolverUtils::EquationSystem::m_fields, m_movingframes, Nektar::SolverUtils::EquationSystem::m_spacedim, RootMeanSquare(), Vmath::Vcopy(), and Vmath::Vvtvp().

Referenced by Nektar::MMFMaxwell::v_InitObject().

◆ ComputeDivCurlMF()

void Nektar::SolverUtils::MMFSystem::ComputeDivCurlMF ( )

protected

Definition at line 442 of file MMFSystem.cpp.

{
    int nq     = m_fields[0]->GetNpoints();
    int MMFdim = 3;
 
    Array<OneD, NekDouble> tmp(nq);
    Array<OneD, NekDouble> Dtmp(nq);
 
    m_DivMF = Array<OneD, Array<OneD, NekDouble>>(MMFdim);
    for (int j = 0; j < MMFdim; ++j)
    {
        m_DivMF[j] = Array<OneD, NekDouble>(nq, 0.0);
        for (int k = 0; k < m_spacedim; ++k)
        {
            Vmath::Vcopy(nq, &m_movingframes[j][k * nq], 1, &tmp[0], 1);
 
            m_fields[0]->PhysDeriv(k, tmp, Dtmp);
            Vmath::Vadd(nq, &Dtmp[0], 1, &m_DivMF[j][0], 1, &m_DivMF[j][0], 1);
        }
    }
 
    std::cout << "*** Divergence of MF1 = " << AvgInt(m_DivMF[0])
              << ", MF2 = " << AvgInt(m_DivMF[1])
              << ", MF3 = " << AvgInt(m_DivMF[2]) << std::endl;
 
    // Compute Curl of MF: CurlMF[i][j] = (\nabla \times e^i) cdot e^j
    m_CurlMF = Array<OneD, Array<OneD, Array<OneD, NekDouble>>>(MMFdim);
    for (int i = 0; i < MMFdim; ++i)
    {
        m_CurlMF[i] = Array<OneD, Array<OneD, NekDouble>>(MMFdim);
 
        for (int j = 0; j < MMFdim; ++j)
        {
            m_CurlMF[i][j] = Array<OneD, NekDouble>(nq, 0.0);
        }
    }
 
    Array<OneD, Array<OneD, NekDouble>> MFtmp(m_spacedim);
    Array<OneD, Array<OneD, NekDouble>> CurlMFtmp(m_spacedim);
 
    for (int i = 0; i < m_spacedim; ++i)
    {
        MFtmp[i]     = Array<OneD, NekDouble>(nq);
        CurlMFtmp[i] = Array<OneD, NekDouble>(nq);
    }
 
    for (int dir = 0; dir < MMFdim; dir++)
    {
        for (int i = 0; i < m_spacedim; ++i)
        {
            Vmath::Vcopy(nq, &m_movingframes[dir][i * nq], 1, &MFtmp[i][0], 1);
        }
 
        ComputeCurl(MFtmp, CurlMFtmp);
 
        for (int j = 0; j < MMFdim; ++j)
        {
            for (int i = 0; i < m_spacedim; ++i)
            {
                Vmath::Vvtvp(nq, &m_movingframes[j][i * nq], 1,
                             &CurlMFtmp[i][0], 1, &m_CurlMF[dir][j][0], 1,
                             &m_CurlMF[dir][j][0], 1);
            }
        }
    }
 
    std::cout << "*** Curl of MF1 = ( " << AvgInt(m_CurlMF[0][0]) << " , "
              << AvgInt(m_CurlMF[0][1]) << " , " << AvgInt(m_CurlMF[0][2])
              << " ) " << std::endl;
    std::cout << "*** Curl of MF2 = ( " << AvgInt(m_CurlMF[1][0]) << " , "
              << AvgInt(m_CurlMF[1][1]) << " , " << AvgInt(m_CurlMF[1][2])
              << " ) " << std::endl;
    std::cout << "*** Curl of MF3 = ( " << AvgInt(m_CurlMF[2][0]) << " , "
              << AvgInt(m_CurlMF[2][1]) << " , " << AvgInt(m_CurlMF[2][2])
              << " ) " << std::endl;
}

References AvgInt(), ComputeCurl(), m_CurlMF, m_DivMF, Nektar::SolverUtils::EquationSystem::m_fields, m_movingframes, Nektar::SolverUtils::EquationSystem::m_spacedim, Vmath::Vadd(), Vmath::Vcopy(), and Vmath::Vvtvp().

Referenced by MMFInitObject().

◆ ComputeMFtrace()

void Nektar::SolverUtils::MMFSystem::ComputeMFtrace ( )

protected

Definition at line 519 of file MMFSystem.cpp.

{
    int MFdim = 3;
 
    int nq              = m_fields[0]->GetNpoints();
    int nTraceNumPoints = GetTraceTotPoints();
 
    Array<OneD, NekDouble> tmp(nq);
    Array<OneD, NekDouble> Fwdtmp(nq);
    Array<OneD, NekDouble> Bwdtmp(nq);
 
    m_MFtraceFwd = Array<OneD, Array<OneD, Array<OneD, NekDouble>>>(MFdim);
    m_MFtraceBwd = Array<OneD, Array<OneD, Array<OneD, NekDouble>>>(MFdim);
 
    for (int j = 0; j < MFdim; ++j)
    {
        m_MFtraceFwd[j] = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
        m_MFtraceBwd[j] = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
    }
 
    // m_MFtraceFwd[0] = e^1_{Fwd}, m_MFtraceFwd[1] = e^2_{Fwd}
    for (int j = 0; j < MFdim; ++j)
    {
        for (int i = 0; i < m_spacedim; ++i)
        {
            m_MFtraceFwd[j][i] = Array<OneD, NekDouble>(nTraceNumPoints);
            m_MFtraceBwd[j][i] = Array<OneD, NekDouble>(nTraceNumPoints);
 
            Vmath::Vcopy(nq, &m_movingframes[j][i * nq], 1, &tmp[0], 1);
 
            m_fields[0]->GetFwdBwdTracePhys(tmp, Fwdtmp, Bwdtmp);
 
            CopyBoundaryTrace(Fwdtmp, Bwdtmp, eFwdEQBwd);
 
            Vmath::Vcopy(nTraceNumPoints, &Fwdtmp[0], 1, &m_MFtraceFwd[j][i][0],
                         1);
            Vmath::Vcopy(nTraceNumPoints, &Bwdtmp[0], 1, &m_MFtraceBwd[j][i][0],
                         1);
        }
    }
 
    std::cout << "*** MFtraceFwd = ( " << VectorAvgMagnitude(m_MFtraceFwd[0])
              << " , " << VectorAvgMagnitude(m_MFtraceFwd[1]) << " , "
              << VectorAvgMagnitude(m_MFtraceFwd[2]) << " ) " << std::endl;
    std::cout << "*** MFtraceBwd = ( " << VectorAvgMagnitude(m_MFtraceBwd[0])
              << " , " << VectorAvgMagnitude(m_MFtraceBwd[1]) << " , "
              << VectorAvgMagnitude(m_MFtraceBwd[2]) << " ) " << std::endl;
}

References CopyBoundaryTrace(), Nektar::SolverUtils::eFwdEQBwd, Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, m_MFtraceBwd, m_MFtraceFwd, m_movingframes, Nektar::SolverUtils::EquationSystem::m_spacedim, Vmath::Vcopy(), and VectorAvgMagnitude().

Referenced by MMFInitObject().

◆ ComputencdotMF()

void Nektar::SolverUtils::MMFSystem::ComputencdotMF ( )

protected

Definition at line 317 of file MMFSystem.cpp.

{
    int nq              = m_fields[0]->GetNpoints();
    int nTracePointsTot = GetTraceNpoints();
 
    // Compute MFjFwd and MFjBwd
    Array<OneD, NekDouble> tmp(nq);
 
    Array<OneD, Array<OneD, Array<OneD, NekDouble>>> MFtraceFwd(m_shapedim);
    Array<OneD, Array<OneD, Array<OneD, NekDouble>>> MFtraceBwd(m_shapedim);
    Array<OneD, Array<OneD, NekDouble>> SurfaceNormalFwd;
    Array<OneD, Array<OneD, NekDouble>> SurfaceNormalBwd;
 
    for (int j = 0; j < m_shapedim; ++j)
    {
        MFtraceFwd[j] = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
        MFtraceBwd[j] = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
 
        SurfaceNormalFwd = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
        SurfaceNormalBwd = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
 
        for (int k = 0; k < m_spacedim; ++k)
        {
            MFtraceFwd[j][k] = Array<OneD, NekDouble>(nTracePointsTot);
            MFtraceBwd[j][k] = Array<OneD, NekDouble>(nTracePointsTot);
 
            SurfaceNormalFwd[k] = Array<OneD, NekDouble>(nTracePointsTot);
            SurfaceNormalBwd[k] = Array<OneD, NekDouble>(nTracePointsTot);
 
            Vmath::Vcopy(nq, &m_movingframes[j][k * nq], 1, &tmp[0], 1);
 
            m_fields[0]->GetFwdBwdTracePhys(tmp, MFtraceFwd[j][k],
                                            MFtraceBwd[j][k]);
 
            CopyBoundaryTrace(MFtraceFwd[j][k], MFtraceBwd[j][k], eFwdEQBwd);
        }
    }
 
    VectorCrossProd(MFtraceFwd[0], MFtraceFwd[1], SurfaceNormalFwd);
    VectorCrossProd(MFtraceBwd[0], MFtraceBwd[1], SurfaceNormalBwd);
 
    // Compute n \times e^i
    m_ncdotMFFwd = Array<OneD, Array<OneD, NekDouble>>(m_shapedim);
    m_ncdotMFBwd = Array<OneD, Array<OneD, NekDouble>>(m_shapedim);
    for (int j = 0; j < m_shapedim; ++j)
    {
        m_ncdotMFFwd[j] = Array<OneD, NekDouble>(nTracePointsTot, 0.0);
        m_ncdotMFBwd[j] = Array<OneD, NekDouble>(nTracePointsTot, 0.0);
 
        VectorDotProd(m_traceNormals, MFtraceFwd[j], m_ncdotMFFwd[j]);
        VectorDotProd(m_traceNormals, MFtraceBwd[j], m_ncdotMFBwd[j]);
    }
 
    // Compute n^{\perp} \times e^i
    Array<OneD, Array<OneD, NekDouble>> SurfaceNormal(m_spacedim);
    Array<OneD, Array<OneD, NekDouble>> Tracevector(m_spacedim);
    for (int k = 0; k < m_spacedim; k++)
    {
        SurfaceNormal[k] = Array<OneD, NekDouble>(nTracePointsTot);
        Tracevector[k]   = Array<OneD, NekDouble>(nTracePointsTot);
 
        Vmath::Vcopy(nTracePointsTot, &m_MFtraceFwd[2][k][0], 1,
                     &SurfaceNormal[k][0], 1);
    }
 
    VectorCrossProd(m_traceNormals, SurfaceNormal, Tracevector);
 
    m_nperpcdotMFFwd = Array<OneD, Array<OneD, NekDouble>>(m_shapedim);
    m_nperpcdotMFBwd = Array<OneD, Array<OneD, NekDouble>>(m_shapedim);
    for (int j = 0; j < m_shapedim; ++j)
    {
        m_nperpcdotMFFwd[j] = Array<OneD, NekDouble>(nTracePointsTot, 0.0);
        m_nperpcdotMFBwd[j] = Array<OneD, NekDouble>(nTracePointsTot, 0.0);
 
        VectorDotProd(Tracevector, MFtraceFwd[j], m_nperpcdotMFFwd[j]);
        VectorDotProd(Tracevector, MFtraceBwd[j], m_nperpcdotMFBwd[j]);
    }
 
    if (m_shapedim == 2)
    {
        std::cout << "*** m_ncdotMFFwd = ( " << RootMeanSquare(m_ncdotMFFwd[0])
                  << " , " << RootMeanSquare(m_ncdotMFFwd[1]) << " ) "
                  << std::endl;
        std::cout << "*** m_ncdotMFBwd = ( " << RootMeanSquare(m_ncdotMFBwd[0])
                  << " , " << RootMeanSquare(m_ncdotMFBwd[1]) << " ) "
                  << std::endl;
 
        std::cout << "*** m_nperpcdotMFFwd = ( "
                  << RootMeanSquare(m_nperpcdotMFFwd[0]) << " , "
                  << RootMeanSquare(m_nperpcdotMFFwd[1]) << " ) " << std::endl;
        std::cout << "*** m_nperpcdotMFBwd = ( "
                  << RootMeanSquare(m_nperpcdotMFBwd[0]) << " , "
                  << RootMeanSquare(m_nperpcdotMFBwd[1]) << " ) " << std::endl;
    }
 
    else if (m_shapedim == 3)
    {
        std::cout << "*** m_ncdotMFFwd = ( "
                  << Vmath::Vsum(nTracePointsTot, m_ncdotMFFwd[0], 1) << " , "
                  << Vmath::Vsum(nTracePointsTot, m_ncdotMFFwd[1], 1) << " , "
                  << Vmath::Vsum(nTracePointsTot, m_ncdotMFFwd[2], 1) << " ) "
                  << std::endl;
        std::cout << "*** m_ncdotMFBwd = ( "
                  << Vmath::Vsum(nTracePointsTot, m_ncdotMFBwd[0], 1) << " , "
                  << Vmath::Vsum(nTracePointsTot, m_ncdotMFBwd[1], 1) << " , "
                  << Vmath::Vsum(nTracePointsTot, m_ncdotMFBwd[2], 1) << " ) "
                  << std::endl;
 
        std::cout << "*** m_nperpcdotMFFwd = ( "
                  << Vmath::Vsum(nTracePointsTot, m_nperpcdotMFFwd[0], 1)
                  << " , "
                  << Vmath::Vsum(nTracePointsTot, m_nperpcdotMFFwd[1], 1)
                  << " , "
                  << Vmath::Vsum(nTracePointsTot, m_nperpcdotMFFwd[2], 1)
                  << " ) " << std::endl;
        std::cout << "*** m_nperpcdotMFBwd = ( "
                  << Vmath::Vsum(nTracePointsTot, m_nperpcdotMFBwd[0], 1)
                  << " , "
                  << Vmath::Vsum(nTracePointsTot, m_nperpcdotMFBwd[1], 1)
                  << " , "
                  << Vmath::Vsum(nTracePointsTot, m_nperpcdotMFBwd[2], 1)
                  << " ) " << std::endl;
    }
}

References CopyBoundaryTrace(), Nektar::SolverUtils::eFwdEQBwd, Nektar::SolverUtils::EquationSystem::GetTraceNpoints(), Nektar::SolverUtils::EquationSystem::m_fields, m_MFtraceFwd, m_movingframes, m_ncdotMFBwd, m_ncdotMFFwd, m_nperpcdotMFBwd, m_nperpcdotMFFwd, m_shapedim, Nektar::SolverUtils::EquationSystem::m_spacedim, Nektar::SolverUtils::EquationSystem::m_traceNormals, RootMeanSquare(), Vmath::Vcopy(), VectorCrossProd(), VectorDotProd(), and Vmath::Vsum().

Referenced by MMFInitObject(), and Nektar::MMFAdvection::v_InitObject().

◆ ComputeNtimesF12()

void Nektar::SolverUtils::MMFSystem::ComputeNtimesF12	(	const Array< OneD, Array< OneD, NekDouble > > &	Fwd,
		const Array< OneD, Array< OneD, NekDouble > > &	Bwd,
		const Array< OneD, const NekDouble > &	im1Fwd,
		const Array< OneD, const NekDouble > &	im1Bwd,
		const Array< OneD, const NekDouble > &	im2Fwd,
		const Array< OneD, const NekDouble > &	im2Bwd,
		Array< OneD, NekDouble > &	outarrayFwd,
		Array< OneD, NekDouble > &	outarrayBwd
	)

protected

Definition at line 945 of file MMFSystem.cpp.

{
    int nTraceNumPoints = GetTraceTotPoints();
 
    NekDouble tmpFwd, tmpBwd, Aver1, Aver2, HFwdk, HBwdk;
 
    Array<OneD, NekDouble> z1HAver(m_spacedim);
    Array<OneD, NekDouble> z2HAver(m_spacedim);
    Array<OneD, NekDouble> n1e1(m_spacedim);
    Array<OneD, NekDouble> n2e2(m_spacedim);
 
    Array<OneD, NekDouble> n1e1_times_z1HAver(m_spacedim);
    Array<OneD, NekDouble> n2e2_times_z2HAver(m_spacedim);
 
    for (int i = 0; i < nTraceNumPoints; ++i)
    {
        Aver1 = 0.5 * (im1Fwd[i] + im1Bwd[i]);
        Aver2 = 0.5 * (im2Fwd[i] + im2Bwd[i]);
 
        for (int k = 0; k < m_spacedim; k++)
        {
            // Compute \vec{HFwd} and \vec{HBwd}
            HFwdk = Fwd[0][i] * m_MFtraceFwd[0][k][i] +
                    Fwd[1][i] * m_MFtraceFwd[1][k][i];
            HBwdk = Bwd[0][i] * m_MFtraceBwd[0][k][i] +
                    Bwd[1][i] * m_MFtraceBwd[1][k][i];
 
            // Compute z_i {{ \vec{H} }}
            z1HAver[k] = 0.5 * (im1Fwd[i] * HFwdk + im1Bwd[i] * HBwdk);
            z2HAver[k] = 0.5 * (im2Fwd[i] * HFwdk + im2Bwd[i] * HBwdk);
 
            // Choose e^i for the one in anisotropy region
            n1e1[k] = m_ncdotMFFwd[0][i] * m_MFtraceFwd[0][k][i];
            n2e2[k] = m_ncdotMFFwd[1][i] * m_MFtraceFwd[1][k][i];
        }
 
        // Compute n1e1 \times z1HAver and n2e2 \times z2HAver
        VectorCrossProd(n1e1, z1HAver, n1e1_times_z1HAver);
        VectorCrossProd(n2e2, z2HAver, n2e2_times_z2HAver);
 
        // e^3 \cdot ( n1e1 \times z1HAver + n2e2 \times z2HAver)
        tmpFwd = 0.0;
        tmpBwd = 0.0;
        for (int k = 0; k < m_spacedim; k++)
        {
            tmpFwd += m_MFtraceFwd[2][k][i] * (n1e1_times_z1HAver[k] / Aver1 +
                                               n2e2_times_z2HAver[k] / Aver2);
            tmpBwd += m_MFtraceBwd[2][k][i] * (n1e1_times_z1HAver[k] / Aver1 +
                                               n2e2_times_z2HAver[k] / Aver2);
        }
 
        outarrayFwd[i] = tmpFwd;
        outarrayBwd[i] = tmpBwd;
    }
}

References Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), m_MFtraceBwd, m_MFtraceFwd, m_ncdotMFFwd, Nektar::SolverUtils::EquationSystem::m_spacedim, and VectorCrossProd().

Referenced by NumericalMaxwellFluxTE(), and NumericalMaxwellFluxTM().

◆ ComputeNtimesFz()

void Nektar::SolverUtils::MMFSystem::ComputeNtimesFz	(	const int	dir,
		const Array< OneD, Array< OneD, NekDouble > > &	Fwd,
		const Array< OneD, Array< OneD, NekDouble > > &	Bwd,
		const Array< OneD, const NekDouble > &	imFwd,
		const Array< OneD, const NekDouble > &	imBwd,
		Array< OneD, NekDouble > &	outarrayFwd,
		Array< OneD, NekDouble > &	outarrayBwd
	)

protected

Definition at line 909 of file MMFSystem.cpp.

{
    int nTraceNumPoints = GetTraceTotPoints();
 
    NekDouble tmpFwd, tmpBwd;
    NekDouble Aver, ntimesz;
 
    for (int i = 0; i < nTraceNumPoints; ++i)
    {
        Aver = 0.5 * (imFwd[i] + imBwd[i]);
 
        tmpFwd = 0.0;
        tmpBwd = 0.0;
        for (int k = 0; k < m_spacedim; ++k)
        {
            ntimesz = 0.5 * (imFwd[i] * Fwd[2][i] + imBwd[i] * Bwd[2][i]);
 
            tmpFwd +=
                m_MFtraceFwd[dir][k][i] * m_ntimesMFFwd[2][k][i] * ntimesz;
            tmpBwd +=
                m_MFtraceBwd[dir][k][i] * m_ntimesMFBwd[2][k][i] * ntimesz;
        }
 
        outarrayFwd[i] = tmpFwd / Aver;
        outarrayBwd[i] = tmpBwd / Aver;
    }
}

References Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), m_MFtraceBwd, m_MFtraceFwd, m_ntimesMFBwd, m_ntimesMFFwd, and Nektar::SolverUtils::EquationSystem::m_spacedim.

Referenced by NumericalMaxwellFluxTE(), and NumericalMaxwellFluxTM().

◆ ComputeNtimesMF()

void Nektar::SolverUtils::MMFSystem::ComputeNtimesMF ( )

protected

Definition at line 615 of file MMFSystem.cpp.

{
    int MFdim           = 3;
    int nTracePointsTot = GetTraceNpoints();
 
    m_ntimesMFFwd = Array<OneD, Array<OneD, Array<OneD, NekDouble>>>(MFdim);
    m_ntimesMFBwd = Array<OneD, Array<OneD, Array<OneD, NekDouble>>>(MFdim);
    m_ntimes_ntimesMFFwd =
        Array<OneD, Array<OneD, Array<OneD, NekDouble>>>(MFdim);
    m_ntimes_ntimesMFBwd =
        Array<OneD, Array<OneD, Array<OneD, NekDouble>>>(MFdim);
    for (int j = 0; j < MFdim; ++j)
    {
        m_ntimesMFFwd[j] = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
        m_ntimesMFBwd[j] = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
        m_ntimes_ntimesMFFwd[j] =
            Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
        m_ntimes_ntimesMFBwd[j] =
            Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
 
        for (int k = 0; k < m_spacedim; ++k)
        {
            m_ntimesMFFwd[j][k] = Array<OneD, NekDouble>(nTracePointsTot);
            m_ntimesMFBwd[j][k] = Array<OneD, NekDouble>(nTracePointsTot);
            m_ntimes_ntimesMFFwd[j][k] =
                Array<OneD, NekDouble>(nTracePointsTot);
            m_ntimes_ntimesMFBwd[j][k] =
                Array<OneD, NekDouble>(nTracePointsTot);
        }
 
        VectorCrossProd(m_traceNormals, m_MFtraceFwd[j], m_ntimesMFFwd[j]);
        VectorCrossProd(m_traceNormals, m_MFtraceBwd[j], m_ntimesMFBwd[j]);
        VectorCrossProd(m_traceNormals, m_ntimesMFFwd[j],
                        m_ntimes_ntimesMFFwd[j]);
        VectorCrossProd(m_traceNormals, m_ntimesMFBwd[j],
                        m_ntimes_ntimesMFBwd[j]);
    }
 
    std::cout << "*** m_ntimesMFFwd = ( "
              << VectorAvgMagnitude(m_ntimesMFFwd[0]) << " , "
              << VectorAvgMagnitude(m_ntimesMFFwd[1]) << " , "
              << VectorAvgMagnitude(m_ntimesMFFwd[2]) << " ) " << std::endl;
    std::cout << "*** m_ntimesMFBwd = ( "
              << VectorAvgMagnitude(m_ntimesMFBwd[0]) << " , "
              << VectorAvgMagnitude(m_ntimesMFBwd[1]) << " , "
              << VectorAvgMagnitude(m_ntimesMFBwd[2]) << " ) " << std::endl;
    std::cout << "*** m_ntimes_ntimesMFFwd = ( "
              << VectorAvgMagnitude(m_ntimes_ntimesMFFwd[0]) << " , "
              << VectorAvgMagnitude(m_ntimes_ntimesMFFwd[1]) << " , "
              << VectorAvgMagnitude(m_ntimes_ntimesMFFwd[2]) << " ) "
              << std::endl;
    std::cout << "*** m_ntimes_ntimesMFBwd = ( "
              << VectorAvgMagnitude(m_ntimes_ntimesMFBwd[0]) << " , "
              << VectorAvgMagnitude(m_ntimes_ntimesMFBwd[1]) << " , "
              << VectorAvgMagnitude(m_ntimes_ntimesMFBwd[2]) << " ) "
              << std::endl;
}

References Nektar::SolverUtils::EquationSystem::GetTraceNpoints(), m_MFtraceBwd, m_MFtraceFwd, m_ntimes_ntimesMFBwd, m_ntimes_ntimesMFFwd, m_ntimesMFBwd, m_ntimesMFFwd, Nektar::SolverUtils::EquationSystem::m_spacedim, Nektar::SolverUtils::EquationSystem::m_traceNormals, VectorAvgMagnitude(), and VectorCrossProd().

Referenced by Nektar::MMFMaxwell::v_InitObject().

◆ ComputeNtimestimesdF12()

void Nektar::SolverUtils::MMFSystem::ComputeNtimestimesdF12	(	const Array< OneD, Array< OneD, NekDouble > > &	Fwd,
		const Array< OneD, Array< OneD, NekDouble > > &	Bwd,
		const Array< OneD, const NekDouble > &	im1Fwd,
		const Array< OneD, const NekDouble > &	im1Bwd,
		const Array< OneD, const NekDouble > &	im2Fwd,
		const Array< OneD, const NekDouble > &	im2Bwd,
		Array< OneD, NekDouble > &	outarrayFwd,
		Array< OneD, NekDouble > &	outarrayBwd
	)

protected

Definition at line 1074 of file MMFSystem.cpp.

{
    int nTraceNumPoints = GetTraceTotPoints();
 
    Array<OneD, NekDouble> directFwd(nTraceNumPoints);
    Array<OneD, NekDouble> directBwd(nTraceNumPoints);
 
    NekDouble Aver1, Aver2;
    for (int i = 0; i < nTraceNumPoints; ++i)
    {
        Aver1 = im1Fwd[i] + im1Bwd[i];
        Aver2 = im2Fwd[i] + im2Bwd[i];
 
        outarrayFwd[i] =
            -m_alpha * (Fwd[2][i] - Bwd[2][i]) * (1.0 / Aver1 + 1.0 / Aver2);
        outarrayBwd[i] =
            -m_alpha * (Fwd[2][i] - Bwd[2][i]) * (1.0 / Aver1 + 1.0 / Aver2);
    }
}

References Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), and m_alpha.

Referenced by NumericalMaxwellFluxTE(), and NumericalMaxwellFluxTM().

◆ ComputeNtimestimesdFz()

void Nektar::SolverUtils::MMFSystem::ComputeNtimestimesdFz	(	const int	dir,
		const Array< OneD, Array< OneD, NekDouble > > &	Fwd,
		const Array< OneD, Array< OneD, NekDouble > > &	Bwd,
		const Array< OneD, const NekDouble > &	imFwd,
		const Array< OneD, const NekDouble > &	imBwd,
		Array< OneD, NekDouble > &	outarrayFwd,
		Array< OneD, NekDouble > &	outarrayBwd
	)

protected

Definition at line 1008 of file MMFSystem.cpp.

{
    int nTraceNumPoints = GetTraceTotPoints();
 
    Array<OneD, NekDouble> dH(m_spacedim);
    Array<OneD, NekDouble> nFwd(m_spacedim);
 
    Array<OneD, NekDouble> eiFwd(m_spacedim);
    Array<OneD, NekDouble> eiBwd(m_spacedim);
 
    Array<OneD, NekDouble> eitimesdHFwd(m_spacedim);
    Array<OneD, NekDouble> eitimesdHBwd(m_spacedim);
 
    Array<OneD, NekDouble> ntimeseitimesdHFwd(m_spacedim);
    Array<OneD, NekDouble> ntimeseitimesdHBwd(m_spacedim);
 
    NekDouble Aver, HFwdk, HBwdk, tmpFwd, tmpBwd;
    for (int i = 0; i < nTraceNumPoints; ++i)
    {
        Aver = 0.5 * (imFwd[i] + imBwd[i]);
 
        // Get [H]
        for (int k = 0; k < m_spacedim; k++)
        {
            HFwdk = Fwd[0][i] * m_MFtraceFwd[0][k][i] +
                    Fwd[1][i] * m_MFtraceFwd[1][k][i];
            HBwdk = Bwd[0][i] * m_MFtraceBwd[0][k][i] +
                    Bwd[1][i] * m_MFtraceBwd[1][k][i];
            dH[k] = HFwdk - HBwdk;
 
            eiFwd[k] = m_MFtraceFwd[dir][k][i];
            eiBwd[k] = m_MFtraceBwd[dir][k][i];
 
            nFwd[k] = m_traceNormals[k][i];
        }
 
        // MFtraceFwd (MFtraceBwd) \times [H]
        // VectorCrossProd(eiFwd, dH, eitimesdHFwd);
        // VectorCrossProd(eiBwd, dH, eitimesdHBwd);
        VectorCrossProd(nFwd, dH, eitimesdHFwd);
        VectorCrossProd(nFwd, dH, eitimesdHBwd);
 
        // n times eitimesdH
        VectorCrossProd(nFwd, eitimesdHFwd, ntimeseitimesdHFwd);
        VectorCrossProd(nFwd, eitimesdHBwd, ntimeseitimesdHBwd);
 
        // MFtraceFwd \cdot ntimeseitimesdH
        tmpFwd = 0.0;
        tmpBwd = 0.0;
        for (int k = 0; k < m_spacedim; k++)
        {
            tmpFwd += eiFwd[k] * ntimeseitimesdHFwd[k];
            tmpBwd += eiBwd[k] * ntimeseitimesdHBwd[k];
        }
 
        outarrayFwd[i] = 0.5 * m_alpha * tmpFwd / Aver;
        outarrayBwd[i] = 0.5 * m_alpha * tmpBwd / Aver;
    }
}

References Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), m_alpha, m_MFtraceBwd, m_MFtraceFwd, Nektar::SolverUtils::EquationSystem::m_spacedim, Nektar::SolverUtils::EquationSystem::m_traceNormals, and VectorCrossProd().

Referenced by NumericalMaxwellFluxTE(), and NumericalMaxwellFluxTM().

◆ ComputeZimYim()

void Nektar::SolverUtils::MMFSystem::ComputeZimYim	(	Array< OneD, Array< OneD, NekDouble > > &	epsvec,
		Array< OneD, Array< OneD, NekDouble > > &	muvec
	)

protected

Definition at line 1102 of file MMFSystem.cpp.

{
    int nTraceNumPoints = GetTraceNpoints();
 
    switch (m_TestMaxwellType)
    {
        case eMaxwell1D:
        case eScatField1D:
        {
            Array<OneD, NekDouble> Fwdeps(nTraceNumPoints, 1.0);
            Array<OneD, NekDouble> Bwdeps(nTraceNumPoints, 1.0);
            Array<OneD, NekDouble> Fwdmu(nTraceNumPoints, 1.0);
            Array<OneD, NekDouble> Bwdmu(nTraceNumPoints, 1.0);
            m_fields[0]->GetFwdBwdTracePhys(epsvec[0], Fwdeps, Bwdeps);
            m_fields[0]->GetFwdBwdTracePhys(muvec[0], Fwdeps, Bwdeps);
 
            CopyBoundaryTrace(Fwdeps, Bwdeps, eFwdEQBwd, 0);
            CopyBoundaryTrace(Fwdmu, Bwdmu, eFwdEQBwd, 1);
 
            m_ZimFwd = Array<OneD, Array<OneD, NekDouble>>(1);
            m_ZimBwd = Array<OneD, Array<OneD, NekDouble>>(1);
            m_YimFwd = Array<OneD, Array<OneD, NekDouble>>(1);
            m_YimBwd = Array<OneD, Array<OneD, NekDouble>>(1);
 
            m_ZimFwd[0] = Array<OneD, NekDouble>(nTraceNumPoints, 1.0);
            m_ZimBwd[0] = Array<OneD, NekDouble>(nTraceNumPoints, 1.0);
            m_YimFwd[0] = Array<OneD, NekDouble>(nTraceNumPoints, 1.0);
            m_YimBwd[0] = Array<OneD, NekDouble>(nTraceNumPoints, 1.0);
 
            // ZimFwd = sqrt( muFwd / epsFwd),  ZimBwd = sqrt( muBwd / epsBwd)
            for (int i = 0; i < nTraceNumPoints; ++i)
            {
                m_ZimFwd[0][i] = sqrt(Fwdmu[i] / Fwdeps[i]);
                m_ZimBwd[0][i] = sqrt(Bwdmu[i] / Bwdeps[i]);
 
                m_YimFwd[0][i] = 1.0 / m_ZimFwd[0][i];
                m_YimBwd[0][i] = 1.0 / m_ZimBwd[0][i];
            }
 
            std::cout << "*** ZimFwd = " << RootMeanSquare(m_ZimFwd[0])
                      << ", ZimBwd = " << RootMeanSquare(m_ZimBwd[0])
                      << ", YimFwd = " << RootMeanSquare(m_YimFwd[0])
                      << ", YimBwd = " << RootMeanSquare(m_YimBwd[0])
                      << std::endl;
        }
        break;
 
        case eTestMaxwell2DPEC:
        case eTestMaxwell2DPECAVGFLUX:
        case eTestMaxwell2DPMC:
        case eScatField2D:
        case eTotField2D:
        case eMaxwellSphere:
        case eELF2DSurface:
        {
            m_ZimFwd = Array<OneD, Array<OneD, NekDouble>>(m_shapedim);
            m_ZimBwd = Array<OneD, Array<OneD, NekDouble>>(m_shapedim);
            m_YimFwd = Array<OneD, Array<OneD, NekDouble>>(m_shapedim);
            m_YimBwd = Array<OneD, Array<OneD, NekDouble>>(m_shapedim);
 
            for (int j = 0; j < m_shapedim; ++j)
            {
                m_ZimFwd[j] = Array<OneD, NekDouble>(nTraceNumPoints, 1.0);
                m_ZimBwd[j] = Array<OneD, NekDouble>(nTraceNumPoints, 1.0);
                m_YimFwd[j] = Array<OneD, NekDouble>(nTraceNumPoints, 1.0);
                m_YimBwd[j] = Array<OneD, NekDouble>(nTraceNumPoints, 1.0);
            }
 
            switch (m_PolType)
            {
                case eTransMagnetic:
                {
                    Array<OneD, NekDouble> Fwdmu1(nTraceNumPoints);
                    Array<OneD, NekDouble> Bwdmu1(nTraceNumPoints);
                    Array<OneD, NekDouble> Fwdmu2(nTraceNumPoints);
                    Array<OneD, NekDouble> Bwdmu2(nTraceNumPoints);
                    Array<OneD, NekDouble> Fwdeps3(nTraceNumPoints);
                    Array<OneD, NekDouble> Bwdeps3(nTraceNumPoints);
 
                    m_fields[0]->GetFwdBwdTracePhys(muvec[0], Fwdmu1, Bwdmu1);
                    m_fields[0]->GetFwdBwdTracePhys(muvec[1], Fwdmu2, Bwdmu2);
                    m_fields[0]->GetFwdBwdTracePhys(epsvec[2], Fwdeps3,
                                                    Bwdeps3);
 
                    CopyBoundaryTrace(Fwdmu1, Bwdmu1, eFwdEQBwd, 0);
                    CopyBoundaryTrace(Fwdmu2, Bwdmu2, eFwdEQBwd, 1);
                    CopyBoundaryTrace(Fwdeps3, Bwdeps3, eFwdEQBwd, 2);
 
                    // ZimFwd = sqrt( muFwd / epsFwd),  ZimBwd = sqrt( muBwd /
                    // epsBwd)
                    for (int i = 0; i < nTraceNumPoints; ++i)
                    {
                        m_ZimFwd[0][i] = sqrt(Fwdmu2[i] / Fwdeps3[i]);
                        m_ZimBwd[0][i] = sqrt(Bwdmu2[i] / Bwdeps3[i]);
 
                        m_YimFwd[0][i] = 1.0 / m_ZimFwd[0][i];
                        m_YimBwd[0][i] = 1.0 / m_ZimBwd[0][i];
 
                        m_ZimFwd[1][i] = sqrt(Fwdmu1[i] / Fwdeps3[i]);
                        m_ZimBwd[1][i] = sqrt(Bwdmu1[i] / Bwdeps3[i]);
 
                        m_YimFwd[1][i] = 1.0 / m_ZimFwd[1][i];
                        m_YimBwd[1][i] = 1.0 / m_ZimBwd[1][i];
                    }
                }
                break; // eTransMagnetic
 
                case eTransElectric:
                {
                    Array<OneD, NekDouble> Fwdeps1(nTraceNumPoints);
                    Array<OneD, NekDouble> Bwdeps1(nTraceNumPoints);
                    Array<OneD, NekDouble> Fwdeps2(nTraceNumPoints);
                    Array<OneD, NekDouble> Bwdeps2(nTraceNumPoints);
                    Array<OneD, NekDouble> Fwdmu3(nTraceNumPoints);
                    Array<OneD, NekDouble> Bwdmu3(nTraceNumPoints);
 
                    m_fields[0]->GetFwdBwdTracePhys(epsvec[0], Fwdeps1,
                                                    Bwdeps1);
                    m_fields[0]->GetFwdBwdTracePhys(epsvec[1], Fwdeps2,
                                                    Bwdeps2);
                    m_fields[0]->GetFwdBwdTracePhys(muvec[2], Fwdmu3, Bwdmu3);
 
                    CopyBoundaryTrace(Fwdeps1, Bwdeps1, eFwdEQBwd, 0);
                    CopyBoundaryTrace(Fwdeps2, Bwdeps2, eFwdEQBwd, 1);
                    CopyBoundaryTrace(Fwdmu3, Bwdmu3, eFwdEQBwd, 2);
 
                    for (int i = 0; i < nTraceNumPoints; ++i)
                    {
                        m_ZimFwd[0][i] = sqrt(Fwdmu3[i] / Fwdeps2[i]);
                        m_ZimBwd[0][i] = sqrt(Bwdmu3[i] / Bwdeps2[i]);
 
                        m_YimFwd[0][i] = 1.0 / m_ZimFwd[0][i];
                        m_YimBwd[0][i] = 1.0 / m_ZimBwd[0][i];
 
                        m_ZimFwd[1][i] = sqrt(Fwdmu3[i] / Fwdeps1[i]);
                        m_ZimBwd[1][i] = sqrt(Bwdmu3[i] / Bwdeps1[i]);
 
                        m_YimFwd[1][i] = 1.0 / m_ZimFwd[1][i];
                        m_YimBwd[1][i] = 1.0 / m_ZimBwd[1][i];
                    }
                }
                break; // eTransELectric
 
                default:
                    break;
            } // PolType
 
            std::cout << "*** ZimFwd0 = [ "
                      << Vmath::Vmin(nTraceNumPoints, m_ZimFwd[0], 1) << " , "
                      << Vmath::Vmax(nTraceNumPoints, m_ZimFwd[0], 1)
                      << " ], ZimBwd0 = [ "
                      << Vmath::Vmin(nTraceNumPoints, m_ZimBwd[0], 1) << " , "
                      << Vmath::Vmax(nTraceNumPoints, m_ZimBwd[0], 1) << " ] "
                      << std::endl;
            std::cout << "*** ZimFwd1 = [ "
                      << Vmath::Vmin(nTraceNumPoints, m_ZimFwd[1], 1) << " , "
                      << Vmath::Vmax(nTraceNumPoints, m_ZimFwd[1], 1)
                      << " ], ZimBwd1 = [ "
                      << Vmath::Vmin(nTraceNumPoints, m_ZimBwd[1], 1) << " , "
                      << Vmath::Vmax(nTraceNumPoints, m_ZimBwd[1], 1) << " ] "
                      << std::endl;
        }
        break; // eMaxwell2D
 
        default:
            break;
    } // TestMaxwellType
}

Referenced by Nektar::MMFMaxwell::v_InitObject().

◆ CopyBoundaryTrace()

void Nektar::SolverUtils::MMFSystem::CopyBoundaryTrace	(	const Array< OneD, const NekDouble > &	Fwd,
		Array< OneD, NekDouble > &	Bwd,
		const BoundaryCopyType	BDCopyType,
		const int	var = `0`,
		const std::string	btype = `"NoUserDefined"`
	)

Definition at line 835 of file MMFSystem.cpp.

{
    int id1, id2, npts, nptselem, cnt = 0;
    Array<OneD, NekDouble> Dirichlet, x0, x1, x2;
 
    // loop over Boundary Regions
    for (int n = 0; n < m_fields[var]->GetBndConditions().size(); ++n)
    {
        nptselem = m_fields[var]->GetBndCondExpansions()[n]->GetNpoints();
 
        Dirichlet = Array<OneD, NekDouble>(nptselem);
        x0        = Array<OneD, NekDouble>(nptselem);
        x1        = Array<OneD, NekDouble>(nptselem);
        x2        = Array<OneD, NekDouble>(nptselem);
 
        if (BDCopyType == eDirichlet)
        {
            m_fields[var]->GetBndCondExpansions()[n]->GetCoords(x0, x1, x2);
            LibUtilities::EquationSharedPtr ifunc =
                m_session->GetFunction("BoundaryConditions", 0);
            ifunc->Evaluate(x0, x1, x2, 0.0, Dirichlet);
        }
 
        for (int e = 0;
             e < m_fields[var]->GetBndCondExpansions()[n]->GetExpSize(); ++e)
        {
            npts = m_fields[var]
                       ->GetBndCondExpansions()[n]
                       ->GetExp(e)
                       ->GetNumPoints(0);
            id1 = m_fields[var]->GetBndCondExpansions()[n]->GetPhys_Offset(e);
            id2 = m_fields[var]->GetTrace()->GetPhys_Offset(
                m_fields[var]->GetTraceMap()->GetBndCondIDToGlobalTraceID(cnt +
                                                                          e));
 
            if (m_fields[var]->GetBndConditions()[n]->GetUserDefined() ==
                    BDtype ||
                BDtype == "NoUserDefined")
            {
                switch (BDCopyType)
                {
                    case eDirichlet:
                    {
                        Vmath::Vcopy(npts, &Dirichlet[id1], 1, &Bwd[id2], 1);
                    }
                    break;
 
                    case eFwdEQBwd:
                    {
                        Vmath::Vcopy(npts, &Fwd[id2], 1, &Bwd[id2], 1);
                    }
                    break;
 
                    case eFwdEQNegBwd:
                    {
                        Vmath::Vcopy(npts, &Fwd[id2], 1, &Bwd[id2], 1);
                        Vmath::Neg(npts, &Bwd[id2], 1);
                    }
                    break;
 
                    default:
                        break;
                }
            }
        }
 
        cnt += m_fields[var]->GetBndCondExpansions()[n]->GetExpSize();
    }
}

References Nektar::SolverUtils::eDirichlet, Nektar::SolverUtils::eFwdEQBwd, Nektar::SolverUtils::eFwdEQNegBwd, Nektar::SolverUtils::EquationSystem::GetExpSize(), Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_session, Vmath::Neg(), and Vmath::Vcopy().

Referenced by AverageMaxwellFlux1D(), ComputeMFtrace(), ComputencdotMF(), ComputeZimYim(), LaxFriedrichMaxwellFlux1D(), NumericalMaxwellFluxTE(), NumericalMaxwellFluxTM(), Nektar::MMFSWE::NumericalSWEFlux(), and UpwindMaxwellFlux1D().

◆ DeriveCrossProductMF()

void Nektar::SolverUtils::MMFSystem::DeriveCrossProductMF ( Array< OneD, Array< OneD, NekDouble > > & CrossProductMF )

protected

Definition at line 568 of file MMFSystem.cpp.

{
    int MFdim = 3;
    int nq    = GetTotPoints();
 
    CrossProductMF = Array<OneD, Array<OneD, NekDouble>>(MFdim);
 
    Array<OneD, Array<OneD, NekDouble>> MF1tmp(m_spacedim);
    Array<OneD, Array<OneD, NekDouble>> MF2tmp(m_spacedim);
    Array<OneD, Array<OneD, NekDouble>> MF3tmp(m_spacedim);
    Array<OneD, Array<OneD, Array<OneD, NekDouble>>> MFtmpCurl(MFdim);
    for (int j = 0; j < MFdim; ++j)
    {
        CrossProductMF[j] = Array<OneD, NekDouble>(nq * m_spacedim);
        MFtmpCurl[j]      = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
        for (int k = 0; k < m_spacedim; ++k)
        {
            MFtmpCurl[j][k] = Array<OneD, NekDouble>(nq);
        }
    }
 
    for (int k = 0; k < m_spacedim; ++k)
    {
        MF1tmp[k] = Array<OneD, NekDouble>(nq);
        MF2tmp[k] = Array<OneD, NekDouble>(nq);
        MF3tmp[k] = Array<OneD, NekDouble>(nq);
 
        Vmath::Vcopy(nq, &m_movingframes[0][k * nq], 1, &MF1tmp[k][0], 1);
        Vmath::Vcopy(nq, &m_movingframes[1][k * nq], 1, &MF2tmp[k][0], 1);
        Vmath::Vcopy(nq, &m_movingframes[2][k * nq], 1, &MF3tmp[k][0], 1);
    }
 
    VectorCrossProd(MF3tmp, MF1tmp, MFtmpCurl[0]);
    VectorCrossProd(MF2tmp, MF3tmp, MFtmpCurl[1]);
    VectorCrossProd(MF1tmp, MF2tmp, MFtmpCurl[2]);
 
    for (int j = 0; j < MFdim; ++j)
    {
        for (int k = 0; k < m_spacedim; ++k)
        {
            Vmath::Vcopy(nq, &MFtmpCurl[j][k][0], 1, &CrossProductMF[j][k * nq],
                         1);
        }
    }
}

References Nektar::SolverUtils::EquationSystem::GetTotPoints(), m_movingframes, Nektar::SolverUtils::EquationSystem::m_spacedim, Vmath::Vcopy(), and VectorCrossProd().

Referenced by Nektar::MMFMaxwell::v_InitObject().

◆ GetIncidentField()

Array< OneD, NekDouble > Nektar::SolverUtils::MMFSystem::GetIncidentField	(	const int	var,
		const NekDouble	time
	)

protected

Definition at line 2005 of file MMFSystem.cpp.

{
    int nq = m_fields[0]->GetNpoints();
 
    Array<OneD, NekDouble> x0(nq);
    Array<OneD, NekDouble> x1(nq);
    Array<OneD, NekDouble> x2(nq);
 
    m_fields[0]->GetCoords(x0, x1, x2);
 
    // GetSmoothFactor such that wave propages from the left to the object.
    // a = 0.1, ta = 1, f = 1.0./(1.0 + exp( -0.5.*(time-ta)/a ));
    Array<OneD, NekDouble> SmoothFactor(nq, 1.0);
    switch (m_SmoothFactor)
    {
        case 0:
        {
            for (int i = 0; i < nq; i++)
            {
                SmoothFactor[i] = 1.0 / (1.0 + exp(-1.0 * (time - 1.0) / 0.1));
            }
        }
        break;
 
        case 1:
        {
            NekDouble xmin = Vmath::Vmin(nq, x0, 1);
            NekDouble xp;
            for (int i = 0; i < nq; i++)
            {
                xp = x0[i] - xmin - time - m_SFinit;
                if (xp > 0.0)
                {
                    SmoothFactor[i] =
                        2.0 / (1.0 + exp(0.5 * (sqrt(xp * xp) - 0.1)));
                }
 
                else
                {
                    SmoothFactor[i] = 1.0;
                }
            }
        }
        break;
 
        default:
            break;
    }
 
    // Generate a factor for smoothly increasing wave
    Array<OneD, NekDouble> F1(nq);
    Array<OneD, NekDouble> F2(nq);
    Array<OneD, NekDouble> F3(nq);
 
    Array<OneD, NekDouble> dF1dt(nq);
    Array<OneD, NekDouble> dF2dt(nq);
    Array<OneD, NekDouble> dF3dt(nq);
 
    Array<OneD, NekDouble> F1int(nq);
    Array<OneD, NekDouble> F2int(nq);
    Array<OneD, NekDouble> F3int(nq);
 
    Array<OneD, NekDouble> outarray(nq);
 
    switch (m_IncType)
    {
        case ePlaneWave:
        {
            NekDouble cs, sn;
            NekDouble e1y, e2y;
            switch (m_PolType)
            {
                case eTransMagnetic:
                {
                    // H = 0 \hat{x} - e^{ikx} \hat{y}
                    // E = e^{ikx} \hat{z}
                    // outarray1 = Hr1inc
                    // outarray2 = Hr2inc
                    // outarray3 = Ezrinc
                    for (int i = 0; i < nq; i++)
                    {
                        e1y = m_movingframes[0][nq + i];
                        e2y = m_movingframes[1][nq + i];
 
                        cs = SmoothFactor[i] * cos(m_Incfreq * (x0[i] - time));
                        sn = SmoothFactor[i] * sin(m_Incfreq * (x0[i] - time));
 
                        F1[i] = -1.0 * cs * e1y;
                        F2[i] = -1.0 * cs * e2y;
                        F3[i] = cs;
 
                        dF1dt[i] = -1.0 * m_Incfreq * sn * e1y;
                        dF2dt[i] = -1.0 * m_Incfreq * sn * e2y;
                        dF3dt[i] = 1.0 * m_Incfreq * sn;
 
                        F1int[i] = (1.0 / m_Incfreq) * sn * e1y;
                        F2int[i] = (1.0 / m_Incfreq) * sn * e2y;
                        F3int[i] = (-1.0 / m_Incfreq) * sn;
                    }
                }
                break;
 
                case eTransElectric:
                {
                    // E = 0 \hat{x} + e^{ikx} \hat{y}
                    // H = e^{ikx} \hat{z}
                    // outarray1 = Er1inc
                    // outarray2 = Er2inc
                    // outarray3 = Hzrinc
                    // outarray1 = Ei1inc
                    // outarray2 = Ei2inc
                    // outarray3 = Hziinc
                    for (int i = 0; i < nq; i++)
                    {
                        e1y = m_movingframes[0][nq + i];
                        e2y = m_movingframes[1][nq + i];
 
                        cs = SmoothFactor[i] * cos(m_Incfreq * (x0[i] - time));
                        sn = SmoothFactor[i] * sin(m_Incfreq * (x0[i] - time));
 
                        F1[i] = cs * e1y;
                        F2[i] = cs * e2y;
                        F3[i] = cs;
 
                        dF1dt[i] = m_Incfreq * sn * e1y;
                        dF2dt[i] = m_Incfreq * sn * e2y;
                        dF3dt[i] = m_Incfreq * sn;
 
                        F1int[i] = (-1.0 / m_Incfreq) * sn * e1y;
                        F2int[i] = (-1.0 / m_Incfreq) * sn * e2y;
                        F3int[i] = (-1.0 / m_Incfreq) * sn;
                    }
                }
                break;
 
                default:
                    break;
            }
        }
        break;
 
        case ePlaneWaveImag:
        {
            NekDouble cs, sn;
            NekDouble e1y, e2y;
            switch (m_PolType)
            {
                case eTransMagnetic:
                {
                    // H = 0 \hat{x} - e^{ikx} \hat{y}
                    // E = e^{ikx} \hat{z}
                    // outarray1 = Hr1inc
                    // outarray2 = Hr2inc
                    // outarray3 = Ezrinc
                    for (int i = 0; i < nq; i++)
                    {
                        e1y = m_movingframes[0][nq + i];
                        e2y = m_movingframes[1][nq + i];
 
                        cs = SmoothFactor[i] * cos(m_Incfreq * (x0[i] - time));
                        sn = SmoothFactor[i] * sin(m_Incfreq * (x0[i] - time));
 
                        F1[i] = -1.0 * sn * e1y;
                        F2[i] = -1.0 * sn * e2y;
                        F3[i] = sn;
 
                        dF1dt[i] = m_Incfreq * cs * e1y;
                        dF2dt[i] = m_Incfreq * cs * e2y;
                        dF3dt[i] = -1.0 * m_Incfreq * cs;
 
                        F1int[i] = (-1.0 / m_Incfreq) * cs * e1y;
                        F2int[i] = (-1.0 / m_Incfreq) * cs * e2y;
                        F3int[i] = (1.0 / m_Incfreq) * cs;
                    }
                }
                break;
 
                case eTransElectric:
                {
                    // E = 0 \hat{x} + e^{ikx} \hat{y}
                    // H = e^{ikx} \hat{z}
                    // outarray1 = Er1inc
                    // outarray2 = Er2inc
                    // outarray3 = Hzrinc
                    // outarray1 = Ei1inc
                    // outarray2 = Ei2inc
                    // outarray3 = Hziinc
                    for (int i = 0; i < nq; i++)
                    {
                        e1y = m_movingframes[0][nq + i];
                        e2y = m_movingframes[1][nq + i];
 
                        cs = SmoothFactor[i] * cos(m_Incfreq * (x0[i] - time));
                        sn = SmoothFactor[i] * sin(m_Incfreq * (x0[i] - time));
 
                        F1[i] = sn * e1y;
                        F2[i] = sn * e2y;
                        F3[i] = sn;
 
                        dF1dt[i] = -1.0 * m_Incfreq * cs * e1y;
                        dF2dt[i] = -1.0 * m_Incfreq * cs * e2y;
                        dF3dt[i] = -1.0 * m_Incfreq * cs;
 
                        F1int[i] = (1.0 / m_Incfreq) * cs * e1y;
                        F2int[i] = (1.0 / m_Incfreq) * cs * e2y;
                        F3int[i] = (1.0 / m_Incfreq) * cs;
                    }
                }
                break;
 
                default:
                    break;
            }
        }
        break;
 
        default:
            break;
    }
 
    switch (var)
    {
        case 0:
        {
            outarray = F1;
        }
        break;
 
        case 1:
        {
            outarray = F2;
        }
        break;
 
        case 2:
        {
            outarray = F3;
        }
        break;
 
        case 10:
        {
            outarray = dF1dt;
        }
        break;
 
        case 11:
        {
            outarray = dF2dt;
        }
        break;
 
        case 12:
        {
            outarray = dF3dt;
        }
        break;
 
        case 20:
        {
            outarray = F1int;
        }
        break;
 
        case 21:
        {
            outarray = F2int;
        }
        break;
 
        case 22:
        {
            outarray = F3int;
        }
        break;
 
        default:
        {
            Vmath::Zero(nq, outarray, 1);
        }
        break;
    }
 
    return outarray;
}

References Nektar::SolverUtils::ePlaneWave, Nektar::SolverUtils::ePlaneWaveImag, Nektar::SolverUtils::eTransElectric, Nektar::SolverUtils::eTransMagnetic, Nektar::SolverUtils::EquationSystem::m_fields, m_Incfreq, m_IncType, m_movingframes, m_PolType, m_SFinit, m_SmoothFactor, tinysimd::sqrt(), Vmath::Vmin(), and Vmath::Zero().

Referenced by Nektar::MMFMaxwell::Checkpoint_TotalFieldOutput(), Nektar::MMFMaxwell::Checkpoint_TotPlotOutput(), Nektar::MMFMaxwell::ComputeSurfaceCurrent(), Nektar::MMFMaxwell::DoOdeRhs(), NumericalMaxwellFluxTE(), NumericalMaxwellFluxTM(), and Nektar::MMFMaxwell::v_DoSolve().

◆ GetMaxwellFlux1D()

void Nektar::SolverUtils::MMFSystem::GetMaxwellFlux1D	(	const int	var,
		const Array< OneD, const Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	flux
	)

protected

Definition at line 1633 of file MMFSystem.cpp.

{
    int nq = m_fields[0]->GetTotPoints();
 
    switch (var)
    {
        case 0:
        {
            // H in flux 0
            Vmath::Vcopy(nq, physfield[1], 1, flux[0], 1);
 
            // E in flux 1
            Vmath::Zero(nq, flux[1], 1);
        }
        break;
 
        case 1:
        {
            // E in flux 0
            Vmath::Vcopy(nq, physfield[0], 1, flux[0], 1);
 
            // H in flux 1
            Vmath::Zero(nq, flux[1], 1);
        }
        break;
            //----------------------------------------------------
 
        default:
            break;
    }
}

References Nektar::SolverUtils::EquationSystem::m_fields, Vmath::Vcopy(), and Vmath::Zero().

Referenced by GetMaxwellFluxVector().

◆ GetMaxwellFlux2D()

void Nektar::SolverUtils::MMFSystem::GetMaxwellFlux2D	(	const int	var,
		const Array< OneD, const Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	flux
	)

protected

Definition at line 1667 of file MMFSystem.cpp.

{
    int nq = m_fields[0]->GetTotPoints();
 
    NekDouble sign = 1.0;
    switch (m_PolType)
    {
        // TransMagnetic
        case 0:
        {
            sign = -1.0;
        }
        break;
 
        // TransElectric
        case 1:
        {
            sign = 1.0;
        }
        break;
 
        default:
            break;
    }
 
    switch (var)
    {
        case 0:
        {
            // -Ez in flux 1
            Vmath::Smul(nq, sign, physfield[2], 1, flux[0], 1);
            Vmath::Zero(nq, flux[1], 1);
        }
        break;
 
        case 1:
        {
            // Ez in flux 0
            Vmath::Zero(nq, flux[0], 1);
            Vmath::Smul(nq, -sign, physfield[2], 1, flux[1], 1);
        }
        break;
 
        case 2:
        {
            Vmath::Smul(nq, sign, physfield[0], 1, flux[0], 1);
            Vmath::Smul(nq, -sign, physfield[1], 1, flux[1], 1);
        }
        break;
 
        default:
            ASSERTL0(false, "GetFluxVector2D: illegal vector index");
    }
}

References ASSERTL0, Nektar::SolverUtils::EquationSystem::m_fields, m_PolType, sign, Vmath::Smul(), and Vmath::Zero().

Referenced by GetMaxwellFluxVector().

◆ GetMaxwellFluxVector()

void Nektar::SolverUtils::MMFSystem::GetMaxwellFluxVector	(	const int	var,
		const Array< OneD, const Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	flux
	)

protected

Definition at line 1603 of file MMFSystem.cpp.

{
    switch (m_TestMaxwellType)
    {
        case eMaxwell1D:
        case eScatField1D:
        {
            GetMaxwellFlux1D(var, physfield, flux);
        }
        break;
 
        case eTestMaxwell2DPEC:
        case eTestMaxwell2DPECAVGFLUX:
        case eTestMaxwell2DPMC:
        case eScatField2D:
        case eTotField2D:
        case eMaxwellSphere:
        case eELF2DSurface:
        {
            GetMaxwellFlux2D(var, physfield, flux);
        }
        break;
 
        default:
            break;
    }
}

References Nektar::SolverUtils::eELF2DSurface, Nektar::SolverUtils::eMaxwell1D, Nektar::SolverUtils::eMaxwellSphere, Nektar::SolverUtils::eScatField1D, Nektar::SolverUtils::eScatField2D, Nektar::SolverUtils::eTestMaxwell2DPEC, Nektar::SolverUtils::eTestMaxwell2DPECAVGFLUX, Nektar::SolverUtils::eTestMaxwell2DPMC, Nektar::SolverUtils::eTotField2D, GetMaxwellFlux1D(), GetMaxwellFlux2D(), and m_TestMaxwellType.

Referenced by Nektar::MMFMaxwell::AddGreenDerivCompensate(), and Nektar::MMFMaxwell::WeakDGMaxwellDirDeriv().

◆ GramSchumitz()

void Nektar::SolverUtils::MMFSystem::GramSchumitz	(	const Array< OneD, const Array< OneD, NekDouble > > &	v1,
		const Array< OneD, const Array< OneD, NekDouble > > &	v2,
		Array< OneD, Array< OneD, NekDouble > > &	outarray,
		bool	KeepTheMagnitude = `true`
	)

protected

Definition at line 2399 of file MMFSystem.cpp.

{
 
    int nq = v1[0].size();
    Array<OneD, NekDouble> tmp(nq, 0.0);
    Array<OneD, NekDouble> mag(nq, 0.0);
 
    for (int i = 0; i < m_spacedim; ++i)
    {
        // u2 = v2 - < u1 , v2 > ( u1 / < u1, u1 > )
        Vmath::Vvtvp(nq, &v1[i][0], 1, &v2[i][0], 1, &tmp[0], 1, &tmp[0], 1);
        Vmath::Vvtvp(nq, &v1[i][0], 1, &v1[i][0], 1, &mag[0], 1, &mag[0], 1);
    }
    Vmath::Vdiv(nq, &tmp[0], 1, &mag[0], 1, &tmp[0], 1);
    Vmath::Neg(nq, &tmp[0], 1);
 
    // outarray = Array<OneD, Array<OneD, NekDouble> >(m_spacedim);
 
    // u2 = v2 - < u1 , v2 > ( u1 / < u1, u1 > )
    for (int i = 0; i < m_spacedim; ++i)
    {
        outarray[i] = Array<OneD, NekDouble>(nq, 0.0);
        Vmath::Vvtvp(nq, &tmp[0], 1, &v1[i][0], 1, &v2[i][0], 1,
                     &outarray[i][0], 1);
    }
 
    if (KeepTheMagnitude)
    {
        Array<OneD, NekDouble> magorig(nq, 0.0);
        Array<OneD, NekDouble> magnew(nq, 0.0);
 
        for (int i = 0; i < m_spacedim; ++i)
        {
            Vmath::Vmul(nq, &v2[0][0], 1, &v2[0][0], 1, &magorig[0], 1);
            Vmath::Vvtvp(nq, &v2[1][0], 1, &v2[1][0], 1, &magorig[0], 1,
                         &magorig[0], 1);
            Vmath::Vvtvp(nq, &v2[2][0], 1, &v2[2][0], 1, &magorig[0], 1,
                         &magorig[0], 1);
 
            Vmath::Vmul(nq, &outarray[0][0], 1, &outarray[0][0], 1, &magnew[0],
                        1);
            Vmath::Vvtvp(nq, &outarray[1][0], 1, &outarray[1][0], 1, &magnew[0],
                         1, &magnew[0], 1);
            Vmath::Vvtvp(nq, &outarray[2][0], 1, &outarray[2][0], 1, &magnew[0],
                         1, &magnew[0], 1);
        }
 
        for (int i = 0; i < m_spacedim; ++i)
        {
            for (int j = 0; j < nq; ++j)
            {
                if (fabs(magnew[j]) > 0.000000001)
                {
                    outarray[i][j] =
                        outarray[i][j] * sqrt(magorig[j] / magnew[j]);
                }
            }
        }
    }
}

References Nektar::SolverUtils::EquationSystem::m_spacedim, Vmath::Neg(), tinysimd::sqrt(), Vmath::Vdiv(), Vmath::Vmul(), and Vmath::Vvtvp().

Referenced by Nektar::MMFAdvection::EvaluateAdvectionVelocity().

◆ LaxFriedrichMaxwellFlux1D()

void Nektar::SolverUtils::MMFSystem::LaxFriedrichMaxwellFlux1D	(	Array< OneD, Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	numfluxFwd,
		Array< OneD, Array< OneD, NekDouble > > &	numfluxBwd
	)

protected

Definition at line 1509 of file MMFSystem.cpp.

{
    int i;
    int nTraceNumPoints = GetTraceTotPoints();
    int nvar            = 2;
 
    // get temporary arrays
    Array<OneD, Array<OneD, NekDouble>> Fwd(nvar);
    Array<OneD, Array<OneD, NekDouble>> Bwd(nvar);
 
    for (i = 0; i < nvar; ++i)
    {
        Fwd[i] = Array<OneD, NekDouble>(nTraceNumPoints);
        Bwd[i] = Array<OneD, NekDouble>(nTraceNumPoints);
    }
 
    // get the physical values at the trace from the dependent variables
    for (i = 0; i < nvar; ++i)
    {
        m_fields[i]->GetFwdBwdTracePhys(physfield[i], Fwd[i], Bwd[i]);
    }
 
    // E = 0 at the boundaries
    CopyBoundaryTrace(Fwd[0], Bwd[0], SolverUtils::eFwdEQNegBwd, 0, "PEC");
 
    // d H / d n = 0 at the boundaries
    CopyBoundaryTrace(Fwd[1], Bwd[1], SolverUtils::eFwdEQBwd, 1, "PEC");
 
    Array<OneD, NekDouble> dE(nTraceNumPoints);
    Array<OneD, NekDouble> dH(nTraceNumPoints);
 
    Vmath::Vsub(nTraceNumPoints, &Fwd[0][0], 1, &Bwd[0][0], 1, &dE[0], 1);
    Vmath::Vsub(nTraceNumPoints, &Fwd[1][0], 1, &Bwd[1][0], 1, &dH[0], 1);
 
    NekDouble nx;
    for (i = 0; i < nTraceNumPoints; ++i)
    {
        nx = m_traceNormals[0][i];
        numfluxFwd[0][i] =
            0.5 * nx * ((Fwd[1][i] + Bwd[1][i]) - nx * m_YimFwd[0][i] * dE[i]);
        numfluxFwd[1][i] =
            0.5 * nx * ((Fwd[0][i] + Bwd[0][i]) - nx * m_ZimFwd[0][i] * dH[i]);
 
        numfluxBwd[0][i] =
            0.5 * nx * ((Fwd[1][i] + Bwd[1][i]) - nx * m_YimFwd[0][i] * dE[i]);
        numfluxBwd[1][i] =
            0.5 * nx * ((Fwd[0][i] + Bwd[0][i]) - nx * m_ZimFwd[0][i] * dH[i]);
    }
}

References CopyBoundaryTrace(), Nektar::SolverUtils::eFwdEQBwd, Nektar::SolverUtils::eFwdEQNegBwd, Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_traceNormals, m_YimFwd, m_ZimFwd, and Vmath::Vsub().

Referenced by NumericalMaxwellFlux().

◆ MMFInitObject()

void Nektar::SolverUtils::MMFSystem::MMFInitObject	(	const Array< OneD, const Array< OneD, NekDouble > > &	Anisotropy,
		const int	TangentXelem = `-1`
	)

Definition at line 51 of file MMFSystem.cpp.

{
    m_pi       = 3.14159265358979323846;
    m_shapedim = m_fields[0]->GetShapeDimension();
 
    ASSERTL0(m_spacedim == 3, "Space Dimension should be 3.");
 
    // Factor for Numerical Flux
    m_session->LoadParameter("alpha", m_alpha, 1.0);
 
    // Factor for Numerical Flux
    m_session->LoadParameter("Incfreq", m_Incfreq, 1.0);
 
    // SmoothFactor
    m_session->LoadParameter("SmoothFactor", m_SmoothFactor, 1);
    m_session->LoadParameter("SFinit", m_SFinit, 0.0);
 
    // Define SurfaceType
    if (m_session->DefinesSolverInfo("SURFACETYPE"))
    {
        std::string SurfaceTypeStr = m_session->GetSolverInfo("SURFACETYPE");
        int i;
        for (i = 0; i < (int)SIZE_SurfaceType; ++i)
        {
            if (boost::iequals(SurfaceTypeMap[i], SurfaceTypeStr))
            {
                m_surfaceType = (SurfaceType)i;
                break;
            }
        }
    }
    else
    {
        m_surfaceType = (SurfaceType)0;
    }
 
    // if discontinuous Galerkin determine numerical flux to use
    for (int i = 0; i < (int)SIZE_UpwindType; ++i)
    {
        bool match;
        m_session->MatchSolverInfo("UPWINDTYPE", UpwindTypeMap[i], match,
                                   false);
        if (match)
        {
            m_upwindType = (UpwindType)i;
            break;
        }
    }
 
    // SetUpMovingFrames: To generate m_movingframes
    SetUpMovingFrames(Anisotropy, TangentXelem);
 
    // Derive movingfrmaes at interfaces
    // Get: m_MFtraceFwd and m_MFtraceBwd
    ComputeMFtrace();
 
    // Check Movingframes and surfraceNormal
    // Get: m_ncdotMFFwd,m_ncdotMFBwd,m_nperpcdotMFFwd,m_nperpcdotMFBwd
    ComputencdotMF();
 
    // Compute nabla cdot m_movingframes
    // Get: m_DivMF, m_CurlMF
    ComputeDivCurlMF();
}

References ASSERTL0, ComputeDivCurlMF(), ComputeMFtrace(), ComputencdotMF(), m_alpha, Nektar::SolverUtils::EquationSystem::m_fields, m_Incfreq, m_pi, Nektar::SolverUtils::EquationSystem::m_session, m_SFinit, m_shapedim, m_SmoothFactor, Nektar::SolverUtils::EquationSystem::m_spacedim, m_surfaceType, m_upwindType, SetUpMovingFrames(), Nektar::SolverUtils::SIZE_SurfaceType, Nektar::SolverUtils::SIZE_UpwindType, Nektar::SolverUtils::SurfaceTypeMap, and Nektar::SolverUtils::UpwindTypeMap.

Referenced by Nektar::MMFDiffusion::v_InitObject(), Nektar::MMFAdvection::v_InitObject(), Nektar::MMFMaxwell::v_InitObject(), and Nektar::MMFSWE::v_InitObject().

◆ NumericalMaxwellFlux()

void Nektar::SolverUtils::MMFSystem::NumericalMaxwellFlux	(	Array< OneD, Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	numfluxFwd,
		Array< OneD, Array< OneD, NekDouble > > &	numfluxBwd,
		const NekDouble	time = `0.0`
	)

protected

Definition at line 1724 of file MMFSystem.cpp.

{
 
    switch (m_TestMaxwellType)
    {
        case eMaxwell1D:
        case eScatField1D:
        {
            switch (m_upwindType)
            {
                case eAverage:
                {
                    AverageMaxwellFlux1D(physfield, numfluxFwd, numfluxBwd);
                }
                break;
 
                case eLaxFriedrich:
                {
                    LaxFriedrichMaxwellFlux1D(physfield, numfluxFwd,
                                              numfluxBwd);
                }
                break;
 
                case eUpwind:
                {
                    UpwindMaxwellFlux1D(physfield, numfluxFwd, numfluxBwd);
                }
                break;
 
                default:
                {
                    ASSERTL0(false,
                             "populate switch statement for upwind flux");
                }
                break; // upwindType
            }
        }
        break; // eMaxwell1D
 
        case eTestMaxwell2DPEC:
        case eTestMaxwell2DPECAVGFLUX:
        case eTestMaxwell2DPMC:
        case eScatField2D:
        case eTotField2D:
        case eMaxwellSphere:
        case eELF2DSurface:
        {
            switch (m_PolType)
            {
                case eTransMagnetic:
                {
                    NumericalMaxwellFluxTM(physfield, numfluxFwd, numfluxBwd,
                                           time);
                }
                break;
 
                case eTransElectric:
                {
                    NumericalMaxwellFluxTE(physfield, numfluxFwd, numfluxBwd,
                                           time);
                }
                break;
 
                default:
                    break;
            }
        }
        break; // eMaxwell2D
 
        default:
            break;
    } // m_TestMaxwellType
}

Referenced by Nektar::MMFMaxwell::WeakDGMaxwellDirDeriv().

◆ NumericalMaxwellFluxTE()

void Nektar::SolverUtils::MMFSystem::NumericalMaxwellFluxTE	(	Array< OneD, Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	numfluxFwd,
		Array< OneD, Array< OneD, NekDouble > > &	numfluxBwd,
		const NekDouble	time
	)

protected

Definition at line 1902 of file MMFSystem.cpp.

{
    int nq              = m_fields[0]->GetNpoints();
    int nTraceNumPoints = GetTraceTotPoints();
    int nvar            = physfield.size();
 
    // Get temporary arrays
    Array<OneD, Array<OneD, NekDouble>> Fwd(nvar);
    Array<OneD, Array<OneD, NekDouble>> Bwd(nvar);
    for (int i = 0; i < nvar; ++i)
    {
        Fwd[i] = Array<OneD, NekDouble>(nTraceNumPoints, 0.0);
        Bwd[i] = Array<OneD, NekDouble>(nTraceNumPoints, 0.0);
 
        // get the physical values at the trace
        m_fields[i]->GetFwdBwdTracePhys(physfield[i], Fwd[i], Bwd[i]);
    }
 
    // E = 0 at the PEC boundaries:
    Array<OneD, NekDouble> IncField(nq, 0.0);
    Array<OneD, NekDouble> IncFieldBwd(nTraceNumPoints, 0.0);
    Array<OneD, Array<OneD, NekDouble>> IncFieldFwd(m_spacedim);
    for (int i = 0; i < m_spacedim; ++i)
    {
        IncFieldFwd[i] = Array<OneD, NekDouble>(nTraceNumPoints, 0.0);
 
        IncField = GetIncidentField(i, time);
        m_fields[0]->GetFwdBwdTracePhys(IncField, IncFieldFwd[i], IncFieldBwd);
 
        Vmath::Svtvp(nTraceNumPoints, 2.0, &IncFieldFwd[i][0], 1, &Fwd[i][0], 1,
                     &IncFieldFwd[i][0], 1);
    }
 
    CopyBoundaryTrace(IncFieldFwd[0], Bwd[0], SolverUtils::eFwdEQNegBwd, 0,
                      "PEC_Forces");
    CopyBoundaryTrace(IncFieldFwd[1], Bwd[1], SolverUtils::eFwdEQNegBwd, 1,
                      "PEC_Forces");
    CopyBoundaryTrace(Fwd[2], Bwd[2], SolverUtils::eFwdEQBwd, 2, "PEC_Forces");
 
    CopyBoundaryTrace(Fwd[0], Bwd[0], SolverUtils::eFwdEQBwd, 0, "PMC_Forces");
    CopyBoundaryTrace(Fwd[1], Bwd[1], SolverUtils::eFwdEQBwd, 1, "PMC_Forces");
    CopyBoundaryTrace(IncFieldFwd[2], Bwd[2], SolverUtils::eFwdEQNegBwd, 2,
                      "PMC_Forces");
 
    CopyBoundaryTrace(Fwd[0], Bwd[0], SolverUtils::eFwdEQNegBwd, 0, "PEC");
    CopyBoundaryTrace(Fwd[1], Bwd[1], SolverUtils::eFwdEQNegBwd, 1, "PEC");
    CopyBoundaryTrace(Fwd[2], Bwd[2], SolverUtils::eFwdEQBwd, 2, "PEC");
 
    CopyBoundaryTrace(Fwd[0], Bwd[0], SolverUtils::eFwdEQBwd, 0, "PMC");
    CopyBoundaryTrace(Fwd[1], Bwd[1], SolverUtils::eFwdEQBwd, 1, "PMC");
    CopyBoundaryTrace(Fwd[2], Bwd[2], SolverUtils::eFwdEQNegBwd, 2, "PMC");
 
    Array<OneD, NekDouble> e1Fwd_cdot_ncrossdE(nTraceNumPoints);
    Array<OneD, NekDouble> e1Bwd_cdot_ncrossdE(nTraceNumPoints);
    Array<OneD, NekDouble> e2Fwd_cdot_ncrossdE(nTraceNumPoints);
    Array<OneD, NekDouble> e2Bwd_cdot_ncrossdE(nTraceNumPoints);
    Array<OneD, NekDouble> e3Fwd_cdot_dHe3(nTraceNumPoints);
    Array<OneD, NekDouble> e3Bwd_cdot_dHe3(nTraceNumPoints);
 
    // Compute  numfluxFwd[dir] = (eFwd^[dir] \cdot n \times e^3) * (ZimFwd *
    // HFwd^3 + ZimBwd * HBwd^3 )
    // Compute  numfluxBwd[dir] = (eBwd^[dir] \cdot n \times e^3) * (ZimFwd *
    // HFwd^3 + ZimBwd * HBwd^3 )
    ComputeNtimesFz(0, Fwd, Bwd, m_ZimFwd[0], m_ZimBwd[0], numfluxFwd[0],
                    numfluxBwd[0]);
    ComputeNtimesFz(1, Fwd, Bwd, m_ZimFwd[1], m_ZimBwd[1], numfluxFwd[1],
                    numfluxBwd[1]);
 
    // Compute numfluxFwd[2] = eFwd^3 \cdot ( n1e1 \times ( imFwd EFwd + imBwd
    // EBwd ) ) / 2 {{Y_i}}
    ComputeNtimesF12(Fwd, Bwd, m_YimFwd[0], m_YimBwd[0], m_YimFwd[1],
                     m_YimBwd[1], numfluxFwd[2], numfluxBwd[2]);
 
    // Compute e1Fwd_cdot_ncrossdE = eFwd[dir] \cdot \alpha n \times n \times
    // [E] / 2 {{ZimFwd}}
    ComputeNtimestimesdFz(0, Fwd, Bwd, m_ZimFwd[0], m_ZimBwd[0],
                          e1Fwd_cdot_ncrossdE, e1Bwd_cdot_ncrossdE);
    ComputeNtimestimesdFz(1, Fwd, Bwd, m_ZimFwd[1], m_ZimBwd[1],
                          e2Fwd_cdot_ncrossdE, e2Bwd_cdot_ncrossdE);
 
    // Compute  - \alpha [H3] * ( 1/2{{Yim1}} + 1/2{{Yim2}} )
    ComputeNtimestimesdF12(Fwd, Bwd, m_YimFwd[0], m_YimBwd[0], m_YimFwd[1],
                           m_YimBwd[1], e3Fwd_cdot_dHe3, e3Bwd_cdot_dHe3);
 
    Vmath::Svtvp(nTraceNumPoints, 1.0, numfluxFwd[0], 1, e1Fwd_cdot_ncrossdE, 1,
                 numfluxFwd[0], 1);
    Vmath::Svtvp(nTraceNumPoints, 1.0, numfluxFwd[1], 1, e2Fwd_cdot_ncrossdE, 1,
                 numfluxFwd[1], 1);
    Vmath::Svtvp(nTraceNumPoints, -1.0, numfluxFwd[2], 1, e3Fwd_cdot_dHe3, 1,
                 numfluxFwd[2], 1);
 
    Vmath::Svtvp(nTraceNumPoints, 1.0, numfluxBwd[0], 1, e1Bwd_cdot_ncrossdE, 1,
                 numfluxBwd[0], 1);
    Vmath::Svtvp(nTraceNumPoints, 1.0, numfluxBwd[1], 1, e2Bwd_cdot_ncrossdE, 1,
                 numfluxBwd[1], 1);
    Vmath::Svtvp(nTraceNumPoints, -1.0, numfluxBwd[2], 1, e3Bwd_cdot_dHe3, 1,
                 numfluxBwd[2], 1);
}

References ComputeNtimesF12(), ComputeNtimesFz(), ComputeNtimestimesdF12(), ComputeNtimestimesdFz(), CopyBoundaryTrace(), Nektar::SolverUtils::eFwdEQBwd, Nektar::SolverUtils::eFwdEQNegBwd, GetIncidentField(), Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_spacedim, m_YimBwd, m_YimFwd, m_ZimBwd, m_ZimFwd, and Vmath::Svtvp().

Referenced by NumericalMaxwellFlux().

◆ NumericalMaxwellFluxTM()

void Nektar::SolverUtils::MMFSystem::NumericalMaxwellFluxTM	(	Array< OneD, Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	numfluxFwd,
		Array< OneD, Array< OneD, NekDouble > > &	numfluxBwd,
		const NekDouble	time
	)

protected

Definition at line 1801 of file MMFSystem.cpp.

{
    int nq              = m_fields[0]->GetNpoints();
    int nTraceNumPoints = GetTraceTotPoints();
    int nvar            = physfield.size();
 
    // get temporary arrays
    Array<OneD, Array<OneD, NekDouble>> Fwd(nvar);
    Array<OneD, Array<OneD, NekDouble>> Bwd(nvar);
    for (int i = 0; i < nvar; ++i)
    {
        Fwd[i] = Array<OneD, NekDouble>(nTraceNumPoints, 0.0);
        Bwd[i] = Array<OneD, NekDouble>(nTraceNumPoints, 0.0);
 
        // get the physical values at the trace
        m_fields[i]->GetFwdBwdTracePhys(physfield[i], Fwd[i], Bwd[i]);
    }
 
    // E^|| = 0 at the PEC boundaries vs. H^|| = 0 at PMC boundaries
    Array<OneD, NekDouble> IncField(nq, 0.0);
    Array<OneD, NekDouble> IncFieldBwd(nTraceNumPoints, 0.0);
    Array<OneD, Array<OneD, NekDouble>> IncFieldFwd(m_spacedim);
    for (int i = 0; i < m_spacedim; ++i)
    {
        IncFieldFwd[i] = Array<OneD, NekDouble>(nTraceNumPoints, 0.0);
 
        IncField = GetIncidentField(i, time);
        m_fields[0]->GetFwdBwdTracePhys(IncField, IncFieldFwd[i], IncFieldBwd);
 
        Vmath::Svtvp(nTraceNumPoints, 2.0, &IncFieldFwd[i][0], 1, &Fwd[i][0], 1,
                     &IncFieldFwd[i][0], 1);
    }
 
    // Total Field Formulation
    CopyBoundaryTrace(Fwd[0], Bwd[0], SolverUtils::eFwdEQBwd, 0, "PEC_Forces");
    CopyBoundaryTrace(Fwd[1], Bwd[1], SolverUtils::eFwdEQBwd, 1, "PEC_Forces");
    CopyBoundaryTrace(IncFieldFwd[2], Bwd[2], SolverUtils::eFwdEQNegBwd, 2,
                      "PEC_Forces");
 
    CopyBoundaryTrace(IncFieldFwd[0], Bwd[0], SolverUtils::eFwdEQNegBwd, 0,
                      "PMC_Forces");
    CopyBoundaryTrace(IncFieldFwd[1], Bwd[1], SolverUtils::eFwdEQNegBwd, 1,
                      "PMC_Forces");
    CopyBoundaryTrace(Fwd[2], Bwd[2], SolverUtils::eFwdEQBwd, 2, "PMC_Forces");
 
    CopyBoundaryTrace(Fwd[0], Bwd[0], SolverUtils::eFwdEQBwd, 0, "PEC");
    CopyBoundaryTrace(Fwd[1], Bwd[1], SolverUtils::eFwdEQBwd, 1, "PEC");
    CopyBoundaryTrace(Fwd[2], Bwd[2], SolverUtils::eFwdEQNegBwd, 2, "PEC");
 
    CopyBoundaryTrace(Fwd[0], Bwd[0], SolverUtils::eFwdEQNegBwd, 0, "PMC");
    CopyBoundaryTrace(Fwd[1], Bwd[1], SolverUtils::eFwdEQNegBwd, 1, "PMC");
    CopyBoundaryTrace(Fwd[2], Bwd[2], SolverUtils::eFwdEQBwd, 2, "PMC");
 
    Array<OneD, NekDouble> e1Fwd_cdot_ncrossdH(nTraceNumPoints, 0.0);
    Array<OneD, NekDouble> e1Bwd_cdot_ncrossdH(nTraceNumPoints, 0.0);
    Array<OneD, NekDouble> e2Fwd_cdot_ncrossdH(nTraceNumPoints, 0.0);
    Array<OneD, NekDouble> e2Bwd_cdot_ncrossdH(nTraceNumPoints, 0.0);
    Array<OneD, NekDouble> e3Fwd_cdot_dEe3(nTraceNumPoints, 0.0);
    Array<OneD, NekDouble> e3Bwd_cdot_dEe3(nTraceNumPoints, 0.0);
 
    // Compute  numfluxFwd[dir] = (eFwd^[dir] \cdot n \times e^3) * (YimFwd *
    // EFwd^3 + YimBwd * EBwd^3 )
    ComputeNtimesFz(0, Fwd, Bwd, m_YimFwd[0], m_YimBwd[0], numfluxFwd[0],
                    numfluxBwd[0]);
    ComputeNtimesFz(1, Fwd, Bwd, m_YimFwd[1], m_YimBwd[1], numfluxFwd[1],
                    numfluxBwd[1]);
 
    // Compute numfluxFwd[2] = eFwd^3 \cdot ( n1e1 \times ( ZimFwd HFwd + ZimBwd
    // HBwd ) ) / 2 {{Z_i}}
    ComputeNtimesF12(Fwd, Bwd, m_ZimFwd[0], m_ZimBwd[0], m_ZimFwd[1],
                     m_ZimBwd[1], numfluxFwd[2], numfluxBwd[2]);
 
    // Compute e1Fwd_cdot_ncrossdE = eFwd[dir] \cdot \alpha n \times n \times
    // [H] / 2 {{YimFwd}}
    ComputeNtimestimesdFz(0, Fwd, Bwd, m_YimFwd[0], m_YimBwd[0],
                          e1Fwd_cdot_ncrossdH, e1Bwd_cdot_ncrossdH);
    ComputeNtimestimesdFz(1, Fwd, Bwd, m_YimFwd[1], m_YimBwd[1],
                          e2Fwd_cdot_ncrossdH, e2Bwd_cdot_ncrossdH);
 
    // Compute  \alpha [E3] * ( 1/2{{Zim1}} + 1/2{{Zim2}} )
    ComputeNtimestimesdF12(Fwd, Bwd, m_ZimFwd[0], m_ZimBwd[0], m_ZimFwd[1],
                           m_ZimBwd[1], e3Fwd_cdot_dEe3, e3Bwd_cdot_dEe3);
 
    Vmath::Svtvp(nTraceNumPoints, -1.0, numfluxFwd[0], 1, e1Fwd_cdot_ncrossdH,
                 1, numfluxFwd[0], 1);
    Vmath::Svtvp(nTraceNumPoints, -1.0, numfluxFwd[1], 1, e2Fwd_cdot_ncrossdH,
                 1, numfluxFwd[1], 1);
    Vmath::Svtvp(nTraceNumPoints, 1.0, numfluxFwd[2], 1, e3Fwd_cdot_dEe3, 1,
                 numfluxFwd[2], 1);
 
    Vmath::Svtvp(nTraceNumPoints, -1.0, numfluxBwd[0], 1, e1Bwd_cdot_ncrossdH,
                 1, numfluxBwd[0], 1);
    Vmath::Svtvp(nTraceNumPoints, -1.0, numfluxBwd[1], 1, e2Bwd_cdot_ncrossdH,
                 1, numfluxBwd[1], 1);
    Vmath::Svtvp(nTraceNumPoints, 1.0, numfluxBwd[2], 1, e3Bwd_cdot_dEe3, 1,
                 numfluxBwd[2], 1);
}

References ComputeNtimesF12(), ComputeNtimesFz(), ComputeNtimestimesdF12(), ComputeNtimestimesdFz(), CopyBoundaryTrace(), Nektar::SolverUtils::eFwdEQBwd, Nektar::SolverUtils::eFwdEQNegBwd, GetIncidentField(), Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_spacedim, m_YimBwd, m_YimFwd, m_ZimBwd, m_ZimFwd, and Vmath::Svtvp().

Referenced by NumericalMaxwellFlux().

◆ RootMeanSquare()

NekDouble Nektar::SolverUtils::MMFSystem::RootMeanSquare ( const Array< OneD, const NekDouble > & inarray )

protected

Definition at line 2338 of file MMFSystem.cpp.

{
    int Ntot = inarray.size();
 
    NekDouble reval = 0.0;
    for (int i = 0; i < Ntot; ++i)
    {
        reval = reval + inarray[i] * inarray[i];
    }
    reval = sqrt(reval / Ntot);
 
    return reval;
}

References tinysimd::sqrt().

Referenced by Computedemdxicdote(), ComputencdotMF(), ComputeZimYim(), Nektar::MMFAdvection::EvaluateAdvectionVelocity(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::MMFAdvection::v_InitObject(), Nektar::MMFMaxwell::v_InitObject(), and VectorAvgMagnitude().

◆ SetUpMovingFrames()

void Nektar::SolverUtils::MMFSystem::SetUpMovingFrames	(	const Array< OneD, const Array< OneD, NekDouble > > &	Anisotropy,
		const int	TangentXelem
	)

protected

Definition at line 118 of file MMFSystem.cpp.

{
 
    int nq    = m_fields[0]->GetNpoints();
    int MFdim = 3;
 
    // Construct The Moving Frames
    m_movingframes = Array<OneD, Array<OneD, NekDouble>>(MFdim);
 
    for (int j = 0; j < MFdim; ++j)
    {
        m_movingframes[j] = Array<OneD, NekDouble>(m_spacedim * nq, 0.0);
    }
 
    // Read MMF Geom Info
    std::string conn = "TangentX";
    m_MMFfactors     = Array<OneD, NekDouble>(4);
 
    m_session->LoadSolverInfo("MMFDir", conn, "LOCAL");
 
    // (x-x_0)^2/a^2 + (y-y_0)^2/b^2 = 1
    // factors[0] = a
    // factors[1] = b
    // factors[2] = x_0
    // factors[3] = y_0
    m_session->LoadParameter("MMFCircAxisX", m_MMFfactors[0], 1.0);
    m_session->LoadParameter("MMFCircAxisY", m_MMFfactors[1], 1.0);
    m_session->LoadParameter("MMFCircCentreX", m_MMFfactors[2], 0.0);
    m_session->LoadParameter("MMFCircCentreY", m_MMFfactors[3], 0.0);
 
    if (conn == "TangentX")
    {
        m_MMFdir = SpatialDomains::eTangentX;
    }
    if (conn == "TangentY")
    {
        m_MMFdir = SpatialDomains::eTangentY;
    }
    if (conn == "TangentXY")
    {
        m_MMFdir = SpatialDomains::eTangentXY;
    }
    if (conn == "TangentZ")
    {
        m_MMFdir = SpatialDomains::eTangentZ;
    }
    if (conn == "TangentCircular")
    {
        m_MMFdir = SpatialDomains::eTangentCircular;
    }
    if (conn == "TangentIrregular")
    {
        m_MMFdir = SpatialDomains::eTangentIrregular;
    }
    if (conn == "TangentNonconvex")
    {
        m_MMFdir = SpatialDomains::eTangentNonconvex;
    }
    if (conn == "LOCAL")
    {
        m_MMFdir = SpatialDomains::eLOCAL;
    }
 
    // Get Tangetn vectors from GeomFactors2D, Orthonormalized = true
    m_fields[0]->GetMovingFrames(m_MMFdir, m_MMFfactors, m_movingframes);
 
    // Align the tangentX direction after TangentXelem
    if (TangentXelem > 0)
    {
        Array<OneD, NekDouble> tmp(nq);
        m_fields[0]->GenerateElementVector(TangentXelem, 1.0, 0.0, tmp);
        for (int j = 0; j < m_shapedim; j++)
        {
            for (int k = 0; k < m_spacedim; k++)
            {
                Vmath::Vmul(nq, &tmp[0], 1, &m_movingframes[j][k * nq], 1,
                            &m_movingframes[j][k * nq], 1);
            }
        }
 
        m_fields[0]->GenerateElementVector(TangentXelem, 0.0, 1.0, tmp);
        Vmath::Vadd(nq, &tmp[0], 1, &m_movingframes[0][0 * nq], 1,
                    &m_movingframes[0][0 * nq], 1);
        Vmath::Vadd(nq, &tmp[0], 1, &m_movingframes[1][1 * nq], 1,
                    &m_movingframes[1][1 * nq], 1);
 
        int indxtmp = Vmath::Imax(nq, tmp, 1);
        std::cout << "*** MF in PML Region is aligned as MF1 = ( "
                  << m_movingframes[0][indxtmp] << " , "
                  << m_movingframes[0][nq + indxtmp] << " , "
                  << m_movingframes[0][2 * nq + indxtmp] << " ) "
                  << ", MF2 = ( " << m_movingframes[1][indxtmp] << " , "
                  << m_movingframes[1][nq + indxtmp] << " , "
                  << m_movingframes[1][2 * nq + indxtmp] << " ) " << std::endl;
    }
 
    // Multiply Anisotropy to movingframes
    for (int j = 0; j < m_shapedim; ++j)
    {
        for (int k = 0; k < m_spacedim; ++k)
        {
            Vmath::Vmul(nq, &Anisotropy[j][0], 1, &m_movingframes[j][k * nq], 1,
                        &m_movingframes[j][k * nq], 1);
        }
    }
 
    // Test the moving frames
    CheckMovingFrames(m_movingframes);
}

Referenced by MMFInitObject().

◆ UpwindMaxwellFlux1D()

void Nektar::SolverUtils::MMFSystem::UpwindMaxwellFlux1D	(	Array< OneD, Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	numfluxFwd,
		Array< OneD, Array< OneD, NekDouble > > &	numfluxBwd
	)

protected

Definition at line 1455 of file MMFSystem.cpp.

{
    int i;
    int nTraceNumPoints = GetTraceTotPoints();
    int nvar            = 2;
 
    // get temporary arrays
    Array<OneD, Array<OneD, NekDouble>> Fwd(nvar);
    Array<OneD, Array<OneD, NekDouble>> Bwd(nvar);
 
    for (i = 0; i < nvar; ++i)
    {
        Fwd[i] = Array<OneD, NekDouble>(nTraceNumPoints);
        Bwd[i] = Array<OneD, NekDouble>(nTraceNumPoints);
    }
 
    // get the physical values at the trace from the dependent variables
    for (i = 0; i < nvar; ++i)
    {
        m_fields[i]->GetFwdBwdTracePhys(physfield[i], Fwd[i], Bwd[i]);
    }
 
    // E = 0 at the boundaries
    CopyBoundaryTrace(Fwd[0], Bwd[0], SolverUtils::eFwdEQNegBwd, 0, "PEC");
 
    // d H / d n = 0 at the boundaries
    CopyBoundaryTrace(Fwd[1], Bwd[1], SolverUtils::eFwdEQBwd, 1, "PEC");
 
    Array<OneD, NekDouble> dE(nTraceNumPoints);
    Array<OneD, NekDouble> dH(nTraceNumPoints);
 
    Vmath::Vsub(nTraceNumPoints, &Fwd[0][0], 1, &Bwd[0][0], 1, &dE[0], 1);
    Vmath::Vsub(nTraceNumPoints, &Fwd[1][0], 1, &Bwd[1][0], 1, &dH[0], 1);
 
    NekDouble nx, AverZ, AverY, AverZH, AverYE;
    for (i = 0; i < nTraceNumPoints; ++i)
    {
        nx     = m_traceNormals[0][i];
        AverZ  = m_ZimFwd[0][i] + m_ZimBwd[0][i];
        AverY  = m_YimFwd[0][i] + m_YimBwd[0][i];
        AverZH = m_ZimFwd[0][i] * Fwd[1][i] + m_ZimBwd[0][i] * Bwd[1][i];
        AverYE = m_YimFwd[0][i] * Fwd[0][i] + m_YimBwd[0][i] * Bwd[0][i];
 
        numfluxFwd[0][i] = nx / AverZ * (AverZH - nx * dE[i]);
        numfluxFwd[1][i] = nx / AverY * (AverYE - nx * dH[i]);
 
        numfluxBwd[0][i] = nx / AverZ * (AverZH - nx * dE[i]);
        numfluxBwd[1][i] = nx / AverY * (AverYE - nx * dH[i]);
    }
}

References CopyBoundaryTrace(), Nektar::SolverUtils::eFwdEQBwd, Nektar::SolverUtils::eFwdEQNegBwd, Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_traceNormals, m_YimBwd, m_YimFwd, m_ZimBwd, m_ZimFwd, and Vmath::Vsub().

Referenced by NumericalMaxwellFlux().

◆ v_GenerateSummary()

void Nektar::SolverUtils::MMFSystem::v_GenerateSummary ( SummaryList & l )

overridevirtual

Virtual function for generating summary information.

Reimplemented from Nektar::SolverUtils::EquationSystem.

Reimplemented in Nektar::MMFAdvection, Nektar::MMFDiffusion, Nektar::MMFMaxwell, and Nektar::MMFSWE.

Definition at line 2463 of file MMFSystem.cpp.

{
    int nq = m_fields[0]->GetNpoints();
    UnsteadySystem::v_GenerateSummary(s);
 
    AddSummaryItem(s, "Total grids", nq);
    AddSummaryItem(s, "Shape Dimension", m_shapedim);
    AddSummaryItem(s, "Surface", SurfaceTypeMap[m_surfaceType]);
    if (m_surfaceType == eSphere)
    {
        NekDouble MeshError;
 
        Array<OneD, NekDouble> x(nq);
        Array<OneD, NekDouble> y(nq);
        Array<OneD, NekDouble> z(nq);
        Array<OneD, NekDouble> rad(nq, 0.0);
 
        m_fields[0]->GetCoords(x, y, z);
 
        Vmath::Vvtvp(nq, x, 1, x, 1, rad, 1, rad, 1);
        Vmath::Vvtvp(nq, y, 1, y, 1, rad, 1, rad, 1);
        Vmath::Vvtvp(nq, z, 1, z, 1, rad, 1, rad, 1);
        Vmath::Vsqrt(nq, rad, 1, rad, 1);
 
        Vmath::Sadd(nq, -1.0, rad, 1, rad, 1);
        Vmath::Vabs(nq, rad, 1, rad, 1);
 
        MeshError = m_fields[0]->Integral(rad);
        SolverUtils::AddSummaryItem(s, "Mesh Error", MeshError);
    }
 
    AddSummaryItem(s, "MMFdir", SpatialDomains::GeomMMFMap[m_MMFdir]);
    AddSummaryItem(s, "SmoothFactor", m_SmoothFactor);
    AddSummaryItem(s, "SFinit", m_SFinit);
 
    if (fabs(m_alpha - 1.0) > 0.001)
    {
        AddSummaryItem(s, "Alpha", m_alpha);
    }
 
    if (m_Incfreq > 0.0)
    {
        AddSummaryItem(s, "Incfreq", m_Incfreq);
    }
 
    if (m_MMFdir == 4)
    {
        AddSummaryItem(s, "MMFCircAxisX", m_MMFfactors[0]);
        AddSummaryItem(s, "MMFCircAxisY", m_MMFfactors[1]);
        AddSummaryItem(s, "MMFCircCentreX", m_MMFfactors[2]);
        AddSummaryItem(s, "MMFCircCentreY", m_MMFfactors[3]);
    }
}

References Nektar::SolverUtils::AddSummaryItem(), Nektar::SolverUtils::eSphere, Nektar::SpatialDomains::GeomMMFMap, m_alpha, Nektar::SolverUtils::EquationSystem::m_fields, m_Incfreq, m_MMFdir, m_MMFfactors, m_SFinit, m_shapedim, m_SmoothFactor, m_surfaceType, Nektar::LibUtilities::rad(), Vmath::Sadd(), Nektar::SolverUtils::SurfaceTypeMap, Nektar::SolverUtils::UnsteadySystem::v_GenerateSummary(), Vmath::Vabs(), Vmath::Vsqrt(), Vmath::Vvtvp(), and Nektar::UnitTests::z().

Referenced by Nektar::MMFAdvection::v_GenerateSummary(), Nektar::MMFDiffusion::v_GenerateSummary(), Nektar::MMFMaxwell::v_GenerateSummary(), and Nektar::MMFSWE::v_GenerateSummary().

◆ VectorAvgMagnitude()

NekDouble Nektar::SolverUtils::MMFSystem::VectorAvgMagnitude ( const Array< OneD, const Array< OneD, NekDouble > > & inarray )

protected

Definition at line 2352 of file MMFSystem.cpp.

{
    int nq = inarray[0].size();
 
    Array<OneD, NekDouble> tmp(nq, 0.0);
    for (int k = 0; k < m_spacedim; k++)
    {
        Vmath::Vvtvp(nq, &inarray[k][0], 1, &inarray[k][0], 1, &tmp[0], 1,
                     &tmp[0], 1);
    }
    Vmath::Vsqrt(nq, tmp, 1, tmp, 1);
 
    return RootMeanSquare(tmp);
}

References Nektar::SolverUtils::EquationSystem::m_spacedim, RootMeanSquare(), Vmath::Vsqrt(), and Vmath::Vvtvp().

Referenced by ComputeMFtrace(), and ComputeNtimesMF().

◆ VectorCrossProd() [1/2]

void Nektar::SolverUtils::MMFSystem::VectorCrossProd	(	const Array< OneD, const Array< OneD, NekDouble > > &	v1,
		const Array< OneD, const Array< OneD, NekDouble > > &	v2,
		Array< OneD, Array< OneD, NekDouble > > &	v3
	)

protected

Computes the vector cross-product in 3D of v1 and v2, storing the result in v3.

Parameters

v1	First input vector.
v2	Second input vector.
v3	Output vector computed to be orthogonal to both v1 and v2.

Definition at line 696 of file MMFSystem.cpp.

{
    ASSERTL0(v1.size() == 3, "Input 1 has dimension not equal to 3.");
    ASSERTL0(v2.size() == 3, "Input 2 has dimension not equal to 3.");
    ASSERTL0(v3.size() == 3, "Output vector has dimension not equal to 3.");
 
    int nq = v1[0].size();
    Array<OneD, NekDouble> temp(nq);
 
    Vmath::Vmul(nq, v1[2], 1, v2[1], 1, temp, 1);
    Vmath::Vvtvm(nq, v1[1], 1, v2[2], 1, temp, 1, v3[0], 1);
 
    Vmath::Vmul(nq, v1[0], 1, v2[2], 1, temp, 1);
    Vmath::Vvtvm(nq, v1[2], 1, v2[0], 1, temp, 1, v3[1], 1);
 
    Vmath::Vmul(nq, v1[1], 1, v2[0], 1, temp, 1);
    Vmath::Vvtvm(nq, v1[0], 1, v2[1], 1, temp, 1, v3[2], 1);
}

References ASSERTL0, Vmath::Vmul(), and Vmath::Vvtvm().

Referenced by ComputencdotMF(), ComputeNtimesF12(), ComputeNtimesMF(), ComputeNtimestimesdFz(), DeriveCrossProductMF(), and Nektar::MMFAdvection::EvaluateAdvectionVelocity().

◆ VectorCrossProd() [2/2]

void Nektar::SolverUtils::MMFSystem::VectorCrossProd	(	const Array< OneD, NekDouble > &	v1,
		const Array< OneD, NekDouble > &	v2,
		Array< OneD, NekDouble > &	v3
	)

protected

Definition at line 718 of file MMFSystem.cpp.

{
    ASSERTL0(v1.size() == 3, "Input 1 has dimension not equal to 3.");
    ASSERTL0(v2.size() == 3, "Input 2 has dimension not equal to 3.");
    ASSERTL0(v3.size() == 3, "Output vector has dimension not equal to 3.");
 
    v3[0] = v1[1] * v2[2] - v1[2] * v2[1];
    v3[1] = v1[2] * v2[0] - v1[0] * v2[2];
    v3[2] = v1[0] * v2[1] - v1[1] * v2[0];
}

References ASSERTL0.

◆ VectorDotProd()

void Nektar::SolverUtils::MMFSystem::VectorDotProd	(	const Array< OneD, const Array< OneD, NekDouble > > &	v1,
		const Array< OneD, const Array< OneD, NekDouble > > &	v2,
		Array< OneD, NekDouble > &	v3
	)

protected

Definition at line 673 of file MMFSystem.cpp.

{
    int coordim = v1.size();
    int nq      = v1[0].size();
 
    v3 = Array<OneD, NekDouble>(nq, 0.0);
    for (int i = 0; i < coordim; ++i)
    {
        Vmath::Vvtvp(nq, &v1[i][0], 1, &v2[i][0], 1, &v3[0], 1, &v3[0], 1);
    }
}

References Vmath::Vvtvp().

Referenced by ComputencdotMF().

Member Data Documentation

◆ m_alpha

NekDouble Nektar::SolverUtils::MMFSystem::m_alpha

protected

Definition at line 177 of file MMFSystem.h.

Referenced by ComputeNtimestimesdF12(), ComputeNtimestimesdFz(), MMFInitObject(), and v_GenerateSummary().

◆ m_CurlMF

Array<OneD, Array<OneD, Array<OneD, NekDouble> > > Nektar::SolverUtils::MMFSystem::m_CurlMF

protected

Definition at line 193 of file MMFSystem.h.

Referenced by Nektar::MMFMaxwell::AddGreenDerivCompensate(), ComputeDivCurlMF(), and Nektar::MMFSWE::ComputeVorticity().

◆ m_dedxi_cdot_e

Array<OneD, Array<OneD, Array<OneD, Array<OneD, NekDouble> > > > Nektar::SolverUtils::MMFSystem::m_dedxi_cdot_e

protected

Definition at line 217 of file MMFSystem.h.

Referenced by AdddedtMaxwell(), and Computedemdxicdote().

◆ m_DivMF

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::MMFSystem::m_DivMF

protected

Definition at line 192 of file MMFSystem.h.

Referenced by Nektar::MMFSWE::AddDivForGradient(), ComputeDivCurlMF(), and Nektar::MMFDiffusion::v_InitObject().

◆ m_epsvec

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::MMFSystem::m_epsvec

protected

Definition at line 209 of file MMFSystem.h.

Referenced by Nektar::MMFMaxwell::AddCoriolis(), AdddedtMaxwell(), Nektar::MMFMaxwell::DoOdeRhs(), and Nektar::MMFMaxwell::v_InitObject().

◆ m_Incfreq

NekDouble Nektar::SolverUtils::MMFSystem::m_Incfreq

protected

Definition at line 179 of file MMFSystem.h.

Referenced by Nektar::MMFMaxwell::ComputeMaterialOpticalCloak(), GetIncidentField(), MMFInitObject(), v_GenerateSummary(), and Nektar::MMFMaxwell::v_InitObject().

◆ m_IncType

IncType Nektar::SolverUtils::MMFSystem::m_IncType

Definition at line 155 of file MMFSystem.h.

Referenced by GetIncidentField(), Nektar::MMFMaxwell::v_GenerateSummary(), and Nektar::MMFMaxwell::v_InitObject().

◆ m_MFtraceBwd

Array<OneD, Array<OneD, Array<OneD, NekDouble> > > Nektar::SolverUtils::MMFSystem::m_MFtraceBwd

protected

Definition at line 197 of file MMFSystem.h.

Referenced by Nektar::MMFSWE::ComputeMagAndDot(), ComputeMFtrace(), ComputeNtimesF12(), ComputeNtimesFz(), ComputeNtimesMF(), and ComputeNtimestimesdFz().

◆ m_MFtraceFwd

Array<OneD, Array<OneD, Array<OneD, NekDouble> > > Nektar::SolverUtils::MMFSystem::m_MFtraceFwd

protected

Definition at line 196 of file MMFSystem.h.

Referenced by Nektar::MMFSWE::ComputeMagAndDot(), ComputeMFtrace(), ComputencdotMF(), ComputeNtimesF12(), ComputeNtimesFz(), ComputeNtimesMF(), and ComputeNtimestimesdFz().

◆ m_MMFdir

SpatialDomains::GeomMMF Nektar::SolverUtils::MMFSystem::m_MMFdir

protected

Definition at line 219 of file MMFSystem.h.

Referenced by CheckMovingFrames(), Nektar::MMFMaxwell::ComputeRadCloak(), SetUpMovingFrames(), and v_GenerateSummary().

◆ m_MMFfactors

Array<OneD, NekDouble> Nektar::SolverUtils::MMFSystem::m_MMFfactors

Definition at line 157 of file MMFSystem.h.

Referenced by Nektar::MMFMaxwell::ComputeMaterialOpticalCloak(), Nektar::MMFMaxwell::ComputeRadCloak(), Nektar::MMFMaxwell::GenerateSigmaPML(), Nektar::MMFMaxwell::Printout_SurfaceCurrent(), SetUpMovingFrames(), and v_GenerateSummary().

◆ m_movingframes

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::MMFSystem::m_movingframes

protected

Definition at line 183 of file MMFSystem.h.

Referenced by CartesianToMovingframes(), Nektar::MMFMaxwell::Checkpoint_EDFluxOutput(), Nektar::MMFSWE::Checkpoint_Output_Cartesian(), Nektar::MMFMaxwell::Checkpoint_PlotOutput(), Nektar::MMFMaxwell::Checkpoint_TotPlotOutput(), Nektar::MMFSWE::Compute_demdt_cdot_ek(), Computedemdxicdote(), ComputeDivCurlMF(), ComputeMFtrace(), Nektar::MMFAdvection::ComputeNablaCdotVelocity(), Nektar::MMFSWE::ComputeNablaCdotVelocity(), ComputencdotMF(), Nektar::MMFAdvection::ComputeveldotMF(), Nektar::MMFSWE::ComputeVorticity(), DeriveCrossProductMF(), Nektar::MMFAdvection::EvaluateAdvectionVelocity(), Nektar::MMFSWE::EvaluateWaterDepth(), GetIncidentField(), SetUpMovingFrames(), Nektar::MMFMaxwell::TestMaxwell2DPEC(), Nektar::MMFMaxwell::TestMaxwell2DPMC(), Nektar::MMFDiffusion::v_InitObject(), Nektar::MMFAdvection::v_InitObject(), Nektar::MMFAdvection::WeakDGDirectionalAdvection(), and Nektar::MMFSWE::WeakDGSWEDirDeriv().

◆ m_muvec

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::MMFSystem::m_muvec

protected

Definition at line 210 of file MMFSystem.h.

Referenced by Nektar::MMFMaxwell::AddCoriolis(), AdddedtMaxwell(), Nektar::MMFMaxwell::DoOdeRhs(), and Nektar::MMFMaxwell::v_InitObject().

◆ m_ncdotMFBwd

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::MMFSystem::m_ncdotMFBwd

protected

Definition at line 187 of file MMFSystem.h.

Referenced by ComputencdotMF(), Nektar::MMFSWE::LaxFriedrichFlux(), Nektar::MMFSWE::NumericalSWEFlux(), Nektar::MMFSWE::RusanovFlux(), and Nektar::MMFAdvection::WeakDGDirectionalAdvection().

◆ m_ncdotMFFwd

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::MMFSystem::m_ncdotMFFwd

protected

Definition at line 186 of file MMFSystem.h.

Referenced by ComputencdotMF(), ComputeNtimesF12(), Nektar::MMFSWE::LaxFriedrichFlux(), Nektar::MMFSWE::NumericalSWEFlux(), Nektar::MMFSWE::RusanovFlux(), Nektar::MMFSWE::WallBoundary2D(), and Nektar::MMFAdvection::WeakDGDirectionalAdvection().

◆ m_negepsvecminus1

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::MMFSystem::m_negepsvecminus1

protected

Definition at line 212 of file MMFSystem.h.

Referenced by Nektar::MMFMaxwell::DoOdeRhs(), and Nektar::MMFMaxwell::v_InitObject().

◆ m_negmuvecminus1

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::MMFSystem::m_negmuvecminus1

protected

Definition at line 213 of file MMFSystem.h.

Referenced by Nektar::MMFMaxwell::DoOdeRhs(), and Nektar::MMFMaxwell::v_InitObject().

◆ m_nperpcdotMFBwd

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::MMFSystem::m_nperpcdotMFBwd

protected

Definition at line 190 of file MMFSystem.h.

Referenced by ComputencdotMF(), and Nektar::MMFSWE::NumericalSWEFlux().

◆ m_nperpcdotMFFwd

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::MMFSystem::m_nperpcdotMFFwd

protected

Definition at line 189 of file MMFSystem.h.

Referenced by ComputencdotMF(), Nektar::MMFSWE::NumericalSWEFlux(), and Nektar::MMFSWE::WallBoundary2D().

◆ m_ntimes_ntimesMFBwd

Array<OneD, Array<OneD, Array<OneD, NekDouble> > > Nektar::SolverUtils::MMFSystem::m_ntimes_ntimesMFBwd

protected

Definition at line 202 of file MMFSystem.h.

Referenced by ComputeNtimesMF().

◆ m_ntimes_ntimesMFFwd

Array<OneD, Array<OneD, Array<OneD, NekDouble> > > Nektar::SolverUtils::MMFSystem::m_ntimes_ntimesMFFwd

protected

Definition at line 201 of file MMFSystem.h.

Referenced by ComputeNtimesMF().

◆ m_ntimesMFBwd

Array<OneD, Array<OneD, Array<OneD, NekDouble> > > Nektar::SolverUtils::MMFSystem::m_ntimesMFBwd

protected

Definition at line 200 of file MMFSystem.h.

Referenced by ComputeNtimesFz(), and ComputeNtimesMF().

◆ m_ntimesMFFwd

Array<OneD, Array<OneD, Array<OneD, NekDouble> > > Nektar::SolverUtils::MMFSystem::m_ntimesMFFwd

protected

Definition at line 199 of file MMFSystem.h.

Referenced by ComputeNtimesFz(), ComputeNtimesMF(), and Nektar::MMFMaxwell::ComputeSurfaceCurrent().

◆ m_pi

NekDouble Nektar::SolverUtils::MMFSystem::m_pi

◆ m_PolType

PolType Nektar::SolverUtils::MMFSystem::m_PolType

Definition at line 154 of file MMFSystem.h.

◆ m_SFinit

NekDouble Nektar::SolverUtils::MMFSystem::m_SFinit

protected

Definition at line 181 of file MMFSystem.h.

Referenced by GetIncidentField(), MMFInitObject(), and v_GenerateSummary().

◆ m_shapedim

int Nektar::SolverUtils::MMFSystem::m_shapedim

Definition at line 148 of file MMFSystem.h.

Referenced by Nektar::MMFMaxwell::AddCoriolis(), Nektar::MMFSWE::AddCoriolis(), AdddedtMaxwell(), Nektar::MMFSWE::AddDivForGradient(), Nektar::MMFSWE::AddElevationEffect(), Nektar::MMFMaxwell::AddGreenDerivCompensate(), CheckMovingFrames(), Nektar::MMFSWE::Compute_demdt_cdot_ek(), Nektar::MMFAdvection::ComputeNablaCdotVelocity(), Nektar::MMFSWE::ComputeNablaCdotVelocity(), ComputencdotMF(), Nektar::MMFAdvection::ComputeveldotMF(), ComputeZimYim(), Nektar::MMFSWE::EvaluateWaterDepth(), Nektar::MMFMaxwell::GenerateSigmaPML(), MMFInitObject(), Nektar::MMFSWE::NumericalSWEFlux(), SetUpMovingFrames(), v_GenerateSummary(), Nektar::MMFAdvection::v_InitObject(), Nektar::MMFAdvection::WeakDGDirectionalAdvection(), Nektar::MMFMaxwell::WeakDGMaxwellDirDeriv(), and Nektar::MMFSWE::WeakDGSWEDirDeriv().

◆ m_SmoothFactor

int Nektar::SolverUtils::MMFSystem::m_SmoothFactor

protected

Definition at line 180 of file MMFSystem.h.

Referenced by GetIncidentField(), MMFInitObject(), and v_GenerateSummary().

◆ m_surfaceNormal

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::MMFSystem::m_surfaceNormal

protected

Definition at line 184 of file MMFSystem.h.

◆ m_surfaceType

SurfaceType Nektar::SolverUtils::MMFSystem::m_surfaceType

Definition at line 150 of file MMFSystem.h.

Referenced by Nektar::MMFAdvection::ComputeCirculatingArclength(), MMFInitObject(), v_GenerateSummary(), Nektar::MMFAdvection::v_InitObject(), and Nektar::MMFSWE::v_InitObject().

◆ m_TestMaxwellType

TestMaxwellType Nektar::SolverUtils::MMFSystem::m_TestMaxwellType

Definition at line 153 of file MMFSystem.h.

Referenced by Nektar::MMFMaxwell::AddGreenDerivCompensate(), Nektar::MMFMaxwell::ComputeMaterialVector(), ComputeZimYim(), Nektar::MMFMaxwell::DoOdeRhs(), GetMaxwellFluxVector(), NumericalMaxwellFlux(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::MMFMaxwell::v_EvaluateExactSolution(), Nektar::MMFMaxwell::v_GenerateSummary(), Nektar::MMFMaxwell::v_InitObject(), and Nektar::MMFMaxwell::v_SetInitialConditions().

◆ m_upwindType

UpwindType Nektar::SolverUtils::MMFSystem::m_upwindType

Definition at line 151 of file MMFSystem.h.

Referenced by MMFInitObject(), NumericalMaxwellFlux(), and Nektar::MMFSWE::NumericalSWEFlux().

◆ m_YimBwd

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::MMFSystem::m_YimBwd

protected

Definition at line 207 of file MMFSystem.h.

Referenced by ComputeZimYim(), NumericalMaxwellFluxTE(), NumericalMaxwellFluxTM(), and UpwindMaxwellFlux1D().

◆ m_YimFwd

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::MMFSystem::m_YimFwd

protected

Definition at line 206 of file MMFSystem.h.

Referenced by ComputeZimYim(), LaxFriedrichMaxwellFlux1D(), NumericalMaxwellFluxTE(), NumericalMaxwellFluxTM(), and UpwindMaxwellFlux1D().

◆ m_ZimBwd

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::MMFSystem::m_ZimBwd

protected

Definition at line 205 of file MMFSystem.h.

Referenced by ComputeZimYim(), NumericalMaxwellFluxTE(), NumericalMaxwellFluxTM(), and UpwindMaxwellFlux1D().

◆ m_ZimFwd

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::MMFSystem::m_ZimFwd

protected

Definition at line 204 of file MMFSystem.h.

Referenced by ComputeZimYim(), LaxFriedrichMaxwellFlux1D(), NumericalMaxwellFluxTE(), NumericalMaxwellFluxTM(), and UpwindMaxwellFlux1D().

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ MMFSystem()

◆ ~MMFSystem()

Member Function Documentation

◆ AbsIntegral()

◆ AdddedtMaxwell()

◆ AverageMaxwellFlux1D()

◆ AvgAbsInt()

◆ AvgInt()

◆ BubbleSort()

◆ CartesianToMovingframes()

◆ CartesianToSpherical()

◆ CheckMovingFrames()

◆ ComputeCurl()

◆ Computedemdxicdote()

◆ ComputeDivCurlMF()

◆ ComputeMFtrace()

◆ ComputencdotMF()

◆ ComputeNtimesF12()

◆ ComputeNtimesFz()

◆ ComputeNtimesMF()

◆ ComputeNtimestimesdF12()

◆ ComputeNtimestimesdFz()

◆ ComputeZimYim()

◆ CopyBoundaryTrace()

◆ DeriveCrossProductMF()

◆ GetIncidentField()

◆ GetMaxwellFlux1D()

◆ GetMaxwellFlux2D()

◆ GetMaxwellFluxVector()

◆ GramSchumitz()

◆ LaxFriedrichMaxwellFlux1D()

◆ MMFInitObject()

◆ NumericalMaxwellFlux()

◆ NumericalMaxwellFluxTE()

◆ NumericalMaxwellFluxTM()

◆ RootMeanSquare()

◆ SetUpMovingFrames()

◆ UpwindMaxwellFlux1D()

◆ v_GenerateSummary()

◆ VectorAvgMagnitude()

◆ VectorCrossProd() [1/2]

◆ VectorCrossProd() [2/2]

◆ VectorDotProd()

Member Data Documentation

◆ m_alpha

◆ m_CurlMF

◆ m_dedxi_cdot_e

◆ m_DivMF

◆ m_epsvec

◆ m_Incfreq

◆ m_IncType

◆ m_MFtraceBwd

◆ m_MFtraceFwd

◆ m_MMFdir

◆ m_MMFfactors

◆ m_movingframes

◆ m_muvec

◆ m_ncdotMFBwd

◆ m_ncdotMFFwd

◆ m_negepsvecminus1

◆ m_negmuvecminus1

◆ m_nperpcdotMFBwd

◆ m_nperpcdotMFFwd

◆ m_ntimes_ntimesMFBwd

◆ m_ntimes_ntimesMFFwd

◆ m_ntimesMFBwd

◆ m_ntimesMFFwd

◆ m_pi

◆ m_PolType

◆ m_SFinit

◆ m_shapedim

◆ m_SmoothFactor

◆ m_surfaceNormal