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)

virtual SOLVER_UTILS_EXPORT	~MMFSystem ()

virtual SOLVER_UTILS_EXPORT void	v_GenerateSummary (SummaryList &s)
	Print a summary of time stepping parameters. 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
virtual SOLVER_UTILS_EXPORT	~UnsteadySystem ()
	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...

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

SOLVER_UTILS_EXPORT void	SetUpTraceNormals (void)

SOLVER_UTILS_EXPORT void	InitObject ()
	Initialises the members of this object. More...

SOLVER_UTILS_EXPORT void	DoInitialise ()
	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 NekDouble	LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
	Linf error computation. 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 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	GetFinalTime ()
	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, Array< OneD, NekDouble > &output)

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 void	SetTime (const NekDouble time)

SOLVER_UTILS_EXPORT void	SetInitialStep (const int step)

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

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

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

Public Attributes inherited from Nektar::SolverUtils::UnsteadySystem
NekDouble	m_cflSafetyFactor
	CFL safety factor (comprise between 0 to 1). More...

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

virtual SOLVER_UTILS_EXPORT void	v_InitObject ()
	Init object for UnsteadySystem class. More...

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

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

virtual SOLVER_UTILS_EXPORT void	v_DoInitialise ()
	Sets up initial conditions. More...

virtual SOLVER_UTILS_EXPORT void	v_AppendOutput1D (Array< OneD, Array< OneD, NekDouble >> &solution1D)
	Print the solution at each solution point in a txt file. 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 ()

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

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

Array< OneD, NekDouble >	m_MFlength

Protected Attributes inherited from Nektar::SolverUtils::UnsteadySystem
int	m_infosteps
	Number of time steps between outputting status information. More...

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

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

int	m_nanSteps

LibUtilities::TimeIntegrationWrapperSharedPtr	m_intScheme
	Wrapper to the time integration scheme. More...

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

LibUtilities::TimeIntegrationSolutionSharedPtr	m_intSoln

NekDouble	m_epsilon

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

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

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

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

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

std::ofstream	m_errFile

std::vector< int >	m_intVariables

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

NekDouble	m_filterTimeWarning
	Number of time steps between outputting status information. More...

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

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

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_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...

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

Additional Inherited Members
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 []

Detailed Description

A base class for PDEs which include an advection component.

Definition at line 140 of file MMFSystem.h.

Constructor & Destructor Documentation

◆ MMFSystem()

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

Definition at line 43 of file MMFSystem.cpp.

     : UnsteadySystem(pSession, pGraph)
 {
 }

◆ ~MMFSystem()

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

virtual

Definition at line 49 of file MMFSystem.cpp.

50 {

51 }

Member Function Documentation

◆ AbsIntegral()

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

protected

Definition at line 2353 of file MMFSystem.cpp.

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

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

◆ AdddedtMaxwell()

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

protected

Definition at line 1369 of file MMFSystem.cpp.

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

 {
     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);
     }
 }

◆ 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 1571 of file MMFSystem.cpp.

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

 {
     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]);
     }
 }

◆ AvgAbsInt()

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

protected

Definition at line 2336 of file MMFSystem.cpp.

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

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

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

◆ AvgInt()

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

protected

Definition at line 2321 of file MMFSystem.cpp.

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

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

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

◆ BubbleSort()

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

protected

Definition at line 2397 of file MMFSystem.cpp.

 {
     int nq = refarray.num_elements();
 
     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 774 of file MMFSystem.cpp.

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

 {
     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;
 }

◆ 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 795 of file MMFSystem.cpp.

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

 {
     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;
 }

◆ CheckMovingFrames()

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

protected

Definition at line 233 of file MMFSystem.cpp.

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

 {
     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;
     }
 }

◆ ComputeCurl()

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

protected

Definition at line 734 of file MMFSystem.cpp.

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

Referenced by ComputeDivCurlMF().

 {
     int nq = inarray[0].num_elements();
 
     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);
     }
 }

◆ Computedemdxicdote()

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

protected

Definition at line 1279 of file MMFSystem.cpp.

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

 {
     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;
 }

◆ ComputeDivCurlMF()

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

protected

Definition at line 445 of file MMFSystem.cpp.

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

 {
     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;
 }

◆ ComputeMFtrace()

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

protected

Definition at line 522 of file MMFSystem.cpp.

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

 {
     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;
 }

◆ ComputencdotMF()

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

protected

Definition at line 320 of file MMFSystem.cpp.

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

 {
     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;
     }
 }

◆ 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 950 of file MMFSystem.cpp.

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

Referenced by NumericalMaxwellFluxTE(), and NumericalMaxwellFluxTM().

 {
     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;
     }
 }

◆ 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 914 of file MMFSystem.cpp.

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

Referenced by NumericalMaxwellFluxTE(), and NumericalMaxwellFluxTM().

 {
     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;
     }
 }

◆ ComputeNtimesMF()

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

protected

Definition at line 618 of file MMFSystem.cpp.

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

 {
     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;
 }

◆ 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 1079 of file MMFSystem.cpp.

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

Referenced by NumericalMaxwellFluxTE(), and NumericalMaxwellFluxTM().

 {
     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);
     }
 }

◆ 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 1013 of file MMFSystem.cpp.

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

 {
     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;
     }
 }

◆ ComputeZimYim()

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

protected

Definition at line 1107 of file MMFSystem.cpp.

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

 {
     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
 }

◆ 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 838 of file MMFSystem.cpp.

References Nektar::SolverUtils::eDirichlet, Nektar::SolverUtils::eFwdEQBwd, Nektar::SolverUtils::eFwdEQNegBwd, 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().

 {
     int id1, id2, npts, nptselem, cnt = 0, bdrycnt = 0;
     Array<OneD, NekDouble> Dirichlet, x0, x1, x2;
 
     // loop over Boundary Regions
     for (int n = 0; n < m_fields[var]->GetBndConditions().num_elements(); ++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()->GetBndCondTraceToGlobalTraceMap(
                     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);
                         bdrycnt++;
                     }
                     break;
 
                     case eFwdEQBwd:
                     {
                         Vmath::Vcopy(npts, &Fwd[id2], 1, &Bwd[id2], 1);
                         bdrycnt++;
                     }
                     break;
 
                     case eFwdEQNegBwd:
                     {
                         Vmath::Vcopy(npts, &Fwd[id2], 1, &Bwd[id2], 1);
                         Vmath::Neg(npts, &Bwd[id2], 1);
                         bdrycnt++;
                     }
                     break;
 
                     default:
                         break;
                 }
             }
         }
 
         cnt += m_fields[var]->GetBndCondExpansions()[n]->GetExpSize();
     }
 }

◆ DeriveCrossProductMF()

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

protected

Definition at line 571 of file MMFSystem.cpp.

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

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

 {
     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);
         }
     }
 }

◆ GetIncidentField()

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

protected

Definition at line 2034 of file MMFSystem.cpp.

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

 {
     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;
 }

◆ 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 1644 of file MMFSystem.cpp.

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

Referenced by GetMaxwellFluxVector().

 {
     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;
     }
 }

◆ 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 1678 of file MMFSystem.cpp.

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

Referenced by GetMaxwellFluxVector().

 {
     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");
     }
 }

◆ 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 1614 of file MMFSystem.cpp.

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

 {
     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;
     }
 }

◆ 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 2428 of file MMFSystem.cpp.

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

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

 {
 
     int nq = v1[0].num_elements();
     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]);
                 }
             }
         }
     }
 }

◆ 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 1516 of file MMFSystem.cpp.

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

 {
     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]);
     }
 }

◆ MMFInitObject()

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

Definition at line 53 of file MMFSystem.cpp.

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::MMFMaxwell::v_InitObject(), Nektar::MMFDiffusion::v_InitObject(), Nektar::MMFAdvection::v_InitObject(), and Nektar::MMFSWE::v_InitObject().

 {
     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();
 }

◆ 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 1735 of file MMFSystem.cpp.

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

 {
 
     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
 }

◆ 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 1922 of file MMFSystem.cpp.

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

 {
     int nq              = m_fields[0]->GetNpoints();
     int nTraceNumPoints = GetTraceTotPoints();
     int nvar            = physfield.num_elements();
 
     // 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);
 }

◆ 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 1812 of file MMFSystem.cpp.

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

 {
     int nq              = m_fields[0]->GetNpoints();
     int nTraceNumPoints = GetTraceTotPoints();
     int nvar            = physfield.num_elements();
 
     // 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);
 }

◆ RootMeanSquare()

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

protected

Definition at line 2367 of file MMFSystem.cpp.

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

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

◆ SetUpMovingFrames()

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

protected

Definition at line 120 of file MMFSystem.cpp.

Referenced by MMFInitObject().

 {
 
     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;
 
     /*for (int j=0; j<m_shapedim; j++)
     {
         for (int k=0; k<m_spacedim; k++)
         {
             std::cout << "before ehsan " << nq << "\t"<< m_shapedim << "\t" <<
     m_spacedim << "\t" <<"m_movingframes " << m_movingframes[j][k*nq] <<
     std::endl;
         }
     }*/
     // Get Tangetn vectors from GeomFactors2D, Orthonormalized = true
     m_fields[0]->GetMovingFrames(m_MMFdir, m_MMFfactors, m_movingframes);
     /*  for (int j=0; j<m_shapedim; j++)
       {
           for (int k=0; k<m_spacedim; k++)
           {
                 std::cout << "ehsan " << nq << "\t"<< m_shapedim << "\t" <<
       m_spacedim << "\t" <<"m_movingframes " << m_movingframes[j][k*nq] <<
       std::endl;
           }
       }*/
     // 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);
 }

◆ 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 1460 of file MMFSystem.cpp.

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

 {
     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]);
     }
 }

◆ v_GenerateSummary()

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

virtual

Print a summary of time stepping parameters.

Prints a summary with some information regards the time-stepping.

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

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

Definition at line 2492 of file MMFSystem.cpp.

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(), and Vmath::Vvtvp().

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

 {
     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]->PhysIntegral(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]);
     }
 }

◆ VectorAvgMagnitude()

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

protected

Definition at line 2381 of file MMFSystem.cpp.

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

Referenced by ComputeMFtrace(), and ComputeNtimesMF().

 {
     int nq = inarray[0].num_elements();
 
     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);
 }

◆ 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 697 of file MMFSystem.cpp.

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

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

 {
     ASSERTL0(v1.num_elements() == 3, "Input 1 has dimension not equal to 3.");
     ASSERTL0(v2.num_elements() == 3, "Input 2 has dimension not equal to 3.");
     ASSERTL0(v3.num_elements() == 3,
              "Output vector has dimension not equal to 3.");
 
     int nq = v1[0].num_elements();
     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);
 }

◆ 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 720 of file MMFSystem.cpp.

References ASSERTL0.

 {
     ASSERTL0(v1.num_elements() == 3, "Input 1 has dimension not equal to 3.");
     ASSERTL0(v2.num_elements() == 3, "Input 2 has dimension not equal to 3.");
     ASSERTL0(v3.num_elements() == 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];
 }

◆ 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 674 of file MMFSystem.cpp.

References Vmath::Vvtvp().

Referenced by ComputencdotMF().

 {
     int coordim = v1.num_elements();
     int nq      = v1[0].num_elements();
 
     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);
     }
 }

Member Data Documentation

◆ m_alpha

NekDouble Nektar::SolverUtils::MMFSystem::m_alpha

protected

Definition at line 174 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 190 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 214 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 189 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 206 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 176 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 152 of file MMFSystem.h.

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

◆ m_MFlength

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

protected

Definition at line 218 of file MMFSystem.h.

◆ m_MFtraceBwd

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

protected

Definition at line 194 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 193 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 216 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 154 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 180 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 207 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 184 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 183 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 209 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 210 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 187 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 186 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 199 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 198 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 197 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 196 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 151 of file MMFSystem.h.

◆ m_SFinit

NekDouble Nektar::SolverUtils::MMFSystem::m_SFinit

protected

Definition at line 178 of file MMFSystem.h.

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

◆ m_shapedim

int Nektar::SolverUtils::MMFSystem::m_shapedim

Definition at line 145 of file MMFSystem.h.

Referenced by Nektar::MMFSWE::AddCoriolis(), Nektar::MMFMaxwell::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 177 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 181 of file MMFSystem.h.

◆ m_surfaceType

SurfaceType Nektar::SolverUtils::MMFSystem::m_surfaceType

Definition at line 147 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 150 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 148 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 204 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 203 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 202 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 201 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_MFlength

◆ 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