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, 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, 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, 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[]);