#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 $\mathbf{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.

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

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

Referenced by v_Solve().

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

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

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

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