Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Protected Member Functions | List of all members
Nektar::APESolver Class Reference

#include <APESolver.h>

Inheritance diagram for Nektar::APESolver:
Inheritance graph
[legend]
Collaboration diagram for Nektar::APESolver:
Collaboration graph
[legend]

Protected Member Functions

 APESolver ()
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)
virtual void v_PointSolve (NekDouble pL, NekDouble uL, NekDouble vL, NekDouble wL, NekDouble pR, NekDouble uR, NekDouble vR, NekDouble wR, NekDouble p0, NekDouble u0, NekDouble v0, NekDouble w0, NekDouble &pF, NekDouble &uF, NekDouble &vF, NekDouble &wF)
Array< OneD, Array< OneD,
NekDouble > > 
GetRotBasefield ()
- Protected Member Functions inherited from Nektar::SolverUtils::RiemannSolver
SOLVER_UTILS_EXPORT RiemannSolver ()
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.

Additional Inherited Members

- 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.
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 inherited from Nektar::SolverUtils::RiemannSolver
int m_spacedim
- 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.
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.
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.

Detailed Description

Definition at line 48 of file APESolver.h.

Constructor & Destructor Documentation

Nektar::APESolver::APESolver ( )
protected

Member Function Documentation

Array< OneD, Array< OneD, NekDouble > > Nektar::APESolver::GetRotBasefield ( )
protected

Definition at line 108 of file RiemannSolvers/APESolver.cpp.

References ASSERTL1, Nektar::SolverUtils::RiemannSolver::CheckVectors(), Nektar::SolverUtils::RiemannSolver::m_vectors, and Nektar::SolverUtils::RiemannSolver::rotateToNormal().

Referenced by v_Solve().

{
ASSERTL1(CheckVectors("N"), "N not defined.");
ASSERTL1(CheckVectors("basefield"), "basefield not defined.");
const Array<OneD, const Array<OneD, NekDouble> > normals = m_vectors["N"]();
const Array<OneD, const Array<OneD, NekDouble> > basefield =
m_vectors["basefield"]();
int nTracePts = normals[0].num_elements();
int nDim = normals.num_elements();
Array< OneD, Array< OneD, NekDouble > > rotBasefield(nDim+1);
for (int i = 0; i < nDim + 1; i++)
{
rotBasefield[i] = Array<OneD, NekDouble>(nTracePts);
}
Array<OneD, Array<OneD, NekDouble> > baseVecLocs(1);
baseVecLocs[0] = Array<OneD, NekDouble>(nDim);
for (int i = 0; i < nDim; ++i)
{
baseVecLocs[0][i] = 1+i;
}
rotateToNormal(basefield, normals, baseVecLocs, rotBasefield);
return rotBasefield;
}
virtual void Nektar::APESolver::v_PointSolve ( NekDouble  pL,
NekDouble  uL,
NekDouble  vL,
NekDouble  wL,
NekDouble  pR,
NekDouble  uR,
NekDouble  vR,
NekDouble  wR,
NekDouble  p0,
NekDouble  u0,
NekDouble  v0,
NekDouble  w0,
NekDouble &  pF,
NekDouble &  uF,
NekDouble &  vF,
NekDouble &  wF 
)
inlineprotectedvirtual

Reimplemented in Nektar::LaxFriedrichsSolver, and Nektar::UpwindSolver.

Definition at line 59 of file APESolver.h.

References ASSERTL0.

Referenced by v_Solve().

{
ASSERTL0(false, "This function should be defined by subclasses.");
}
void Nektar::APESolver::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 
)
protectedvirtual

Implements Nektar::SolverUtils::RiemannSolver.

Definition at line 57 of file RiemannSolvers/APESolver.cpp.

References GetRotBasefield(), and v_PointSolve().

{
Array< OneD, Array< OneD, NekDouble > > basefield = GetRotBasefield();
int expDim = nDim;
NekDouble uF, vF;
if (expDim == 1)
{
for (int i = 0; i < Fwd[0].num_elements(); ++i)
{
Fwd[0][i], Fwd[1][i], 0.0, 0.0,
Bwd[0][i], Bwd[1][i], 0.0, 0.0,
basefield[0][i], basefield[1][i], 0.0, 0.0,
flux[0][i], flux[1][i], uF, vF);
}
}
else if (expDim == 2)
{
for (int i = 0; i < Fwd[0].num_elements(); ++i)
{
Fwd[0][i], Fwd[1][i], Fwd[2][i], 0.0,
Bwd[0][i], Bwd[1][i], Bwd[2][i], 0.0,
basefield[0][i], basefield[1][i], basefield[2][i], 0.0,
flux[0][i], flux[1][i], flux[2][i], vF);
}
}
else if (expDim == 3)
{
for (int i = 0; i < Fwd[0].num_elements(); ++i)
{
Fwd[0][i], Fwd[1][i], Fwd[2][i], Fwd[3][i],
Bwd[0][i], Bwd[1][i], Bwd[2][i], Bwd[3][i],
basefield[0][i], basefield[1][i], basefield[2][i], basefield[3][i],
flux[0][i], flux[1][i], flux[2][i], flux[3][i]);
}
}
}