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.