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

#include <UpwindSolver.h>

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

Static Public Member Functions

static RiemannSolverSharedPtr create ()

Static Public Attributes

static std::string solverName

Protected Member Functions

 UpwindSolver ()
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)
 Upwind Riemann solver.
- Protected Member Functions inherited from Nektar::APESolver
 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)
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 solvers/APESolver/RiemannSolvers/UpwindSolver.h.

Constructor & Destructor Documentation

Nektar::UpwindSolver::UpwindSolver ( )
protected

Definition at line 47 of file solvers/APESolver/RiemannSolvers/UpwindSolver.cpp.

:
APESolver()
{
}

Member Function Documentation

static RiemannSolverSharedPtr Nektar::UpwindSolver::create ( )
inlinestatic

Definition at line 51 of file solvers/APESolver/RiemannSolvers/UpwindSolver.h.

{
return RiemannSolverSharedPtr(new UpwindSolver());
}
void Nektar::UpwindSolver::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 
)
protectedvirtual

Upwind Riemann solver.

Parameters
pLPerturbation pressure left state.
pRPerturbation pressure right state.
uLx perturbation verlocity component left state.
uRx perturbation verlocity component right state.
vLy perturbation verlocity component left state.
vRy perturbation verlocity component right state.
wLz perturbation verlocity component left state.
wRz perturbation verlocity component right state.
p0Base pressure.
u0Base x verlocity component
v0Base y verlocity component
w0Base z verlocity component
pFComputed Riemann flux for perturbation pressure.
uFComputed Riemann flux for x perturbation verlocity component
vFComputed Riemann flux for y perturbation verlocity component
wFComputed Riemann flux for z perturbation verlocity component

Reimplemented from Nektar::APESolver.

Definition at line 74 of file solvers/APESolver/RiemannSolvers/UpwindSolver.cpp.

References ASSERTL1, Nektar::SolverUtils::RiemannSolver::CheckParams(), and Nektar::SolverUtils::RiemannSolver::m_params.

{
// fetch params
ASSERTL1(CheckParams("Gamma"), "Gamma not defined.");
ASSERTL1(CheckParams("Rho"), "Rho not defined.");
const NekDouble &gamma= m_params["Gamma"]();
const NekDouble &rho = m_params["Rho"]();
Array<OneD, NekDouble> characteristic(4);
Array<OneD, NekDouble> W(2);
Array<OneD, NekDouble> lambda(2);
// compute the wave speeds
lambda[0]=u0 + sqrt(p0*gamma*rho)/rho;
lambda[1]=u0 - sqrt(p0*gamma*rho)/rho;
// calculate the caracteristic variables
//left characteristics
characteristic[0] = pL/2 + uL*sqrt(p0*gamma*rho)/2;
characteristic[1] = pL/2 - uL*sqrt(p0*gamma*rho)/2;
//right characteristics
characteristic[2] = pR/2 + uR*sqrt(p0*gamma*rho)/2;
characteristic[3] = pR/2 - uR*sqrt(p0*gamma*rho)/2;
//take left or right value of characteristic variable
for (int j = 0; j < 2; j++)
{
if (lambda[j]>=0)
{
W[j]=characteristic[j];
}
if(lambda[j]<0)
{
W[j]=characteristic[j+2];
}
}
//calculate conservative variables from characteristics
NekDouble p = W[0]+W[1];
NekDouble u = (W[0]-W[1])/sqrt(p0*gamma*rho);
// do not divide by zero
if (p0*gamma*rho == 0)
{
u = 0.0;
}
// assemble the fluxes
pF = gamma*p0 * u + u0*p;
uF = p/rho + u0*u + v0*vL + w0*wL;
vF = 0.0;
wF = 0.0;
}

Member Data Documentation

std::string Nektar::UpwindSolver::solverName
static
Initial value:
SolverUtils::GetRiemannSolverFactory().
RegisterCreatorFunction("APEUpwind", UpwindSolver::create, "Upwind solver for the APE equation")

Definition at line 56 of file solvers/APESolver/RiemannSolvers/UpwindSolver.h.

Generated on Wed Mar 4 2015 16:33:32 for Nektar++ by   doxygen 1.8.1.2