#include <UpwindPulseSolver.h>

Inheritance diagram for Nektar::UpwindPulseSolver:

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

Static Public Attributes
static std::string	solverName

Protected Member Functions
	UpwindPulseSolver (const LibUtilities::SessionReaderSharedPtr &pSession)

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)

void	RiemannSolverUpwind (NekDouble AL, NekDouble uL, NekDouble AR, NekDouble uR, NekDouble &Aflux, NekDouble &uflux, NekDouble A_0, NekDouble beta, NekDouble n)

Protected Member Functions inherited from Nektar::SolverUtils::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

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...

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. 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 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. 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 44 of file UpwindPulseSolver.h.

Constructor & Destructor Documentation

◆ UpwindPulseSolver()

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

protected

Definition at line 43 of file UpwindPulseSolver.cpp.

     : RiemannSolver(pSession)
 {
 }

Member Function Documentation

◆ create()

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

inlinestatic

Definition at line 47 of file UpwindPulseSolver.h.

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

◆ RiemannSolverUpwind()

void Nektar::UpwindPulseSolver::RiemannSolverUpwind	(	NekDouble	AL,
		NekDouble	uL,
		NekDouble	AR,
		NekDouble	uR,
		NekDouble &	Aflux,
		NekDouble &	uflux,
		NekDouble	A_0,
		NekDouble	beta,
		NekDouble	n
	)

protected

Riemann solver for upwinding at an interface between two elements. Uses the characteristic variables for calculating the upwinded state $(A_u,u_u)$ from the left $(A_L,u_L)$ and right state $(A_R,u_R)$. Returns the upwinded flux ${F}^u$ needed for the weak formulation (1). Details can be found in "Pulse wave propagation in the human vascular system", section 3.3

Definition at line 89 of file UpwindPulseSolver.cpp.

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

Referenced by v_Solve().

 {
     Array<OneD, NekDouble> W(2);
     Array<OneD, NekDouble> upwindedphysfield(2);
     NekDouble cL  = 0.0;
     NekDouble cR  = 0.0;
     NekDouble p   = 0.0;
     NekDouble p_t = 0.0;
 
     ASSERTL1(CheckParams("rho"), "rho not defined.");
     NekDouble rho = m_params["rho"]();
 
     ASSERTL1(CheckParams("pext"), "pext not defined.");
     NekDouble pext = m_params["pext"]();
 
     // Compute the wave speeds. The use of the normal here allows
     // for the definition of the characteristics to be inverted
     // (and hence the left and right state) if n is in the -ve
     // x-direction. This means we end up with the positive
     // defintion of the flux which has to therefore be multiplied
     // by the normal at the end of the methods This is a bit of a
     // mind twister but is efficient from a coding perspective.
     cL = sqrt(beta * sqrt(AL) / (2 * rho)) * n;
     cR = sqrt(beta * sqrt(AR) / (2 * rho)) * n;
 
     ASSERTL1(fabs(cL + cR) > fabs(uL + uR), "Conditions are not sub-sonic");
 
     // If upwinding from left and right for subsonic domain
     // then know characteristics immediately
     W[0] = uL + 4 * cL;
     W[1] = uR - 4 * cR;
 
     // Calculate conservative variables from characteristics
     NekDouble w0mw1 = 0.25 * (W[0] - W[1]);
     NekDouble fac   = rho / (2 * beta);
     w0mw1 *= w0mw1; // squared
     w0mw1 *= w0mw1; // fourth power
     fac *= fac;     // squared
     upwindedphysfield[0] = w0mw1 * fac;
     upwindedphysfield[1] = 0.5 * (W[0] + W[1]);
 
     // Compute the fluxes multipled by the normal.
     Aflux = upwindedphysfield[0] * upwindedphysfield[1] * n;
     p     = pext + beta * (sqrt(upwindedphysfield[0]) - sqrt(A_0));
     p_t   = 0.5 * (upwindedphysfield[1] * upwindedphysfield[1]) + p / rho;
     uflux = p_t * n;
 }

◆ v_Solve()

void Nektar::UpwindPulseSolver::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

Calculates the third term of the weak form (1): numerical flux at boundary $ \left[ \mathbf{\psi}^{\delta} \cdot \{ \mathbf{F}^u - \mathbf{F}(\mathbf{U}^{\delta}) \} \right]_{x_e^l}^{x_eû} $

Definition at line 55 of file UpwindPulseSolver.cpp.

References ASSERTL1, Nektar::SolverUtils::RiemannSolver::CheckScalars(), Nektar::SolverUtils::RiemannSolver::m_scalars, and RiemannSolverUpwind().

 {
     int i;
     int nTracePts = Fwd[0].num_elements();
 
     ASSERTL1(CheckScalars("A0"), "A0 not defined.");
     const Array<OneD, NekDouble> &A0 = m_scalars["A0"]();
 
     ASSERTL1(CheckScalars("beta"), "beta not defined.");
     const Array<OneD, NekDouble> &beta = m_scalars["beta"]();
 
     ASSERTL1(CheckScalars("N"), "N not defined.");
     const Array<OneD, NekDouble> &N = m_scalars["N"]();
 
     for (i = 0; i < nTracePts; ++i)
     {
         RiemannSolverUpwind(Fwd[0][i], Fwd[1][i], Bwd[0][i], Bwd[1][i],
                             flux[0][i], flux[1][i], A0[i], beta[i], N[i]);
     }
 }

Member Data Documentation

◆ solverName

std::string Nektar::UpwindPulseSolver::solverName

static

Initial value:

=
    SolverUtils::GetRiemannSolverFactory().RegisterCreatorFunction(
        "UpwindPulse", UpwindPulseSolver::create, "UpwindPulseSolver")

Definition at line 53 of file UpwindPulseSolver.h.

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Additional Inherited Members