Advection Face Integrals

AdvectionEquationMod.evalFaceIntegrals

This function evaluates the interior face integrals for DG methods, using the flux function from eqn.flux_func. The solution variables are interpolated to the faces, the flux computed, and then interpolated back to the solution points.

This function also logs some quantities to disk (TODO: move this to Utils/logging)

Inputs: mesh: an AbstractDGMesh sbp eqn opts

This function calculates the DG flux between a specified set of faces, using the solution data at the faces stored in eqn.q_face. Note that the flux is negated because the face integrals have a negative sign in the weak form.

Inputs:

mesh
sbp
eqn
functor: the functor that calculates the flux at a node
interfaces: an array of type Interface that specifies which interfaces
            to calculate the flux for

Inputs/Outputs:

face_flux: array to store the flux in, numDofPerNode x nnodesPerFace
           x length(interfaces)

The functor must have the signature: func( uL, qR, alpha_x, alpha_y, dxidx, nrm, params)

where uL and uR are the solution values for a node on the left and right elements, alpha_x and alpha_y are the x and y advection velocities, dxidx is the scaled mapping jacobian for elementL, and nrm is the face normal in reference space. params is eqn.params

Compute the face integrals without using eqn.q_face or eqn.flux_face. The integral is computed directly and res is updated

Inputs:

mesh
sbp
eqn
opts
flux_func: the flux functor that computes the face flux at a node

Thin wrapper around calcSharedFaceIntegrals_inner. This function is passed to finishDataExchange, and internally calls calcSharedFaceIntegrals_inner. See finishExchangeData for details on the interface and calcSharedFaceIntegrals_inner for the integral that is computed.

AdvectionEquationMod.calcSharedFaceIntegrals

This function calculates the shared face integrals for the faces shared with a single peer process. This function is for opts["parallel_type"] == "face" and regular face integrals (ie. not the entropy-stable face integrals) only.

Inputs:

mesh
sbp
eqn
opts:
data: a SharedFaceData specifying which faces to compute
functor: the FluxType to use for the face flux

Like calcSharedFaceIntegrals_inner_nopre, but it computes the integral one face at a time rather than computing all the flux, storing it in eqn.flux_sharedface and then doing the integral

See calcSharedFaceIntegrals_inner for a description of the arguments

Thin wrapper around calcSharedFaceIntegrals_inner. This function is passed to finishDataExchange, and internally calls calcSharedFaceIntegrals_inner. See finishDataExchange for details on the interface and calcSharedFaceIntegrals_inner for the integral that is computed.

Like calcSharedFaceIntegrals_inner, but for the case when opts["parallel_data"] == element. This effectively means it has to interpolate the solution from the elements to the faces and then do the integral

Like calcSharedFaceIntegrals_element_inner, but computes the integral one face at a time instead of computing the entire flux and then integrating.