The RiemannSolver class provides an abstract interface under which solvers for various Riemann problems can be implemented. More...

#include <RiemannSolver.h>

Inheritance diagram for Nektar::SolverUtils::RiemannSolver:

[legend]

Public Member Functions
SOLVER_UTILS_EXPORT void	Solve (const int nDim, const Array< OneD, const Array< OneD, NekDouble > > &Fwd, const Array< OneD, const Array< OneD, NekDouble > > &Bwd, Array< OneD, Array< OneD, NekDouble > > &flux)
	Perform the Riemann solve given the forwards and backwards spaces. More...

template<typename FuncPointerT , typename ObjectPointerT >
void	SetScalar (std::string name, FuncPointerT func, ObjectPointerT obj)

void	SetScalar (std::string name, RSScalarFuncType fp)

template<typename FuncPointerT , typename ObjectPointerT >
void	SetVector (std::string name, FuncPointerT func, ObjectPointerT obj)

void	SetVector (std::string name, RSVecFuncType fp)

template<typename FuncPointerT , typename ObjectPointerT >
void	SetParam (std::string name, FuncPointerT func, ObjectPointerT obj)

void	SetParam (std::string name, RSParamFuncType fp)

template<typename FuncPointerT , typename ObjectPointerT >
void	SetAuxScal (std::string name, FuncPointerT func, ObjectPointerT obj)

template<typename FuncPointerT , typename ObjectPointerT >
void	SetAuxVec (std::string name, FuncPointerT func, ObjectPointerT obj)

std::map< std::string, RSScalarFuncType > &	GetScalars ()

std::map< std::string, RSVecFuncType > &	GetVectors ()

std::map< std::string, RSParamFuncType > &	GetParams ()

Public Attributes
int	m_spacedim

Protected Member Functions
SOLVER_UTILS_EXPORT	RiemannSolver (const LibUtilities::SessionReaderSharedPtr &pSession)

virtual SOLVER_UTILS_EXPORT	~RiemannSolver ()

virtual void	v_Solve (const int nDim, const Array< OneD, const Array< OneD, NekDouble > > &Fwd, const Array< OneD, const Array< OneD, NekDouble > > &Bwd, Array< OneD, Array< OneD, NekDouble > > &flux)=0

void	GenerateRotationMatrices (const Array< OneD, const Array< OneD, NekDouble > > &normals)
	Generate rotation matrices for 3D expansions. More...

void	FromToRotation (Array< OneD, const NekDouble > &from, Array< OneD, const NekDouble > &to, NekDouble *mat)
	A function for creating a rotation matrix that rotates a vector from into another vector to. More...

SOLVER_UTILS_EXPORT void	rotateToNormal (const Array< OneD, const Array< OneD, NekDouble > > &inarray, const Array< OneD, const Array< OneD, NekDouble > > &normals, const Array< OneD, const Array< OneD, NekDouble > > &vecLocs, Array< OneD, Array< OneD, NekDouble > > &outarray)
	Rotate a vector field to trace normal. More...

SOLVER_UTILS_EXPORT void	rotateFromNormal (const Array< OneD, const Array< OneD, NekDouble > > &inarray, const Array< OneD, const Array< OneD, NekDouble > > &normals, const Array< OneD, const Array< OneD, NekDouble > > &vecLocs, Array< OneD, Array< OneD, NekDouble > > &outarray)
	Rotate a vector field from trace normal. More...

SOLVER_UTILS_EXPORT bool	CheckScalars (std::string name)
	Determine whether a scalar has been defined in m_scalars. More...

SOLVER_UTILS_EXPORT bool	CheckVectors (std::string name)
	Determine whether a vector has been defined in m_vectors. More...

SOLVER_UTILS_EXPORT bool	CheckParams (std::string name)
	Determine whether a parameter has been defined in m_params. More...

SOLVER_UTILS_EXPORT bool	CheckAuxScal (std::string name)
	Determine whether a scalar has been defined in m_auxScal. More...

SOLVER_UTILS_EXPORT bool	CheckAuxVec (std::string name)
	Determine whether a vector has been defined in m_auxVec. More...

Protected Attributes
bool	m_requiresRotation
	Indicates whether the Riemann solver requires a rotation to be applied to the velocity fields. More...

std::map< std::string, RSScalarFuncType >	m_scalars
	Map of scalar function types. More...

std::map< std::string, RSVecFuncType >	m_vectors
	Map of vector function types. More...

std::map< std::string, RSParamFuncType >	m_params
	Map of parameter function types. More...

std::map< std::string, RSScalarFuncType >	m_auxScal
	Map of auxiliary scalar function types. More...

std::map< std::string, RSVecFuncType >	m_auxVec
	Map of auxiliary vector function types. More...

Array< OneD, Array< OneD, NekDouble > >	m_rotMat
	Rotation matrices for each trace quadrature point. More...

Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	m_rotStorage
	Rotation storage. More...

Detailed Description

The RiemannSolver class provides an abstract interface under which solvers for various Riemann problems can be implemented.

Definition at line 59 of file RiemannSolver.h.

Constructor & Destructor Documentation

◆ RiemannSolver()

Nektar::SolverUtils::RiemannSolver::RiemannSolver ( const LibUtilities::SessionReaderSharedPtr & pSession )

protected

Definition at line 76 of file RiemannSolver.cpp.

             : m_requiresRotation(false), m_rotStorage (3)
         {
             boost::ignore_unused(pSession);
         }

◆ ~RiemannSolver()

virtual SOLVER_UTILS_EXPORT Nektar::SolverUtils::RiemannSolver::~RiemannSolver ( )

inlineprotectedvirtual

Definition at line 162 of file RiemannSolver.h.

References CheckAuxScal(), CheckAuxVec(), CheckParams(), CheckScalars(), CheckVectors(), FromToRotation(), GenerateRotationMatrices(), CellMLToNektar.pycml::name, rotateFromNormal(), rotateToNormal(), SOLVER_UTILS_EXPORT, and v_Solve().

163 {};

Member Function Documentation

◆ CheckAuxScal()

bool Nektar::SolverUtils::RiemannSolver::CheckAuxScal ( std::string name )

protected

Determine whether a scalar has been defined in m_auxScal.

Parameters

name	Scalar name.

Definition at line 364 of file RiemannSolver.cpp.

References m_auxScal.

Referenced by ~RiemannSolver().

         {
             return m_auxScal.find(name) != m_auxScal.end();
         }

◆ CheckAuxVec()

bool Nektar::SolverUtils::RiemannSolver::CheckAuxVec ( std::string name )

protected

Determine whether a vector has been defined in m_auxVec.

Parameters

name	Vector name.

Definition at line 374 of file RiemannSolver.cpp.

References m_auxVec.

Referenced by Solve(), and ~RiemannSolver().

         {
             return m_auxVec.find(name) != m_auxVec.end();
         }

◆ CheckParams()

bool Nektar::SolverUtils::RiemannSolver::CheckParams ( std::string name )

protected

Determine whether a parameter has been defined in m_params.

Parameters

name	Parameter name.

Definition at line 354 of file RiemannSolver.cpp.

References m_params.

Referenced by Nektar::UpwindPulseSolver::RiemannSolverUpwind(), and ~RiemannSolver().

         {
             return m_params.find(name) != m_params.end();
         }

◆ CheckScalars()

bool Nektar::SolverUtils::RiemannSolver::CheckScalars ( std::string name )

protected

Determine whether a scalar has been defined in m_scalars.

Parameters

name	Scalar name.

Definition at line 334 of file RiemannSolver.cpp.

References m_scalars.

Referenced by Nektar::UpwindPulseSolver::v_Solve(), Nektar::SolverUtils::UpwindSolver::v_Solve(), Nektar::SolverUtils::UpwindLDGSolver::v_Solve(), and ~RiemannSolver().

         {
             return m_scalars.find(name) != m_scalars.end();
         }

◆ CheckVectors()

bool Nektar::SolverUtils::RiemannSolver::CheckVectors ( std::string name )

protected

Determine whether a vector has been defined in m_vectors.

Parameters

name	Vector name.

Definition at line 344 of file RiemannSolver.cpp.

References m_vectors.

Referenced by Nektar::AcousticSolver::GetRotBasefield(), Solve(), and ~RiemannSolver().

         {
             return m_vectors.find(name) != m_vectors.end();
         }

◆ FromToRotation()

void Nektar::SolverUtils::RiemannSolver::FromToRotation	(	Array< OneD, const NekDouble > &	from,
		Array< OneD, const NekDouble > &	to,
		NekDouble *	mat
	)

protected

A function for creating a rotation matrix that rotates a vector from into another vector to.

Authors: Tomas Möller, John Hughes "Efficiently Building a Matrix to Rotate One Vector to Another" Journal of Graphics Tools, 4(4):1-4, 1999

Parameters

from	Normalised 3-vector to rotate from.
to	Normalised 3-vector to rotate to.
out	Resulting 3x3 rotation matrix (row-major order).

Definition at line 427 of file RiemannSolver.cpp.

References CROSS, DOT, and EPSILON.

Referenced by GenerateRotationMatrices(), and ~RiemannSolver().

         {
             NekDouble v[3];
             NekDouble e, h, f;
         
             CROSS(v, from, to);
             e = DOT(from, to);
             f = (e < 0)? -e:e;
             if (f > 1.0 - EPSILON)
             {
                 NekDouble u[3], v[3];
                 NekDouble x[3];
                 NekDouble c1, c2, c3;
                 int i, j;
             
                 x[0] = (from[0] > 0.0)? from[0] : -from[0];
                 x[1] = (from[1] > 0.0)? from[1] : -from[1];
                 x[2] = (from[2] > 0.0)? from[2] : -from[2];
             
                 if (x[0] < x[1])
                 {
                     if (x[0] < x[2])
                     {
                         x[0] = 1.0; x[1] = x[2] = 0.0;
                     }
                     else
                     {
                         x[2] = 1.0; x[0] = x[1] = 0.0;
                     }
                 }
                 else
                 {
                     if (x[1] < x[2])
                     {
                         x[1] = 1.0; x[0] = x[2] = 0.0;
                     }
                     else
                     {
                         x[2] = 1.0; x[0] = x[1] = 0.0;
                     }
                 }
             
                 u[0] = x[0] - from[0]; 
                 u[1] = x[1] - from[1]; 
                 u[2] = x[2] - from[2];
                 v[0] = x[0] - to  [0];   
                 v[1] = x[1] - to  [1];   
                 v[2] = x[2] - to  [2];
             
                 c1 = 2.0 / DOT(u, u);
                 c2 = 2.0 / DOT(v, v);
                 c3 = c1 * c2  * DOT(u, v);
                 
                 for (i = 0; i < 3; i++) {
                     for (j = 0; j < 3; j++) {
                         mat[3*i+j] =  - c1 * u[i] * u[j]
                             - c2 * v[i] * v[j]
                             + c3 * v[i] * u[j];
                     }
                     mat[i+3*i] += 1.0;
                 }
             }
             else
             {
                 NekDouble hvx, hvz, hvxy, hvxz, hvyz;
                 h = 1.0/(1.0 + e);
                 hvx = h * v[0];
                 hvz = h * v[2];
                 hvxy = hvx * v[1];
                 hvxz = hvx * v[2];
                 hvyz = hvz * v[1];
                 mat[0] = e + hvx * v[0];
                 mat[1] = hvxy - v[2];
                 mat[2] = hvxz + v[1];
                 mat[3] = hvxy + v[2];
                 mat[4] = e + h * v[1] * v[1];
                 mat[5] = hvyz - v[0];
                 mat[6] = hvxz - v[1];
                 mat[7] = hvyz + v[0];
                 mat[8] = e + hvz * v[2];
             }
         }

◆ GenerateRotationMatrices()

void Nektar::SolverUtils::RiemannSolver::GenerateRotationMatrices ( const Array< OneD, const Array< OneD, NekDouble > > & normals )

protected

Generate rotation matrices for 3D expansions.

Definition at line 382 of file RiemannSolver.cpp.

References FromToRotation(), and m_rotMat.

Referenced by rotateToNormal(), and ~RiemannSolver().

         {
             Array<OneD, NekDouble> xdir(3,0.0);
             Array<OneD, NekDouble> tn  (3);
             NekDouble tmp[9];
             const int nq = normals[0].num_elements();
             int i, j;
             xdir[0] = 1.0;
 
             // Allocate storage for rotation matrices.
             m_rotMat = Array<OneD, Array<OneD, NekDouble> >(9);
             
             for (i = 0; i < 9; ++i)
             {
                 m_rotMat[i] = Array<OneD, NekDouble>(nq);
             }
             for (i = 0; i < normals[0].num_elements(); ++i)
             {
                 // Generate matrix which takes us from (1,0,0) vector to trace
                 // normal.
                 tn[0] = normals[0][i];
                 tn[1] = normals[1][i];
                 tn[2] = normals[2][i];
                 FromToRotation(tn, xdir, tmp);
                 
                 for (j = 0; j < 9; ++j)
                 {
                     m_rotMat[j][i] = tmp[j];
                 }
             }
         }

◆ GetParams()

std::map<std::string, RSParamFuncType>& Nektar::SolverUtils::RiemannSolver::GetParams ( )

inline

Definition at line 133 of file RiemannSolver.h.

References m_params.

             {
                 return m_params;
             }

◆ GetScalars()

std::map<std::string, RSScalarFuncType>& Nektar::SolverUtils::RiemannSolver::GetScalars ( )

inline

Definition at line 123 of file RiemannSolver.h.

References m_scalars.

             {
                 return m_scalars;
             }

◆ GetVectors()

std::map<std::string, RSVecFuncType>& Nektar::SolverUtils::RiemannSolver::GetVectors ( )

inline

Definition at line 128 of file RiemannSolver.h.

References m_vectors.

             {
                 return m_vectors;
             }

◆ rotateFromNormal()

void Nektar::SolverUtils::RiemannSolver::rotateFromNormal	(	const Array< OneD, const Array< OneD, NekDouble > > &	inarray,
		const Array< OneD, const Array< OneD, NekDouble > > &	normals,
		const Array< OneD, const Array< OneD, NekDouble > > &	vecLocs,
		Array< OneD, Array< OneD, NekDouble > > &	outarray
	)

protected

Rotate a vector field from trace normal.

This function performs a rotation of the triad of vector components provided in inarray so that the first component aligns with the Cartesian components; it performs the inverse operation of RiemannSolver::rotateToNormal.

Definition at line 253 of file RiemannSolver.cpp.

References ASSERTL1, m_rotMat, Vmath::Vcopy(), Vmath::Vmul(), Vmath::Vvtvm(), Vmath::Vvtvp(), and Vmath::Vvtvvtp().

Referenced by Solve(), and ~RiemannSolver().

         {
             for (int i = 0; i < inarray.num_elements(); ++i)
             {
                 Vmath::Vcopy(inarray[i].num_elements(), inarray[i], 1,
                              outarray[i], 1);
             }
 
             for (int i = 0; i < vecLocs.num_elements(); i++)
             {
                 ASSERTL1(vecLocs[i].num_elements() == normals.num_elements(),
                          "vecLocs[i] element count mismatch");
 
                 switch (normals.num_elements())
                 {
                     case 1:
                     {    // do nothing
                         const int nq = normals[0].num_elements();
                         const int vx = (int)vecLocs[i][0];
                         Vmath::Vmul (nq, inarray [vx], 1, normals [0],  1,
                                          outarray[vx], 1);
                         break;
                     }
                     case 2:
                     {
                         const int nq = normals[0].num_elements();
                         const int vx = (int)vecLocs[i][0];
                         const int vy = (int)vecLocs[i][1];
 
                         Vmath::Vmul (nq, inarray [vy], 1, normals [1],  1,
                                          outarray[vx], 1);
                         Vmath::Vvtvm(nq, inarray [vx], 1, normals [0],  1,
                                          outarray[vx], 1, outarray[vx], 1);
                         Vmath::Vmul (nq, inarray [vx], 1, normals [1],  1,
                                          outarray[vy], 1);
                         Vmath::Vvtvp(nq, inarray [vy], 1, normals [0],  1,
                                          outarray[vy], 1, outarray[vy], 1);
                         break;
                     }
 
                     case 3:
                     {
                         const int nq = normals[0].num_elements();
                         const int vx = (int)vecLocs[i][0];
                         const int vy = (int)vecLocs[i][1];
                         const int vz = (int)vecLocs[i][2];
 
                         Vmath::Vvtvvtp(nq, inarray [vx], 1, m_rotMat[0],  1,
                                            inarray [vy], 1, m_rotMat[3],  1,
                                            outarray[vx], 1);
                         Vmath::Vvtvp  (nq, inarray [vz], 1, m_rotMat[6],  1,
                                            outarray[vx], 1, outarray[vx], 1);
                         Vmath::Vvtvvtp(nq, inarray [vx], 1, m_rotMat[1],  1,
                                            inarray [vy], 1, m_rotMat[4],  1,
                                            outarray[vy], 1);
                         Vmath::Vvtvp  (nq, inarray [vz], 1, m_rotMat[7],  1,
                                            outarray[vy], 1, outarray[vy], 1);
                         Vmath::Vvtvvtp(nq, inarray [vx], 1, m_rotMat[2],  1,
                                            inarray [vy], 1, m_rotMat[5],  1,
                                            outarray[vz], 1);
                         Vmath::Vvtvp  (nq, inarray [vz], 1, m_rotMat[8],  1,
                                            outarray[vz], 1, outarray[vz], 1);
                         break;
                     }
 
                     default:
                         ASSERTL1(false, "Invalid space dimension.");
                         break;
                 }
             }
         }

◆ rotateToNormal()

void Nektar::SolverUtils::RiemannSolver::rotateToNormal	(	const Array< OneD, const Array< OneD, NekDouble > > &	inarray,
		const Array< OneD, const Array< OneD, NekDouble > > &	normals,
		const Array< OneD, const Array< OneD, NekDouble > > &	vecLocs,
		Array< OneD, Array< OneD, NekDouble > > &	outarray
	)

protected

Rotate a vector field to trace normal.

This function performs a rotation of a vector so that the first component aligns with the trace normal direction.

The vectors components are stored in inarray. Their locations must be specified in the "vecLocs" array. vecLocs[0] contains the locations of the first vectors components, vecLocs[1] those of the second and so on.

In 2D, this is accomplished through the transform:

\[ (u_x, u_y) = (n_x u_x + n_y u_y, -n_x v_x + n_y v_y) \]

In 3D, we generate a (non-unique) transformation using RiemannSolver::fromToRotation.

Definition at line 162 of file RiemannSolver.cpp.

References ASSERTL1, GenerateRotationMatrices(), m_rotMat, Vmath::Vcopy(), Vmath::Vmul(), Vmath::Vvtvm(), Vmath::Vvtvp(), and Vmath::Vvtvvtp().

Referenced by Nektar::AcousticSolver::GetRotBasefield(), Solve(), and ~RiemannSolver().

         {
             for (int i = 0; i < inarray.num_elements(); ++i)
             {
                 Vmath::Vcopy(inarray[i].num_elements(), inarray[i], 1,
                              outarray[i], 1);
             }
 
             for (int i = 0; i < vecLocs.num_elements(); i++)
             {
                 ASSERTL1(vecLocs[i].num_elements() == normals.num_elements(),
                          "vecLocs[i] element count mismatch");
 
                 switch (normals.num_elements())
                 {
                     case 1:
                     {    // do nothing
                         const int nq = inarray[0].num_elements();
                         const int vx = (int)vecLocs[i][0];
                         Vmath::Vmul (nq, inarray [vx], 1, normals [0],  1,
                                          outarray[vx], 1);
                         break;
                     }
                     case 2:
                     {
                         const int nq = inarray[0].num_elements();
                         const int vx = (int)vecLocs[i][0];
                         const int vy = (int)vecLocs[i][1];
 
                         Vmath::Vmul (nq, inarray [vx], 1, normals [0],  1,
                                          outarray[vx], 1);
                         Vmath::Vvtvp(nq, inarray [vy], 1, normals [1],  1,
                                          outarray[vx], 1, outarray[vx], 1);
                         Vmath::Vmul (nq, inarray [vx], 1, normals [1],  1,
                                          outarray[vy], 1);
                         Vmath::Vvtvm(nq, inarray [vy], 1, normals [0],  1,
                                          outarray[vy], 1, outarray[vy], 1);
                         break;
                     }
 
                     case 3:
                     {
                         const int nq = inarray[0].num_elements();
                         const int vx = (int)vecLocs[i][0];
                         const int vy = (int)vecLocs[i][1];
                         const int vz = (int)vecLocs[i][2];
 
                         // Generate matrices if they don't already exist.
                         if (m_rotMat.num_elements() == 0)
                         {
                             GenerateRotationMatrices(normals);
                         }
 
                         // Apply rotation matrices.
                         Vmath::Vvtvvtp(nq, inarray [vx], 1, m_rotMat[0],  1,
                                            inarray [vy], 1, m_rotMat[1],  1,
                                            outarray[vx], 1);
                         Vmath::Vvtvp  (nq, inarray [vz], 1, m_rotMat[2],  1,
                                            outarray[vx], 1, outarray[vx], 1);
                         Vmath::Vvtvvtp(nq, inarray [vx], 1, m_rotMat[3],  1,
                                            inarray [vy], 1, m_rotMat[4],  1,
                                            outarray[vy], 1);
                         Vmath::Vvtvp  (nq, inarray [vz], 1, m_rotMat[5],  1,
                                            outarray[vy], 1, outarray[vy], 1);
                         Vmath::Vvtvvtp(nq, inarray [vx], 1, m_rotMat[6],  1,
                                            inarray [vy], 1, m_rotMat[7],  1,
                                            outarray[vz], 1);
                         Vmath::Vvtvp  (nq, inarray [vz], 1, m_rotMat[8],  1,
                                            outarray[vz], 1, outarray[vz], 1);
                         break;
                     }
 
                     default:
                         ASSERTL1(false, "Invalid space dimension.");
                         break;
                 }
             }
         }

◆ SetAuxScal()

template<typename FuncPointerT , typename ObjectPointerT >

void Nektar::SolverUtils::RiemannSolver::SetAuxScal	(	std::string	name,
		FuncPointerT	func,
		ObjectPointerT	obj
	)

inline

Definition at line 108 of file RiemannSolver.h.

References m_auxScal, and CellMLToNektar.pycml::name.

             {
                 m_auxScal[name] = std::bind(func, obj);
             }

◆ SetAuxVec()

template<typename FuncPointerT , typename ObjectPointerT >

void Nektar::SolverUtils::RiemannSolver::SetAuxVec	(	std::string	name,
		FuncPointerT	func,
		ObjectPointerT	obj
	)

inline

Definition at line 116 of file RiemannSolver.h.

References m_auxVec, and CellMLToNektar.pycml::name.

             {
                 m_auxVec[name] = std::bind(func, obj);
             }

◆ SetParam() [1/2]

template<typename FuncPointerT , typename ObjectPointerT >

void Nektar::SolverUtils::RiemannSolver::SetParam	(	std::string	name,
		FuncPointerT	func,
		ObjectPointerT	obj
	)

inline

Definition at line 95 of file RiemannSolver.h.

References m_params, and CellMLToNektar.pycml::name.

             {
                 m_params[name] = std::bind(func, obj);
             }

◆ SetParam() [2/2]

void Nektar::SolverUtils::RiemannSolver::SetParam	(	std::string	name,
		RSParamFuncType	fp
	)

inline

Definition at line 102 of file RiemannSolver.h.

References m_params, and CellMLToNektar.pycml::name.

             {
                 m_params[name] = fp;
             }

◆ SetScalar() [1/2]

template<typename FuncPointerT , typename ObjectPointerT >

void Nektar::SolverUtils::RiemannSolver::SetScalar	(	std::string	name,
		FuncPointerT	func,
		ObjectPointerT	obj
	)

inline

Definition at line 69 of file RiemannSolver.h.

References m_scalars, and CellMLToNektar.pycml::name.

             {
                 m_scalars[name] = std::bind(func, obj);
             }

◆ SetScalar() [2/2]

void Nektar::SolverUtils::RiemannSolver::SetScalar	(	std::string	name,
		RSScalarFuncType	fp
	)

inline

Definition at line 76 of file RiemannSolver.h.

References m_scalars, and CellMLToNektar.pycml::name.

             {
                 m_scalars[name] = fp;
             }

◆ SetVector() [1/2]

template<typename FuncPointerT , typename ObjectPointerT >

void Nektar::SolverUtils::RiemannSolver::SetVector	(	std::string	name,
		FuncPointerT	func,
		ObjectPointerT	obj
	)

inline

Definition at line 82 of file RiemannSolver.h.

References m_vectors, and CellMLToNektar.pycml::name.

             {
                 m_vectors[name] = std::bind(func, obj);
             }

◆ SetVector() [2/2]

void Nektar::SolverUtils::RiemannSolver::SetVector	(	std::string	name,
		RSVecFuncType	fp
	)

inline

Definition at line 89 of file RiemannSolver.h.

References m_vectors, and CellMLToNektar.pycml::name.

             {
                 m_vectors[name] = fp;
             }

◆ Solve()

void Nektar::SolverUtils::RiemannSolver::Solve	(	const int	nDim,
		const Array< OneD, const Array< OneD, NekDouble > > &	Fwd,
		const Array< OneD, const Array< OneD, NekDouble > > &	Bwd,
		Array< OneD, Array< OneD, NekDouble > > &	flux
	)

Perform the Riemann solve given the forwards and backwards spaces.

This routine calls the virtual function v_Solve to perform the Riemann solve. If the flag m_requiresRotation is set, then the velocity field is rotated to the normal direction to perform dimensional splitting, and the resulting fluxes are rotated back to the Cartesian directions before being returned. For the Rotation to work, the normal vectors "N" and the location of the vector components in Fwd "vecLocs"must be set via the SetAuxVec() method.

Parameters

Fwd	Forwards trace space.
Bwd	Backwards trace space.
flux	Resultant flux along trace space.

Definition at line 99 of file RiemannSolver.cpp.

References ASSERTL1, CheckAuxVec(), CheckVectors(), m_auxVec, m_requiresRotation, m_rotStorage, m_vectors, rotateFromNormal(), rotateToNormal(), and v_Solve().

         {
             if (m_requiresRotation)
             {
                 ASSERTL1(CheckVectors("N"), "N not defined.");
                 ASSERTL1(CheckAuxVec("vecLocs"), "vecLocs not defined.");
                 const Array<OneD, const Array<OneD, NekDouble> > normals =
                     m_vectors["N"]();
                 const Array<OneD, const Array<OneD, NekDouble> > vecLocs =
                     m_auxVec["vecLocs"]();
 
                 int nFields = Fwd   .num_elements();
                 int nPts    = Fwd[0].num_elements();
                 
                 if (m_rotStorage[0].num_elements()    != nFields ||
                     m_rotStorage[0][0].num_elements() != nPts)
                 {
                     for (int i = 0; i < 3; ++i)
                     {
                         m_rotStorage[i] =
                             Array<OneD, Array<OneD, NekDouble> >(nFields);
                         for (int j = 0; j < nFields; ++j)
                         {
                             m_rotStorage[i][j] = Array<OneD, NekDouble>(nPts);
                         }
                     }
                 }
 
                 rotateToNormal  (Fwd, normals, vecLocs, m_rotStorage[0]);
                 rotateToNormal  (Bwd, normals, vecLocs, m_rotStorage[1]);
                 v_Solve         (nDim, m_rotStorage[0], m_rotStorage[1],
                                        m_rotStorage[2]);
                 rotateFromNormal(m_rotStorage[2], normals, vecLocs, flux);
             }
             else
             {
                 v_Solve(nDim, Fwd, Bwd, flux);
             }
         }

◆ v_Solve()

virtual void Nektar::SolverUtils::RiemannSolver::v_Solve	(	const int	nDim,
		const Array< OneD, const Array< OneD, NekDouble > > &	Fwd,
		const Array< OneD, const Array< OneD, NekDouble > > &	Bwd,
		Array< OneD, Array< OneD, NekDouble > > &	flux
	)

protectedpure virtual

Implemented in Nektar::SolverUtils::UpwindLDGSolver, Nektar::SolverUtils::UpwindSolver, Nektar::CompressibleSolver, Nektar::NonlinearSWESolver, and Nektar::LinearSWESolver.

Referenced by Solve(), and ~RiemannSolver().

Member Data Documentation

◆ m_auxScal

std::map<std::string, RSScalarFuncType> Nektar::SolverUtils::RiemannSolver::m_auxScal

protected

Map of auxiliary scalar function types.

Definition at line 151 of file RiemannSolver.h.

Referenced by CheckAuxScal(), and SetAuxScal().

◆ m_auxVec

std::map<std::string, RSVecFuncType> Nektar::SolverUtils::RiemannSolver::m_auxVec

protected

Map of auxiliary vector function types.

Definition at line 153 of file RiemannSolver.h.

Referenced by CheckAuxVec(), SetAuxVec(), and Solve().

◆ m_params

std::map<std::string, RSParamFuncType > Nektar::SolverUtils::RiemannSolver::m_params

protected

Map of parameter function types.

Definition at line 149 of file RiemannSolver.h.

Referenced by CheckParams(), GetParams(), Nektar::CompressibleSolver::GetRoeSoundSpeed(), Nektar::UpwindPulseSolver::RiemannSolverUpwind(), SetParam(), Nektar::HLLCSolver::v_PointSolve(), Nektar::LinearHLLSolver::v_PointSolve(), Nektar::HLLSolver::v_PointSolve(), Nektar::RoeSolver::v_PointSolve(), Nektar::LaxFriedrichsSolver::v_PointSolve(), Nektar::ExactSolverToro::v_PointSolve(), Nektar::LinearAverageSolver::v_PointSolve(), and Nektar::AverageSolver::v_PointSolve().

◆ m_requiresRotation

bool Nektar::SolverUtils::RiemannSolver::m_requiresRotation

protected

Indicates whether the Riemann solver requires a rotation to be applied to the velocity fields.

Definition at line 143 of file RiemannSolver.h.

Referenced by Nektar::AcousticSolver::AcousticSolver(), Nektar::CompressibleSolver::CompressibleSolver(), Nektar::LEESolver::LEESolver(), Nektar::LinearSWESolver::LinearSWESolver(), Nektar::NonlinearSWESolver::NonlinearSWESolver(), and Solve().

◆ m_rotMat

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::RiemannSolver::m_rotMat

protected

Rotation matrices for each trace quadrature point.

Definition at line 155 of file RiemannSolver.h.

Referenced by GenerateRotationMatrices(), rotateFromNormal(), and rotateToNormal().

◆ m_rotStorage

Array<OneD, Array<OneD, Array<OneD, NekDouble> > > Nektar::SolverUtils::RiemannSolver::m_rotStorage

protected

Rotation storage.

Definition at line 157 of file RiemannSolver.h.

Referenced by Solve().

◆ m_scalars

std::map<std::string, RSScalarFuncType> Nektar::SolverUtils::RiemannSolver::m_scalars

protected

Map of scalar function types.

Definition at line 145 of file RiemannSolver.h.

Referenced by CheckScalars(), GetScalars(), SetScalar(), Nektar::LinearSWESolver::v_Solve(), Nektar::UpwindPulseSolver::v_Solve(), Nektar::SolverUtils::UpwindSolver::v_Solve(), and Nektar::SolverUtils::UpwindLDGSolver::v_Solve().

◆ m_spacedim

int Nektar::SolverUtils::RiemannSolver::m_spacedim

Definition at line 138 of file RiemannSolver.h.

◆ m_vectors

std::map<std::string, RSVecFuncType> Nektar::SolverUtils::RiemannSolver::m_vectors

protected

Map of vector function types.

Definition at line 147 of file RiemannSolver.h.

Referenced by CheckVectors(), Nektar::AcousticSolver::GetRotBasefield(), GetVectors(), SetVector(), and Solve().

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ RiemannSolver()

◆ ~RiemannSolver()

Member Function Documentation

◆ CheckAuxScal()

◆ CheckAuxVec()

◆ CheckParams()

◆ CheckScalars()

◆ CheckVectors()

◆ FromToRotation()

◆ GenerateRotationMatrices()

◆ GetParams()

◆ GetScalars()

◆ GetVectors()

◆ rotateFromNormal()

◆ rotateToNormal()

◆ SetAuxScal()

◆ SetAuxVec()

◆ SetParam() [1/2]

◆ SetParam() [2/2]

◆ SetScalar() [1/2]

◆ SetScalar() [2/2]

◆ SetVector() [1/2]

◆ SetVector() [2/2]

◆ Solve()

◆ v_Solve()

Member Data Documentation

◆ m_auxScal

◆ m_auxVec

◆ m_params

◆ m_requiresRotation

◆ m_rotMat

◆ m_rotStorage

◆ m_scalars

◆ m_spacedim

◆ m_vectors