Actual source code: petscfeimpl.h
1: #pragma once
3: #include <petscfe.h>
4: #ifdef PETSC_HAVE_LIBCEED
5: #include <petscfeceed.h>
6: #endif
7: #include <petscds.h>
8: #include <petsc/private/petscimpl.h>
9: #include <petsc/private/dmpleximpl.h>
11: PETSC_EXTERN PetscBool PetscSpaceRegisterAllCalled;
12: PETSC_EXTERN PetscBool PetscDualSpaceRegisterAllCalled;
13: PETSC_EXTERN PetscBool PetscFERegisterAllCalled;
14: PETSC_EXTERN PetscErrorCode PetscSpaceRegisterAll(void);
15: PETSC_EXTERN PetscErrorCode PetscDualSpaceRegisterAll(void);
16: PETSC_EXTERN PetscErrorCode PetscFERegisterAll(void);
18: PETSC_EXTERN PetscBool FEcite;
19: PETSC_EXTERN const char FECitation[];
21: PETSC_EXTERN PetscLogEvent PETSCDUALSPACE_SetUp;
22: PETSC_EXTERN PetscLogEvent PETSCFE_SetUp;
24: typedef struct _PetscSpaceOps *PetscSpaceOps;
25: struct _PetscSpaceOps {
26: PetscErrorCode (*setfromoptions)(PetscSpace, PetscOptionItems *);
27: PetscErrorCode (*setup)(PetscSpace);
28: PetscErrorCode (*view)(PetscSpace, PetscViewer);
29: PetscErrorCode (*destroy)(PetscSpace);
31: PetscErrorCode (*getdimension)(PetscSpace, PetscInt *);
32: PetscErrorCode (*evaluate)(PetscSpace, PetscInt, const PetscReal *, PetscReal *, PetscReal *, PetscReal *);
33: PetscErrorCode (*getheightsubspace)(PetscSpace, PetscInt, PetscSpace *);
34: };
36: struct _p_PetscSpace {
37: PETSCHEADER(struct _PetscSpaceOps);
38: void *data; /* Implementation object */
39: PetscInt degree; /* The approximation order of the space */
40: PetscInt maxDegree; /* The containing approximation order of the space */
41: PetscInt Nc; /* The number of components */
42: PetscInt Nv; /* The number of variables in the space, e.g. x and y */
43: PetscInt dim; /* The dimension of the space */
44: DM dm; /* Shell to use for temp allocation */
45: };
47: typedef struct {
48: PetscBool tensor; /* Flag for tensor product */
49: PetscBool setupCalled;
50: PetscSpace *subspaces; /* Subspaces for each dimension */
51: } PetscSpace_Poly;
53: typedef struct {
54: PetscInt formDegree;
55: PetscBool setupCalled;
56: PetscSpace *subspaces;
57: } PetscSpace_Ptrimmed;
59: typedef struct {
60: PetscSpace *tensspaces;
61: PetscInt numTensSpaces;
62: PetscInt dim;
63: PetscBool uniform;
64: PetscBool setupCalled;
65: PetscSpace *heightsubspaces; /* Height subspaces */
66: } PetscSpace_Tensor;
68: typedef struct {
69: PetscSpace *sumspaces;
70: PetscInt numSumSpaces;
71: PetscBool uniform;
72: PetscBool concatenate;
73: PetscBool setupCalled;
74: PetscBool interleave_basis;
75: PetscBool interleave_components;
76: PetscSpace *heightsubspaces; /* Height subspaces */
77: } PetscSpace_Sum;
79: typedef struct {
80: PetscQuadrature quad; /* The points defining the space */
81: } PetscSpace_Point;
83: typedef struct {
84: PetscBool setupCalled;
85: } PetscSpace_WXY;
87: typedef struct _PetscDualSpaceOps *PetscDualSpaceOps;
88: struct _PetscDualSpaceOps {
89: PetscErrorCode (*setfromoptions)(PetscDualSpace, PetscOptionItems *);
90: PetscErrorCode (*setup)(PetscDualSpace);
91: PetscErrorCode (*view)(PetscDualSpace, PetscViewer);
92: PetscErrorCode (*destroy)(PetscDualSpace);
94: PetscErrorCode (*duplicate)(PetscDualSpace, PetscDualSpace);
95: PetscErrorCode (*createheightsubspace)(PetscDualSpace, PetscInt, PetscDualSpace *);
96: PetscErrorCode (*createpointsubspace)(PetscDualSpace, PetscInt, PetscDualSpace *);
97: PetscErrorCode (*getsymmetries)(PetscDualSpace, const PetscInt ****, const PetscScalar ****);
98: PetscErrorCode (*apply)(PetscDualSpace, PetscInt, PetscReal, PetscFEGeom *, PetscInt, PetscErrorCode (*)(PetscInt, PetscReal, const PetscReal[], PetscInt, PetscScalar *, void *), void *, PetscScalar *);
99: PetscErrorCode (*applyall)(PetscDualSpace, const PetscScalar *, PetscScalar *);
100: PetscErrorCode (*applyint)(PetscDualSpace, const PetscScalar *, PetscScalar *);
101: PetscErrorCode (*createalldata)(PetscDualSpace, PetscQuadrature *, Mat *);
102: PetscErrorCode (*createintdata)(PetscDualSpace, PetscQuadrature *, Mat *);
103: };
105: struct _p_PetscDualSpace {
106: PETSCHEADER(struct _PetscDualSpaceOps);
107: void *data; /* Implementation object */
108: DM dm; /* The integration region K */
109: PetscInt order; /* The approximation order of the space */
110: PetscInt Nc; /* The number of components */
111: PetscQuadrature *functional; /* The basis of functionals for this space */
112: Mat allMat;
113: PetscQuadrature allNodes; /* Collects all quadrature points representing functionals in the basis */
114: Vec allNodeValues;
115: Vec allDofValues;
116: Mat intMat;
117: PetscQuadrature intNodes; /* Collects all quadrature points representing functionals in the basis in the interior of the cell */
118: Vec intNodeValues;
119: Vec intDofValues;
120: PetscInt spdim; /* The dual-space dimension */
121: PetscInt spintdim; /* The dual-space interior dimension */
122: PetscInt k; /* k-simplex corresponding to the dofs in this basis (we always use the 3D complex right now) */
123: PetscBool uniform;
124: PetscBool setupcalled;
125: PetscBool setfromoptionscalled;
126: PetscSection pointSection;
127: PetscSection intPointSection;
128: PetscDualSpace *pointSpaces;
129: PetscDualSpace *heightSpaces;
130: PetscInt *numDof;
131: };
133: typedef struct _n_Petsc1DNodeFamily *Petsc1DNodeFamily;
134: typedef struct _n_PetscLagNodeIndices *PetscLagNodeIndices;
136: PETSC_EXTERN PetscErrorCode PetscLagNodeIndicesGetData_Internal(PetscLagNodeIndices, PetscInt *, PetscInt *, PetscInt *, const PetscInt *[], const PetscReal *[]);
137: PETSC_EXTERN PetscErrorCode PetscDualSpaceCreateInteriorSymmetryMatrix_Lagrange(PetscDualSpace sp, PetscInt ornt, Mat *symMat);
139: typedef struct {
140: /* these describe the types of dual spaces implemented */
141: PetscBool tensorCell; /* Flag for tensor product cell */
142: PetscBool tensorSpace; /* Flag for tensor product space of polynomials, as opposed to a space of maximum degree */
143: PetscBool trimmed; /* Flag for dual space of trimmed polynomial spaces */
144: PetscBool continuous; /* Flag for a continuous basis, as opposed to discontinuous across element boundaries */
146: PetscBool interiorOnly; /* To make setup faster for tensor elements, only construct interior dofs in recursive calls */
148: /* these keep track of symmetries */
149: PetscInt ***symperms;
150: PetscScalar ***symflips;
151: PetscInt numSelfSym;
152: PetscInt selfSymOff;
153: PetscBool symComputed;
155: /* these describe different schemes of placing nodes in a simplex, from
156: * which are derived all dofs in Lagrange dual spaces */
157: PetscDTNodeType nodeType;
158: PetscBool endNodes;
159: PetscReal nodeExponent;
160: PetscInt numNodeSkip; /* The number of end nodes from the 1D Node family to skip */
161: Petsc1DNodeFamily nodeFamily;
163: PetscInt numCopies;
165: PetscBool useMoments; /* Use moments for functionals */
166: PetscInt momentOrder; /* Order for moment quadrature */
168: /* these are ways of indexing nodes in a way that makes
169: * the computation of symmetries programmatic */
170: PetscLagNodeIndices vertIndices;
171: PetscLagNodeIndices intNodeIndices;
172: PetscLagNodeIndices allNodeIndices;
173: } PetscDualSpace_Lag;
175: typedef struct {
176: PetscDualSpace *sumspaces;
177: PetscInt numSumSpaces;
178: PetscBool uniform;
179: PetscBool uniform_all_points;
180: PetscBool uniform_interior_points;
181: PetscBool concatenate;
182: PetscBool setupCalled;
183: PetscBool interleave_basis;
184: PetscBool interleave_components;
185: ISLocalToGlobalMapping *all_rows;
186: ISLocalToGlobalMapping *all_cols;
187: ISLocalToGlobalMapping *int_rows;
188: ISLocalToGlobalMapping *int_cols;
190: PetscInt ***symperms;
191: PetscScalar ***symflips;
192: PetscInt numSelfSym;
193: PetscInt selfSymOff;
194: PetscBool symComputed;
195: } PetscDualSpace_Sum;
197: typedef struct {
198: PetscInt dim;
199: PetscInt *numDof;
200: } PetscDualSpace_Simple;
202: typedef struct _PetscFEOps *PetscFEOps;
203: struct _PetscFEOps {
204: PetscErrorCode (*setfromoptions)(PetscFE, PetscOptionItems *);
205: PetscErrorCode (*setup)(PetscFE);
206: PetscErrorCode (*view)(PetscFE, PetscViewer);
207: PetscErrorCode (*destroy)(PetscFE);
208: PetscErrorCode (*getdimension)(PetscFE, PetscInt *);
209: PetscErrorCode (*createpointtrace)(PetscFE, PetscInt, PetscFE *);
210: PetscErrorCode (*createtabulation)(PetscFE, PetscInt, const PetscReal *, PetscInt, PetscTabulation);
211: /* Element integration */
212: PetscErrorCode (*integrate)(PetscDS, PetscInt, PetscInt, PetscFEGeom *, const PetscScalar[], PetscDS, const PetscScalar[], PetscScalar[]);
213: PetscErrorCode (*integratebd)(PetscDS, PetscInt, PetscBdPointFunc, PetscInt, PetscFEGeom *, const PetscScalar[], PetscDS, const PetscScalar[], PetscScalar[]);
214: PetscErrorCode (*integrateresidual)(PetscDS, PetscFormKey, PetscInt, PetscFEGeom *, const PetscScalar[], const PetscScalar[], PetscDS, const PetscScalar[], PetscReal, PetscScalar[]);
215: PetscErrorCode (*integratebdresidual)(PetscDS, PetscWeakForm, PetscFormKey, PetscInt, PetscFEGeom *, const PetscScalar[], const PetscScalar[], PetscDS, const PetscScalar[], PetscReal, PetscScalar[]);
216: PetscErrorCode (*integratehybridresidual)(PetscDS, PetscDS, PetscFormKey, PetscInt, PetscInt, PetscFEGeom *, const PetscScalar[], const PetscScalar[], PetscDS, const PetscScalar[], PetscReal, PetscScalar[]);
217: PetscErrorCode (*integratejacobianaction)(PetscFE, PetscDS, PetscInt, PetscInt, PetscFEGeom *, const PetscScalar[], const PetscScalar[], PetscDS, const PetscScalar[], PetscReal, PetscReal, PetscScalar[]);
218: PetscErrorCode (*integratejacobian)(PetscDS, PetscFEJacobianType, PetscFormKey, PetscInt, PetscFEGeom *, const PetscScalar[], const PetscScalar[], PetscDS, const PetscScalar[], PetscReal, PetscReal, PetscScalar[]);
219: PetscErrorCode (*integratebdjacobian)(PetscDS, PetscWeakForm, PetscFEJacobianType, PetscFormKey, PetscInt, PetscFEGeom *, const PetscScalar[], const PetscScalar[], PetscDS, const PetscScalar[], PetscReal, PetscReal, PetscScalar[]);
220: PetscErrorCode (*integratehybridjacobian)(PetscDS, PetscDS, PetscFEJacobianType, PetscFormKey, PetscInt, PetscInt, PetscFEGeom *, const PetscScalar[], const PetscScalar[], PetscDS, const PetscScalar[], PetscReal, PetscReal, PetscScalar[]);
221: };
223: struct _p_PetscFE {
224: PETSCHEADER(struct _PetscFEOps);
225: void *data; /* Implementation object */
226: PetscSpace basisSpace; /* The basis space P */
227: PetscDualSpace dualSpace; /* The dual space P' */
228: PetscInt numComponents; /* The number of field components */
229: PetscQuadrature quadrature; /* Suitable quadrature on K */
230: PetscQuadrature faceQuadrature; /* Suitable face quadrature on \partial K */
231: PetscFE *subspaces; /* Subspaces for each dimension */
232: PetscReal *invV; /* Change of basis matrix, from prime to nodal basis set */
233: PetscTabulation T; /* Tabulation of basis and derivatives at quadrature points */
234: PetscTabulation Tf; /* Tabulation of basis and derivatives at quadrature points on each face */
235: PetscTabulation Tc; /* Tabulation of basis at face centroids */
236: PetscInt blockSize, numBlocks; /* Blocks are processed concurrently */
237: PetscInt batchSize, numBatches; /* A batch is made up of blocks, Batches are processed in serial */
238: PetscBool setupcalled;
239: #ifdef PETSC_HAVE_LIBCEED
240: Ceed ceed; /* The LibCEED context, usually set by the DM */
241: CeedBasis ceedBasis; /* Basis for libCEED matching this element */
242: #endif
243: };
245: typedef struct {
246: PetscInt cellType;
247: } PetscFE_Basic;
249: #ifdef PETSC_HAVE_OPENCL
251: #ifdef __APPLE__
252: #include <OpenCL/cl.h>
253: #else
254: #include <CL/cl.h>
255: #endif
257: typedef struct {
258: cl_platform_id pf_id;
259: cl_device_id dev_id;
260: cl_context ctx_id;
261: cl_command_queue queue_id;
262: PetscDataType realType;
263: PetscLogEvent residualEvent;
264: PetscInt op; /* ANDY: Stand-in for real equation code generation */
265: } PetscFE_OpenCL;
266: #endif
268: typedef struct {
269: PetscInt numSubelements; /* The number of subelements */
270: PetscReal *v0; /* The affine transformation for each subelement */
271: PetscReal *jac, *invjac;
272: PetscInt *embedding; /* Map from subelements dofs to element dofs */
273: } PetscFE_Composite;
275: /* Utility functions */
276: static inline void CoordinatesRefToReal(PetscInt dimReal, PetscInt dimRef, const PetscReal xi0[], const PetscReal v0[], const PetscReal J[], const PetscReal xi[], PetscReal x[])
277: {
278: PetscInt d, e;
280: for (d = 0; d < dimReal; ++d) {
281: x[d] = v0[d];
282: for (e = 0; e < dimRef; ++e) x[d] += J[d * dimReal + e] * (xi[e] - xi0[e]);
283: }
284: }
286: static inline void CoordinatesRealToRef(PetscInt dimReal, PetscInt dimRef, const PetscReal xi0[], const PetscReal v0[], const PetscReal invJ[], const PetscReal x[], PetscReal xi[])
287: {
288: PetscInt d, e;
290: for (d = 0; d < dimRef; ++d) {
291: xi[d] = xi0[d];
292: for (e = 0; e < dimReal; ++e) xi[d] += invJ[d * dimReal + e] * (x[e] - v0[e]);
293: }
294: }
296: static inline PetscErrorCode PetscFEInterpolate_Static(PetscFE fe, const PetscScalar x[], PetscFEGeom *fegeom, PetscInt q, PetscScalar interpolant[])
297: {
298: PetscTabulation T;
300: PetscFunctionBeginHot;
301: PetscCall(PetscFEGetCellTabulation(fe, 0, &T));
302: {
303: const PetscReal *basis = T->T[0];
304: const PetscInt Nb = T->Nb;
305: const PetscInt Nc = T->Nc;
306: for (PetscInt fc = 0; fc < Nc; ++fc) {
307: interpolant[fc] = 0.0;
308: for (PetscInt f = 0; f < Nb; ++f) interpolant[fc] += x[f] * basis[(q * Nb + f) * Nc + fc];
309: }
310: }
311: PetscCall(PetscFEPushforward(fe, fegeom, 1, interpolant));
312: PetscFunctionReturn(PETSC_SUCCESS);
313: }
315: static inline PetscErrorCode PetscFEInterpolateAtPoints_Static(PetscFE fe, PetscTabulation T, const PetscScalar x[], PetscFEGeom *fegeom, PetscInt q, PetscScalar interpolant[])
316: {
317: PetscInt fc, f;
319: PetscFunctionBeginHot;
320: {
321: const PetscReal *basis = T->T[0];
322: const PetscInt Nb = T->Nb;
323: const PetscInt Nc = T->Nc;
324: for (fc = 0; fc < Nc; ++fc) {
325: interpolant[fc] = 0.0;
326: for (f = 0; f < Nb; ++f) interpolant[fc] += x[f] * basis[(q * Nb + f) * Nc + fc];
327: }
328: }
329: PetscCall(PetscFEPushforward(fe, fegeom, 1, interpolant));
330: PetscFunctionReturn(PETSC_SUCCESS);
331: }
333: static inline PetscErrorCode PetscFEInterpolateGradient_Static(PetscFE fe, PetscInt k, const PetscScalar x[], PetscFEGeom *fegeom, PetscInt q, PetscScalar interpolant[])
334: {
335: PetscTabulation T;
336: PetscInt fc, f, d;
338: PetscFunctionBeginHot;
339: PetscCall(PetscFEGetCellTabulation(fe, k, &T));
340: {
341: const PetscReal *basisDer = T->T[1];
342: const PetscReal *basisHes = k > 1 ? T->T[2] : NULL;
343: const PetscInt Nb = T->Nb;
344: const PetscInt Nc = T->Nc;
345: const PetscInt cdim = T->cdim;
347: PetscCheck(cdim == fegeom->dimEmbed, PETSC_COMM_SELF, PETSC_ERR_ARG_INCOMP, "Geometry dim %" PetscInt_FMT " must match tabulation dim %" PetscInt_FMT, fegeom->dimEmbed, cdim);
348: for (fc = 0; fc < Nc; ++fc) {
349: for (d = 0; d < cdim; ++d) interpolant[fc * cdim + d] = 0.0;
350: for (f = 0; f < Nb; ++f) {
351: for (d = 0; d < cdim; ++d) interpolant[fc * cdim + d] += x[f] * basisDer[((q * Nb + f) * Nc + fc) * cdim + d];
352: }
353: }
354: if (k > 1) {
355: const PetscInt off = Nc * cdim;
357: for (fc = 0; fc < Nc; ++fc) {
358: for (d = 0; d < cdim * cdim; ++d) interpolant[off + fc * cdim * cdim + d] = 0.0;
359: for (f = 0; f < Nb; ++f) {
360: for (d = 0; d < cdim * cdim; ++d) interpolant[off + fc * cdim + d] += x[f] * basisHes[((q * Nb + f) * Nc + fc) * cdim * cdim + d];
361: }
362: }
363: }
364: }
365: PetscCall(PetscFEPushforwardGradient(fe, fegeom, 1, interpolant));
366: PetscFunctionReturn(PETSC_SUCCESS);
367: }
369: static inline PetscErrorCode PetscFEFreeInterpolateGradient_Static(PetscFE fe, const PetscReal basisDer[], const PetscScalar x[], PetscInt dim, const PetscReal invJ[], const PetscReal n[], PetscInt q, PetscScalar interpolant[])
370: {
371: PetscReal realSpaceDer[3];
372: PetscScalar compGradient[3];
373: PetscInt Nb, Nc, fc, f, d, g;
375: PetscFunctionBeginHot;
376: PetscCall(PetscFEGetDimension(fe, &Nb));
377: PetscCall(PetscFEGetNumComponents(fe, &Nc));
379: for (fc = 0; fc < Nc; ++fc) {
380: interpolant[fc] = 0.0;
381: for (d = 0; d < dim; ++d) compGradient[d] = 0.0;
382: for (f = 0; f < Nb; ++f) {
383: for (d = 0; d < dim; ++d) {
384: realSpaceDer[d] = 0.0;
385: for (g = 0; g < dim; ++g) realSpaceDer[d] += invJ[g * dim + d] * basisDer[((q * Nb + f) * Nc + fc) * dim + g];
386: compGradient[d] += x[f] * realSpaceDer[d];
387: }
388: }
389: if (n) {
390: for (d = 0; d < dim; ++d) interpolant[fc] += compGradient[d] * n[d];
391: } else {
392: for (d = 0; d < dim; ++d) interpolant[d] = compGradient[d];
393: }
394: }
395: PetscFunctionReturn(PETSC_SUCCESS);
396: }
398: static inline PetscErrorCode PetscFEInterpolateFieldAndGradient_Static(PetscFE fe, PetscInt k, const PetscScalar x[], PetscFEGeom *fegeom, PetscInt q, PetscScalar interpolant[], PetscScalar interpolantGrad[])
399: {
400: PetscTabulation T;
401: PetscInt fc, f, d;
403: PetscFunctionBeginHot;
404: PetscCall(PetscFEGetCellTabulation(fe, k, &T));
405: {
406: const PetscReal *basis = T->T[0];
407: const PetscReal *basisDer = T->T[1];
408: const PetscReal *basisHes = k > 1 ? T->T[2] : NULL;
409: const PetscInt Nb = T->Nb;
410: const PetscInt Nc = T->Nc;
411: const PetscInt cdim = T->cdim;
413: PetscCheck(cdim == fegeom->dimEmbed, PETSC_COMM_SELF, PETSC_ERR_ARG_INCOMP, "Geometry dim %" PetscInt_FMT " must match tabulation dim %" PetscInt_FMT, fegeom->dimEmbed, cdim);
414: for (fc = 0; fc < Nc; ++fc) {
415: interpolant[fc] = 0.0;
416: for (d = 0; d < cdim; ++d) interpolantGrad[fc * cdim + d] = 0.0;
417: for (f = 0; f < Nb; ++f) {
418: interpolant[fc] += x[f] * basis[(q * Nb + f) * Nc + fc];
419: for (d = 0; d < cdim; ++d) interpolantGrad[fc * cdim + d] += x[f] * basisDer[((q * Nb + f) * Nc + fc) * cdim + d];
420: }
421: }
422: if (k > 1) {
423: const PetscInt off = Nc * cdim;
425: for (fc = 0; fc < Nc; ++fc) {
426: for (d = 0; d < cdim * cdim; ++d) interpolantGrad[off + fc * cdim * cdim + d] = 0.0;
427: for (f = 0; f < Nb; ++f) {
428: for (d = 0; d < cdim * cdim; ++d) interpolantGrad[off + fc * cdim + d] += x[f] * basisHes[((q * Nb + f) * Nc + fc) * cdim * cdim + d];
429: }
430: }
431: PetscCall(PetscFEPushforwardHessian(fe, fegeom, 1, &interpolantGrad[off]));
432: }
433: }
434: PetscCall(PetscFEPushforward(fe, fegeom, 1, interpolant));
435: PetscCall(PetscFEPushforwardGradient(fe, fegeom, 1, interpolantGrad));
436: PetscFunctionReturn(PETSC_SUCCESS);
437: }
439: PETSC_INTERN PetscErrorCode PetscDualSpaceLatticePointLexicographic_Internal(PetscInt, PetscInt, PetscInt[]);
440: PETSC_INTERN PetscErrorCode PetscDualSpaceTensorPointLexicographic_Internal(PetscInt, PetscInt, PetscInt[]);
441: PETSC_INTERN PetscErrorCode PetscDualSpaceComputeFunctionalsFromAllData(PetscDualSpace);
442: PETSC_INTERN PetscErrorCode PetscDualSpaceGetBoundarySymmetries_Internal(PetscDualSpace, PetscInt ***, PetscScalar ***);
444: PETSC_INTERN PetscErrorCode PetscDualSpaceSectionCreate_Internal(PetscDualSpace, PetscSection *);
445: PETSC_INTERN PetscErrorCode PetscDualSpaceSectionSetUp_Internal(PetscDualSpace, PetscSection);
446: PETSC_INTERN PetscErrorCode PetscDualSpacePushForwardSubspaces_Internal(PetscDualSpace, PetscInt, PetscInt);
448: PETSC_INTERN PetscErrorCode PetscFEEvaluateFieldJets_Internal(PetscDS, PetscInt, PetscInt, PetscInt, PetscTabulation[], PetscFEGeom *, const PetscScalar[], const PetscScalar[], PetscScalar[], PetscScalar[], PetscScalar[]);
449: PETSC_INTERN PetscErrorCode PetscFEEvaluateFaceFields_Internal(PetscDS, PetscInt, PetscInt, const PetscScalar[], PetscScalar[]);
450: PETSC_INTERN PetscErrorCode PetscFEUpdateElementVec_Internal(PetscFE, PetscTabulation, PetscInt, PetscScalar[], PetscScalar[], PetscInt, PetscFEGeom *, PetscScalar[], PetscScalar[], PetscScalar[]);
451: PETSC_INTERN PetscErrorCode PetscFEUpdateElementMat_Internal(PetscFE, PetscFE, PetscInt, PetscInt, PetscTabulation, PetscScalar[], PetscScalar[], PetscTabulation, PetscScalar[], PetscScalar[], PetscFEGeom *, const PetscScalar[], const PetscScalar[], const PetscScalar[], const PetscScalar[], PetscInt, PetscInt, PetscInt, PetscScalar[]);
453: PETSC_INTERN PetscErrorCode PetscFEEvaluateFieldJets_Hybrid_Internal(PetscDS, PetscInt, PetscInt, PetscInt, PetscTabulation[], const PetscInt[], const PetscInt[], PetscTabulation[], PetscFEGeom *, const PetscScalar[], const PetscScalar[], PetscScalar[], PetscScalar[], PetscScalar[]);
454: PETSC_INTERN PetscErrorCode PetscFEUpdateElementVec_Hybrid_Internal(PetscFE, PetscTabulation, PetscInt, PetscInt, PetscScalar[], PetscScalar[], PetscFEGeom *, PetscScalar[], PetscScalar[], PetscScalar[]);
455: PETSC_INTERN PetscErrorCode PetscFEUpdateElementMat_Hybrid_Internal(PetscFE, PetscBool, PetscFE, PetscBool, PetscInt, PetscInt, PetscInt, PetscInt, PetscTabulation, PetscScalar[], PetscScalar[], PetscTabulation, PetscScalar[], PetscScalar[], PetscFEGeom *, const PetscScalar[], const PetscScalar[], const PetscScalar[], const PetscScalar[], PetscInt, PetscInt, PetscInt, PetscInt, PetscScalar[]);
457: PETSC_EXTERN PetscErrorCode PetscFEGetDimension_Basic(PetscFE, PetscInt *);
458: PETSC_EXTERN PetscErrorCode PetscFEIntegrateResidual_Basic(PetscDS, PetscFormKey, PetscInt, PetscFEGeom *, const PetscScalar[], const PetscScalar[], PetscDS, const PetscScalar[], PetscReal, PetscScalar[]);
459: PETSC_EXTERN PetscErrorCode PetscFEIntegrateBdResidual_Basic(PetscDS, PetscWeakForm, PetscFormKey, PetscInt, PetscFEGeom *, const PetscScalar[], const PetscScalar[], PetscDS, const PetscScalar[], PetscReal, PetscScalar[]);
460: PETSC_EXTERN PetscErrorCode PetscFEIntegrateJacobian_Basic(PetscDS, PetscFEJacobianType, PetscFormKey, PetscInt, PetscFEGeom *, const PetscScalar[], const PetscScalar[], PetscDS, const PetscScalar[], PetscReal, PetscReal, PetscScalar[]);