Nektar::RoeSolverSIMD Class Reference

#include <RoeSolverSIMD.h>

Inheritance diagram for Nektar::RoeSolverSIMD:

Public Member Functions
	RoeSolverSIMD ()
	programmatic ctor More...
Public Member Functions inherited from Nektar::SolverUtils::RiemannSolver
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)
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. More...

Static Public Member Functions
static RiemannSolverSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession)

Static Public Attributes
static std::string	solverName

Protected Types
using	ND = NekDouble
Protected Types inherited from Nektar::CompressibleSolver
using	ND = NekDouble

Protected Member Functions
	RoeSolverSIMD (const LibUtilities::SessionReaderSharedPtr &pSession)
void	v_Solve (const int nDim, const Array< OneD, const Array< OneD, ND > > &Fwd, const Array< OneD, const Array< OneD, ND > > &Bwd, Array< OneD, Array< OneD, ND > > &flux) final
Protected Member Functions inherited from Nektar::CompressibleSolver
	CompressibleSolver (const LibUtilities::SessionReaderSharedPtr &pSession)
	Session ctor. More...
	CompressibleSolver ()
	Programmatic ctor. More...
virtual void	v_ArraySolve (const Array< OneD, const Array< OneD, ND > > &Fwd, const Array< OneD, const Array< OneD, ND > > &Bwd, Array< OneD, Array< OneD, ND > > &flux)
virtual void	v_PointSolve (ND rhoL, ND rhouL, ND rhovL, ND rhowL, ND EL, ND rhoR, ND rhouR, ND rhovR, ND rhowR, ND ER, ND &rhof, ND &rhouf, ND &rhovf, ND &rhowf, ND &Ef)
ND	GetRoeSoundSpeed (ND rhoL, ND pL, ND eL, ND HL, ND srL, ND rhoR, ND pR, ND eR, ND HR, ND srR, ND HRoe, ND URoe2, ND srLR)
Protected Member Functions inherited from Nektar::SolverUtils::RiemannSolver
SOLVER_UTILS_EXPORT	RiemannSolver ()
SOLVER_UTILS_EXPORT	RiemannSolver (const LibUtilities::SessionReaderSharedPtr &pSession)
virtual SOLVER_UTILS_EXPORT	~RiemannSolver ()
SOLVER_UTILS_EXPORT 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...
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)

Additional Inherited Members
Public Attributes inherited from Nektar::SolverUtils::RiemannSolver
int	m_spacedim
Protected Attributes inherited from Nektar::CompressibleSolver
bool	m_pointSolve
EquationOfStateSharedPtr	m_eos
bool	m_idealGas
Protected Attributes inherited from Nektar::SolverUtils::RiemannSolver
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

Definition at line 43 of file RoeSolverSIMD.h.

Member Typedef Documentation

ND

using Nektar::RoeSolverSIMD::ND = NekDouble

protected

Definition at line 61 of file RoeSolverSIMD.h.

Constructor & Destructor Documentation

RoeSolverSIMD() [1/2]

Nektar::RoeSolverSIMD::RoeSolverSIMD

(

)

programmatic ctor

Definition at line 56 of file RoeSolverSIMD.cpp.

                            :
CompressibleSolver()
{
    m_requiresRotation = false;
}

References Nektar::SolverUtils::RiemannSolver::m_requiresRotation.

Referenced by create().

RoeSolverSIMD() [2/2]

Nektar::RoeSolverSIMD::RoeSolverSIMD ( const LibUtilities::SessionReaderSharedPtr &  pSession )

protected

Definition at line 48 of file RoeSolverSIMD.cpp.

    :
    CompressibleSolver(pSession)
{
    m_requiresRotation = false;
}

References Nektar::SolverUtils::RiemannSolver::m_requiresRotation.

Member Function Documentation

create()

static RiemannSolverSharedPtr Nektar::RoeSolverSIMD::create ( const LibUtilities::SessionReaderSharedPtr &  pSession )

inlinestatic

Definition at line 46 of file RoeSolverSIMD.h.

    {
        return RiemannSolverSharedPtr(
            new RoeSolverSIMD(pSession));
    }

References RoeSolverSIMD().

v_Solve()

void Nektar::RoeSolverSIMD::v_Solve ( const int  nDim, const Array< OneD, const Array< OneD, ND > > &  Fwd, const Array< OneD, const Array< OneD, ND > > &  Bwd, Array< OneD, Array< OneD, ND > > &  flux  )

finalprotectedvirtual

Reimplemented from Nektar::CompressibleSolver.

Definition at line 62 of file RoeSolverSIMD.cpp.

{
    static auto gamma = m_params["gamma"]();
    static auto nVars = fwd.size();
    static auto spaceDim = nVars-2;
 
    // 3D case only so far
    ASSERTL0(spaceDim == 3, "SIMD Roe implemented only for 3D case...");
 
    using namespace tinysimd;
    using vec_t = simd<NekDouble>;
    // using vec_t = typename tinysimd::abi::scalar<NekDouble>::type;
 
    // get limit of vectorizable chunk
    size_t sizeScalar = fwd[0].size();
    size_t sizeVec = (sizeScalar / vec_t::width) * vec_t::width;
 
    // get normal, vellocs
    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"]();
 
    // const unsigned int vx = (int)vecLocs[0][0];
    // const unsigned int vy = (int)vecLocs[0][1];
    // const unsigned int vz = (int)vecLocs[0][2];
 
    // Generate matrices if they don't already exist.
    if (m_rotMat.size() == 0)
    {
        GenerateRotationMatrices(normals);
    }
 
    // SIMD loop
    size_t i = 0;
    for (; i < sizeVec; i+=vec_t::width)
    {
        // load scalars
        vec_t rhoL, rhoR, ER, EL;
        rhoL.load(&(fwd[0][i]), is_not_aligned);
        rhoR.load(&(bwd[0][i]), is_not_aligned);
        ER.load(&(bwd[spaceDim+1][i]), is_not_aligned);
        EL.load(&(fwd[spaceDim+1][i]), is_not_aligned);
 
        // load vectors left
        vec_t tmpIn[3], tmpOut[3];
        tmpIn[0].load(&(fwd[1][i]), is_not_aligned);
        tmpIn[1].load(&(fwd[2][i]), is_not_aligned);
        tmpIn[2].load(&(fwd[3][i]), is_not_aligned);
 
        // load rotation matrix
        vec_t rotMat[9];
        for (size_t j = 0; j < 9; ++j)
        {
            rotMat[j].load(&(m_rotMat[j][i]), is_not_aligned);
        }
 
        // rotateTo kernel Fwd
        rotateToNormalKernel(tmpIn, rotMat, tmpOut);
 
        vec_t rhouL = tmpOut[0];
        vec_t rhovL = tmpOut[1];
        vec_t rhowL = tmpOut[2];
 
        // load vectors right
        tmpIn[0].load(&(bwd[1][i]), is_not_aligned);
        tmpIn[1].load(&(bwd[2][i]), is_not_aligned);
        tmpIn[2].load(&(bwd[3][i]), is_not_aligned);
 
        // rotateTo kernel Bwd
        rotateToNormalKernel(tmpIn, rotMat, tmpOut);
 
        vec_t rhouR = tmpOut[0];
        vec_t rhovR = tmpOut[1];
        vec_t rhowR = tmpOut[2];
 
        // Roe kernel
        vec_t rhof{}, Ef{};
        RoeKernel(
            rhoL, rhouL, rhovL, rhowL, EL,
            rhoR, rhouR, rhovR, rhowR, ER,
            rhof, tmpIn[0], tmpIn[1], tmpIn[2], Ef,
            gamma);
 
        // rotateFrom kernel
        rotateFromNormalKernel(tmpIn, rotMat, tmpOut);
 
        // store scalar
        rhof.store(&(flux[0][i]), is_not_aligned);
        Ef.store(&(flux[nVars-1][i]), is_not_aligned);
 
        // store vector 3D only
        tmpOut[0].store(&(flux[1][i]), is_not_aligned);
        tmpOut[1].store(&(flux[2][i]), is_not_aligned);
        tmpOut[2].store(&(flux[3][i]), is_not_aligned);
    }
 
    // spillover loop
    for (; i < sizeScalar; ++i)
    {
        // load scalars
        NekDouble rhoL = fwd[0][i];
        NekDouble rhoR = bwd[0][i];
        NekDouble EL   = fwd[spaceDim+1][i];
        NekDouble ER   = bwd[spaceDim+1][i];
 
        // 3D case only
        // load vectors left
        NekDouble tmpIn[3], tmpOut[3];
        tmpIn[0] = fwd[1][i];
        tmpIn[1] = fwd[2][i];
        tmpIn[2] = fwd[3][i];
 
        // load rotation matrix
        NekDouble rotMat[9];
        for (size_t j = 0; j < 9; ++j)
        {
            rotMat[j] = m_rotMat[j][i];
        }
 
        // rotateTo kernel Fwd
        rotateToNormalKernel(tmpIn, rotMat, tmpOut);
 
        NekDouble rhouL = tmpOut[0];
        NekDouble rhovL = tmpOut[1];
        NekDouble rhowL = tmpOut[2];
 
        // load vectors right
        tmpIn[0] = bwd[1][i];
        tmpIn[1] = bwd[2][i];
        tmpIn[2] = bwd[3][i];
 
        // rotateTo kernel Bwd
        rotateToNormalKernel(tmpIn, rotMat, tmpOut);
 
        NekDouble rhouR = tmpOut[0];
        NekDouble rhovR = tmpOut[1];
        NekDouble rhowR = tmpOut[2];
 
        // Roe kernel
        NekDouble rhof{}, Ef{};
        RoeKernel(
            rhoL, rhouL, rhovL, rhowL, EL,
            rhoR, rhouR, rhovR, rhowR, ER,
            rhof, tmpIn[0], tmpIn[1], tmpIn[2], Ef,
            gamma);
 
        // rotateFrom kernel
        rotateFromNormalKernel(tmpIn, rotMat, tmpOut);
 
        // store scalar
        flux[0][i] = rhof;
        flux[nVars-1][i] = Ef;
 
        // store vector 3D only
        flux[1][i] = tmpOut[0];
        flux[2][i] = tmpOut[1];
        flux[3][i] = tmpOut[2];
 
    }
}

References ASSERTL0, ASSERTL1, Nektar::SolverUtils::RiemannSolver::CheckVectors(), Nektar::SolverUtils::RiemannSolver::GenerateRotationMatrices(), tinysimd::is_not_aligned, Nektar::SolverUtils::RiemannSolver::m_params, Nektar::SolverUtils::RiemannSolver::m_rotMat, Nektar::SolverUtils::RiemannSolver::m_vectors, Nektar::RoeKernel(), Nektar::SolverUtils::rotateFromNormalKernel(), and Nektar::SolverUtils::rotateToNormalKernel().

Member Data Documentation

solverName

std::string Nektar::RoeSolverSIMD::solverName

static

Initial value:

=
    SolverUtils::GetRiemannSolverFactory().RegisterCreatorFunction(
        "RoeOpt",
        RoeSolverSIMD::create,
        "Roe Riemann solver opt")

Definition at line 53 of file RoeSolverSIMD.h.