Internal Functions#

These are additional functions that do not clearly fit into another category.

typedef struct RatelViewer_private *RatelViewer#

Ratel viewer information for monitor routines.

typedef struct RatelCheckpointCtx_private *RatelCheckpointCtx#

Ratel context for checkpoints.

typedef struct RatelOperatorApplyContext_private *RatelOperatorApplyContext#

Ratel operator context for applying composite CeedOperator on a DM.

typedef struct RatelProlongRestrictContext_private *RatelProlongRestrictContext#

Ratel operator context for prolongation and restriction operations between pMG levels.

typedef struct RatelFormJacobianContext_private *RatelFormJacobianContext#

Ratel Jacobian setup context.

typedef struct RatelPMGContext_private *RatelPMGContext#

Ratel pMG context, does rely upon Ratel DM setup.

PetscClassId RATEL_CLASSID#
PetscLogStage RATEL_Setup#
PetscLogEvent RATEL_DMSetupByOrder#
PetscLogEvent RATEL_DMSetupSolver#
PetscLogEvent RATEL_Diagnostics#
PetscLogEvent RATEL_Jacobian#
PetscLogEvent RATEL_CeedOperatorApply#
static inline PetscInt RatelIntMin(PetscInt a, PetscInt b)#

Return minimum of two integers.

Parameters:
  • a[in] The first integer to compare

  • b[in] The second integer to compare

Returns:

The minimum of the two integers

static inline PetscInt RatelIntMax(PetscInt a, PetscInt b)#

Return maximum of two integers.

Parameters:
  • a[in] The first integer to compare

  • b[in] The second integer to compare

Returns:

The maximum of the two integers

static inline CeedInt RatelGetQuadratureSize(CeedEvalMode eval_mode, CeedInt dim, CeedInt num_components)#

Return the quadrature size from the eval mode, dimension, and number of components.

Parameters:
  • eval_mode[in] The basis evaluation mode

  • dim[in] The basis dimension

  • num_components[in] The basis number of components

Returns:

The maximum of the two integers

static inline CeedMemType RatelMemTypeP2C(PetscMemType mem_type)#

Translate PetscMemType to CeedMemType.

Parameters:
  • mem_type[in] PetscMemType

Returns:

Equivalent CeedMemType

int MMSError_CEED_ScalarBPs(void *ctx, const CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out)#

Compute error from true solution for CEED scalar BPs MMS.

Parameters:
  • ctx[in] QFunction context, unused

  • Q[in] Number of quadrature points

  • in[in] Input arrays 0 - qdata 1 - quadrature point coordinates 2 - computed solution

  • out[out] Output array 0 - error from true solution

Returns:

An error code: 0 - success, otherwise - failure

int MMSError_CEED_VectorBPs(void *ctx, const CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out)#

Compute error from true solution for CEED vector BPs MMS.

Parameters:
  • ctx[in] QFunction context, unused

  • Q[in] Number of quadrature points

  • in[in] Input arrays 0 - qdata 1 - quadrature point coordinates 2 - computed solution

  • out[out] Output array 0 - error from true solution

Returns:

An error code: 0 - success, otherwise - failure

int MMSError_Linear(void *ctx, const CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out)#

Compute error from true solution for linear elasticity MMS.

Uses an MMS adapted from doi:10.1016/j.compstruc.2019.106175

Parameters:
  • ctx[in] QFunction context, unused

  • Q[in] Number of quadrature points

  • in[in] Input arrays 0 - qdata 1 - quadrature point coordinates 2 - computed solution

  • out[out] Output array 0 - error from true solution

Returns:

An error code: 0 - success, otherwise - failure

int MMSError_MixedLinear(void *ctx, const CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out)#

Compute error from true solution for mixed linear elasticity MMS.

Parameters:
  • ctx[in] QFunction context, holding LinearElasticityParams

  • Q[in] Number of quadrature points

  • in[in] Input arrays 0 - qdata 1 - quadrature point coordinates 2 - computed solution, displacement field 3 - computed solution, pressure field

  • out[out] Output array 0 - error from true solution, displacement field 0 - error from true solution, pressure field

Returns:

An error code: 0 - success, otherwise - failure

int MMSForce_CEED_BP1(void *ctx, const CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out)#

Compute forcing term for CEED scalar BP1 MMS.

Parameters:
  • ctx[in] QFunction context, unused

  • Q[in] Number of quadrature points

  • in[in] Input arrays 0 - qdata 1 - quadrature point coordinates

  • out[out] Output array 0 - forcing term

Returns:

An error code: 0 - success, otherwise - failure

int MMSForce_CEED_BP2(void *ctx, const CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out)#

Compute forcing term for CEED vector BP2 MMS.

Parameters:
  • ctx[in] QFunction context, unused

  • Q[in] Number of quadrature points

  • in[in] Input arrays 0 - qdata 1 - quadrature point coordinates

  • out[out] Output array 0 - forcing term

Returns:

An error code: 0 - success, otherwise - failure

int MMSForce_CEED_BP3(void *ctx, const CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out)#

Compute forcing term for CEED scalar BP3 MMS.

Parameters:
  • ctx[in] QFunction context, unused

  • Q[in] Number of quadrature points

  • in[in] Input arrays 0 - qdata 1 - quadrature point coordinates

  • out[out] Output array 0 - forcing term

Returns:

An error code: 0 - success, otherwise - failure

int MMSForce_CEED_BP4(void *ctx, const CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out)#

Compute forcing term for CEED vector BP4 MMS.

Parameters:
  • ctx[in] QFunction context, unused

  • Q[in] Number of quadrature points

  • in[in] Input arrays 0 - qdata 1 - quadrature point coordinates

  • out[out] Output array 0 - forcing term

Returns:

An error code: 0 - success, otherwise - failure

int ConstantForce(void *ctx, const CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out)#

Compute constant forcing term.

Parameters:
  • ctx[in] QFunction context, holding RatelForcingVectorContext

  • Q[in] Number of quadrature points

  • in[in] Input arrays 0 - qdata

  • out[out] Output array 0 - forcing term

Returns:

An error code: 0 - success, otherwise - failure

int MMSForce_Linear(void *ctx, const CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out)#

Compute forcing term for linear elasticity MMS.

Parameters:
  • ctx[in] QFunction context, holding LinearElasticityParams

  • Q[in] Number of quadrature points

  • in[in] Input arrays 0 - qdata 1 - quadrature point coordinates

  • out[out] Output array 0 - forcing term

Returns:

An error code: 0 - success, otherwise - failure

int MMSForce_MixedLinear(void *ctx, const CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out)#

Compute forcing term for mixed linear elasticity MMS.

Parameters:
  • ctx[in] QFunction context, holding LinearElasticityParams

  • Q[in] Number of quadrature points

  • in[in] Input arrays 0 - qdata 1 - quadrature point coordinates

  • out[out] Output array 0 - forcing term, displacement field 1 - forcing term, pressure field

Returns:

An error code: 0 - success, otherwise - failure

int Mass(void *ctx, const CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out)#

Apply mass operator.

Parameters:
  • ctx[in] QFunction context, holding the number of components

  • Q[in] Number of quadrature points

  • in[in] Input arrays 0 - volumetric qdata 1 - u

  • out[out] Output array 0 - v

Returns:

An error code: 0 - success, otherwise - failure

int ScaledMass(void *ctx, const CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out)#

Apply scaled mass operator.

Parameters:
  • ctx[in] QFunction context, holding ScaledMassContext struct

  • Q[in] Number of quadrature points

  • in[in] Input arrays 0 - volumetric qdata 1 - u

  • out[out] Output array 0 - v

Returns:

An error code: 0 - success, otherwise - failure

int ComputeCentroid(void *ctx, CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out)#

Compute face centroid.

Parameters:
  • ctx[in] QFunction context, unused

  • Q[in] Number of quadrature points

  • in[in] Input arrays 0 - volumetric qdata 1 - quadrature point coordinates

  • out[out] Output array 0 - centroid

Returns:

An error code: 0 - success, otherwise - failure

CeedScalar RatelLog1pSeries(CeedScalar x)#

Series approximation of log1p()

log1p() is not vectorized in libc. The series expansion up to the sixth term is accurate to 1e-10 relative error in the range 2/3 < J < 3/2. This is accurate enough for many hyperelastic applications, but perhaps not for materials like foams that may encounter volumetric strains on the order of 1/5 < J < 5.

Parameters:
  • x[in] Scalar value

Returns:

A scalar value: log1p(x)

CeedInt RatelSign(CeedScalar x)#

Compute sign of scalar value.

Parameters:
  • x[in] Scalar value

Returns:

An integer: -1 if x is negative and 1 if x is positive

int RatelQdataUnpack(CeedInt Q, CeedInt i, const CeedScalar stored[10][CEED_Q_VLA], CeedScalar local[3][3])#

Unpack qdata at quadrature point.

Parameters:
  • Q[in] Number of quadrature points

  • i[in] Current quadrature point

  • stored[in] All qdata

  • local[out] Qdata for quadrature point i

Returns:

An error code: 0 - success, otherwise - failure

int RatelStoredValuesPack(CeedInt Q, CeedInt i, CeedInt start, CeedInt num_comp, const CeedScalar *local, CeedScalar *stored)#

Pack stored values at quadrature point.

Parameters:
  • Q[in] Number of quadrature points

  • i[in] Current quadrature point

  • start[in] Starting index to store components

  • num_comp[in] Number of components to store

  • local[in] Local values for quadrature point i

  • stored[out] Stored values

Returns:

An error code: 0 - success, otherwise - failure

int RatelStoredValuesUnpack(CeedInt Q, CeedInt i, CeedInt start, CeedInt num_comp, const CeedScalar *stored, CeedScalar *local)#

Unpack stored values at quadrature point.

Parameters:
  • Q[in] Number of quadrature points

  • i[in] Current quadrature point

  • start[in] Starting index to store components

  • num_comp[in] Number of components to store

  • stored[in] Stored values

  • local[out] Local values for quadrature point i

Returns:

An error code: 0 - success, otherwise - failure

int RatelGradUnpack(CeedInt Q, CeedInt i, const CeedScalar grad[3][3][CEED_Q_VLA], CeedScalar local[3][3])#

Unpack gradient at quadrature point.

Parameters:
  • Q[in] Number of quadrature points

  • i[in] Current quadrature point

  • grad[in] Gradient of u, x (or du in jacobian) w.r.t X, X is ref coordinate [-1, 1]^3

  • local[out] dudX, dxdX (or ddudX in jacobian) for quadrature point i

Returns:

An error code: 0 - success, otherwise - failure

CeedScalar RatelDot3(const CeedScalar a[3], const CeedScalar b[3])#

Compute dot product of two length 3 vectors.

Parameters:
  • a[in] First input vector

  • b[in] Second input vector

Returns:

A scalar value: a . b

CeedScalar RatelNorm3(const CeedScalar a[3])#

Compute norm of a length 3 vector.

Parameters:
  • a[in] Input vector

Returns:

A scalar value: |a|

int RatelScalarVecMult(CeedScalar alpha, const CeedScalar a[3], CeedScalar b[3])#

Compute b = alpha a for a length 3 vector.

Parameters:
  • alpha[in] Scaling factor

  • a[in] Input vector

  • b[out] Output vector

Returns:

An error code: 0 - success, otherwise - failure

int RatelVecVecSubtract(const CeedScalar a[3], const CeedScalar b[3], CeedScalar c[3])#

Compute c = a - b for two length 3 vectors.

Parameters:
  • a[in] First input vector

  • b[in] Second input vector

  • c[out] Output vector

Returns:

An error code: 0 - success, otherwise - failure

int RatelVecVecCross(const CeedScalar a[3], const CeedScalar b[3], CeedScalar c[3])#

Compute c = a x b for two length 3 vectors.

Parameters:
  • a[in] First input vector

  • b[in] Second input vector

  • c[out] Output vector

Returns:

An error code: 0 - success, otherwise - failure

int RatelVecOuterMult(const CeedScalar a[3], CeedScalar A_sym[6])#

Compute outer product of a vector length 3 with it self results in symmetric matrix A_sym = a*a^T

Parameters:
  • a[in] Input vector

  • A_sym[out] Symmetric matrix

Returns:

An error code: 0 - success, otherwise - failure

int RatelVecVecOuterMult(const CeedScalar a[3], const CeedScalar b[3], CeedScalar A[3][3])#

Compute outer product of two vectors of length 3 results in a matrix A = a*b^T

Parameters:
  • a[in] Input vector

  • b[in] Input vector

  • A[out] Matrix

Returns:

An error code: 0 - success, otherwise - failure

int RatelScalarMatMultSymmetric(CeedScalar alpha, const CeedScalar A_sym[6], CeedScalar B_sym[6])#

Compute B_sym = alpha A_sym

Parameters:
  • alpha[in] Scaling factor

  • A_sym[in] Input 3x3 matrix, in symmetric representation

  • B_sym[out] Output 3x3 matrix, in symmetric representation

Returns:

An error code: 0 - success, otherwise - failure

int RatelMatVecMult(CeedScalar alpha, const CeedScalar A[3][3], const CeedScalar x[3], CeedScalar b[3])#

Compute b = alpha A x for a length 3 vector and a 3x3 matrix.

Parameters:
  • alpha[in] Scaling factor

  • A[in] Input matrix

  • x[in] Input vector

  • b[out] Output vector

Returns:

An error code: 0 - success, otherwise - failure

int RatelSymmetricMatPack(const CeedScalar full[3][3], CeedScalar sym[6])#

Pack symmetric 3x3 matrix from full to symmetric representation.

Matrix is packed as

| 0 5 4 | | 5 1 3 | | 4 3 2 |

Parameters:
  • full[in] Input full 3x3 matrix

  • sym[out] Output matrix as length 6 vector, in symmetric representation

Returns:

An error code: 0 - success, otherwise - failure

int RatelSymmetricMatUnpack(const CeedScalar sym[6], CeedScalar full[3][3])#

Unpack symmetric 3x3 matrix from symmetric to full representation.

Matrix is packed as

| 0 5 4 | | 5 1 3 | | 4 3 2 |

Parameters:
  • sym[in] Input matrix as length 6 vector, in symmetric representation

  • full[out] Output full 3x3 matrix

Returns:

An error code: 0 - success, otherwise - failure

CeedScalar RatelMatTrace(const CeedScalar A[3][3])#

Compute the trace of a 3x3 matrix.

Parameters:
  • A[in] Input 3x3 matrix

Returns:

A scalar value: trace(A)

CeedScalar RatelMatTraceSymmetric(const CeedScalar A_sym[6])#

Compute the trace of a 3x3 matrix.

Parameters:
  • A_sym[in] Input 3x3 matrix, in symmetric representation

Returns:

A scalar value: trace(A)

int RatelMatMatAdd(CeedScalar alpha, const CeedScalar A[3][3], CeedScalar beta, const CeedScalar B[3][3], CeedScalar C[3][3])#

Compute C = alpha A + beta B for 3x3 matrices.

Parameters:
  • alpha[in] First scaling factor

  • A[in] First input matrix

  • beta[in] Second scaling factor

  • B[in] Second input matrix

  • C[out] Output matrix

Returns:

An error code: 0 - success, otherwise - failure

int RatelMatMatAddSymmetric(CeedScalar alpha, const CeedScalar A_sym[6], CeedScalar beta, const CeedScalar B_sym[6], CeedScalar C_sym[6])#

Compute C = alpha A + beta B for 3x3 matrices, in symmetric representation.

Parameters:
  • alpha[in] First scaling factor

  • A_sym[in] First input matrix, in symmetric representation

  • beta[in] Second scaling factor

  • B_sym[in] Second input matrix, in symmetric representation

  • C_sym[out] Output matrix, in symmetric representation

Returns:

An error code: 0 - success, otherwise - failure

int RatelMatMatMatAddSymmetric(CeedScalar alpha, const CeedScalar A_sym[6], CeedScalar beta, const CeedScalar B_sym[6], CeedScalar gamma, const CeedScalar C_sym[6], CeedScalar D_sym[6])#

Compute D = alpha A + beta B + gamma C for 3x3 matrices, in symmetric representation.

Parameters:
  • alpha[in] First scaling factor

  • A_sym[in] First input matrix, in symmetric representation

  • beta[in] Second scaling factor

  • B_sym[in] Second input matrix, in symmetric representation

  • gamma[in] Third scaling factor

  • C_sym[in] Third input matrix, in symmetric representation

  • D_sym[out] Output matrix, in symmetric representation

Returns:

An error code: 0 - success, otherwise - failure

int RatelMatDeviatoricSymmetric(CeedScalar trace_A, const CeedScalar A_sym[6], CeedScalar A_sym_dev[6])#

Compute deviatoric part of symmetric matrix; A_sym_dev = A_sym - (1/3) trace(A) I for 3x3 matrix, in symmetric representation.

Parameters:
  • trace_A[in] Trace of input matrix

  • A_sym[in] Input matrix, in symmetric representation

  • A_sym_dev[out] Deviatoric part of input matrix, in symmetric representation

Returns:

An error code: 0 - success, otherwise - failure

int RatelMatMatMult(CeedScalar alpha, const CeedScalar A[3][3], const CeedScalar B[3][3], CeedScalar C[3][3])#

Compute C = alpha A * B for 3x3 matrices.

Parameters:
  • alpha[in] Scaling factor

  • A[in] First input matrix

  • B[in] Second input matrix

  • C[out] Output matrix

Returns:

An error code: 0 - success, otherwise - failure

int RatelMatTransposeMatMult(CeedScalar alpha, const CeedScalar A[3][3], const CeedScalar B[3][3], CeedScalar C[3][3])#

Compute C = alpha A^T * B for 3x3 matrices.

Parameters:
  • alpha[in] Scaling factor

  • A[in] First input matrix

  • B[in] Second input matrix

  • C[out] Output matrix

Returns:

An error code: 0 - success, otherwise - failure

int RatelMatMatTransposeMult(CeedScalar alpha, const CeedScalar A[3][3], const CeedScalar B[3][3], CeedScalar C[3][3])#

Compute C = alpha A * B^T for 3x3 matrices.

Parameters:
  • alpha[in] Scaling factor

  • A[in] First input matrix

  • B[in] Second input matrix

  • C[out] Output matrix

Returns:

An error code: 0 - success, otherwise - failure

int RatelMatMatMultAtQuadraturePoint(CeedInt Q, CeedInt i, CeedScalar alpha, const CeedScalar A[3][3], const CeedScalar B[3][3], CeedScalar C[3][3][CEED_Q_VLA])#

Compute C = alpha A * B for 3x3 matrices at a quadrature point.

Parameters:
  • Q[in] Number of quadrature points

  • i[in] Current quadrature point

  • alpha[in] Scaling factor

  • A[in] First input matrix

  • B[in] Second input matrix

  • C[out] Output matrix, stored for quadrature point i

Returns:

An error code: 0 - success, otherwise - failure

int RatelMatMatTransposeMultAtQuadraturePoint(CeedInt Q, CeedInt i, CeedScalar alpha, const CeedScalar A[3][3], const CeedScalar B[3][3], CeedScalar C[3][3][CEED_Q_VLA])#

Compute C = alpha A * B^T for 3x3 matrices at a quadrature point.

Parameters:
  • Q[in] Number of quadrature points

  • i[in] Current quadrature point

  • alpha[in] Scaling factor

  • A[in] First input matrix

  • B[in] Second input matrix

  • C[out] Output matrix, stored for quadrature point i

Returns:

An error code: 0 - success, otherwise - failure

int RatelMatMatMultPlusMatMatMult(const CeedScalar A[3][3], const CeedScalar B[3][3], const CeedScalar C[3][3], const CeedScalar D[3][3], CeedScalar E[3][3])#

Compute E = A * B + C * D for 3x3 matrices.

Parameters:
  • A[in] First input matrix

  • B[in] Second input matrix

  • C[in] Third input matrix

  • D[in] Fourth input matrix

  • E[out] Output matrix

Returns:

An error code: 0 - success, otherwise - failure

CeedScalar RatelMatMatContract(CeedScalar alpha, const CeedScalar A[3][3], const CeedScalar B[3][3])#

Compute c = alpha A : B for 3x3 matrices.

Parameters:
  • alpha[in] Scaling factor

  • A[in] First input matrix

  • B[in] Second input matrix

Returns:

A scalar value: alpha A : B

CeedScalar RatelMatMatContractSymmetric(CeedScalar alpha, const CeedScalar A_sym[6], const CeedScalar B_sym[6])#

Compute c = alpha A_sym : B_sym for 3x3 matrices, in symmetric representation.

Parameters:
  • alpha[in] Scaling factor

  • A_sym[in] First input matrix, in symmetric representation

  • B_sym[in] Second input matrix, in symmetric representation

Returns:

A scalar value: alpha A_sym : B_sym

CeedScalar RatelMatDetA(const CeedScalar A[3][3])#

Compute det(A) for a 3x3 matrix.

Parameters:
  • A[in] Input matrix

Returns:

A scalar value: det(A)

CeedScalar RatelMatDetAM1(const CeedScalar A[3][3])#

Compute det(A) - 1 for a 3x3 matrix.

Parameters:
  • A[in] Input matrix

Returns:

A scalar value: det(A) - 1

CeedScalar RatelMatDetAM1Symmetric(const CeedScalar A_sym[6])#

Compute det(A_sym) - 1 for a 3x3 matrix, in symmetric representation.

Parameters:
  • A_sym[in] Input matrix, in symmetric representation

Returns:

A scalar value: det(A_sym) - 1

int RatelMatMatMultSymmetric(CeedScalar alpha, const CeedScalar A_sym[6], const CeedScalar B_sym[6], CeedScalar C_sym[6])#

Compute C_sym = alpha A_sym * B_sym for 3x3 matrices, in symmetric representation.

Note C_sym will not be symmetric in general. Only use this function when A_sym and B_sym have same eigenvectors.

Parameters:
  • alpha[in] Scaling factor

  • A_sym[in] First input matrix, in symmetric representation

  • B_sym[in] Second input matrix, in symmetric representation

  • C_sym[out] Output matrix, in symmetric representation

Returns:

An error code: 0 - success, otherwise - failure

CeedScalar RatelMatNorm(const CeedScalar A[3][3])#

Compute the Frobenius norm ||A|| = sqrt(sum_ij |a_ij|^2) for a symmetric 3x3 matrix.

Parameters:
  • A[in] Input matrix

Returns:

A scalar value: ||A||

int RatelMatMatMatMultSymmetric(CeedScalar alpha, const CeedScalar A_sym[6], const CeedScalar B_sym[6], CeedScalar C_sym[6])#

Compute C_sym = A_sym * B_sym * A_sym for 3x3 matrices, in symmetric representation.

Parameters:
  • alpha[in] Scaling factor

  • A_sym[in] First input matrix, in symmetric representation

  • B_sym[in] Second input matrix, in symmetric representation

  • C_sym[out] Output matrix, in symmetric representation

Returns:

An error code: 0 - success, otherwise - failure

int RatelMatInverse(const CeedScalar A[3][3], CeedScalar det_A, CeedScalar A_inv[3][3])#

Compute A^-1 for a 3x3 matrix.

Parameters:
  • A[in] Input matrix

  • det_A[in] Determinant of A

  • A_inv[out] Output matrix inverse

Returns:

An error code: 0 - success, otherwise - failure

int RatelMatInverseSymmetric(const CeedScalar A[3][3], CeedScalar det_A, CeedScalar A_inv[6])#

Compute A^-1 for a symmetric 3x3 matrix.

Parameters:
  • A[in] Input matrix

  • det_A[in] Determinant of A

  • A_inv[out] Output matrix inverse, in symmetric representation

Returns:

An error code: 0 - success, otherwise - failure

int RatelScaledMassApplyAtQuadraturePoint(CeedInt Q, CeedInt i, CeedInt num_comp, CeedScalar alpha, const CeedScalar *u, CeedScalar *v)#

Apply mass matrix for all components at a quadrature point.

Parameters:
  • Q[in] Number of quadrature points

  • i[in] Current quadrature point

  • num_comp[in] Number of components in u

  • alpha[in] Scaling factor

  • u[in] Input array

  • v[out] Output array

Returns:

An error code: 0 - success, otherwise - failure

int RatelCInverse(const CeedScalar E_sym[6], CeedScalar Jm1, CeedScalar C_inv_sym[6])#

Compute inverse of right Cauchy-Green tensor.

Parameters:
  • E_sym[in] Strain tensor, in symmetric representation

  • Jm1[in] Determinant of deformation gradient(F) - 1; J = det(F)

  • C_inv_sym[out] Inverse of right Cauchy-Green tensor, in symmetric representation

Returns:

An error code: 0 - success, otherwise - failure

int RatelCInverse_fwd(const CeedScalar C_inv_sym[6], const CeedScalar dE_sym[6], CeedScalar dC_inv_sym[6])#

Compute dC_inv_sym = -2 C_inv_sym * dE_sym * C_inv_sym

Parameters:
  • C_inv_sym[in] Inverse of right Cauchy-Green tensor, in symmetric representation

  • dE_sym[in] Incremental strain energy tensor, in symmetric representation

  • dC_inv_sym[out] Inverse of incremental right Cauchy-Green tensor, in symmetric representation

Returns:

An error code: 0 - success, otherwise - failure

int RatelLinearStrain(const CeedScalar grad_u[3][3], CeedScalar e_sym[6])#

Compute linear strain e = (grad_u + grad_u^T) / 2

Parameters:
  • grad_u[in] Gradient of u

  • e_sym[out] Linear strain, in symmetric representation

Returns:

An error code: 0 - success, otherwise - failure

int RatelLinearStrain_fwd(const CeedScalar grad_du[3][3], CeedScalar de_sym[6])#

Compute incremental linear strain de = (grad_du + grad_du^T) / 2

Parameters:
  • grad_du[in] Gradient of incremental change to u

  • de_sym[out] Incremental linear strain, in symmetric representation

Returns:

An error code: 0 - success, otherwise - failure

int RatelGreenEulerStrain(const CeedScalar grad_u[3][3], CeedScalar e_sym[6])#

Compute Green Euler strain e = (b - I) / 2 = (grad_u + grad_u^T + grad_u * grad_u^T) / 2 for current configuration.

Parameters:
  • grad_u[in] Gradient of u

  • e_sym[out] Green Euler strain, in symmetric representation

Returns:

An error code: 0 - success, otherwise - failure

int RatelGreenEulerStrain_fwd(const CeedScalar grad_du[3][3], const CeedScalar b[3][3], CeedScalar de_sym[6])#

Compute incremental Green Euler strain de = db / 2 = (grad_du b + b grad_du^T) / 2 for current configuration.

grad_du = d(du)/dx where x is physical coordinate in current configuration.

Parameters:
  • grad_du[in] Gradient of incremental change to u

  • b[in] Left Cauchy-Green deformation tensor

  • de_sym[out] Incremental Green Euler strain, in symmetric representation

Returns:

An error code: 0 - success, otherwise - failure

int RatelGreenLagrangeStrain(const CeedScalar grad_u[3][3], CeedScalar E_sym[6])#

Compute Green Lagrange strain E = (C - I)/2 = (grad_u + grad_u^T + grad_u^T * grad_u)/2 for initial configuration.

Parameters:
  • grad_u[in] Gradient of u

  • E_sym[out] Green Lagrange strain, in symmetric representation

Returns:

An error code: 0 - success, otherwise - failure

int RatelGreenLagrangeStrain_fwd(const CeedScalar grad_du[3][3], const CeedScalar F[3][3], CeedScalar dE_sym[6])#

Compute incremental Green Lagrange strain dE = (grad_du^T * F + F^T * grad_du) / 2 for initial configuration.

Parameters:
  • grad_du[in] Gradient of incremental change to u

  • F[in] Deformation gradient

  • dE_sym[out] Incremental Green Lagrange strain, in symmetric representation

Returns:

An error code: 0 - success, otherwise - failure

int RatelOrthogonalComplement(const CeedScalar w[3], CeedScalar u[3], CeedScalar v[3])#

Compute right handed orthonormal set {w, u, v} for length 3 unit vectors.

Ref https://www.geometrictools.com/GTE/Mathematics/SymmetricEigensolver3x3.h

Parameters:
  • w[in] Input vector, unit length

  • u[out] First output vector

  • v[out] Second output vector

Returns:

An error code: 0 - success, otherwise - failure

int RatelComputeEigenvector0(const CeedScalar A_sym[6], CeedScalar e_val_0, CeedScalar e_vec_0[3])#

Compute unit length eigenvector for the first eigenvalue of 3x3 symmetric matrix A_sym.

Ref https://www.geometrictools.com/GTE/Mathematics/SymmetricEigensolver3x3.h

Parameters:
  • A_sym[in] Symmetric matrix

  • e_val_0[in] First eigenvalue

  • e_vec_0[out] First eigenvector

Returns:

An error code: 0 - success, otherwise - failure

int RatelComputeEigenvector1(const CeedScalar A_sym[6], const CeedScalar e_vec_0[3], CeedScalar e_val_1, CeedScalar e_vec_1[3])#

Compute unit length eigenvector for the second eigenvalue of 3x3 symmetric matrix A_sym.

Ref https://www.geometrictools.com/GTE/Mathematics/SymmetricEigensolver3x3.h

Parameters:
  • A_sym[in] Symmetric matrix

  • e_vec_0[in] First eigenvector

  • e_val_1[in] Second eigenvalue

  • e_vec_1[out] Second eigenvector

Returns:

An error code: 0 - success, otherwise - failure

int RatelMatComputeEigensystemSymmetric(const CeedScalar A_sym[6], CeedScalar e_vals[3], CeedScalar e_vecs[3][3])#

Compute eigenvalues/vectors of 3x3 symmetric matrix A_sym.

Ref https://onlinelibrary.wiley.com/doi/10.1002/nme.7153?af=R

The rows of e_vecs are the eigenvectors for each eigenvalue.

Parameters:
  • A_sym[in] Symmetric matrix

  • e_vals[out] Array of eigenvalues

  • e_vecs[out] Array of eigenvectors

Returns:

An error code: 0 - success, otherwise - failure

int RatelEigenValue_fwd(const CeedScalar dA_sym[6], const CeedScalar e_vecs[3][3], CeedScalar de_vals[3])#

Compute eigenvalue’s increment de_vals[i] = (dA*e_vecs[i], e_vecs[i]) for Newton linearization.

Parameters:
  • dA_sym[in] Increment of symmetric matrix A

  • e_vecs[in] Eigenvectors of A_sym

  • de_vals[out] Increment eigenvalues

Returns:

An error code: 0 - success, otherwise - failure

int RatelEigenVector_fwd(const CeedScalar dA_sym[6], const CeedScalar e_vals[3], const CeedScalar e_vecs[3][3], CeedInt i, CeedScalar de_vec[3])#

Compute eigenvector’s increment de_vec[i] = sum_{j!=i} (dA*e_vecs[i], e_vecs[j]) * e_vecs[j] / (e_vals[i] - e_vals[j]) for Newton linearization.

Parameters:
  • dA_sym[in] Increment of symmetric matrix A

  • e_vals[in] Eigenvalues of A_sym

  • e_vecs[in] Eigenvectors of A_sym

  • i[in] ith de_vec that we want to return

  • de_vec[out] Increment of ith eigenvector

Returns:

An error code: 0 - success, otherwise - failure

int RatelPrincipalStretch(const CeedScalar e_vals[3], CeedScalar pr_str[3])#

Compute principal stretch pr[i] = sqrt(1 + e_vals[i]) where e_vals are eigenvalue of Green-Lagrange strain tensor E (in initial configuration) or Green-Euler strain tensor e (in current configuration)

Parameters:
  • e_vals[in] Array of eigenvalues of E or e

  • pr_str[out] Array of principal stretch

Returns:

An error code: 0 - success, otherwise - failure

int RatelPrincipalStretch_fwd(const CeedScalar dA_sym[6], const CeedScalar e_vecs[3][3], const CeedScalar pr_str[3], CeedScalar dpr_str[3])#

Compute principal stretch increment dpr_str[i] = (dA*e_vecs[i], e_vecs[i]) / pr[i] for Newton linearization.

Parameters:
  • dA_sym[in] Increment of Green-Lagrange dE (in initial configuration) or Green-Euler de (in current configuration)

  • e_vecs[in] Array of eigenvectors of A_sym

  • pr_str[in] Array of principal stretch

  • dpr_str[out] Array of increment principal stretch

Returns:

An error code: 0 - success, otherwise - failure

int RatelEigenVectorOuterMult(const CeedScalar e_vals[3], const CeedScalar e_vecs[3][3], CeedScalar outer_mult[3][6])#

Compute outer product of eigenvector outer_mult[i][6] = (N[i] * N[i]^T) for i=0:2.

Parameters:
  • e_vals[in] Input eigenvalues

  • e_vecs[in] Input eigenvectors 3x3

  • outer_mult[out] Matrix of size 3x6

Returns:

An error code: 0 - success, otherwise - failure

int RatelEigenVectorOuterMult_fwd(const CeedScalar dA_sym[6], const CeedScalar e_vals[3], const CeedScalar e_vecs[3][3], CeedScalar outer_mult_fwd[3][6])#

Compute outer product increment of eigenvector Outer_mult_fwd[i][6] = d(N[i] * N[i]^T) for Newton linearization.

Parameters:
  • dA_sym[in] Increment of symmetric matrix A

  • e_vecs[in] Eigenvectors of A

  • e_vals[in] Eigenvalues of A

  • outer_mult_fwd[out] Matrix of size 3x6

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelProcessCommandLineOptions(Ratel ratel)#

Process general command line options.

Collective across MPI processes.

Parameters:
  • ratel[inout] Ratel context object

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelDMPlexCreateFromOptions(Ratel ratel, VecType vec_type, DM *dm)#

Read mesh and setup DMPlex from options.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • vec_type[in] Default vector type (can be changed at run-time using -dm_vec_type)

  • dm[out] New distributed DMPlex

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelDMPlexCreateFaceLabel(Ratel ratel, DM dm, RatelMaterial material, PetscInt dm_face, PetscInt *num_label_values, char **face_label_name)#

Create a label with separate values for the FE orientations for all cells with this material for the DMPlex face.

Collective across MPI processes.

Parameters:
  • ratel[inout] Ratel context

  • dm[inout] DMPlex holding mesh

  • material[in] RatelMaterial to setup operators for

  • dm_face[in] Face number on DMPlex

  • num_label_values[out] Number of label values for newly created label

  • face_label_name[out] Label name for newly created label, or NULL if no elements match the material and dm_face

Returns:

An error code: 0 - success, otherwise - failure

static PetscErrorCode RatelDMFieldToDSField(Ratel ratel, DM dm, DMLabel domain_label, PetscInt dm_field, PetscInt *ds_field)#

Convert DM field to DS field.

Not collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • dm[in] DM holding mesh

  • domain_label[in] Label for DM domain

  • dm_field[in] Index of DM field

  • ds_field[out] Index of DS field

Returns:

An error code: 0 - success, otherwise - failure

static inline PetscErrorCode RatelGetClosurePermutationAndFieldOffsetAtDepth(Ratel ratel, DM dm, PetscInt depth, PetscInt field, IS *permutation, PetscInt *field_offset)#

Get the permutation and field offset for a given depth.

Not collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • dm[in] DMPlex holding mesh

  • depth[in] Depth of DMPlex topology

  • field[in] Index of DMPlex field

  • permutation[out] Permutation for DMPlex field

  • field_offset[out] Offset to DMPlex field

Returns:

An error code: 0 - success, otherwise - failure

static inline PetscErrorCode RatelGetQuadratureDataP2C(Ratel ratel, PetscFE fe, PetscQuadrature quadrature, PetscInt *q_dim, PetscInt *num_comp, PetscInt *Q, CeedScalar **q_points, CeedScalar **q_weights)#

Get quadrature data from PetscQuadrature for use with libCEED.

Not collective across MPI processes.

Note

q_weights and q_points are allocated using PetscCalloc1 and must be freed by the user.

Parameters:
  • ratel[in] Ratel context

  • fe[in] PetscFE object

  • quadrature[in] PETSc basis quadrature

  • q_dim[out] Quadrature dimension, or NULL if not needed

  • num_comp[out] Number of components, or NULL if not needed

  • Q[out] Number of quadrature points, or NULL if not needed

  • q_points[out] Quadrature points in libCEED orientation, or NULL if not needed

  • q_weights[out] Quadrature weights in libCEED orientation, or NULL if not needed

Returns:

An error code: 0 - success, otherwise - failure

static inline PetscErrorCode RatelCreateFEHeightSubspace(Ratel ratel, PetscFE fe, PetscInt height, PetscFE *fe_height)#

Create a PetscFE for a given height with subspaces and quadrature from a given PetscFE.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • fe[in] Reference PetscFE

  • height[in] Height of subspace

  • fe_height[out] Output PetscFE

Returns:

An error code: 0 - success, otherwise - failure

static inline PetscErrorCode RatelCreate1DTabulation_Tensor(Ratel ratel, PetscFE fe, PetscTabulation *tabulation, PetscReal **q_points_1d, CeedScalar **q_weights_1d)#

Create 1D tabulation from PetscFE.

Collective across MPI processes.

Note

q_weights and q_points are allocated using PetscCalloc1 and must be freed by the user.

Parameters:
  • ratel[in] Ratel context

  • fe[in] PETSc basis FE object

  • tabulation[out] PETSc basis tabulation

  • q_points_1d[out] Quadrature points in libCEED orientation

  • q_weights_1d[out] Quadrature weights in libCEED orientation

Returns:

An error code: 0 - success, otherwise - failure

static inline PetscErrorCode RatelComputeFieldTabulationP2C(Ratel ratel, DM dm, PetscInt field, PetscInt face, PetscTabulation tabulation, CeedScalar **interp, CeedScalar **grad)#

Compute field tabulation from PetscTabulation.

Not collective across MPI processes.

Note

interp and grad are allocated using PetscCalloc1 and must be freed by the user.

Parameters:
  • ratel[in] Ratel context

  • dm[in] DMPlex holding mesh

  • field[in] Index of DMPlex field

  • face[in] Index of basis face, or 0

  • tabulation[in] PETSc basis tabulation

  • interp[out] Interpolation matrix in libCEED orientation

  • grad[out] Gradient matrix in libCEED orientation

Returns:

An error code: 0 - success, otherwise - failure

static inline PetscErrorCode RatelGetGlobalDMPolytopeType(Ratel ratel, DM dm, DMLabel domain_label, PetscInt label_value, PetscInt height, DMPolytopeType *cell_type)#

Get global DMPlex topology type.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • dm[in] DMPlex holding mesh

  • domain_label[in] DMLabel for DMPlex domain

  • label_value[in] Stratum value

  • height[in] Height of DMPlex topology

  • cell_type[out] DMPlex topology type

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelDMPlexCeedBasisCreate(Ratel ratel, DM dm, DMLabel domain_label, PetscInt label_value, PetscInt height, PetscInt dm_field, CeedBasis *basis)#

Create CeedBasis from DMPlex.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • dm[in] DMPlex holding mesh

  • domain_label[in] DMLabel for DMPlex domain

  • label_value[in] Stratum value

  • height[in] Height of DMPlex topology

  • dm_field[in] Index of DMPlex field

  • basis[out] CeedBasis for DMPlex

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelDMPlexCeedBasisCoordinateCreate(Ratel ratel, DM dm, DMLabel domain_label, PetscInt label_value, PetscInt height, CeedBasis *basis)#

Create CeedBasis for coordinate space of DMPlex.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • dm[in] DMPlex holding mesh

  • domain_label[in] DMLabel for DMPlex domain

  • label_value[in] Stratum value

  • height[in] Height of DMPlex topology

  • basis[out] CeedBasis for coordinate space of DMPlex

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelDMPlexCeedBasisCellToFaceCreate(Ratel ratel, DM dm, DMLabel domain_label, PetscInt label_value, PetscInt face, PetscInt dm_field, CeedBasis *basis)#

Create CeedBasis for cell to face quadrature space evaluation from DMPlex.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • dm[in] DMPlex holding mesh

  • domain_label[in] DMLabel for DMPlex domain

  • label_value[in] Stratum value

  • face[in] Index of face

  • dm_field[in] Index of DMPlex field

  • basis[out] CeedBasis for cell to face evaluation

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelDMPlexCeedBasisCellToFaceCoordinateCreate(Ratel ratel, DM dm, DMLabel domain_label, PetscInt label_value, PetscInt face, CeedBasis *basis)#

Create CeedBasis for cell to face quadrature space evaluation on coordinate space of DMPlex.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • dm[in] DMPlex holding mesh

  • domain_label[in] DMLabel for DMPlex domain

  • label_value[in] Stratum value

  • face[in] Index of face

  • basis[out] CeedBasis for cell to face evaluation on coordinate space of DMPlex

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelDMPlexCeedElemRestrictionCreate(Ratel ratel, DM dm, DMLabel domain_label, PetscInt label_value, PetscInt height, PetscInt dm_field, CeedElemRestriction *restriction)#

Create CeedElemRestriction from DMPlex.

Not collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • dm[in] DMPlex holding mesh

  • domain_label[in] DMLabel for DMPlex domain

  • label_value[in] Stratum value

  • height[in] Height of DMPlex topology

  • dm_field[in] Index of DMPlex field

  • restriction[out] CeedElemRestriction for DMPlex

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelDMPlexCeedElemRestrictionCoordinateCreate(Ratel ratel, DM dm, DMLabel domain_label, PetscInt label_value, PetscInt height, CeedElemRestriction *restriction)#

Create CeedElemRestriction from DMPlex domain for mesh coordinates.

Not collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • dm[in] DMPlex holding mesh

  • domain_label[in] Label for DMPlex domain

  • label_value[in] Stratum value

  • height[in] Height of DMPlex topology

  • restriction[out] CeedElemRestriction for mesh

Returns:

An error code: 0 - success, otherwise - failure

static PetscErrorCode RatelDMPlexCeedElemRestrictionStridedCreate(Ratel ratel, DM dm, DMLabel domain_label, PetscInt label_value, PetscInt height, PetscInt q_data_size, PetscBool is_collocated, CeedElemRestriction *restriction)#

Create CeedElemRestriction from DMPlex domain for auxiliary QFunction data.

Not collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • dm[in] DMPlex holding mesh

  • domain_label[in] Label for DMPlex domain

  • label_value[in] Stratum value

  • height[in] Height of DMPlex topology

  • q_data_size[in] Number of components for QFunction data

  • is_collocated[in] Boolean flag indicating if the data is collocated on the nodes (PETSC_TRUE) on on quadrature points (PETSC_FALSE)

  • restriction[out] Strided CeedElemRestriction for QFunction data

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelDMPlexCeedElemRestrictionQDataCreate(Ratel ratel, DM dm, DMLabel domain_label, PetscInt label_value, PetscInt height, PetscInt q_data_size, CeedElemRestriction *restriction)#

Create CeedElemRestriction from DMPlex domain for auxiliary QFunction data.

Not collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • dm[in] DMPlex holding mesh

  • domain_label[in] Label for DMPlex domain

  • label_value[in] Stratum value

  • height[in] Height of DMPlex topology

  • q_data_size[in] Number of components for QFunction data

  • restriction[out] Strided CeedElemRestriction for QFunction data

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelDMPlexCeedElemRestrictionCollocatedCreate(Ratel ratel, DM dm, DMLabel domain_label, PetscInt label_value, PetscInt height, PetscInt q_data_size, CeedElemRestriction *restriction)#

Create CeedElemRestriction from DMPlex domain for nodally collocated auxiliary QFunction data.

Not collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • dm[in] DMPlex holding mesh

  • domain_label[in] Label for DMPlex domain

  • label_value[in] Stratum value

  • height[in] Height of DMPlex topology

  • q_data_size[in] Number of components for QFunction data

  • restriction[out] Strided CeedElemRestriction for QFunction data

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelDMGetFieldISLocal(Ratel ratel, DM dm, PetscInt field, PetscInt *block_size, IS *is)#

Create index set for each local field DoF in DM, including constrained and ghost nodes.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • dm[in] DM holding mesh

  • field[in] Field index

  • block_size[out] Number of components of requested field

  • is[out] Output IS with one index for each DoF of field

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelDMHasFace(Ratel ratel, DM dm, PetscInt face_id, PetscBool *has_face)#

Check whether a given face id exists in the “Face Sets” DMLabel.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • dm[in] DM holding mesh

  • face_id[in] Stratum value of face in “Face Sets” DM:abel

  • has_face[out] PETSC_TRUE if face exists in “Face Sets” DMLabel, otherwise PETSC_FALSE

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelMaterialSetupForcingSuboperator(RatelMaterial material, CeedOperator op_residual)#

Add forcing term to residual u term operator.

Collective across MPI processes.

Parameters:
  • material[in] RatelMaterial context

  • op_residual[out] Composite residual u term CeedOperator to add RatelMaterial sub-operator

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelOperatorApplyContextCreate(Ratel ratel, const char *name, DM dm_x, DM dm_y, Vec X_loc, Vec X_dot_loc, Vec Y_loc, CeedVector x_loc, CeedVector x_dot_loc, CeedVector y_loc, CeedOperator op, RatelOperatorApplyContext *ctx)#

Setup context data for operator application.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • name[in] Context name

  • dm_x[in] Input DM

  • dm_y[in] Output DM

  • X_loc[in] Input PETSc local vector, or NULL

  • X_dot_loc[in] Input PETSc local time derivative vector, or NULL

  • Y_loc[in] Output PETSc local vector, or NULL

  • x_loc[in] Input libCEED local vector, or NULL

  • x_dot_loc[in] Input libCEED local time derivative vector, or NULL

  • y_loc[in] Output libCEED local vector, or NULL

  • op[in] CeedOperator for evaluation

  • ctx[out] Context data for operator evaluation

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelOperatorApplyContextReference(RatelOperatorApplyContext ctx)#

Increment reference counter for operator context.

Not collective across MPI processes.

Parameters:
  • ctx[inout] Context data for operator evaluation

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelOperatorApplyContextReferenceCopy(RatelOperatorApplyContext ctx, RatelOperatorApplyContext *ctx_copy)#

Copy reference for operator context.

Note: If ctx_copy is non-null, it is assumed to be a valid pointer to a RatelOperatorApplyContext.

Not collective across MPI processes.

Parameters:
  • ctx[in] Context data for operator evaluation

  • ctx_copy[out] Copy of pointer to context data for operator evaluation

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelOperatorApplyContextDestroy(RatelOperatorApplyContext ctx)#

Destroy context data for operator application.

Collective across MPI processes.

Parameters:
  • ctx[inout] Context data for operator evaluation

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelProlongRestrictContextCreate(Ratel ratel, const char *name, PetscInt level, DM dm_c, DM dm_f, Vec X_loc_c, Vec X_loc_f, CeedVector x_loc_c, CeedVector x_loc_f, CeedVector y_loc_c, CeedVector y_loc_f, CeedOperator op_prolong, CeedOperator op_restrict, RatelProlongRestrictContext *ctx)#

Setup context data for prolongation/restriction.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • name[in] Context name

  • level[in] Index of multigrid level

  • dm_c[in] Coarse gridDM

  • dm_f[in] Fine grid DM

  • X_loc_c[in] Coarse grid input PETSc local vector

  • X_loc_f[in] Fine grid input PETSc local vector

  • x_loc_c[in] Coarse grid input libCEED local vector, or NULL

  • x_loc_f[in] Fine grid input libCEED local vector, or NULL

  • y_loc_c[in] Coarse grid output libCEED local vector, or NULL

  • y_loc_f[in] Fine grid output libCEED local vector, or NULL

  • op_prolong[in] CeedOperator for prolongation

  • op_restrict[in] CeedOperator for restriction

  • ctx[out] Context data for prolongation/restriction evaluation

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelProlongRestrictContextReference(RatelProlongRestrictContext ctx)#

Increment reference counter for prolongation/restriction context.

Not collective across MPI processes.

Parameters:
  • ctx[inout] Context data for prolongation/restriction evaluation

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelProlongRestrictContextDestroy(RatelProlongRestrictContext ctx)#

Destroy context data for prolongation/restriction.

Collective across MPI processes.

Parameters:
  • ctx[inout] Context data for prolongation/restriction evaluation

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelGetDiagonal(Mat A, Vec D)#

Compute the diagonal of an operator via libCEED.

Collective across MPI processes.

Parameters:
  • A[in] Operator MatShell

  • D[out] Vector holding operator diagonal

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelMatSetPreallocationCOO(Ratel ratel, CeedOperator op, CeedVector *coo_values, Mat A)#

Set COO preallocation for Mat associated with a CeedOperator.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • op[in] CeedOperator to assemble sparsity pattern

  • coo_values[out] CeedVector to hold COO values

  • A[inout] Sparse matrix to hold assembled CeedOperator

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelMatSetValuesCOO(Ratel ratel, CeedOperator op, CeedVector coo_values, CeedMemType mem_type, Mat A)#

Set COO values for Mat associated with a CeedOperator.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • op[in] CeedOperator to assemble

  • coo_values[in] CeedVector to hold COO values

  • mem_type[in] MemType to pass COO values

  • A[inout] Sparse matrix to hold assembled CeedOperator

Returns:

An error code: 0 - success, otherwise - failure

static inline PetscErrorCode RatelApplyAddCeedOperator_Core(RatelOperatorApplyContext ctx, Vec X, Vec Y, Vec X_loc, Vec X_dot_loc, Vec Y_loc)#

Apply the local action of a CeedOperator and store result in PETSc vector.

Collective across MPI processes.

Parameters:
  • ctx[in] User context struct containing CeedOperator data

  • X[in] Input PETSc global vector, for logging only

  • Y[in] Output PETSc global vector, for logging only

  • X_loc[in] Input PETSc local vector

  • X_dot_loc[in] Input PETSc local time derivative vector, or NULL if and only if X_dot is NULL

  • Y_loc[out] Output PETSc local vector

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelApplyCeedOperatorLocalToLocal(RatelOperatorApplyContext ctx, Vec X_loc, Vec Y_loc)#

Apply the local action of a CeedOperator and store result in PETSc vector.

Collective across MPI processes.

Parameters:
  • ctx[in] User context struct containing CeedOperator data

  • X_loc[in] Input PETSc local vector

  • Y_loc[out] Output PETSc local vector

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelApplyCeedOperatorGlobalToLocal(RatelOperatorApplyContext ctx, Vec X, Vec Y_loc)#

Apply the local action of a CeedOperator and store result in PETSc vector.

Collective across MPI processes.

Parameters:
  • ctx[in] User context struct containing CeedOperator data

  • X[in] Input PETSc global vector

  • Y_loc[out] Output PETSc local vector

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelApplyCeedOperatorGlobalToGlobal(RatelOperatorApplyContext ctx, Vec X, Vec Y)#

Apply the local action of a CeedOperator and store result in PETSc vector.

Collective across MPI processes.

Parameters:
  • ctx[in] User context struct containing CeedOperator data

  • X[in] Input PETSc global vector

  • Y[out] Output PETSc global vector

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelApplyCeedOperatorVelocityGlobalToGlobal(RatelOperatorApplyContext ctx, Vec X, Vec X_dot, Vec Y)#

Apply the local action of a velocity-dependent CeedOperator and store result in PETSc vector.

Collective across MPI processes.

Parameters:
  • ctx[in] User context struct containing CeedOperator data

  • X[in] Input PETSc global vector

  • X_dot[in] Input PETSc global time derivative vector

  • Y[out] Output PETSc global vector

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelApplyAddCeedOperatorGlobalToGlobal(RatelOperatorApplyContext ctx, Vec X, Vec Y)#

Apply the local action of a CeedOperator and store result in PETSc vector.

Collective across MPI processes.

Parameters:
  • ctx[in] User context struct containing CeedOperator data

  • X[in] Input PETSc global vector

  • Y[out] Output PETSc global vector

Returns:

An error code: 0 - success, otherwise - failure

static PetscErrorCode RatelGetCurrentTime(Ratel ratel, PetscReal *current_time)#

Get the current time used in all CeedOperator.

Not collective across MPI processes.

Parameters:
  • ratel[in] Ratel context to get time

  • current_time[out] Current time

Returns:

An error code: 0 - success, otherwise - failure

static PetscErrorCode RatelUpdateTimeContexts(Ratel ratel, PetscReal time)#

Update the current time used in all CeedOperator.

Not collective across MPI processes.

Parameters:
  • ratel[inout] Ratel context to update boundary conditions

  • time[in] Current time

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelDMPlexInsertBoundaryValues(DM dm, PetscBool insert_essential, Vec U_loc, PetscReal time, Vec face_geometry_FVM, Vec cell_geometry_FVM, Vec grad_FVM)#

Compute the Dirichlet boundary values via CeedOperator.

Collective across MPI processes.

Parameters:
  • dm[in] DM to insert boundary values on

  • insert_essential[in] Boolean flag for Dirichlet or Neumann boundary conditions

  • U_loc[out] Local vector to insert the boundary values into

  • time[in] Current time

  • face_geometry_FVM[in] Face geometry data for finite volume discretizations

  • cell_geometry_FVM[in] Cell geometry data for finite volume discretizations

  • grad_FVM[in] Gradient reconstruction data for finite volume discretizations

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelUpdateTimeAndBoundaryValues(Ratel ratel, PetscReal time)#

Update time contexts and boundary values.

Collective across MPI processes.

Parameters:
  • ratel[inout] Ratel context to update boundary conditions

  • time[in] Current time

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelApplyOperator(Mat A, Vec X, Vec Y)#

Compute the action of the matrix-free CeedOperator.

Collective across MPI processes.

Parameters:
  • A[in] Operator MatShell

  • X[in] Input PETSc vector

  • Y[out] Output PETSc vector

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelApplyJacobian(Mat A, Vec X, Vec Y)#

Compute the action of the Jacobian for a SNES.

Collective across MPI processes.

Parameters:
  • A[in] Jacobian operator MatShell

  • X[in] Input PETSc vector

  • Y[out] Output PETSc vector

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelApplyProlongation(Mat A, Vec C, Vec F)#

Compute action of a p-multigrid prolongation operator.

Collective across MPI processes.

Parameters:
  • A[in] Prolongation operator MatShell

  • C[in] Input PETSc vector on coarse grid

  • F[out] Output PETSc vector on fine grid

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelApplyRestriction(Mat A, Vec F, Vec C)#

Compute action of a p-multigrid restriction operator.

Collective across MPI processes.

Parameters:
  • A[in] Restriction operator MatShell

  • F[in] Input PETSc vector on fine grid

  • C[out] Output PETSc vector on coarse grid

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelSNESFormResidual(SNES snes, Vec X, Vec Y, void *ctx_residual_u)#

Compute the non-linear residual for a SNES.

Collective across MPI processes.

Parameters:
  • snes[in] Non-linear solver

  • X[in] Current state vector

  • Y[out] Residual vector

  • ctx_residual_u[in] User context struct containing CeedOperator data

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelSNESFormJacobian(SNES snes, Vec X, Mat J, Mat J_pre, void *ctx_form_jacobian)#

Assemble SNES Jacobian for each level of multigrid hierarchy.

Collective across MPI processes.

Parameters:
  • snes[in] Non-linear solver

  • X[in] Current non-linear residual

  • J[out] Fine grid Jacobian operator

  • J_pre[out] Fine grid Jacobian operator for preconditioning

  • ctx_form_jacobian[inout] Jacobian context, holding Jacobian CeedOperator for each level of multigrid hierarchy

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelTSFormIResidual(TS ts, PetscReal time, Vec X, Vec X_t, Vec Y, void *ctx_residual_ut)#

Compute the non-linear residual for a TS.

Collective across MPI processes.

Parameters:
  • ts[in] Time-stepper

  • time[in] Current time

  • X[in] Current state vector

  • X_t[in] Time derivative of current state vector

  • Y[out] Function vector

  • ctx_residual_ut[inout] User context struct containing CeedOperator data

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelTSFormIJacobian(TS ts, PetscReal time, Vec X, Vec X_t, PetscReal v, Mat J, Mat J_pre, void *ctx_form_jacobian)#

Assemble TS Jacobian for each level of multigrid hierarchy.

Collective across MPI processes.

Parameters:
  • ts[in] Time-stepper

  • time[in] Current time

  • X[in] Current non-linear residual

  • X_t[in] Time derivative of current non-linear residual

  • v[in] Shift

  • J[out] Fine grid Jacobian operator

  • J_pre[out] Fine grid Jacobian operator for preconditioning

  • ctx_form_jacobian[inout] Jacobian context, holding Jacobian CeedOperator for each level of multigrid hierarchy

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelTSFormI2Residual(TS ts, PetscReal time, Vec X, Vec X_t, Vec X_tt, Vec Y, void *ctx_residual_utt)#

Compute the non-linear residual for a TS.

Collective across MPI processes.

Parameters:
  • ts[in] Time-stepper

  • time[in] Current time

  • X[in] Current state vector

  • X_t[in] Time derivative of current state vector

  • X_tt[in] Second time derivative of current state vector

  • Y[out] Function vector

  • ctx_residual_utt[inout] User context struct containing CeedOperator data

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelTSFormI2Jacobian(TS ts, PetscReal time, Vec X, Vec X_t, Vec X_tt, PetscReal v, PetscReal a, Mat J, Mat J_pre, void *ctx_form_jacobian)#

Assemble TS Jacobian for each level of multigrid hierarchy.

Collective across MPI processes.

Parameters:
  • ts[in] Time-stepper

  • time[in] Current time

  • X[in] Current non-linear residual

  • X_t[in] Time derivative of current non-linear residual

  • X_tt[in] Second time derivative of current non-linear residual

  • v[in] Shift for X_t

  • a[in] Shift for X_tt

  • J[out] Fine grid Jacobian operator

  • J_pre[out] Fine grid Jacobian operator for preconditioning

  • ctx_form_jacobian[inout] Jacobian context, holding Jacobian CeedOperator for each level of multigrid hierarchy

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelTSPostStage(TS ts, PetscReal stage_time, PetscInt stage_index, Vec *X)#

TS post-stage routine to accept state values.

Collective across MPI processes.

Parameters:
  • ts[in] Time-stepper

  • stage_time[in] Current time

  • stage_index[in] Index of current stage solution vector

  • X[in] Array of accepted stage solution vectors

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelIntArrayC2P(PetscInt num_entries, CeedInt **array_ceed, PetscInt **array_petsc)#

Translate array of CeedInt to PetscInt.

If the types differ, array_ceed is freed with free() and array_petsc is allocated with malloc(). Caller is responsible for freeing array_petsc with free().

Not collective across MPI processes.

Parameters:
  • num_entries[in] Number of array entries

  • array_ceed[inout] Array of CeedInt

  • array_petsc[out] Array of PetscInt

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelIntArrayP2C(PetscInt num_entries, PetscInt **array_petsc, CeedInt **array_ceed)#

Translate array of PetscInt to CeedInt.

If the types differ, array_petsc is freed with PetscFree() and array_ceed is allocated with PetscMalloc1(). Caller is responsible for freeing array_ceed with PetscFree().

Not collective across MPI processes.

Parameters:
  • num_entries[in] Number of array entries

  • array_petsc[inout] Array of PetscInt

  • array_ceed[out] Array of CeedInt

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelVecP2C(Ratel ratel, Vec X_petsc, PetscMemType *mem_type, CeedVector x_ceed)#

Transfer array from PETSc Vec to CeedVector.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context object

  • X_petsc[in] PETSc Vec

  • mem_type[out] PETSc MemType

  • x_ceed[out] CeedVector

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelVecC2P(Ratel ratel, CeedVector x_ceed, PetscMemType mem_type, Vec X_petsc)#

Transfer array from CeedVector to PETSc Vec.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context object

  • x_ceed[in] CeedVector

  • mem_type[in] PETSc MemType

  • X_petsc[out] PETSc Vec

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelVecReadP2C(Ratel ratel, Vec X_petsc, PetscMemType *mem_type, CeedVector x_ceed)#

Transfer read only array from PETSc Vec to CeedVector.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context object

  • X_petsc[in] PETSc Vec

  • mem_type[out] PETSc MemType

  • x_ceed[out] CeedVector

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelVecReadC2P(Ratel ratel, CeedVector x_ceed, PetscMemType mem_type, Vec X_petsc)#

Transfer read only array from CeedVector to PETSc Vec.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context object

  • x_ceed[in] CeedVector

  • mem_type[in] PETSc MemType

  • X_petsc[out] PETSc Vec

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelSetupEnergyOperator(Ratel ratel, RatelOperatorApplyContext *ctx_energy)#

Setup context computing strain energy.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • ctx_energy[out] Computed diagnostic quantities context

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelSetupDiagnosticOperators(Ratel ratel, RatelOperatorApplyContext *ctx_diagnostic_projection, RatelOperatorApplyContext *ctx_projected_diagnostic, RatelOperatorApplyContext *ctx_dual_diagnostic)#

Setup contexts computing diagnostic values.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • ctx_diagnostic_projection[out] Diagnostic quantity L2 projection context

  • ctx_projected_diagnostic[out] Diagnostic quantity projected values context

  • ctx_dual_diagnostic[out] Diagnostic quantity dual space values context

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelSetupSurfaceForceCellToFaceOperators(Ratel ratel, RatelOperatorApplyContext *ctx_surface_force_cell_to_face, CeedOperator ops_surface_force[])#

Setup contexts computing surface forces with cell-to-face bases.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • ctx_surface_force_cell_to_face[out] Surface force computation context

  • ops_surface_force[out] Surface force CeedOperator

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelSetupSurfaceForceOperator(Ratel ratel, RatelOperatorApplyContext *ctx_surface_force)#

Setup context for computing surface forces.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • ctx_surface_force[out] Surface force computation context

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelSetupSurfaceCentroidOperators(Ratel ratel, RatelOperatorApplyContext *ctx_surface_centroid, CeedOperator ops_surface_centroid[])#

Setup contexts computing surface centroids.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • ctx_surface_centroid[out] Surface centroid computation context

  • ops_surface_centroid[out] Surface centroid CeedOperator

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelSetupMMSErrorOperator(Ratel ratel, RatelOperatorApplyContext *ctx_mms_error)#

Setup context computing MMS error.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • ctx_mms_error[out] MMS error computation context

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelComputeDiagnosticQuantities_Internal(Ratel ratel, Vec U, PetscScalar time, Vec D)#

Internal code for computing diagnostic quantities.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • U[in] Computed solution vector

  • time[in] Final time value, or 1.0 for SNES solution

  • D[out] Computed diagnostic quantities vector

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelComputeSurfaceForcesCellToFace_Internal(Ratel ratel, Vec U, PetscScalar time, PetscScalar *surface_forces)#

Internal routine for computing diagnostic quantities on mesh faces.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • U[in] Computed solution vector

  • time[in] Current time value, or 1.0 for SNESsolution

  • surface_forces[out] Computed face forces

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelComputeSurfaceForces_Internal(Ratel ratel, Vec U, PetscScalar time, PetscScalar *surface_forces)#

Internal routine for computing surface forces on mesh faces.

Collective across MPI processes.

Parameters:
  • ratel[in] Ratel context

  • U[in] Computed solution vector

  • time[in] Current time value, or 1.0 for SNES solution

  • surface_forces[out] Computed face forces

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelComputeSurfaceCentroids_Internal(Ratel ratel, Vec U, PetscScalar time, PetscScalar *surface_centroids)#

Internal routine for computing centroids of mesh faces.

Parameters:
  • ratel[in] Ratel context

  • U[in] Computed solution vector

  • time[in] Current time value, or 1.0 for SNES solution

  • surface_centroids[out] Computed centroids

Returns:

An error code: 0 - success, otherwise - failure

PetscErrorCode RatelDebugImpl256(MPI_Comm comm, PetscBool is_debug, PetscBool all_ranks, PetscInt comm_rank, const unsigned char color, const char *format, ...)#

Print Ratel debugging information in color.

Forward RatelDebug* declarations & macros.

Parameters:
  • comm[in] MPI communicator for debugging

  • is_debug[in] Boolean flag for debugging

  • all_ranks[in] Boolean flag to force printing on all ranks

  • comm_rank[in] MPI communicator rank

  • color[in] Color to print

  • format[in] Printing format

RatelCeedCall(ratel, ...)#

Calls a libCEED function and then checks the resulting error code.

If the error code is non-zero, then a PETSc error is set with the libCEED error message.

RATEL_PI_DOUBLE#
RATEL_EPSILON_DOUBLE#
RatelMax(a, b)#

Generic max function.

Parameters:
  • a[in] First value

  • b[in] Second value

Returns:

Maximum of both values

RatelMin(a, b)#

Generic min function.

Parameters:
  • a[in] First value

  • b[in] Second value

Returns:

Minimum of both values

FLOPS_dXdxwdetJ#
FLOPS_ScaledMass#
FLOPS_Log1pSeries#
FLOPS_Dot3#
FLOPS_ScalarVecMult#
FLOPS_VecVecSubtract#
FLOPS_VecVecCross#
FLOPS_VecOuterMult#
FLOPS_VecVecOuterMult#
FLOPS_ScalarMatMultSymmetric#
FLOPS_MatVecMult#
FLOPS_MatTrace#
FLOPS_MatMatAdd#
FLOPS_MatMatAddSymmetric#
FLOPS_MatMatMatAddSymmetric#
FLOPS_MatDeviatoricSymmetric#
FLOPS_MatMatMult#
FLOPS_MatMatMultPlusMatMatMult#
FLOPS_MatMatContractSymmetric#
FLOPS_MatDetA#
FLOPS_MatDetAM1#
FLOPS_MatMatMultSymmetric#
FLOPS_MatNorm#
FLOPS_MatMatMatMultSymmetric#
FLOPS_MatInverse#
FLOPS_MatInverseSymmetric#
FLOPS_CInverse#
FLOPS_CInverse_fwd#
FLOPS_LinearStrain#
FLOPS_LinearStrain_fwd#
FLOPS_GreenEulerStrain#
FLOPS_GreenEulerStrain_fwd#
FLOPS_GreenLagrangeStrain#
FLOPS_GreenLagrangeStrain_fwd#
FLOPS_OrthogonalComplement#
FLOPS_ComputeEigenvector0#
FLOPS_ComputeEigenvector1#
FLOPS_MatComputeEigenValueSymmetric#
FLOPS_MatComputeEigenVectorSymmetric#
FLOPS_MatComputeEigensystemSymmetric#
FLOPS_EigenValue_fwd#
FLOPS_EigenVector_fwd#
FLOPS_PrincipalStretch#
FLOPS_PrincipalStretch_fwd#
FLOPS_EigenVectorOuterMult#
FLOPS_EigenVectorOuterMult_fwd#
struct ScaledMassContext#
#include <scaled-mass.h>

Scaled mass context.

Public Members

CeedScalar rho#

Scaling parameter.

CeedInt num_fields#

Number of fields.

CeedInt field_sizes[]#

Number of components in each field.

struct RatelForcingVectorContext#
#include <constant-force.h>

Constant forcing context.

Public Members

CeedScalar direction[3]#

Forcing vector.

CeedScalar time#

Current solver time.