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:

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.
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)
template<typename FuncPointerT , typename ObjectPointerT >
void	SetUpdateNormalsFlag (FuncPointerT func, ObjectPointerT obj)
void	SetALEFlag (bool &ALE)
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)
void	SetAuxVec (std::string name, RSVecFuncType fp)
std::map< std::string, RSScalarFuncType > &	GetScalars ()
std::map< std::string, RSVecFuncType > &	GetVectors ()
std::map< std::string, RSParamFuncType > &	GetParams ()
SOLVER_UTILS_EXPORT void	CalcFluxJacobian (const int nDim, const Array< OneD, const Array< OneD, NekDouble > > &Fwd, const Array< OneD, const Array< OneD, NekDouble > > &Bwd, DNekBlkMatSharedPtr &FJac, DNekBlkMatSharedPtr &BJac)
	Calculate the flux jacobian of Fwd and Bwd.
SOLVER_UTILS_EXPORT void	ResetRotMatrix (void)

Public Attributes
int	m_spacedim

Protected Member Functions
SOLVER_UTILS_EXPORT	RiemannSolver ()
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
SOLVER_UTILS_EXPORT void	GenerateRotationMatrices (const Array< OneD, const Array< OneD, NekDouble > > &normals)
	Generate rotation matrices for 3D expansions.
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.
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.
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.
SOLVER_UTILS_EXPORT bool	CheckScalars (std::string name)
	Determine whether a scalar has been defined in m_scalars.
SOLVER_UTILS_EXPORT bool	CheckVectors (std::string name)
	Determine whether a vector has been defined in m_vectors.
SOLVER_UTILS_EXPORT bool	CheckParams (std::string name)
	Determine whether a parameter has been defined in m_params.
SOLVER_UTILS_EXPORT bool	CheckAuxScal (std::string name)
	Determine whether a scalar has been defined in m_auxScal.
SOLVER_UTILS_EXPORT bool	CheckAuxVec (std::string name)
	Determine whether a vector has been defined in m_auxVec.
virtual SOLVER_UTILS_EXPORT void	v_CalcFluxJacobian (const int nDim, const Array< OneD, const Array< OneD, NekDouble > > &Fwd, const Array< OneD, const Array< OneD, NekDouble > > &Bwd, const Array< OneD, const Array< OneD, NekDouble > > &normals, DNekBlkMatSharedPtr &FJac, DNekBlkMatSharedPtr &BJac)

Protected Attributes
bool	m_requiresRotation
	Indicates whether the Riemann solver requires a rotation to be applied to the velocity fields.
std::map< std::string, RSScalarFuncType >	m_scalars
	Map of scalar function types.
std::map< std::string, RSVecFuncType >	m_vectors
	Map of vector function types.
std::map< std::string, RSParamFuncType >	m_params
	Map of parameter function types.
std::map< std::string, RSScalarFuncType >	m_auxScal
	Map of auxiliary scalar function types.
std::map< std::string, RSVecFuncType >	m_auxVec
	Map of auxiliary vector function types.
std::function< bool()>	m_updateNormals
	Function of normals updated flag.
Array< OneD, Array< OneD, NekDouble > >	m_rotMat
	Rotation matrices for each trace quadrature point.
Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	m_rotStorage
	Rotation storage.
bool	m_ALESolver = false
	Flag if using the ALE formulation.

Detailed Description

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

Definition at line 58 of file RiemannSolver.h.

Constructor & Destructor Documentation

RiemannSolver() [1/2]

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

protected

Definition at line 74 of file RiemannSolver.cpp.

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

RiemannSolver() [2/2]

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

protected

Definition at line 78 of file RiemannSolver.cpp.

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

~RiemannSolver()

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

inlineprotectedvirtual

Definition at line 181 of file RiemannSolver.h.

{};

Member Function Documentation

CalcFluxJacobian()

void Nektar::SolverUtils::RiemannSolver::CalcFluxJacobian	(	const int	nDim,
		const Array< OneD, const Array< OneD, NekDouble > > &	Fwd,
		const Array< OneD, const Array< OneD, NekDouble > > &	Bwd,
		DNekBlkMatSharedPtr &	FJac,
		DNekBlkMatSharedPtr &	BJac
	)

Calculate the flux jacobian of Fwd and Bwd.

Parameters

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

Definition at line 539 of file RiemannSolver.cpp.

{
    int nPts = Fwd[0].size();
 
    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"]();
 
        v_CalcFluxJacobian(nDim, Fwd, Bwd, normals, FJac, BJac);
    }
    else
    {
        Array<OneD, Array<OneD, NekDouble>> normals(nDim);
        for (int i = 0; i < nDim; i++)
        {
            normals[i] = Array<OneD, NekDouble>(nPts, 0.0);
        }
        Vmath::Fill(nPts, 1.0, normals[0], 1);
 
        v_CalcFluxJacobian(nDim, Fwd, Bwd, normals, FJac, BJac);
    }
}

References ASSERTL1, CheckAuxVec(), CheckVectors(), Vmath::Fill(), m_auxVec, m_requiresRotation, m_vectors, and v_CalcFluxJacobian().

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

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

References m_auxScal.

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

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

References m_auxVec.

Referenced by CalcFluxJacobian(), and Solve().

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

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

References m_params.

Referenced by Nektar::UpwindPulseSolver::RiemannSolverUpwind().

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

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

References m_scalars.

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

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

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

References m_vectors.

Referenced by CalcFluxJacobian(), Nektar::AcousticSolver::GetRotBasefield(), Solve(), and Nektar::RoeSolverSIMD::v_Solve().

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

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

References CROSS, DOT, and EPSILON.

Referenced by GenerateRotationMatrices().

GenerateRotationMatrices()

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

protected

Generate rotation matrices for 3D expansions.

Definition at line 397 of file RiemannSolver.cpp.

{
    Array<OneD, NekDouble> xdir(3, 0.0);
    Array<OneD, NekDouble> tn(3);
    NekDouble tmp[9];
    const int nq = normals[0].size();
    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].size(); ++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];
        }
    }
}

References FromToRotation(), and m_rotMat.

Referenced by rotateToNormal(), and Nektar::RoeSolverSIMD::v_Solve().

GetParams()

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

inline

Definition at line 137 of file RiemannSolver.h.

    {
        return m_params;
    }

References m_params.

GetScalars()

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

inline

Definition at line 127 of file RiemannSolver.h.

    {
        return m_scalars;
    }

References m_scalars.

GetVectors()

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

inline

Definition at line 132 of file RiemannSolver.h.

    {
        return m_vectors;
    }

References m_vectors.

ResetRotMatrix()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::RiemannSolver::ResetRotMatrix ( void  )

inline

Definition at line 149 of file RiemannSolver.h.

    {
        m_rotMat = NullNekDoubleArrayOfArray;
    }

References m_rotMat, and Nektar::NullNekDoubleArrayOfArray.

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

{
    for (int i = 0; i < inarray.size(); ++i)
    {
        Vmath::Vcopy(inarray[i].size(), inarray[i], 1, outarray[i], 1);
    }
 
    for (int i = 0; i < vecLocs.size(); i++)
    {
        ASSERTL1(vecLocs[i].size() == normals.size(),
                 "vecLocs[i] element count mismatch");
 
        switch (normals.size())
        {
            case 1:
            { // do nothing
                const int nq = normals[0].size();
                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].size();
                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].size();
                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;
        }
    }
}

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

Referenced by Solve().

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

{
    for (int i = 0; i < inarray.size(); ++i)
    {
        Vmath::Vcopy(inarray[i].size(), inarray[i], 1, outarray[i], 1);
    }
 
    for (int i = 0; i < vecLocs.size(); i++)
    {
        ASSERTL1(vecLocs[i].size() == normals.size(),
                 "vecLocs[i] element count mismatch");
 
        switch (normals.size())
        {
            case 1:
            { // do nothing
                const int nq = inarray[0].size();
                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].size();
                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].size();
                const int vx = (int)vecLocs[i][0];
                const int vy = (int)vecLocs[i][1];
                const int vz = (int)vecLocs[i][2];
 
                if (m_ALESolver)
                {
                    // Generate matrices if they don't already exist.
                    if (m_rotMat.size() == 0 || m_updateNormals())
                    {
                        GenerateRotationMatrices(normals);
                    }
                }
                else
                {
                    // Generate matrices if they don't already exist.
                    if (m_rotMat.size() == 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;
        }
    }
}

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

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

SetALEFlag()

void Nektar::SolverUtils::RiemannSolver::SetALEFlag ( bool &  ALE )

inline

Definition at line 100 of file RiemannSolver.h.

    {
        m_ALESolver = ALE;
    }

References m_ALESolver.

SetAuxScal()

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.

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

References m_auxScal.

SetAuxVec() [1/2]

template<typename FuncPointerT , typename ObjectPointerT >

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

inline

Definition at line 117 of file RiemannSolver.h.

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

References m_auxVec.

SetAuxVec() [2/2]

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

inline

Definition at line 122 of file RiemannSolver.h.

    {
        m_auxVec[name] = fp;
    }

References m_auxVec.

SetParam() [1/2]

template<typename FuncPointerT , typename ObjectPointerT >

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

inline

Definition at line 89 of file RiemannSolver.h.

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

References m_params.

SetParam() [2/2]

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

inline

Definition at line 105 of file RiemannSolver.h.

    {
        m_params[name] = fp;
    }

References m_params.

SetScalar() [1/2]

template<typename FuncPointerT , typename ObjectPointerT >

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

inline

Definition at line 67 of file RiemannSolver.h.

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

References m_scalars.

SetScalar() [2/2]

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

inline

Definition at line 72 of file RiemannSolver.h.

    {
        m_scalars[name] = fp;
    }

References m_scalars.

SetUpdateNormalsFlag()

template<typename FuncPointerT , typename ObjectPointerT >

void Nektar::SolverUtils::RiemannSolver::SetUpdateNormalsFlag ( FuncPointerT  func, ObjectPointerT  obj  )

inline

Definition at line 95 of file RiemannSolver.h.

    {
        m_updateNormals = std::bind(func, obj);
    }

References m_updateNormals.

SetVector() [1/2]

template<typename FuncPointerT , typename ObjectPointerT >

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

inline

Definition at line 78 of file RiemannSolver.h.

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

References m_vectors.

SetVector() [2/2]

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

inline

Definition at line 83 of file RiemannSolver.h.

    {
        m_vectors[name] = fp;
    }

References m_vectors.

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

{
    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.size();
        int nPts    = Fwd[0].size();
 
        if (m_rotStorage[0].size() != nFields ||
            m_rotStorage[0][0].size() != 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);
 
        // Attempt to subtract (\vec{U}\vec{vg})\dot n for ALE
        if (m_ALESolver)
        {
            auto vgt = m_vectors["vgt"]();
            auto N   = m_vectors["N"]();
            for (int i = 0; i < flux.size(); ++i)
            {
                for (int j = 0; j < flux[i].size(); ++j)
                {
                    NekDouble tmp = 0;
                    for (int k = 0; k < nDim; ++k)
                    {
                        tmp += N[k][j] * vgt[k][j];
                    }
                    flux[i][j] -= 0.5 * (Fwd[i][j] + Bwd[i][j]) * tmp;
                }
            }
        }
    }
    else
    {
        v_Solve(nDim, Fwd, Bwd, flux);
    }
}

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

v_CalcFluxJacobian()

void Nektar::SolverUtils::RiemannSolver::v_CalcFluxJacobian ( const int  nDim, const Array< OneD, const Array< OneD, NekDouble > > &  Fwd, const Array< OneD, const Array< OneD, NekDouble > > &  Bwd, const Array< OneD, const Array< OneD, NekDouble > > &  normals, DNekBlkMatSharedPtr &  FJac, DNekBlkMatSharedPtr &  BJac  )

protectedvirtual

Definition at line 570 of file RiemannSolver.cpp.

{
    NEKERROR(ErrorUtil::efatal, "v_CalcFluxJacobian not specified.");
}

References Nektar::ErrorUtil::efatal, and NEKERROR.

Referenced by CalcFluxJacobian().

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::RoeSolverSIMD, Nektar::CompressibleSolver, Nektar::SolverUtils::UpwindSolver, Nektar::AcousticSolver, Nektar::LEESolver, Nektar::UpwindPulseSolver, Nektar::LinearSWESolver, and Nektar::NonlinearSWESolver.

Referenced by Solve().

Member Data Documentation

m_ALESolver

bool Nektar::SolverUtils::RiemannSolver::m_ALESolver = false

protected

Flag if using the ALE formulation.

Definition at line 175 of file RiemannSolver.h.

Referenced by rotateToNormal(), SetALEFlag(), and Solve().

m_auxScal

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

protected

Map of auxiliary scalar function types.

Definition at line 165 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 167 of file RiemannSolver.h.

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

m_params

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

protected

Map of parameter function types.

Definition at line 163 of file RiemannSolver.h.

Referenced by CheckParams(), GetParams(), Nektar::CompressibleSolver::GetRoeSoundSpeed(), Nektar::UpwindPulseSolver::RiemannSolverUpwind(), SetParam(), SetParam(), Nektar::RoeSolver::v_ArraySolve(), Nektar::RoeSolver::v_PointSolve(), Nektar::LinearAverageSolver::v_PointSolve(), Nektar::LinearHLLSolver::v_PointSolve(), Nektar::ExactSolverToro::v_PointSolve(), and Nektar::RoeSolverSIMD::v_Solve().

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

Referenced by Nektar::AcousticSolver::AcousticSolver(), CalcFluxJacobian(), Nektar::CompressibleSolver::CompressibleSolver(), Nektar::CompressibleSolver::CompressibleSolver(), Nektar::LEESolver::LEESolver(), Nektar::LinearSWESolver::LinearSWESolver(), Nektar::NonlinearSWESolver::NonlinearSWESolver(), Nektar::RoeSolverSIMD::RoeSolverSIMD(), Nektar::RoeSolverSIMD::RoeSolverSIMD(), 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 171 of file RiemannSolver.h.

Referenced by GenerateRotationMatrices(), ResetRotMatrix(), rotateFromNormal(), rotateToNormal(), and Nektar::RoeSolverSIMD::v_Solve().

m_rotStorage

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

protected

Rotation storage.

Definition at line 173 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 159 of file RiemannSolver.h.

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

m_spacedim

int Nektar::SolverUtils::RiemannSolver::m_spacedim

Definition at line 142 of file RiemannSolver.h.

m_updateNormals

std::function<bool()> Nektar::SolverUtils::RiemannSolver::m_updateNormals

protected

Function of normals updated flag.

Definition at line 169 of file RiemannSolver.h.

Referenced by rotateToNormal(), and SetUpdateNormalsFlag().

m_vectors

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

protected

Map of vector function types.

Definition at line 161 of file RiemannSolver.h.

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