Actual source code: petscdsimpl.h
1: #pragma once
3: #include <petscds.h>
4: #include <petsc/private/petscimpl.h>
5: #include <petsc/private/hashmap.h>
7: PETSC_EXTERN PetscBool PetscDSRegisterAllCalled;
8: PETSC_EXTERN PetscErrorCode PetscDSRegisterAll(void);
10: typedef struct _n_DSBoundary *DSBoundary;
12: struct _n_DSBoundary {
13: const char *name; /* A unique identifier for the condition */
14: DMLabel label; /* The DMLabel indicating the mesh region over which the condition holds */
15: const char *lname; /* The label name if the label is missing from the DM */
16: PetscInt Nv; /* The number of label values defining the region */
17: PetscInt *values; /* The labels values defining the region */
18: PetscWeakForm wf; /* Holds the pointwise functions defining the form (only for NATURAL conditions) */
19: DMBoundaryConditionType type; /* The type of condition, usually either ESSENTIAL or NATURAL */
20: PetscInt field; /* The field constrained by the condition */
21: PetscInt Nc; /* The number of constrained field components */
22: PetscInt *comps; /* The constrained field components */
23: void (*func)(void); /* Function that provides the boundary values (only for ESSENTIAL conditions) */
24: void (*func_t)(void); /* Function that provides the time derivative of the boundary values (only for ESSENTIAL conditions) */
25: void *ctx; /* The user context for func and func_t */
26: DSBoundary next;
27: };
29: typedef struct {
30: PetscCount start; /* Starting entry of the chunk in an array (in bytes) */
31: PetscCount size; /* Current number of entries of the chunk */
32: PetscCount reserved; /* Number of reserved entries in the chunk */
33: } PetscChunk;
35: typedef struct {
36: PetscCount size; /* Current number of entries used in array */
37: size_t alloc; /* Number of bytes allocated for array */
38: size_t unitbytes; /* Number of bytes per entry */
39: char *array;
40: } PetscChunkBuffer;
42: #define PetscFormKeyHash(key) PetscHashCombine(PetscHashCombine(PetscHashCombine(PetscHashPointer((key).label), PetscHashInt((key).value)), PetscHashInt((key).field)), PetscHashInt((key).part))
44: #define PetscFormKeyEqual(k1, k2) (((k1).label == (k2).label) ? ((k1).value == (k2).value) ? ((k1).field == (k2).field) ? ((k1).part == (k2).part) : 0 : 0 : 0)
46: static PetscChunk _PetscInvalidChunk = {-1, -1, -1};
48: PETSC_HASH_MAP(HMapForm, PetscFormKey, PetscChunk, PetscFormKeyHash, PetscFormKeyEqual, _PetscInvalidChunk)
50: /*
51: We sort lexicographically on the structure.
52: Returns
53: -1: left < right
54: 0: left = right
55: 1: left > right
56: */
57: static inline int Compare_PetscFormKey_Private(const void *left, const void *right, PETSC_UNUSED void *ctx)
58: {
59: PetscFormKey l = *(const PetscFormKey *)left;
60: PetscFormKey r = *(const PetscFormKey *)right;
61: return (l.label < r.label) ? -1 : ((l.label > r.label) ? 1 : ((l.value < r.value) ? -1 : (l.value > r.value) ? 1 : ((l.field < r.field) ? -1 : (l.field > r.field) ? 1 : ((l.part < r.part) ? -1 : (l.part > r.part)))));
62: }
64: typedef struct _PetscWeakFormOps *PetscWeakFormOps;
65: struct _PetscWeakFormOps {
66: PetscErrorCode (*setfromoptions)(PetscWeakForm);
67: PetscErrorCode (*setup)(PetscWeakForm);
68: PetscErrorCode (*view)(PetscWeakForm, PetscViewer);
69: PetscErrorCode (*destroy)(PetscWeakForm);
70: };
72: struct _p_PetscWeakForm {
73: PETSCHEADER(struct _PetscWeakFormOps);
74: void *data; /* Implementation object */
76: PetscInt Nf; /* The number of fields in the system */
77: PetscChunkBuffer *funcs; /* Buffer holding all function pointers */
78: PetscHMapForm *form; /* Stores function pointers for forms */
79: };
81: typedef struct _PetscDSOps *PetscDSOps;
82: struct _PetscDSOps {
83: PetscErrorCode (*setfromoptions)(PetscDS);
84: PetscErrorCode (*setup)(PetscDS);
85: PetscErrorCode (*view)(PetscDS, PetscViewer);
86: PetscErrorCode (*destroy)(PetscDS);
87: };
89: struct _p_PetscDS {
90: PETSCHEADER(struct _PetscDSOps);
91: void *data; /* Implementation object */
92: PetscDS *subprobs; /* The subspaces for each dimension */
93: PetscBool setup; /* Flag for setup */
94: PetscInt dimEmbed; /* The real space coordinate dimension */
95: PetscInt Nf; /* The number of solution fields */
96: PetscObject *disc; /* The discretization for each solution field (PetscFE, PetscFV, etc.) */
97: PetscBool *cohesive; /* Flag for cohesive discretization */
98: PetscBool isCohesive; /* We are on a cohesive cell, meaning lower dimensional FE used on a 0-volume cell. Normal fields appear on both endcaps, whereas cohesive field only appear once in the middle */
99: PetscInt printIntegrate; /* Debugging level for kernels */
100: /* Quadrature */
101: PetscBool forceQuad; /* Flag to force matching quadratures in discretizations */
102: IS *quadPerm[DM_NUM_POLYTOPES]; /* qP[ct][o]: q point permutation for orientation o of integ domain */
103: /* Equations */
104: DSBoundary boundary; // Linked list of boundary conditions
105: PetscBool useJacPre; // Flag for using the Jacobian preconditioner
106: PetscBool *implicit; // Flag for implicit or explicit solve for each field
107: PetscInt *jetDegree; // The highest derivative for each field equation, or the k-jet that each discretization needs to tabulate
108: PetscWeakForm wf; // The PetscWeakForm holding all pointwise functions
109: PetscPointFunc *update; // Direct update of field coefficients
110: PetscSimplePointFn **exactSol; // Exact solutions for each field
111: void **exactCtx; // Contexts for the exact solution functions
112: PetscSimplePointFn **exactSol_t; // Time derivative of the exact solutions for each field
113: void **exactCtx_t; // Contexts for the time derivative of the exact solution functions
114: PetscInt numConstants; // Number of constants passed to all point functions
115: PetscInt numFuncConstants; // Number of constant passed to an individual point function (like field)
116: PetscScalar *constants; // Array of constants passed to point functions
117: void **ctx; // User contexts for each field
118: /* Computed sizes */
119: PetscInt totDim; /* Total system dimension */
120: PetscInt totComp; /* Total field components */
121: PetscInt *Nc; /* Number of components for each field */
122: PetscInt *Nb; /* Number of basis functions for each field */
123: PetscInt *off; /* Offsets for each field */
124: PetscInt *offDer; /* Derivative offsets for each field */
125: PetscInt *offCohesive[3]; /* Offsets for each field on side s of a cohesive cell */
126: PetscInt *offDerCohesive[3]; /* Derivative offsets for each field on side s of a cohesive cell */
127: PetscTabulation *T; /* Basis function and derivative tabulation for each field */
128: PetscTabulation *Tf; /* Basis function and derivative tabulation for each local face and field */
129: /* Work space */
130: PetscScalar *u; /* Field evaluation */
131: PetscScalar *u_t; /* Field time derivative evaluation */
132: PetscScalar *u_x; /* Field gradient evaluation */
133: PetscScalar *basisReal; /* Workspace for pushforward */
134: PetscScalar *basisDerReal; /* Workspace for derivative pushforward */
135: PetscScalar *testReal; /* Workspace for pushforward */
136: PetscScalar *testDerReal; /* Workspace for derivative pushforward */
137: PetscReal *x; /* Workspace for computing real coordinates */
138: PetscScalar *f0, *f1; /* Point evaluations of weak form residual integrands */
139: PetscScalar *g0, *g1, *g2, *g3; /* Point evaluations of weak form Jacobian integrands */
140: };
142: typedef struct {
143: PetscInt dummy; /* */
144: } PetscDS_Basic;
146: PETSC_INTERN PetscErrorCode PetscDSGetDiscType_Internal(PetscDS, PetscInt, PetscDiscType *);