Cardinal-specific nekRS API. More...

Classes
struct	characteristicScales

Functions
std::vector< std::vector< int > >	cornerGLLIndices (const int &n, const bool exact)
	Get the corner indices for the GLL points in a NekRS element on a single face.

std::vector< std::vector< int > >	nestedElementsOnFace (const int &n)

int	Nscalar ()

void	initializeHostMeshParameters ()
	Allocate memory for the host mesh parameters.

void	updateHostMeshParameters ()
	Update the mesh parameters on host.

dfloat *	host_x ()

dfloat *	host_y ()

dfloat *	host_z ()

nrs_t *	nrsPtr ()

dfloat *	getSgeo ()

dfloat *	getVgeo ()

void	checkFieldValidity (const field::NekFieldEnum &field)

void	checkFieldValidity (const field::NekWriteEnum &field)

void	copyDeviceToHost ()

void	computeWallDistance (const std::vector< int > &boundary_id)

std::vector< dfloat >	yPlus (const std::vector< int > &boundary_id)

std::vector< dfloat >	viscousDrag (const std::vector< int > &boundary)

void	setAbsoluteTol (double tol)

Real	scratchUnits (const int slot)

void	nondimensional (const bool n)

void	setRelativeTol (double tol)

void	setNekSetupTime (const double &time)

double	getNekSetupTime ()

void	setStartTime (const double &start)

bool	isInitialized ()

void	write_usrwrk_field_file (const int &size, const int &index, const int &slot, const std::string &prefix, const dfloat &time, const int &step, const bool &write_coords)

void	write_field_file (const std::string &prefix, const dfloat time, const int &step)

void	buildOnly (int buildOnly)

int	buildOnly ()

void	interpolateVolumeHex3D (const double I, double x, int N, double *Ix, int M)

bool	hasCHT ()

bool	hasMovingMesh ()

bool	hasVariableDt ()

bool	hasBlendingSolver ()

bool	hasUserMeshSolver ()

bool	endControlElapsedTime ()

bool	endControlTime ()

bool	endControlNumSteps ()

int	scalarFieldOffset ()

int	velocityFieldOffset ()

int	fieldOffset ()

mesh_t *	entireMesh ()

mesh_t *	flowMesh ()

mesh_t *	temperatureMesh ()

mesh_t *	getMesh (const nek_mesh::NekMeshEnum pp_mesh)

int	commRank ()

int	commSize ()

bool	hasTemperatureVariable ()

bool	hasTemperatureSolve ()

bool	hasScalarVariable (int scalarId)

bool	hasHeatSourceKernel ()

bool	scratchAvailable ()

void	initializeScratch (const unsigned int &n_slots)

void	freeScratch ()
	Free the scratch space.

double	viscosity ()

double	Pr ()

void	copyDeformationToDevice ()
	Copy the deformation from host to device.

template<typename T >
void	allgatherv (const std::vector< int > &base_counts, const T input, T output, const int multiplier=1)

void	displacementAndCounts (const std::vector< int > &base_counts, int counts, int displacement, const int multiplier)

void	interpolationMatrix (double *I, int starting_points, int ending_points)

void	interpolateSurfaceFaceHex3D (double scratch, const double I, double x, int N, double Ix, int M)

Point	centroidFace (int local_elem_id, int local_face_id)

Point	centroid (int local_elem_id)

Point	gllPoint (int local_elem_id, int local_node_id)

Point	gllPointFace (int local_elem_id, int local_face_id, int local_node_id)

std::vector< double >	usrwrkSideIntegral (const unsigned int &slot, const std::vector< int > &boundary, const nek_mesh::NekMeshEnum pp_mesh)

double	usrwrkVolumeIntegral (const unsigned int &slot, const nek_mesh::NekMeshEnum pp_mesh)

void	scaleUsrwrk (const unsigned int &slot, const dfloat &value)

double	area (const std::vector< int > &boundary_id, const nek_mesh::NekMeshEnum pp_mesh)

double	sideIntegral (const std::vector< int > &boundary_id, const field::NekFieldEnum &integrand, const nek_mesh::NekMeshEnum pp_mesh)

double	volume (const nek_mesh::NekMeshEnum pp_mesh)

void	dimensionalizeVolume (double &integral)

void	dimensionalizeArea (double &integral)

void	dimensionalizeVolumeIntegral (const field::NekFieldEnum &integrand, const Real &volume, double &integral)

void	dimensionalizeSideIntegral (const field::NekFieldEnum &integrand, const Real &area, double &integral)

void	dimensionalizeSideIntegral (const field::NekFieldEnum &integrand, const std::vector< int > &boundary_id, double &integral, const nek_mesh::NekMeshEnum pp_mesh)

double	functionVolumeIntegral (const field::NekFieldEnum &integrand, const double &volume, const nek_mesh::NekMeshEnum pp_mesh, const Function *function, const Real &time)

double	volumeIntegral (const field::NekFieldEnum &integrand, const double &volume, const nek_mesh::NekMeshEnum pp_mesh, const Function *function, const Real &time)

double	evaluateFunctionOnMesh (const Function *f, const Real time, const int id)

double	volumeNorm (const field::NekFieldEnum &integrand, const nek_mesh::NekMeshEnum pp_mesh, const Function *function, const Real &time, const Real &N)

double	massFlowrate (const std::vector< int > &boundary_id, const nek_mesh::NekMeshEnum pp_mesh)

double	sideMassFluxWeightedIntegral (const std::vector< int > &boundary_id, const field::NekFieldEnum &integrand, const nek_mesh::NekMeshEnum pp_mesh)

double	pressureSurfaceForce (const std::vector< int > &boundary_id, const Point &direction, const nek_mesh::NekMeshEnum pp_mesh)

double	heatFluxIntegral (const std::vector< int > &boundary_id, const nek_mesh::NekMeshEnum pp_mesh)

void	limitTemperature (const double min_T, const double max_T)

void	gradient (const int offset, const int e, const double f, double grad_f, const nek_mesh::NekMeshEnum pp_mesh)

double	volumeExtremeValue (const field::NekFieldEnum &field, const nek_mesh::NekMeshEnum pp_mesh, const Function *function, const Real &time, const bool max)

double	sideExtremeValue (const std::vector< int > &boundary_id, const field::NekFieldEnum &field, const nek_mesh::NekMeshEnum pp_mesh, const bool max)

int	Nfaces ()

bool	isHeatFluxBoundary (const int boundary)

bool	isMovingMeshBoundary (const int boundary)

bool	isTemperatureBoundary (const int boundary)

const std::string	temperatureBoundaryType (const int boundary)

int	polynomialOrder ()

int	Nelements ()

int	dim ()

int	NfaceVertices ()
	Number of vertices required to define an element face Vertices refer to the points required to place the "corners" of an element face, and not the quadrature points. For instance, for hexahedral elements, the number of vertices per face is 4 regardless of the polynomial order.

int	NboundaryFaces ()

int	NboundaryID ()

bool	validBoundaryIDs (const std::vector< int > &boundary_id, int &first_invalid_id, int &n_boundaries)

void	storeBoundaryCoupling (const std::vector< int > &boundary_id, int &N)

int	scalarSlot (const int id)

double	get_scalar01 (const int id, const int surf_offset)

double	get_scalar02 (const int id, const int surf_offset)

double	get_scalar03 (const int id, const int surf_offset)

double	get_usrwrk00 (const int id, const int surf_offset)

double	get_usrwrk01 (const int id, const int surf_offset)

double	get_usrwrk02 (const int id, const int surf_offset)

double	get_temperature (const int id, const int surf_offset)

double	get_pressure (const int id, const int surf_offset)

double	get_zero (const int id, const int surf_offset)

double	get_unity (const int id, const int surf_offset)

double	get_velocity_x (const int id, const int surf_offset)

double	get_velocity_y (const int id, const int surf_offset)

double	get_velocity_z (const int id, const int surf_offset)

double	get_velocity (const int id, const int surf_offset)

double	get_velocity_x_squared (const int id, const int surf_offset)

double	get_velocity_y_squared (const int id, const int surf_offset)

double	get_velocity_z_squared (const int id, const int surf_offset)

void	initializeDimensionalScales (const double U, const double T, const double dT, const double L, const double rho, const double Cp, const double s01, const double ds01, const double s02, const double ds02, const double s03, const double ds03)

Real	nondimensionalDivisor (const field::NekFieldEnum &field)
	Return the reference divisor scale that defines the non-dimensional field.

Real	nondimensionalDivisor (const field::NekWriteEnum &field)

Real	nondimensionalAdditive (const field::NekFieldEnum &field)

Real	nondimensionalAdditive (const field::NekWriteEnum &field)

double	referenceLength ()

double	referenceTime ()

double	referenceArea ()

double	referenceVolume ()

template<typename T >
MPI_Datatype	resolveType ()

void	initializeNekHostArrays ()

std::tuple< dfloat , dfloat , dfloat * >	host_xyz ()

std::vector< dfloat > &	host_U ()

std::vector< dfloat > &	host_P ()

std::vector< dfloat > &	host_S ()

dfloat *	host_wrk ()

mesh_t *	createMesh2 (mesh_t *_mesh, int Nc)

Variables
double(*)(int, int)	solutionPointer (const field::NekFieldEnum &field)

Detailed Description

Cardinal-specific nekRS API.

nekRS ships with a rudimentary API in their nekrs namespace, but we need additional functionality from within Cardinal. Many of these functions are quite basic and could eventually be ported back into nekRS itself.

Function Documentation

◆ allgatherv()

template<typename T >

void nekrs::allgatherv	(	const std::vector< int > &	base_counts,
		const T *	input,
		T *	output,
		const int	multiplier
	)

Helper function for MPI_Allgatherv of results in NekRS

Parameters

[in]	base_counts	once multiplied by 'multiplier', the number of counts on each rank
[in]	input	rank-local data
[out]	output	collected result
[in]	multiplier	constant multiplier to set on each count indicator

◆ area()

double nekrs::area	(	const std::vector< int > &	boundary_id,
		const nek_mesh::NekMeshEnum	pp_mesh
	)

Compute the area of a set of boundary IDs

Parameters

[in]	boundary_id	nekRS boundary IDs for which to perform the integral
[in]	pp_mesh	which NekRS mesh to operate on

Returns: area integral

◆ buildOnly() [1/2]

int nekrs::buildOnly ( )

Whether NekRS was run in JIT build-only mode

Returns: whether NekRS was run in build-only mode

◆ buildOnly() [2/2]

void nekrs::buildOnly ( int buildOnly )

Indicate whether NekRS was run in build-only mode (this doesn't actually cause NekRS to run in build-only mode, but only provides an interface to this information elsewhere).

Parameters

[in] buildOnly whether NekRS is to be run in build-only mode

◆ centroid()

Point nekrs::centroid ( int local_elem_id )

Compute the centroid given a local element ID (NOTE: returns in dimensional form)

Parameters

[in] local_elem_id local element ID on this rank

Returns: centroid

◆ centroidFace()

Point nekrs::centroidFace	(	int	local_elem_id,
		int	local_face_id
	)

Compute the face centroid given a local element ID and face ID (NOTE: returns in dimensional form)

Parameters

[in]	local_elem_id	local element ID on this rank
[in]	local_face_id	local face ID on the element

Returns: centroid

◆ checkFieldValidity() [1/2]

void nekrs::checkFieldValidity ( const field::NekFieldEnum & field )

Check that the field specified can be accessed, e.g., if a user is requesting to access temperature, the problem must have a temperature variable

Parameters

[in] field field to check

◆ checkFieldValidity() [2/2]

void nekrs::checkFieldValidity ( const field::NekWriteEnum & field )

◆ commRank()

int nekrs::commRank ( )

Get the process rank

Returns: process rank

◆ commSize()

int nekrs::commSize ( )

Get the communicator size

Returns: communicator size

◆ computeWallDistance()

void nekrs::computeWallDistance ( const std::vector< int > & boundary_id )

Compute the minimum distance to a wall as a mesh field

Parameters

[in] boundary_id boundary(s) on which to compute the distance to the wall

◆ copyDeformationToDevice()

void nekrs::copyDeformationToDevice ( )

Copy the deformation from host to device.

◆ copyDeviceToHost()

void nekrs::copyDeviceToHost ( )

◆ cornerGLLIndices()

std::vector< std::vector< int > > nekrs::cornerGLLIndices	(	const int &	n,
		const bool	exact
	)

Get the corner indices for the GLL points in a NekRS element on a single face.

Support the NekRS mesh face has nodes

6 – 7 – 8 | | | 3 – 4 – 5 | | | 0 – 1 – 2

If 'exact' is false, this method returns {0, 2, 6, 8}. If 'exact' is true, this method returns:

element 0: {0, 1, 3, 4}
element 1: {1, 2, 4, 5}
element 2: {3, 4, 6, 7}
element 3: {4, 5, 7, 8}

Parameters

[in]	n	order of mesh (1 = first-order, 2 = second-order)
[in]	exact	whether the MOOSE elements will exactly represent the NekRS mesh

Returns: GLL indices, indexed first by element to build, then second by nodes on that element

◆ createMesh2()

mesh_t * nekrs::createMesh2	(	mesh_t *	_mesh,
		int	Nc
	)

◆ dim()

int nekrs::dim ( )

Mesh dimension

Returns: mesh dimension

◆ dimensionalizeArea()

void nekrs::dimensionalizeArea ( double & integral )

Dimensionalize an area

Parameters

[in] integral integral to dimensionalize

◆ dimensionalizeSideIntegral() [1/2]

void nekrs::dimensionalizeSideIntegral	(	const field::NekFieldEnum &	integrand,
		const Real &	area,
		double &	integral
	)

Dimensionalize a given integral of f over a side, i.e. fdS

Parameters

[in]	integrand	field to dimensionalize
[in]	area	area of the boundary
[in]	integral	integral to dimensionalize

◆ dimensionalizeSideIntegral() [2/2]

void nekrs::dimensionalizeSideIntegral	(	const field::NekFieldEnum &	integrand,
		const std::vector< int > &	boundary_id,
		double &	integral,
		const nek_mesh::NekMeshEnum	pp_mesh
	)

Dimensionalize a given integral of f over a side, i.e. fdS

Parameters

[in]	integrand	field to dimensionalize
[in]	boundary_id	boundary IDs for the integral
[in]	integral	integral to dimensionalize
[in]	pp_mesh	which NekRS mesh to operate on

◆ dimensionalizeVolume()

void nekrs::dimensionalizeVolume ( double & integral )

Dimensionalize a volume

Parameters

[in] integral integral to dimensionalize

◆ dimensionalizeVolumeIntegral()

void nekrs::dimensionalizeVolumeIntegral	(	const field::NekFieldEnum &	integrand,
		const Real &	volume,
		double &	integral
	)

Dimensionalize a given integral of f over volume, i.e. fdV

Parameters

[in]	integrand	field to dimensionalize
[in]	volume	volume of the domain (only used for dimensionalizing temperature)
[in]	integral	integral to dimensionalize

◆ displacementAndCounts()

void nekrs::displacementAndCounts	(	const std::vector< int > &	base_counts,
		int *	counts,
		int *	displacement,
		const int	multiplier
	)

Determine the receiving counts and displacements for all gather routines

Parameters

[in]	base_counts	unit-wise receiving counts for each process
[out]	counts	receiving counts from each process
[out]	displacement	displacement for each process's counts
[in]	multiplier	optional multiplier on the face-based data

◆ endControlElapsedTime()

bool nekrs::endControlElapsedTime ( )

Whether nekRS's input file intends to terminate the simulation based on a wall time

Returns: whether a wall time is used in nekRS to end the simulation

◆ endControlNumSteps()

bool nekrs::endControlNumSteps ( )

Whether nekRS's input file intends to terminate the simulation based on a number of steps

Returns: whether a time step interval is used in nekRS to end the simulation

◆ endControlTime()

bool nekrs::endControlTime ( )

Whether nekRS's input file intends to terminate the simulation based on an end time

Returns: whether an end time is used in nekRS to end the simulation

◆ entireMesh()

mesh_t * nekrs::entireMesh ( )

Get the "entire" NekRS mesh. For cases with a temperature scalar, this returns nrs->meshT, which will cover both the fluid and solid regions if CHT is present. For flow-only cases, this will return the flow mesh.

Returns: entire NekRS mesh

◆ evaluateFunctionOnMesh()

double nekrs::evaluateFunctionOnMesh	(	const Function *	f,
		const Real	time,
		const int	id
	)

Transform the point and time passed into a function into dimensional form, because the functions on the MOOSE side are defined in dimensional form.

Parameters

[in]	f	function to query
[in]	time	time
[in]	id	element ID

Returns: function evaluation, in dimensional form

◆ fieldOffset()

int nekrs::fieldOffset ( )

Offset increment to use for generic slice indexing

Returns: field offset

◆ flowMesh()

mesh_t * nekrs::flowMesh ( )

Get the mesh for the flow solve

Returns: flow mesh

◆ freeScratch()

void nekrs::freeScratch ( )

Free the scratch space.

◆ functionVolumeIntegral()

double nekrs::functionVolumeIntegral	(	const field::NekFieldEnum &	integrand,
		const double &	volume,
		const nek_mesh::NekMeshEnum	pp_mesh,
		const Function *	function,
		const Real &	time
	)

Compute the volume integral of a given function over the entire scalar mesh

Parameters

[in]	integrand	field to integrate
[in]	volume	volume of the domain (only used for dimensionalizing temperature)
[in]	pp_mesh	which NekRS mesh to operate on
[in]	function	MOOSE function to use to shift the field
[in]	time	time to evaluate function at

Returns: volume integral of a field

◆ get_pressure()

double nekrs::get_pressure	(	const int	id,
		const int	surf_offset
	)

Get the pressure solution at given GLL index

Parameters

[in] id GLL index

Returns: pressure value at index

◆ get_scalar01()

double nekrs::get_scalar01	(	const int	id,
		const int	surf_offset
	)

Get the scalar01 solution at given GLL index

Parameters

[in] id GLL index

Returns: scalar01 value at index

◆ get_scalar02()

double nekrs::get_scalar02	(	const int	id,
		const int	surf_offset
	)

Get the scalar02 solution at given GLL index

Parameters

[in] id GLL index

Returns: scalar02 value at index

◆ get_scalar03()

double nekrs::get_scalar03	(	const int	id,
		const int	surf_offset
	)

Get the scalar03 solution at given GLL index

Parameters

[in] id GLL index

Returns: scalar03 value at index

◆ get_temperature()

double nekrs::get_temperature	(	const int	id,
		const int	surf_offset
	)

Get the temperature solution at given GLL index

Parameters

[in] id GLL index

Returns: temperature value at index

◆ get_unity()

double nekrs::get_unity	(	const int	id,
		const int	surf_offset
	)

Return unity, for cases where the integrand or operator we are generalizing acts on 1

Parameters

[in] id GLL index

Returns: unity

◆ get_usrwrk00()

double nekrs::get_usrwrk00	(	const int	id,
		const int	surf_offset
	)

Get the usrwrk zeroth slice at given GLL index

Parameters

[in] id GLL index

Returns: zeroth slice of usrwrk value at index

◆ get_usrwrk01()

double nekrs::get_usrwrk01	(	const int	id,
		const int	surf_offset
	)

Get the usrwrk first slice at given GLL index

Parameters

[in] id GLL index

Returns: first slice of usrwrk value at index

◆ get_usrwrk02()

double nekrs::get_usrwrk02	(	const int	id,
		const int	surf_offset
	)

Get the usrwrk second slice at given GLL index

Parameters

[in] id GLL index

Returns: second slice of usrwrk value at index

◆ get_velocity()

double nekrs::get_velocity	(	const int	id,
		const int	surf_offset
	)

Get the magnitude of the velocity solution at given GLL index

Parameters

[in] id GLL index

Returns: velocity magnitude at index

◆ get_velocity_x()

double nekrs::get_velocity_x	(	const int	id,
		const int	surf_offset
	)

Get the x-velocity at given GLL index

Parameters

[in] id GLL index

Returns: x-velocity at index

◆ get_velocity_x_squared()

double nekrs::get_velocity_x_squared	(	const int	id,
		const int	surf_offset
	)

Get the x-velocity squared at given GLL index

Parameters

[in] id GLL index

Returns: square of x-velocity at index

◆ get_velocity_y()

double nekrs::get_velocity_y	(	const int	id,
		const int	surf_offset
	)

Get the y-velocity at given GLL index

Parameters

[in] id GLL index

Returns: y-velocity at index

◆ get_velocity_y_squared()

double nekrs::get_velocity_y_squared	(	const int	id,
		const int	surf_offset
	)

Get the y-velocity squared at given GLL index

Parameters

[in] id GLL index

Returns: square of y-velocity at index

◆ get_velocity_z()

double nekrs::get_velocity_z	(	const int	id,
		const int	surf_offset
	)

Get the z-velocity at given GLL index

Parameters

[in] id GLL index

Returns: z-velocity at index

◆ get_velocity_z_squared()

double nekrs::get_velocity_z_squared	(	const int	id,
		const int	surf_offset
	)

Get the z-velocity squared at given GLL index

Parameters

[in] id GLL index

Returns: square of z-velocity at index

◆ get_zero()

double nekrs::get_zero	(	const int	id,
		const int	surf_offset
	)

Return unity, for cases where the integrand or operator we are generalizing acts on 0

Parameters

[in] id GLL index

Returns: zero

◆ getMesh()

mesh_t * nekrs::getMesh ( const nek_mesh::NekMeshEnum pp_mesh )

Get the mesh to act on

Parameters

[in] pp_mesh which NekRS mesh to operate on

Returns: mesh to act on

◆ getNekSetupTime()

double nekrs::getNekSetupTime ( )

Get time spent on initialization

Returns: time spent on initialization

◆ getSgeo()

dfloat * nekrs::getSgeo ( )

◆ getVgeo()

dfloat * nekrs::getVgeo ( )

◆ gllPoint()

Point nekrs::gllPoint	(	int	local_elem_id,
		int	local_node_id
	)

Get the coordinate given a local element ID and local node ID (NOTE: returns in dimensional form)

Parameters

[in]	local_elem_id	local element ID on this rank
[in]	local_node_id	local node ID on this element

Returns: point

◆ gllPointFace()

Point nekrs::gllPointFace	(	int	local_elem_id,
		int	local_face_id,
		int	local_node_id
	)

Get the coordinate given a local element ID, a local face ID, and local node ID (NOTE: returns in dimensional form)

Parameters

[in]	local_elem_id	local element ID on this rank
[in]	local_face_id	local face ID on this element
[in]	local_node_id	local node ID on this element

Returns: point

◆ gradient()

void nekrs::gradient	(	const int	offset,
		const int	e,
		const double *	f,
		double *	grad_f,
		const nek_mesh::NekMeshEnum	pp_mesh
	)

Compute the gradient of a volume field

Parameters

[in]	offset	in the gradient field for each component (grad_x, grad_y, or grad_z)
[in]	e	element ID to compute gradient
[in]	f	field to compute the gradient of
[in]	pp_mesh	which NekRS mesh to operate on
[out]	grad_f	gradient of field

◆ hasBlendingSolver()

bool nekrs::hasBlendingSolver ( )

Whether nekRS's input file has the blending mesh solver

Returns: whether nekRS's input file has a non-user [MESH] solver

◆ hasCHT()

bool nekrs::hasCHT ( )

Whether nekRS's input file has CHT

Returns: whether nekRS input files model CHT

◆ hasHeatSourceKernel()

bool nekrs::hasHeatSourceKernel ( )

Whether nekRS contains an OCCA kernel to apply a source to the passive scalar equations

Returns: whether nekRS has an OCCA kernel for apply a passive scalar source

◆ hasMovingMesh()

bool nekrs::hasMovingMesh ( )

Whether nekRS's input file indicates a moving mesh

Returns: whether nekRS's input file indicates a moving mesh

◆ hasScalarVariable()

bool nekrs::hasScalarVariable ( int scalarId )

Whether nekRS's input file indicates that the problem has a scalar0(scalarId) variable

Parameters

[in] scalarId scalar number, i.e. for scalar03 scalarId=3

Returns: whether the nekRS problem includes the scalar0(scalarId) variable

◆ hasTemperatureSolve()

bool nekrs::hasTemperatureSolve ( )

Whether nekRS actually solves for temperature (as opposed to setting its solver to 'none')

Returns: whether nekRS will solve for temperature

◆ hasTemperatureVariable()

bool nekrs::hasTemperatureVariable ( )

Whether nekRS's input file indicates that the problem has a temperature variable

Returns: whether the nekRS problem includes a temperature variable

◆ hasUserMeshSolver()

bool nekrs::hasUserMeshSolver ( )

Whether nekRS's input file has the user mesh solver

Returns: whether nekRS's input file has [MESH] solver = user

◆ hasVariableDt()

bool nekrs::hasVariableDt ( )

Whether nekRS's input file indicates a variable time stepping scheme

Returns: whether nekRS's input file indicates a variable time stepping

◆ heatFluxIntegral()

double nekrs::heatFluxIntegral	(	const std::vector< int > &	boundary_id,
		const nek_mesh::NekMeshEnum	pp_mesh
	)

Compute the heat flux over a set of boundary IDs

Parameters

[in]	boundary_id	nekRS boundary IDs for which to perform the integral
[in]	pp_mesh	which NekRS mesh to operate on

Returns: heat flux area integral

◆ host_P()

std::vector< dfloat > & nekrs::host_P ( )

◆ host_S()

std::vector< dfloat > & nekrs::host_S ( )

◆ host_U()

std::vector< dfloat > & nekrs::host_U ( )

◆ host_wrk()

dfloat * nekrs::host_wrk ( )

◆ host_x()

dfloat * nekrs::host_x ( )

◆ host_xyz()

std::tuple< dfloat *, dfloat *, dfloat * > nekrs::host_xyz ( )

◆ host_y()

dfloat * nekrs::host_y ( )

◆ host_z()

dfloat * nekrs::host_z ( )

◆ initializeDimensionalScales()

void nekrs::initializeDimensionalScales	(	const double	U,
		const double	T,
		const double	dT,
		const double	L,
		const double	rho,
		const double	Cp,
		const double	s01,
		const double	ds01,
		const double	s02,
		const double	ds02,
		const double	s03,
		const double	ds03
	)

Initialize the characteristic scales for a nondimesional solution

Parameters

[in]	U	reference velocity
[in]	T	reference temperature
[in]	dT	reference temperature range
[in]	L	reference length scale
[in]	rho	reference density
[in]	Cp	reference heat capacity
[in]	s01	reference scalar01
[in]	ds01	reference s01 range
[in]	s02	reference scalar02
[in]	ds02	reference s02 range
[in]	s03	reference scalar03
[in]	ds03	reference s03 range

◆ initializeHostMeshParameters()

void nekrs::initializeHostMeshParameters ( )

Allocate memory for the host mesh parameters.

◆ initializeNekHostArrays()

void nekrs::initializeNekHostArrays ( )

◆ initializeScratch()

void nekrs::initializeScratch ( const unsigned int & n_slots )

Initialize scratch space for data to get sent into NekRS

Parameters

[in] n_slots number of slots (for volume arrays) to allocate

◆ interpolateSurfaceFaceHex3D()

void nekrs::interpolateSurfaceFaceHex3D	(	double *	scratch,
		const double *	I,
		double *	x,
		int	N,
		double *	Ix,
		int	M
	)

Interpolate face data onto a new set of points

Parameters

[in]	scratch	available scratch space for the calculation
[in]	I	interpolation matrix
[in]	x	face data to be interpolated
[in]	N	number of points in 1-D to be interpolated
[out]	Ix	interpolated data
[in]	M	resulting number of interpolated points in 1-D

◆ interpolateVolumeHex3D()

void nekrs::interpolateVolumeHex3D	(	const double *	I,
		double *	x,
		int	N,
		double *	Ix,
		int	M
	)

Interpolate a volume between NekRS's GLL points and a given-order receiving/sending mesh

◆ interpolationMatrix()

void nekrs::interpolationMatrix	(	double *	I,
		int	starting_points,
		int	ending_points
	)

Form the 2-D interpolation matrix from a starting GLL quadrature rule to an ending GLL quadrature rule.

Parameters

[out]	I	interpolation matrix
[in]	starting_points	number of points in the source quadrature rule
[in]	ending_points	number of points in the end quadrature rule

◆ isHeatFluxBoundary()

bool nekrs::isHeatFluxBoundary ( const int boundary )

Whether the specific boundary is a flux boundary

Parameters

[in] boundary boundary ID

Returns: whether boundary is a flux boundary

◆ isInitialized()

bool nekrs::isInitialized ( )

Whether NekRS itself has been initialized yet

Returns: whether NekRS is initialized

◆ isMovingMeshBoundary()

bool nekrs::isMovingMeshBoundary ( const int boundary )

Whether the specific boundary is a moving mesh boundary

Parameters

[in] boundary boundary ID

Returns: whether boundary is a moving mesh boundary

◆ isTemperatureBoundary()

bool nekrs::isTemperatureBoundary ( const int boundary )

Whether the specific boundary is a specified temperature boundary

Parameters

[in] boundary boundary ID

Returns: whether boundary is a temperature boundary

◆ limitTemperature()

void nekrs::limitTemperature	(	const double *	min_T,
		const double *	max_T
	)

Limit the temperature in nekRS to within the range of [min_T, max_T]

Parameters

[in]	min_T	minimum temperature allowable in nekRS
[in]	max_T	maximum temperature allowable in nekRS

◆ massFlowrate()

double nekrs::massFlowrate	(	const std::vector< int > &	boundary_id,
		const nek_mesh::NekMeshEnum	pp_mesh
	)

Compute the mass flowrate over a set of boundary IDs

Parameters

[in]	boundary_id	nekRS boundary IDs for which to compute the mass flowrate
[in]	pp_mesh	which NekRS mesh to operate on

Returns: mass flowrate

◆ NboundaryFaces()

int nekrs::NboundaryFaces ( )

Total number of element faces on a boundary of the nekRS mesh summed over all processes

Returns: number of boundary element faces

◆ NboundaryID()

int nekrs::NboundaryID ( )

Number of boundary IDs in the nekRS mesh

Returns: number of boundary IDs

◆ Nelements()

int nekrs::Nelements ( )

Total number of volume elements in nekRS mesh summed over all processes

Returns: number of volume elements

◆ nestedElementsOnFace()

std::vector< std::vector< int > > nekrs::nestedElementsOnFace ( const int & n )

Get all the element IDs that touch each face of a parent NekRS element

Parameters

[in] n NekRS polynomial order

Returns: nested element IDs, indexed by face

◆ Nfaces()

int nekrs::Nfaces ( )

Number of faces per element; because NekRS only supports HEX20, this should be 6

Returns: number of faces per mesh element

◆ NfaceVertices()

int nekrs::NfaceVertices ( )

Number of vertices required to define an element face Vertices refer to the points required to place the "corners" of an element face, and not the quadrature points. For instance, for hexahedral elements, the number of vertices per face is 4 regardless of the polynomial order.

Returns: Number of vertices per element face

◆ nondimensional()

void nekrs::nondimensional ( const bool n )

Inform backend if dimensionalization should be performed

Parameters

[in] n if dimensionalize should be performed

◆ nondimensionalAdditive() [1/2]

Real nekrs::nondimensionalAdditive ( const field::NekFieldEnum & field )

All fields in NekRS are assumed non-dimensionalized according to the general form f (non-dimensional) = (f - f_ref) / df

so that to define a nondimensionalization requires two scales: the divisor scale (df) and the additive scale (f_ref).

Parameters

[in]	field	physical interpretation of value
[out]	value	nondimensional additive scale (f_ref)

◆ nondimensionalAdditive() [2/2]

Real nekrs::nondimensionalAdditive ( const field::NekWriteEnum & field )

◆ nondimensionalDivisor() [1/2]

Real nekrs::nondimensionalDivisor ( const field::NekFieldEnum & field )

Return the reference divisor scale that defines the non-dimensional field.

All fields in NekRS are assumed non-dimensionalized according to the general form f (non-dimensional) = (f - f_ref) / df

so that to define a nondimensionalization requires two scales: the divisor scale (df) and the additive scale (f_ref).

Parameters

[in]	field	physical interpretation of value
[out]	value	nondimensional divisor scale (df)

◆ nondimensionalDivisor() [2/2]

Real nekrs::nondimensionalDivisor ( const field::NekWriteEnum & field )

◆ nrsPtr()

nrs_t * nekrs::nrsPtr ( )

◆ Nscalar()

int nekrs::Nscalar ( )

Number of passive scalars

Returns: number of passive scalars

◆ polynomialOrder()

int nekrs::polynomialOrder ( )

Polynomial order used in nekRS solution

Returns: polynomial order

◆ Pr()

double nekrs::Pr ( )

Get the Prandtl number; note that for dimensional cases, this is only guaranteed to be correct if the density, viscosity, heat capacity, and conductivity are constant.

Returns: constant Prandtl number

◆ pressureSurfaceForce()

double nekrs::pressureSurfaceForce	(	const std::vector< int > &	boundary_id,
		const Point &	direction,
		const nek_mesh::NekMeshEnum	pp_mesh
	)

Compute the integral of pressure on a surface, multiplied by the unit normal of the surface with a specified direction vector. This represents the force that the fluid exerts ON the boundary.

Parameters

[in]	boundary_id	NekRS boundary IDs for which to perform the integral
[in]	direction	unit vector to dot with the boundary surface normal
[in]	pp_mesh	which NekRS mesh to operate on

Returns: pressure surface force, along a particular direction

◆ referenceArea()

double nekrs::referenceArea ( )

Get the reference area scale

Returns: reference area scale

◆ referenceLength()

double nekrs::referenceLength ( )

Get the reference length scale

Returns: reference length scale

◆ referenceTime()

double nekrs::referenceTime ( )

Get the reference time scale

Returns: reference time scale

◆ referenceVolume()

double nekrs::referenceVolume ( )

Get the reference volume scale

Returns: reference volume scale

◆ resolveType()

template<typename T >

MPI_Datatype nekrs::resolveType ( )

◆ scalarFieldOffset()

int nekrs::scalarFieldOffset ( )

Offset increment for indexing into multi-volume arrays for the scalar fields. This assumes that all scalars are the same length as the temperature scalar. TODO: evaluate whether this works if nekRS uses CHT

Returns: scalar field offset

◆ scalarSlot()

int nekrs::scalarSlot ( const int id )

Determine the index in the scalar array for the non-temperature scalars

Parameters

[in] id id of the scalar; 1 corresponds to first non-temperature scalar, etc.

Returns: slot in scalar array that holds this variable

◆ scaleUsrwrk()

void nekrs::scaleUsrwrk	(	const unsigned int &	slot,
		const dfloat &	value
	)

Scale a slot in the usrwrk by a fixed value (multiplication)

Parameters

[in]	slot	slot in usrwrk to modify
[in]	value	value to multiply on scratch slot

◆ scratchAvailable()

bool nekrs::scratchAvailable ( )

Whether the scratch space has already been allocated by the user

Returns: whether scratch space is already allocated

◆ scratchUnits()

Real nekrs::scratchUnits ( const int slot )

Return the reference units for a usrwrk slot

Parameters

[in] slot usrwrk slot

Returns: value by which to multiply the usrwrk slot to go from non-dimensional form into dimensional form

◆ setAbsoluteTol()

void nekrs::setAbsoluteTol ( double tol )

Set the absolute tolerance for checking energy conservation in data transfers to Nek

Parameters

[in] tol tolerance

◆ setNekSetupTime()

void nekrs::setNekSetupTime ( const double & time )

Nek's runtime statistics are formed by collecting a timer of both the initialization and accumulated run time. We unfortunately have to split this across multiple classes, so if we want correct times we need to have NekInitAction save the value of the time spent on initialization.

Parameters

[in] time time spent on initialization

◆ setRelativeTol()

void nekrs::setRelativeTol ( double tol )

Set the relative tolerance for checking energy conservation in data transfers to Nek

Parameters

[in] tol tolerance

◆ setStartTime()

void nekrs::setStartTime ( const double & start )

Set the start time used by NekRS

Parameters

[in] start start time

◆ sideExtremeValue()

double nekrs::sideExtremeValue	(	const std::vector< int > &	boundary_id,
		const field::NekFieldEnum &	field,
		const nek_mesh::NekMeshEnum	pp_mesh,
		const bool	max
	)

Find the extreme of a given field over a set of boundary IDs

Parameters

[in]	boundary_id	nekRS boundary IDs for which to find the extreme value
[in]	field	field to find the maximum value of
[in]	pp_mesh	which NekRS mesh to operate on
[in]	max	whether to take the maximum (or if false, the minimum)

Returns: max or min value of field on boundary

◆ sideIntegral()

double nekrs::sideIntegral	(	const std::vector< int > &	boundary_id,
		const field::NekFieldEnum &	integrand,
		const nek_mesh::NekMeshEnum	pp_mesh
	)

Compute the area integral of a given integrand over a set of boundary IDs

Parameters

[in]	boundary_id	nekRS boundary IDs for which to perform the integral
[in]	integrand	field to integrate
[in]	pp_mesh	which NekRS mesh to operate on

Returns: area integral of a field

◆ sideMassFluxWeightedIntegral()

double nekrs::sideMassFluxWeightedIntegral	(	const std::vector< int > &	boundary_id,
		const field::NekFieldEnum &	integrand,
		const nek_mesh::NekMeshEnum	pp_mesh
	)

Compute the mass flux weighted integral of a given integrand over a set of boundary IDs

Parameters

[in]	boundary_id	nekRS boundary IDs for which to perform the integral
[in]	integrand	field to integrate and weight by mass flux
[in]	pp_mesh	which NekRS mesh to operate on

Returns: mass flux weighted area average of a field

◆ storeBoundaryCoupling()

void nekrs::storeBoundaryCoupling	(	const std::vector< int > &	boundary_id,
		int &	N
	)

Store the rank-local element, element-local face, and rank ownership for boundary coupling

Parameters

[in]	boundary_id	boundaries through which nekRS will be coupled
[out]	N	total number of surface elements

◆ temperatureBoundaryType()

const std::string nekrs::temperatureBoundaryType ( const int boundary )

String name indicating the temperature boundary condition type on a given boundary

Parameters

[in] boundary boundary ID

Returns: string name of boundary condition type

◆ temperatureMesh()

mesh_t * nekrs::temperatureMesh ( )

Get the mesh for the temperature scalar

Returns: temperature mesh

◆ updateHostMeshParameters()

void nekrs::updateHostMeshParameters ( )

Update the mesh parameters on host.

◆ usrwrkSideIntegral()

std::vector< double > nekrs::usrwrkSideIntegral	(	const unsigned int &	slot,
		const std::vector< int > &	boundary,
		const nek_mesh::NekMeshEnum	pp_mesh
	)

Integrate the scratch space over boundaries

Parameters

[in]	slot	slot in scratch space
[in]	boundary	boundaries over which to integrate the scratch space
[in]	pp_mesh	portion of NekRS mesh to integrate over

Returns: boundary integrated scratch space, with one value per sideset

◆ usrwrkVolumeIntegral()

double nekrs::usrwrkVolumeIntegral	(	const unsigned int &	slot,
		const nek_mesh::NekMeshEnum	pp_mesh
	)

Volume integrate the scratch space

Parameters

[in]	slot	slot in scratch space to i ntegrat
[in]	pp_mesh	NekRS mesh to integrate over

Returns: volume integrated scratch space

◆ validBoundaryIDs()

bool nekrs::validBoundaryIDs	(	const std::vector< int > &	boundary_id,
		int &	first_invalid_id,
		int &	n_boundaries
	)

Whether the provided boundary IDs are all valid in the nekRS mesh

Parameters

[in]	boundary_id	vector of boundary IDs to check
[out]	first_invalid_id	first invalid ID encountered for printing an error on the MOOSE side
[out]	n_boundaries	maximum valid boundary ID for printing an error on the MOOSE side

Returns: whether all boundaries are valid

◆ velocityFieldOffset()

int nekrs::velocityFieldOffset ( )

Offset increment for indexing into the velocity array

Returns: velocity field offset

◆ viscosity()

double nekrs::viscosity ( )

Get the viscosity used in the definition of the Reynolds number; note that for dimensional cases, this is only guaranteed to be correct if the viscosity is constant.

Returns: constant dynamic viscosity

◆ viscousDrag()

std::vector< dfloat > nekrs::viscousDrag ( const std::vector< int > & boundary )

Compute the three components of the viscous drag along a given boundary

Parameters

[in] boundary boundary IDs for drag computation

Returns: components of drag (force fluid exerts on walls)

◆ volume()

double nekrs::volume ( const nek_mesh::NekMeshEnum pp_mesh )

Compute the volume over the entire scalar mesh

Parameters

[in] pp_mesh which NekRS mesh to operate on

Returns: volume integral

◆ volumeExtremeValue()

double nekrs::volumeExtremeValue	(	const field::NekFieldEnum &	field,
		const nek_mesh::NekMeshEnum	pp_mesh,
		const Function *	function,
		const Real &	time,
		const bool	max
	)

Find the extreme value of a given field over the entire nekRS domain

Parameters

[in]	field	field to find the minimum value of
[in]	pp_mesh	which NekRS mesh to operate on
[in]	function	MOOSE function to use to shift the field
[in]	time	time to evaluate function at
[in]	max	whether to take the maximum (or if false, the minimum)

Returns: max or min value of field in volume

◆ volumeIntegral()

double nekrs::volumeIntegral	(	const field::NekFieldEnum &	integrand,
		const double &	volume,
		const nek_mesh::NekMeshEnum	pp_mesh,
		const Function *	function,
		const Real &	time
	)

Compute the volume integral of a given integrand over the entire scalar mesh

Parameters

[in]	integrand	field to integrate
[in]	volume	volume of the domain (only used for dimensionalizing temperature)
[in]	pp_mesh	which NekRS mesh to operate on
[in]	function	MOOSE function to use to shift the field
[in]	time	time to evaluate function at

Returns: volume integral of a field

◆ volumeNorm()

double nekrs::volumeNorm	(	const field::NekFieldEnum &	integrand,
		const nek_mesh::NekMeshEnum	pp_mesh,
		const Function *	function,
		const Real &	time,
		const Real &	N
	)

Compute the L^N norm of a given integrand over the mesh

Parameters

[in]	integrand	field to integrate
[in]	pp_mesh	which NekRS mesh to operate on
[in]	function	MOOSE function to use to shift the field
[in]	time	time to evaluate function at
[in]	N	order of the norm

Returns: integrated L^N norm of the NekRS field, relative to a function

◆ write_field_file()

void nekrs::write_field_file	(	const std::string &	prefix,
		const dfloat	time,
		const int &	step
	)

Write a field file containing pressure, velocity, and scalars with given prefix

Parameters

[in]	prefix	three-character prefix
[in]	time	time
[in]	step	time step index

◆ write_usrwrk_field_file()

void nekrs::write_usrwrk_field_file	(	const int &	size,
		const int &	index,
		const int &	slot,
		const std::string &	prefix,
		const dfloat &	time,
		const int &	step,
		const bool &	write_coords
	)

Write a field file containing a specific slot of the nrs->usrwrk scratch space; this will write the field to the 'temperature' slot in a field file.

Parameters

[in]	slot	index in the nrs->usrwrk array to write
[in]	prefix	prefix for file name
[in]	time	simulation time to write file for
[in]	step	time step index
[in]	write_coords	whether to write the mesh coordinates

◆ yPlus()

std::vector< dfloat > nekrs::yPlus ( const std::vector< int > & boundary_id )

Compute y+ on the NekRS mesh

Parameters

[in] boundary_id boundary(s) on which to compute y+

Returns: max, min, average y+

Variable Documentation

◆ solutionPointer

double(*)(int, int) nekrs::solutionPointer(const field::NekWriteEnum &field) ( const field::NekFieldEnum & field )

Get pointer to various solution functions (for reading only) based on enumeration

Parameters

[in] field field to return a pointer to

Returns: function pointer to method that returns said field as a function of GLL index

Classes

Functions

Variables

Detailed Description

Function Documentation

◆ allgatherv()

◆ area()

◆ buildOnly() [1/2]

◆ buildOnly() [2/2]

◆ centroid()

◆ centroidFace()

◆ checkFieldValidity() [1/2]

◆ checkFieldValidity() [2/2]

◆ commRank()

◆ commSize()

◆ computeWallDistance()

◆ copyDeformationToDevice()

◆ copyDeviceToHost()

◆ cornerGLLIndices()

◆ createMesh2()

◆ dim()

◆ dimensionalizeArea()

◆ dimensionalizeSideIntegral() [1/2]

◆ dimensionalizeSideIntegral() [2/2]

◆ dimensionalizeVolume()

◆ dimensionalizeVolumeIntegral()

◆ displacementAndCounts()

◆ endControlElapsedTime()

◆ endControlNumSteps()

◆ endControlTime()

◆ entireMesh()

◆ evaluateFunctionOnMesh()

◆ fieldOffset()

◆ flowMesh()

◆ freeScratch()

◆ functionVolumeIntegral()

◆ get_pressure()

◆ get_scalar01()

◆ get_scalar02()

◆ get_scalar03()

◆ get_temperature()

◆ get_unity()

◆ get_usrwrk00()

◆ get_usrwrk01()

◆ get_usrwrk02()

◆ get_velocity()

◆ get_velocity_x()

◆ get_velocity_x_squared()

◆ get_velocity_y()

◆ get_velocity_y_squared()

◆ get_velocity_z()

◆ get_velocity_z_squared()

◆ get_zero()

◆ getMesh()

◆ getNekSetupTime()

◆ getSgeo()

◆ getVgeo()

◆ gllPoint()

◆ gllPointFace()

◆ gradient()

◆ hasBlendingSolver()

◆ hasCHT()

◆ hasHeatSourceKernel()

◆ hasMovingMesh()

◆ hasScalarVariable()

◆ hasTemperatureSolve()

◆ hasTemperatureVariable()

◆ hasUserMeshSolver()

◆ hasVariableDt()

◆ heatFluxIntegral()

◆ host_P()

◆ host_S()

◆ host_U()

◆ host_wrk()

◆ host_x()

◆ host_xyz()

◆ host_y()

◆ host_z()

◆ initializeDimensionalScales()

◆ initializeHostMeshParameters()