1: #include <petscao.h>
  2: #include <petsc/private/dmlabelimpl.h>
  3: #include <petsc/private/dmfieldimpl.h>
  4: #include <petsc/private/dmpleximpl.h>
  5: #include <petsc/private/dmplextransformimpl.h>
  6: #include <petsc/private/petscdsimpl.h>
  7: #include <petsc/private/petscfeimpl.h>
  8: #include <petsc/private/petscfvimpl.h>
  9: #include <petsc/private/dmswarmimpl.h>
 10: #include <petsc/private/dmnetworkimpl.h>

 12: static PetscBool DMPackageInitialized = PETSC_FALSE;
 13: /*@
 14:   DMFinalizePackage - This function finalizes everything in the `DM` package. It is called
 15:   from `PetscFinalize()`.

 17:   Level: developer

 19: .seealso: `PetscInitialize()`
 20: @*/
 21: PetscErrorCode DMFinalizePackage(void)
 22: {
 23:   PetscFunctionBegin;
 24:   PetscCall(PetscFunctionListDestroy(&DMList));
 25:   DMPackageInitialized = PETSC_FALSE;
 26:   DMRegisterAllCalled  = PETSC_FALSE;
 27:   PetscFunctionReturn(PETSC_SUCCESS);
 28: }

 30: #if PetscDefined(HAVE_HYPRE)
 31: PETSC_EXTERN PetscErrorCode MatCreate_HYPREStruct(Mat);
 32: PETSC_EXTERN PetscErrorCode MatCreate_HYPRESStruct(Mat);
 33: #endif

 35: /*@
 36:   DMInitializePackage - This function initializes everything in the `DM` package. It is called
 37:   from `PetscDLLibraryRegister_petscdm()` when using dynamic libraries, and on the first call to `DMCreate()`
 38:   or similar routines when using shared or static libraries.

 40:   Level: developer

 42:   Note:
 43:   This function never needs to be called by PETSc users.

 45: .seealso: `PetscInitialize()`
 46: @*/
 47: PetscErrorCode DMInitializePackage(void)
 48: {
 49:   char      logList[256];
 50:   PetscBool opt, pkg;

 52:   PetscFunctionBegin;
 53:   if (DMPackageInitialized) PetscFunctionReturn(PETSC_SUCCESS);
 54:   DMPackageInitialized = PETSC_TRUE;

 56:   /* Register Classes */
 57:   PetscCall(PetscClassIdRegister("Distributed Mesh", &DM_CLASSID));
 58:   PetscCall(PetscClassIdRegister("DM Label", &DMLABEL_CLASSID));
 59:   PetscCall(PetscClassIdRegister("Quadrature", &PETSCQUADRATURE_CLASSID));
 60:   PetscCall(PetscClassIdRegister("Mesh Transform", &DMPLEXTRANSFORM_CLASSID));
 61:   PetscCall(PetscClassIdRegister("Swarm Sort Ctx", &DMSWARMSORT_CLASSID));
 62:   PetscCall(PetscClassIdRegister("Swarm Cell DM", &DMSWARMCELLDM_CLASSID));

 64: #if PetscDefined(HAVE_HYPRE)
 65:   PetscCall(MatRegister(MATHYPRESTRUCT, MatCreate_HYPREStruct));
 66:   PetscCall(MatRegister(MATHYPRESSTRUCT, MatCreate_HYPRESStruct));
 67: #endif
 68:   PetscCall(PetscSectionSymRegister(PETSCSECTIONSYMLABEL, PetscSectionSymCreate_Label));

 70:   /* Register Constructors */
 71:   PetscCall(DMRegisterAll());
 72:   /* Register Events */
 73:   PetscCall(PetscLogEventRegister("DMConvert", DM_CLASSID, &DM_Convert));
 74:   PetscCall(PetscLogEventRegister("DMGlobalToLocal", DM_CLASSID, &DM_GlobalToLocal));
 75:   PetscCall(PetscLogEventRegister("DMLocalToGlobal", DM_CLASSID, &DM_LocalToGlobal));
 76:   PetscCall(PetscLogEventRegister("DMLocatePoints", DM_CLASSID, &DM_LocatePoints));
 77:   PetscCall(PetscLogEventRegister("DMCoarsen", DM_CLASSID, &DM_Coarsen));
 78:   PetscCall(PetscLogEventRegister("DMRefine", DM_CLASSID, &DM_Refine));
 79:   PetscCall(PetscLogEventRegister("DMCreateInterp", DM_CLASSID, &DM_CreateInterpolation));
 80:   PetscCall(PetscLogEventRegister("DMCreateRestrict", DM_CLASSID, &DM_CreateRestriction));
 81:   PetscCall(PetscLogEventRegister("DMCreateInject", DM_CLASSID, &DM_CreateInjection));
 82:   PetscCall(PetscLogEventRegister("DMCreateMat", DM_CLASSID, &DM_CreateMatrix));
 83:   PetscCall(PetscLogEventRegister("DMCreateMassMat", DM_CLASSID, &DM_CreateMassMatrix));
 84:   PetscCall(PetscLogEventRegister("DMLoad", DM_CLASSID, &DM_Load));
 85:   PetscCall(PetscLogEventRegister("DMView", DM_CLASSID, &DM_View));
 86:   PetscCall(PetscLogEventRegister("DMAdaptInterp", DM_CLASSID, &DM_AdaptInterpolator));
 87:   PetscCall(PetscLogEventRegister("DMProjectFunc", DM_CLASSID, &DM_ProjectFunction));

 89:   PetscCall(PetscLogEventRegister("DMPlexBuFrCeLi", DM_CLASSID, &DMPLEX_BuildFromCellList));
 90:   PetscCall(PetscLogEventRegister("DMPlexBuCoFrCeLi", DM_CLASSID, &DMPLEX_BuildCoordinatesFromCellList));
 91:   PetscCall(PetscLogEventRegister("DMPlexCreateGmsh", DM_CLASSID, &DMPLEX_CreateGmsh));
 92:   PetscCall(PetscLogEventRegister("DMPlexCrBoxSFC", DM_CLASSID, &DMPLEX_CreateBoxSFC));
 93:   PetscCall(PetscLogEventRegister("DMPlexCrFromFile", DM_CLASSID, &DMPLEX_CreateFromFile));
 94:   PetscCall(PetscLogEventRegister("DMPlexCrFromOpts", DM_CLASSID, &DMPLEX_CreateFromOptions));
 95:   PetscCall(PetscLogEventRegister("Mesh Partition", DM_CLASSID, &DMPLEX_Partition));
 96:   PetscCall(PetscLogEventRegister("Mesh Migration", DM_CLASSID, &DMPLEX_Migrate));
 97:   PetscCall(PetscLogEventRegister("DMPlexPartSelf", DM_CLASSID, &DMPLEX_PartSelf));
 98:   PetscCall(PetscLogEventRegister("DMPlexPartLblInv", DM_CLASSID, &DMPLEX_PartLabelInvert));
 99:   PetscCall(PetscLogEventRegister("DMPlexPartLblSF", DM_CLASSID, &DMPLEX_PartLabelCreateSF));
100:   PetscCall(PetscLogEventRegister("DMPlexPartStrtSF", DM_CLASSID, &DMPLEX_PartStratSF));
101:   PetscCall(PetscLogEventRegister("DMPlexPointSF", DM_CLASSID, &DMPLEX_CreatePointSF));
102:   PetscCall(PetscLogEventRegister("DMPlexInterp", DM_CLASSID, &DMPLEX_Interpolate));
103:   PetscCall(PetscLogEventRegister("DMPlexDistribute", DM_CLASSID, &DMPLEX_Distribute));
104:   PetscCall(PetscLogEventRegister("DMPlexDistMS", DM_CLASSID, &DMPLEX_DistributeMultistage));
105:   PetscCall(PetscLogEventRegister("DMPlexDistCones", DM_CLASSID, &DMPLEX_DistributeCones));
106:   PetscCall(PetscLogEventRegister("DMPlexDistLabels", DM_CLASSID, &DMPLEX_DistributeLabels));
107:   PetscCall(PetscLogEventRegister("DMPlexDistSF", DM_CLASSID, &DMPLEX_DistributeSF));
108:   PetscCall(PetscLogEventRegister("DMPlexDistOvrlp", DM_CLASSID, &DMPLEX_DistributeOverlap));
109:   PetscCall(PetscLogEventRegister("DMPlexDistField", DM_CLASSID, &DMPLEX_DistributeField));
110:   PetscCall(PetscLogEventRegister("DMPlexDistData", DM_CLASSID, &DMPLEX_DistributeData));
111:   PetscCall(PetscLogEventRegister("DMPlexInterpSF", DM_CLASSID, &DMPLEX_InterpolateSF));
112:   PetscCall(PetscLogEventRegister("DMPlexGToNBegin", DM_CLASSID, &DMPLEX_GlobalToNaturalBegin));
113:   PetscCall(PetscLogEventRegister("DMPlexGToNEnd", DM_CLASSID, &DMPLEX_GlobalToNaturalEnd));
114:   PetscCall(PetscLogEventRegister("DMPlexNToGBegin", DM_CLASSID, &DMPLEX_NaturalToGlobalBegin));
115:   PetscCall(PetscLogEventRegister("DMPlexNToGEnd", DM_CLASSID, &DMPLEX_NaturalToGlobalEnd));
116:   PetscCall(PetscLogEventRegister("DMPlexStratify", DM_CLASSID, &DMPLEX_Stratify));
117:   PetscCall(PetscLogEventRegister("DMPlexSymmetrize", DM_CLASSID, &DMPLEX_Symmetrize));
118:   PetscCall(PetscLogEventRegister("DMPlexPrealloc", DM_CLASSID, &DMPLEX_Preallocate));
119:   PetscCall(PetscLogEventRegister("DMPlexResidualFE", DM_CLASSID, &DMPLEX_ResidualFEM));
120:   PetscCall(PetscLogEventRegister("DMPlexJacobianFE", DM_CLASSID, &DMPLEX_JacobianFEM));
121:   PetscCall(PetscLogEventRegister("DMPlexInterpFE", DM_CLASSID, &DMPLEX_InterpolatorFEM));
122:   PetscCall(PetscLogEventRegister("DMPlexInjectorFE", DM_CLASSID, &DMPLEX_InjectorFEM));
123:   PetscCall(PetscLogEventRegister("DMPlexIntegralFE", DM_CLASSID, &DMPLEX_IntegralFEM));
124:   PetscCall(PetscLogEventRegister("DMPlexRebalance", DM_CLASSID, &DMPLEX_RebalanceSharedPoints));
125:   PetscCall(PetscLogEventRegister("DMPlexLocatePoints", DM_CLASSID, &DMPLEX_LocatePoints));
126:   PetscCall(PetscLogEventRegister("DMPlexTopologyView", DM_CLASSID, &DMPLEX_TopologyView));
127:   PetscCall(PetscLogEventRegister("DMPlexLabelsView", DM_CLASSID, &DMPLEX_LabelsView));
128:   PetscCall(PetscLogEventRegister("DMPlexCoordinatesView", DM_CLASSID, &DMPLEX_CoordinatesView));
129:   PetscCall(PetscLogEventRegister("DMPlexSectionView", DM_CLASSID, &DMPLEX_SectionView));
130:   PetscCall(PetscLogEventRegister("DMPlexGlobalVectorView", DM_CLASSID, &DMPLEX_GlobalVectorView));
131:   PetscCall(PetscLogEventRegister("DMPlexLocalVectorView", DM_CLASSID, &DMPLEX_LocalVectorView));
132:   PetscCall(PetscLogEventRegister("DMPlexTopologyLoad", DM_CLASSID, &DMPLEX_TopologyLoad));
133: #if PetscDefined(HAVE_HDF5)
134:   PetscCall(PetscLogEventRegister("DMPlexDistributionView", DM_CLASSID, &DMPLEX_DistributionView));
135:   PetscCall(PetscLogEventRegister("DMPlexDistributionLoad", DM_CLASSID, &DMPLEX_DistributionLoad));
136: #endif
137:   PetscCall(PetscLogEventRegister("DMPlexLabelsLoad", DM_CLASSID, &DMPLEX_LabelsLoad));
138:   PetscCall(PetscLogEventRegister("DMPlexCoordinatesLoad", DM_CLASSID, &DMPLEX_CoordinatesLoad));
139:   PetscCall(PetscLogEventRegister("DMPlexSectionLoad", DM_CLASSID, &DMPLEX_SectionLoad));
140:   PetscCall(PetscLogEventRegister("DMPlexGlobalVectorLoad", DM_CLASSID, &DMPLEX_GlobalVectorLoad));
141:   PetscCall(PetscLogEventRegister("DMPlexLocalVectorLoad", DM_CLASSID, &DMPLEX_LocalVectorLoad));
142:   PetscCall(PetscLogEventRegister("DMPlexMetricEnforceSPD", DM_CLASSID, &DMPLEX_MetricEnforceSPD));
143:   PetscCall(PetscLogEventRegister("DMPlexMetricNormalize", DM_CLASSID, &DMPLEX_MetricNormalize));
144:   PetscCall(PetscLogEventRegister("DMPlexMetricAverage", DM_CLASSID, &DMPLEX_MetricAverage));
145:   PetscCall(PetscLogEventRegister("DMPlexMetricIntersect", DM_CLASSID, &DMPLEX_MetricIntersection));
146:   PetscCall(PetscLogEventRegister("DMPlexGenerate", DM_CLASSID, &DMPLEX_Generate));
147:   PetscCall(PetscLogEventRegister("DMPlexGetLocOff", DM_CLASSID, &DMPLEX_GetLocalOffsets));

149:   PetscCall(PetscLogEventRegister("RebalBuildGraph", DM_CLASSID, &DMPLEX_RebalBuildGraph));
150:   PetscCall(PetscLogEventRegister("RebalGatherGraph", DM_CLASSID, &DMPLEX_RebalGatherGraph));
151:   PetscCall(PetscLogEventRegister("RebalPartition", DM_CLASSID, &DMPLEX_RebalPartition));
152:   PetscCall(PetscLogEventRegister("RebalScatterPart", DM_CLASSID, &DMPLEX_RebalScatterPart));
153:   PetscCall(PetscLogEventRegister("RebalRewriteSF", DM_CLASSID, &DMPLEX_RebalRewriteSF));
154:   PetscCall(PetscLogEventRegister("DMPlexUninterp", DM_CLASSID, &DMPLEX_Uninterpolate));

156:   PetscCall(PetscLogEventRegister("DMPlexTrSetUp", DM_CLASSID, &DMPLEXTRANSFORM_SetUp));
157:   PetscCall(PetscLogEventRegister("DMPlexTrApply", DM_CLASSID, &DMPLEXTRANSFORM_Apply));
158:   PetscCall(PetscLogEventRegister("DMPlexTrSizes", DM_CLASSID, &DMPLEXTRANSFORM_SetConeSizes));
159:   PetscCall(PetscLogEventRegister("DMPlexTrCones", DM_CLASSID, &DMPLEXTRANSFORM_SetCones));
160:   PetscCall(PetscLogEventRegister("DMPlexTrSF", DM_CLASSID, &DMPLEXTRANSFORM_CreateSF));
161:   PetscCall(PetscLogEventRegister("DMPlexTrLabels", DM_CLASSID, &DMPLEXTRANSFORM_CreateLabels));
162:   PetscCall(PetscLogEventRegister("DMPlexTrCoords", DM_CLASSID, &DMPLEXTRANSFORM_SetCoordinates));
163:   PetscCall(PetscLogEventRegister("DMPlexTrCheck", DM_CLASSID, &DMPLEXTRANSFORM_Check));

165:   PetscCall(PetscLogEventRegister("DMSwarmMigrate", DM_CLASSID, &DMSWARM_Migrate));
166:   PetscCall(PetscLogEventRegister("DMSwarmDETSetup", DM_CLASSID, &DMSWARM_DataExchangerTopologySetup));
167:   PetscCall(PetscLogEventRegister("DMSwarmDExBegin", DM_CLASSID, &DMSWARM_DataExchangerBegin));
168:   PetscCall(PetscLogEventRegister("DMSwarmDExEnd", DM_CLASSID, &DMSWARM_DataExchangerEnd));
169:   PetscCall(PetscLogEventRegister("DMSwarmDESendCnt", DM_CLASSID, &DMSWARM_DataExchangerSendCount));
170:   PetscCall(PetscLogEventRegister("DMSwarmDEPack", DM_CLASSID, &DMSWARM_DataExchangerPack));
171:   PetscCall(PetscLogEventRegister("DMSwarmAddPnts", DM_CLASSID, &DMSWARM_AddPoints));
172:   PetscCall(PetscLogEventRegister("DMSwarmRmvPnts", DM_CLASSID, &DMSWARM_RemovePoints));
173:   PetscCall(PetscLogEventRegister("DMSwarmSort", DM_CLASSID, &DMSWARM_Sort));
174:   PetscCall(PetscLogEventRegister("DMSwarmSetSizes", DM_CLASSID, &DMSWARM_SetSizes));

176:   PetscCall(PetscLogEventRegister("DMNtLayoutSetUp", DM_CLASSID, &DMNetwork_LayoutSetUp));
177:   PetscCall(PetscLogEventRegister("DMNtSetUp", DM_CLASSID, &DMNetwork_SetUpNetwork));
178:   PetscCall(PetscLogEventRegister("DMNtDistribute", DM_CLASSID, &DMNetwork_Distribute));
179:   /* Process Info */
180:   {
181:     PetscClassId classids[1];

183:     classids[0] = DM_CLASSID;
184:     PetscCall(PetscInfoProcessClass("dm", 1, classids));
185:   }

187:   /* Process summary exclusions */
188:   PetscCall(PetscOptionsGetString(NULL, NULL, "-log_exclude", logList, sizeof(logList), &opt));
189:   if (opt) {
190:     PetscCall(PetscStrInList("dm", logList, ',', &pkg));
191:     if (pkg) PetscCall(PetscLogEventExcludeClass(DM_CLASSID));
192:   }

194:   PetscCall(DMGenerateRegisterAll());
195:   PetscCall(PetscRegisterFinalize(DMGenerateRegisterDestroy));
196:   PetscCall(DMGeomModelRegisterAll());
197:   PetscCall(PetscRegisterFinalize(DMGeomModelRegisterDestroy));
198:   PetscCall(DMPlexTransformRegisterAll());
199:   PetscCall(PetscRegisterFinalize(DMPlexTransformRegisterDestroy));
200:   PetscCall(DMLabelRegisterAll());
201:   PetscCall(PetscRegisterFinalize(DMLabelRegisterDestroy));
202:   PetscCall(PetscRegisterFinalize(DMFinalizePackage));
203:   PetscFunctionReturn(PETSC_SUCCESS);
204: }
205: #include <petscfe.h>

207: static PetscBool PetscFEPackageInitialized = PETSC_FALSE;

209: /*@
210:   PetscFEFinalizePackage - This function finalizes everything in the `PetscFE` package. It is called
211:   from `PetscFinalize()`.

213:   Level: developer

215: .seealso: `PetscInitialize()`
216: @*/
217: PetscErrorCode PetscFEFinalizePackage(void)
218: {
219:   PetscFunctionBegin;
220:   PetscCall(PetscFunctionListDestroy(&PetscSpaceList));
221:   PetscCall(PetscFunctionListDestroy(&PetscDualSpaceList));
222:   PetscCall(PetscFunctionListDestroy(&PetscFEList));
223:   PetscFEPackageInitialized       = PETSC_FALSE;
224:   PetscSpaceRegisterAllCalled     = PETSC_FALSE;
225:   PetscDualSpaceRegisterAllCalled = PETSC_FALSE;
226:   PetscFERegisterAllCalled        = PETSC_FALSE;
227:   PetscFunctionReturn(PETSC_SUCCESS);
228: }

230: /*@
231:   PetscFEInitializePackage - This function initializes everything in the `PetscFE` package. It is called
232:   from `PetscDLLibraryRegister()` when using dynamic libraries, and on the first call to `PetscSpaceCreate()`
233:   when using static libraries.

235:   Level: developer

237: .seealso: `PetscInitialize()`
238: @*/
239: PetscErrorCode PetscFEInitializePackage(void)
240: {
241:   char      logList[256];
242:   PetscBool opt, pkg;

244:   PetscFunctionBegin;
245:   if (PetscFEPackageInitialized) PetscFunctionReturn(PETSC_SUCCESS);
246:   PetscFEPackageInitialized = PETSC_TRUE;

248:   /* Register Classes */
249:   PetscCall(PetscClassIdRegister("Linear Space", &PETSCSPACE_CLASSID));
250:   PetscCall(PetscClassIdRegister("Dual Space", &PETSCDUALSPACE_CLASSID));
251:   PetscCall(PetscClassIdRegister("FE Space", &PETSCFE_CLASSID));
252:   /* Register Constructors */
253:   PetscCall(PetscSpaceRegisterAll());
254:   PetscCall(PetscDualSpaceRegisterAll());
255:   PetscCall(PetscFERegisterAll());
256:   /* Register Events */
257:   PetscCall(PetscLogEventRegister("DualSpaceSetUp", PETSCDUALSPACE_CLASSID, &PETSCDUALSPACE_SetUp));
258:   PetscCall(PetscLogEventRegister("FESetUp", PETSCFE_CLASSID, &PETSCFE_SetUp));
259:   /* Process Info */
260:   {
261:     PetscClassId classids[3];

263:     classids[0] = PETSCFE_CLASSID;
264:     classids[1] = PETSCSPACE_CLASSID;
265:     classids[2] = PETSCDUALSPACE_CLASSID;
266:     PetscCall(PetscInfoProcessClass("fe", 1, classids));
267:     PetscCall(PetscInfoProcessClass("space", 1, &classids[1]));
268:     PetscCall(PetscInfoProcessClass("dualspace", 1, &classids[2]));
269:   }
270:   /* Process summary exclusions */
271:   PetscCall(PetscOptionsGetString(NULL, NULL, "-log_exclude", logList, sizeof(logList), &opt));
272:   if (opt) {
273:     PetscCall(PetscStrInList("fe", logList, ',', &pkg));
274:     if (pkg) PetscCall(PetscLogEventExcludeClass(PETSCFE_CLASSID));
275:   }
276:   /* Register package finalizer */
277:   PetscCall(PetscRegisterFinalize(PetscFEFinalizePackage));
278:   PetscFunctionReturn(PETSC_SUCCESS);
279: }
280: #include <petscfv.h>

282: static PetscBool PetscFVPackageInitialized = PETSC_FALSE;

284: /*@
285:   PetscFVFinalizePackage - This function finalizes everything in the `PetscFV` package. It is called
286:   from `PetscFinalize()`.

288:   Level: developer

290: .seealso: `PetscInitialize()`
291: @*/
292: PetscErrorCode PetscFVFinalizePackage(void)
293: {
294:   PetscFunctionBegin;
295:   PetscCall(PetscFunctionListDestroy(&PetscLimiterList));
296:   PetscCall(PetscFunctionListDestroy(&PetscFVList));
297:   PetscFVPackageInitialized     = PETSC_FALSE;
298:   PetscFVRegisterAllCalled      = PETSC_FALSE;
299:   PetscLimiterRegisterAllCalled = PETSC_FALSE;
300:   PetscFunctionReturn(PETSC_SUCCESS);
301: }

303: /*@
304:   PetscFVInitializePackage - This function initializes everything in the `PetscFV` package. It is called
305:   from `PetscDLLibraryRegister()` when using dynamic libraries, and on the first call to `PetscFVCreate()`
306:   when using static libraries.

308:   Level: developer

310: .seealso: `PetscInitialize()`
311: @*/
312: PetscErrorCode PetscFVInitializePackage(void)
313: {
314:   char      logList[256];
315:   PetscBool opt, pkg;

317:   PetscFunctionBegin;
318:   if (PetscFVPackageInitialized) PetscFunctionReturn(PETSC_SUCCESS);
319:   PetscFVPackageInitialized = PETSC_TRUE;

321:   /* Register Classes */
322:   PetscCall(PetscClassIdRegister("FV Space", &PETSCFV_CLASSID));
323:   PetscCall(PetscClassIdRegister("Limiter", &PETSCLIMITER_CLASSID));
324:   /* Register Constructors */
325:   PetscCall(PetscFVRegisterAll());
326:   /* Register Events */
327:   /* Process Info */
328:   {
329:     PetscClassId classids[2];

331:     classids[0] = PETSCFV_CLASSID;
332:     classids[1] = PETSCLIMITER_CLASSID;
333:     PetscCall(PetscInfoProcessClass("fv", 1, classids));
334:     PetscCall(PetscInfoProcessClass("limiter", 1, &classids[1]));
335:   }
336:   /* Process summary exclusions */
337:   PetscCall(PetscOptionsGetString(NULL, NULL, "-log_exclude", logList, sizeof(logList), &opt));
338:   if (opt) {
339:     PetscCall(PetscStrInList("fv", logList, ',', &pkg));
340:     if (pkg) PetscCall(PetscLogEventExcludeClass(PETSCFV_CLASSID));
341:     PetscCall(PetscStrInList("limiter", logList, ',', &pkg));
342:     if (pkg) PetscCall(PetscLogEventExcludeClass(PETSCLIMITER_CLASSID));
343:   }
344:   /* Register package finalizer */
345:   PetscCall(PetscRegisterFinalize(PetscFVFinalizePackage));
346:   PetscFunctionReturn(PETSC_SUCCESS);
347: }
348: #include <petscds.h>

350: static PetscBool PetscDSPackageInitialized = PETSC_FALSE;

352: /*@
353:   PetscDSFinalizePackage - This function finalizes everything in the `PetscDS` package. It is called
354:   from `PetscFinalize()`.

356:   Level: developer

358: .seealso: `PetscInitialize()`
359: @*/
360: PetscErrorCode PetscDSFinalizePackage(void)
361: {
362:   PetscFunctionBegin;
363:   PetscCall(PetscFunctionListDestroy(&PetscDSList));
364:   PetscDSPackageInitialized = PETSC_FALSE;
365:   PetscDSRegisterAllCalled  = PETSC_FALSE;
366:   PetscFunctionReturn(PETSC_SUCCESS);
367: }

369: /*@
370:   PetscDSInitializePackage - This function initializes everything in the `PetscDS` package. It is called
371:   from `PetscDLLibraryRegister()` when using dynamic libraries, and on the first call to `PetscDSCreate()`
372:   when using static libraries.

374:   Level: developer

376: .seealso: `PetscInitialize()`
377: @*/
378: PetscErrorCode PetscDSInitializePackage(void)
379: {
380:   char      logList[256];
381:   PetscBool opt, pkg;

383:   PetscFunctionBegin;
384:   if (PetscDSPackageInitialized) PetscFunctionReturn(PETSC_SUCCESS);
385:   PetscDSPackageInitialized = PETSC_TRUE;

387:   /* Register Classes */
388:   PetscCall(PetscClassIdRegister("Discrete System", &PETSCDS_CLASSID));
389:   PetscCall(PetscClassIdRegister("Weak Form", &PETSCWEAKFORM_CLASSID));
390:   /* Register Constructors */
391:   PetscCall(PetscDSRegisterAll());
392:   /* Register Events */
393:   /* Process Info */
394:   {
395:     PetscClassId classids[1];

397:     classids[0] = PETSCDS_CLASSID;
398:     PetscCall(PetscInfoProcessClass("ds", 1, classids));
399:   }
400:   /* Process summary exclusions */
401:   PetscCall(PetscOptionsGetString(NULL, NULL, "-log_exclude", logList, sizeof(logList), &opt));
402:   if (opt) {
403:     PetscCall(PetscStrInList("ds", logList, ',', &pkg));
404:     if (pkg) PetscCall(PetscLogEventExcludeClass(PETSCDS_CLASSID));
405:   }
406:   /* Register package finalizer */
407:   PetscCall(PetscRegisterFinalize(PetscDSFinalizePackage));
408:   PetscFunctionReturn(PETSC_SUCCESS);
409: }

411: #if PetscDefined(HAVE_DYNAMIC_LIBRARIES)
412: /*
413:   PetscDLLibraryRegister - This function is called when the dynamic library it is in is opened.

415:   This one registers all the mesh generators and partitioners that are in
416:   the basic DM library.

418: */
419: PETSC_EXTERN PetscErrorCode PetscDLLibraryRegister_petscdm(void)
420: {
421:   PetscFunctionBegin;
422:   PetscCall(AOInitializePackage());
423:   PetscCall(PetscPartitionerInitializePackage());
424:   PetscCall(DMInitializePackage());
425:   PetscCall(PetscFEInitializePackage());
426:   PetscCall(PetscFVInitializePackage());
427:   PetscCall(DMFieldInitializePackage());
428:   PetscCall(PetscDSInitializePackage());
429:   PetscFunctionReturn(PETSC_SUCCESS);
430: }

432: #endif /* PETSC_HAVE_DYNAMIC_LIBRARIES */