Nektar::SolverUtils::RiemannSolver Class Reference

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:

Collaboration diagram for Nektar::SolverUtils::RiemannSolver:

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 ()
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 62 of file RiemannSolver.h.

Constructor & Destructor Documentation

Nektar::SolverUtils::RiemannSolver::RiemannSolver ( )

protected

Definition at line 79 of file RiemannSolver.cpp.

                                     : m_requiresRotation(false),
                                         m_rotStorage      (3)
        {
            
        }

Member Function Documentation

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 375 of file RiemannSolver.cpp.

References Nektar::iterator, and m_auxScal.

        {
            std::map<std::string, RSScalarFuncType>::iterator it =
                m_auxScal.find(name);

            return it != m_auxScal.end();
        }

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 388 of file RiemannSolver.cpp.

References Nektar::iterator, and m_auxVec.

Referenced by Solve().

        {
            std::map<std::string, RSVecFuncType>::iterator it =
                m_auxVec.find(name);

            return it != m_auxVec.end();
        }

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 362 of file RiemannSolver.cpp.

References Nektar::iterator, and m_params.

Referenced by Nektar::LaxFriedrichsSolver::v_PointSolve(), and Nektar::UpwindSolver::v_PointSolve().

        {
            std::map<std::string, RSParamFuncType>::iterator it = 
                m_params.find(name);
            
            return it != m_params.end();
        }

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 336 of file RiemannSolver.cpp.

References Nektar::iterator, and m_scalars.

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

        {
            std::map<std::string, RSScalarFuncType>::iterator it = 
                m_scalars.find(name);
            
            return it != m_scalars.end();
        }

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 349 of file RiemannSolver.cpp.

References Nektar::iterator, and m_vectors.

Referenced by Nektar::APESolver::GetRotBasefield(), and Solve().

        {
            std::map<std::string, RSVecFuncType>::iterator it = 
                m_vectors.find(name);
            
            return it != m_vectors.end();
        }

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 444 of file RiemannSolver.cpp.

References CROSS, DOT, and EPSILON.

Referenced by GenerateRotationMatrices().

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

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

protected

Generate rotation matrices for 3D expansions.

Definition at line 399 of file RiemannSolver.cpp.

References FromToRotation(), and m_rotMat.

Referenced by rotateToNormal().

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

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

inline

Definition at line 136 of file RiemannSolver.h.

References m_params.

            {
                return m_params;
            }

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

inline

Definition at line 126 of file RiemannSolver.h.

References m_scalars.

            {
                return m_scalars;
            }

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

inline

Definition at line 131 of file RiemannSolver.h.

References m_vectors.

            {
                return m_vectors;
            }

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 255 of file RiemannSolver.cpp.

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

Referenced by Solve().

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

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:

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

Definition at line 164 of file RiemannSolver.cpp.

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

Referenced by Nektar::APESolver::GetRotBasefield(), and Solve().

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

template<typename FuncPointerT , typename ObjectPointerT >

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

inline

Definition at line 111 of file RiemannSolver.h.

References m_auxScal.

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

template<typename FuncPointerT , typename ObjectPointerT >

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

inline

Definition at line 119 of file RiemannSolver.h.

References m_auxVec.

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

template<typename FuncPointerT , typename ObjectPointerT >

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

inline

Definition at line 98 of file RiemannSolver.h.

References m_params.

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

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

inline

Definition at line 105 of file RiemannSolver.h.

References m_params.

            {
                m_params[name] = fp;
            }

template<typename FuncPointerT , typename ObjectPointerT >

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

inline

Definition at line 72 of file RiemannSolver.h.

References m_scalars.

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

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

inline

Definition at line 79 of file RiemannSolver.h.

References m_scalars.

            {
                m_scalars[name] = fp;
            }

template<typename FuncPointerT , typename ObjectPointerT >

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

inline

Definition at line 85 of file RiemannSolver.h.

References m_vectors.

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

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

inline

Definition at line 92 of file RiemannSolver.h.

References m_vectors.

            {
                m_vectors[name] = fp;
            }

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

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::APESolver, Nektar::CompressibleSolver, Nektar::LinearSWESolver, and Nektar::NonlinearSWESolver.

Referenced by Solve().

Member Data Documentation

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

protected

Map of auxiliary scalar function types.

Definition at line 154 of file RiemannSolver.h.

Referenced by CheckAuxScal(), and SetAuxScal().

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

protected

Map of auxiliary vector function types.

Definition at line 156 of file RiemannSolver.h.

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

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

protected

Map of parameter function types.

Definition at line 152 of file RiemannSolver.h.

Referenced by CheckParams(), GetParams(), SetParam(), Nektar::AverageSolver::v_ArraySolve(), Nektar::HLLCSolver::v_PointSolve(), Nektar::ExactSolverToro::v_PointSolve(), Nektar::AUSM2Solver::v_PointSolve(), Nektar::AUSM0Solver::v_PointSolve(), Nektar::AUSM3Solver::v_PointSolve(), Nektar::AUSM1Solver::v_PointSolve(), Nektar::HLLSolver::v_PointSolve(), Nektar::LinearHLLSolver::v_PointSolve(), Nektar::RoeSolver::v_PointSolve(), Nektar::LinearAverageSolver::v_PointSolve(), Nektar::AverageSolver::v_PointSolve(), Nektar::UpwindSolver::v_PointSolve(), Nektar::LaxFriedrichsSolver::v_PointSolve(), and Nektar::HLLCSolver::v_PointSolveVisc().

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 146 of file RiemannSolver.h.

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

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

protected

Rotation matrices for each trace quadrature point.

Definition at line 158 of file RiemannSolver.h.

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

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

protected

Rotation storage.

Definition at line 160 of file RiemannSolver.h.

Referenced by Solve().

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

protected

Map of scalar function types.

Definition at line 148 of file RiemannSolver.h.

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

int Nektar::SolverUtils::RiemannSolver::m_spacedim

Definition at line 141 of file RiemannSolver.h.

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

protected

Map of vector function types.

Definition at line 150 of file RiemannSolver.h.

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