Actual source code: dlregisdmdm.c


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

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

 18:   Level: developer

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

 31: #if defined(PETSC_HAVE_HYPRE)
 32: PETSC_EXTERN PetscErrorCode MatCreate_HYPREStruct(Mat);
 33: PETSC_EXTERN PetscErrorCode MatCreate_HYPRESStruct(Mat);
 34: #endif

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

 41:   Level: developer

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

 50:   PetscFunctionBegin;
 51:   if (DMPackageInitialized) PetscFunctionReturn(PETSC_SUCCESS);
 52:   DMPackageInitialized = PETSC_TRUE;

 54:   /* Register Classes */
 55:   PetscCall(PetscClassIdRegister("Distributed Mesh", &DM_CLASSID));
 56:   PetscCall(PetscClassIdRegister("DM Label", &DMLABEL_CLASSID));
 57:   PetscCall(PetscClassIdRegister("Quadrature", &PETSCQUADRATURE_CLASSID));
 58:   PetscCall(PetscClassIdRegister("Mesh Transform", &DMPLEXTRANSFORM_CLASSID));

 60: #if defined(PETSC_HAVE_HYPRE)
 61:   PetscCall(MatRegister(MATHYPRESTRUCT, MatCreate_HYPREStruct));
 62:   PetscCall(MatRegister(MATHYPRESSTRUCT, MatCreate_HYPRESStruct));
 63: #endif
 64:   PetscCall(PetscSectionSymRegister(PETSCSECTIONSYMLABEL, PetscSectionSymCreate_Label));

 66:   /* Register Constructors */
 67:   PetscCall(DMRegisterAll());
 68:   /* Register Events */
 69:   PetscCall(PetscLogEventRegister("DMConvert", DM_CLASSID, &DM_Convert));
 70:   PetscCall(PetscLogEventRegister("DMGlobalToLocal", DM_CLASSID, &DM_GlobalToLocal));
 71:   PetscCall(PetscLogEventRegister("DMLocalToGlobal", DM_CLASSID, &DM_LocalToGlobal));
 72:   PetscCall(PetscLogEventRegister("DMLocatePoints", DM_CLASSID, &DM_LocatePoints));
 73:   PetscCall(PetscLogEventRegister("DMCoarsen", DM_CLASSID, &DM_Coarsen));
 74:   PetscCall(PetscLogEventRegister("DMRefine", DM_CLASSID, &DM_Refine));
 75:   PetscCall(PetscLogEventRegister("DMCreateInterp", DM_CLASSID, &DM_CreateInterpolation));
 76:   PetscCall(PetscLogEventRegister("DMCreateRestrict", DM_CLASSID, &DM_CreateRestriction));
 77:   PetscCall(PetscLogEventRegister("DMCreateInject", DM_CLASSID, &DM_CreateInjection));
 78:   PetscCall(PetscLogEventRegister("DMCreateMat", DM_CLASSID, &DM_CreateMatrix));
 79:   PetscCall(PetscLogEventRegister("DMCreateMassMat", DM_CLASSID, &DM_CreateMassMatrix));
 80:   PetscCall(PetscLogEventRegister("DMLoad", DM_CLASSID, &DM_Load));
 81:   PetscCall(PetscLogEventRegister("DMAdaptInterp", DM_CLASSID, &DM_AdaptInterpolator));

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

137:   PetscCall(PetscLogEventRegister("RebalBuildGraph", DM_CLASSID, &DMPLEX_RebalBuildGraph));
138:   PetscCall(PetscLogEventRegister("RebalGatherGraph", DM_CLASSID, &DMPLEX_RebalGatherGraph));
139:   PetscCall(PetscLogEventRegister("RebalPartition", DM_CLASSID, &DMPLEX_RebalPartition));
140:   PetscCall(PetscLogEventRegister("RebalScatterPart", DM_CLASSID, &DMPLEX_RebalScatterPart));
141:   PetscCall(PetscLogEventRegister("RebalRewriteSF", DM_CLASSID, &DMPLEX_RebalRewriteSF));

143:   PetscCall(PetscLogEventRegister("DMSwarmMigrate", DM_CLASSID, &DMSWARM_Migrate));
144:   PetscCall(PetscLogEventRegister("DMSwarmDETSetup", DM_CLASSID, &DMSWARM_DataExchangerTopologySetup));
145:   PetscCall(PetscLogEventRegister("DMSwarmDExBegin", DM_CLASSID, &DMSWARM_DataExchangerBegin));
146:   PetscCall(PetscLogEventRegister("DMSwarmDExEnd", DM_CLASSID, &DMSWARM_DataExchangerEnd));
147:   PetscCall(PetscLogEventRegister("DMSwarmDESendCnt", DM_CLASSID, &DMSWARM_DataExchangerSendCount));
148:   PetscCall(PetscLogEventRegister("DMSwarmDEPack", DM_CLASSID, &DMSWARM_DataExchangerPack));
149:   PetscCall(PetscLogEventRegister("DMSwarmAddPnts", DM_CLASSID, &DMSWARM_AddPoints));
150:   PetscCall(PetscLogEventRegister("DMSwarmRmvPnts", DM_CLASSID, &DMSWARM_RemovePoints));
151:   PetscCall(PetscLogEventRegister("DMSwarmSort", DM_CLASSID, &DMSWARM_Sort));
152:   PetscCall(PetscLogEventRegister("DMSwarmSetSizes", DM_CLASSID, &DMSWARM_SetSizes));

154:   PetscCall(PetscLogEventRegister("DMNtLayoutSetUp", DM_CLASSID, &DMNetwork_LayoutSetUp));
155:   PetscCall(PetscLogEventRegister("DMNtSetUp", DM_CLASSID, &DMNetwork_SetUpNetwork));
156:   PetscCall(PetscLogEventRegister("DMNtDistribute", DM_CLASSID, &DMNetwork_Distribute));
157:   /* Process Info */
158:   {
159:     PetscClassId classids[1];

161:     classids[0] = DM_CLASSID;
162:     PetscCall(PetscInfoProcessClass("dm", 1, classids));
163:   }

165:   /* Process summary exclusions */
166:   PetscCall(PetscOptionsGetString(NULL, NULL, "-log_exclude", logList, sizeof(logList), &opt));
167:   if (opt) {
168:     PetscCall(PetscStrInList("dm", logList, ',', &pkg));
169:     if (pkg) PetscCall(PetscLogEventExcludeClass(DM_CLASSID));
170:   }

172:   PetscCall(DMGenerateRegisterAll());
173:   PetscCall(PetscRegisterFinalize(DMGenerateRegisterDestroy));
174:   PetscCall(DMPlexTransformRegisterAll());
175:   PetscCall(PetscRegisterFinalize(DMPlexTransformRegisterDestroy));
176:   PetscCall(DMLabelRegisterAll());
177:   PetscCall(PetscRegisterFinalize(DMLabelRegisterDestroy));
178:   PetscCall(PetscRegisterFinalize(DMFinalizePackage));
179:   PetscFunctionReturn(PETSC_SUCCESS);
180: }
181: #include <petscfe.h>

183: static PetscBool PetscFEPackageInitialized = PETSC_FALSE;
184: /*@C
185:   PetscFEFinalizePackage - This function finalizes everything in the PetscFE package. It is called
186:   from PetscFinalize().

188:   Level: developer

190: .seealso: `PetscInitialize()`
191: @*/
192: PetscErrorCode PetscFEFinalizePackage(void)
193: {
194:   PetscFunctionBegin;
195:   PetscCall(PetscFunctionListDestroy(&PetscSpaceList));
196:   PetscCall(PetscFunctionListDestroy(&PetscDualSpaceList));
197:   PetscCall(PetscFunctionListDestroy(&PetscFEList));
198:   PetscFEPackageInitialized       = PETSC_FALSE;
199:   PetscSpaceRegisterAllCalled     = PETSC_FALSE;
200:   PetscDualSpaceRegisterAllCalled = PETSC_FALSE;
201:   PetscFERegisterAllCalled        = PETSC_FALSE;
202:   PetscFunctionReturn(PETSC_SUCCESS);
203: }

205: /*@C
206:   PetscFEInitializePackage - This function initializes everything in the FE package. It is called
207:   from PetscDLLibraryRegister() when using dynamic libraries, and on the first call to PetscSpaceCreate()
208:   when using static libraries.

210:   Level: developer

212: .seealso: `PetscInitialize()`
213: @*/
214: PetscErrorCode PetscFEInitializePackage(void)
215: {
216:   char      logList[256];
217:   PetscBool opt, pkg;

219:   PetscFunctionBegin;
220:   if (PetscFEPackageInitialized) PetscFunctionReturn(PETSC_SUCCESS);
221:   PetscFEPackageInitialized = PETSC_TRUE;

223:   /* Register Classes */
224:   PetscCall(PetscClassIdRegister("Linear Space", &PETSCSPACE_CLASSID));
225:   PetscCall(PetscClassIdRegister("Dual Space", &PETSCDUALSPACE_CLASSID));
226:   PetscCall(PetscClassIdRegister("FE Space", &PETSCFE_CLASSID));
227:   /* Register Constructors */
228:   PetscCall(PetscSpaceRegisterAll());
229:   PetscCall(PetscDualSpaceRegisterAll());
230:   PetscCall(PetscFERegisterAll());
231:   /* Register Events */
232:   PetscCall(PetscLogEventRegister("DualSpaceSetUp", PETSCDUALSPACE_CLASSID, &PETSCDUALSPACE_SetUp));
233:   PetscCall(PetscLogEventRegister("FESetUp", PETSCFE_CLASSID, &PETSCFE_SetUp));
234:   /* Process Info */
235:   {
236:     PetscClassId classids[3];

238:     classids[0] = PETSCFE_CLASSID;
239:     classids[1] = PETSCSPACE_CLASSID;
240:     classids[2] = PETSCDUALSPACE_CLASSID;
241:     PetscCall(PetscInfoProcessClass("fe", 1, classids));
242:     PetscCall(PetscInfoProcessClass("space", 1, &classids[1]));
243:     PetscCall(PetscInfoProcessClass("dualspace", 1, &classids[2]));
244:   }
245:   /* Process summary exclusions */
246:   PetscCall(PetscOptionsGetString(NULL, NULL, "-log_exclude", logList, sizeof(logList), &opt));
247:   if (opt) {
248:     PetscCall(PetscStrInList("fe", logList, ',', &pkg));
249:     if (pkg) PetscCall(PetscLogEventExcludeClass(PETSCFE_CLASSID));
250:   }
251:   /* Register package finalizer */
252:   PetscCall(PetscRegisterFinalize(PetscFEFinalizePackage));
253:   PetscFunctionReturn(PETSC_SUCCESS);
254: }
255: #include <petscfv.h>

257: static PetscBool PetscFVPackageInitialized = PETSC_FALSE;
258: /*@C
259:   PetscFVFinalizePackage - This function finalizes everything in the PetscFV package. It is called
260:   from PetscFinalize().

262:   Level: developer

264: .seealso: `PetscInitialize()`
265: @*/
266: PetscErrorCode PetscFVFinalizePackage(void)
267: {
268:   PetscFunctionBegin;
269:   PetscCall(PetscFunctionListDestroy(&PetscLimiterList));
270:   PetscCall(PetscFunctionListDestroy(&PetscFVList));
271:   PetscFVPackageInitialized     = PETSC_FALSE;
272:   PetscFVRegisterAllCalled      = PETSC_FALSE;
273:   PetscLimiterRegisterAllCalled = PETSC_FALSE;
274:   PetscFunctionReturn(PETSC_SUCCESS);
275: }

277: /*@C
278:   PetscFVInitializePackage - This function initializes everything in the FV package. It is called
279:   from PetscDLLibraryRegister() when using dynamic libraries, and on the first call to PetscFVCreate()
280:   when using static libraries.

282:   Level: developer

284: .seealso: `PetscInitialize()`
285: @*/
286: PetscErrorCode PetscFVInitializePackage(void)
287: {
288:   char      logList[256];
289:   PetscBool opt, pkg;

291:   PetscFunctionBegin;
292:   if (PetscFVPackageInitialized) PetscFunctionReturn(PETSC_SUCCESS);
293:   PetscFVPackageInitialized = PETSC_TRUE;

295:   /* Register Classes */
296:   PetscCall(PetscClassIdRegister("FV Space", &PETSCFV_CLASSID));
297:   PetscCall(PetscClassIdRegister("Limiter", &PETSCLIMITER_CLASSID));
298:   /* Register Constructors */
299:   PetscCall(PetscFVRegisterAll());
300:   /* Register Events */
301:   /* Process Info */
302:   {
303:     PetscClassId classids[2];

305:     classids[0] = PETSCFV_CLASSID;
306:     classids[1] = PETSCLIMITER_CLASSID;
307:     PetscCall(PetscInfoProcessClass("fv", 1, classids));
308:     PetscCall(PetscInfoProcessClass("limiter", 1, &classids[1]));
309:   }
310:   /* Process summary exclusions */
311:   PetscCall(PetscOptionsGetString(NULL, NULL, "-log_exclude", logList, sizeof(logList), &opt));
312:   if (opt) {
313:     PetscCall(PetscStrInList("fv", logList, ',', &pkg));
314:     if (pkg) PetscCall(PetscLogEventExcludeClass(PETSCFV_CLASSID));
315:     PetscCall(PetscStrInList("limiter", logList, ',', &pkg));
316:     if (pkg) PetscCall(PetscLogEventExcludeClass(PETSCLIMITER_CLASSID));
317:   }
318:   /* Register package finalizer */
319:   PetscCall(PetscRegisterFinalize(PetscFVFinalizePackage));
320:   PetscFunctionReturn(PETSC_SUCCESS);
321: }
322: #include <petscds.h>

324: static PetscBool PetscDSPackageInitialized = PETSC_FALSE;
325: /*@C
326:   PetscDSFinalizePackage - This function finalizes everything in the PetscDS package. It is called
327:   from PetscFinalize().

329:   Level: developer

331: .seealso: `PetscInitialize()`
332: @*/
333: PetscErrorCode PetscDSFinalizePackage(void)
334: {
335:   PetscFunctionBegin;
336:   PetscCall(PetscFunctionListDestroy(&PetscDSList));
337:   PetscDSPackageInitialized = PETSC_FALSE;
338:   PetscDSRegisterAllCalled  = PETSC_FALSE;
339:   PetscFunctionReturn(PETSC_SUCCESS);
340: }

342: /*@C
343:   PetscDSInitializePackage - This function initializes everything in the DS package. It is called
344:   from PetscDLLibraryRegister() when using dynamic libraries, and on the first call to PetscDSCreate()
345:   when using static libraries.

347:   Level: developer

349: .seealso: `PetscInitialize()`
350: @*/
351: PetscErrorCode PetscDSInitializePackage(void)
352: {
353:   char      logList[256];
354:   PetscBool opt, pkg;

356:   PetscFunctionBegin;
357:   if (PetscDSPackageInitialized) PetscFunctionReturn(PETSC_SUCCESS);
358:   PetscDSPackageInitialized = PETSC_TRUE;

360:   /* Register Classes */
361:   PetscCall(PetscClassIdRegister("Discrete System", &PETSCDS_CLASSID));
362:   PetscCall(PetscClassIdRegister("Weak Form", &PETSCWEAKFORM_CLASSID));
363:   /* Register Constructors */
364:   PetscCall(PetscDSRegisterAll());
365:   /* Register Events */
366:   /* Process Info */
367:   {
368:     PetscClassId classids[1];

370:     classids[0] = PETSCDS_CLASSID;
371:     PetscCall(PetscInfoProcessClass("ds", 1, classids));
372:   }
373:   /* Process summary exclusions */
374:   PetscCall(PetscOptionsGetString(NULL, NULL, "-log_exclude", logList, sizeof(logList), &opt));
375:   if (opt) {
376:     PetscCall(PetscStrInList("ds", logList, ',', &pkg));
377:     if (pkg) PetscCall(PetscLogEventExcludeClass(PETSCDS_CLASSID));
378:   }
379:   /* Register package finalizer */
380:   PetscCall(PetscRegisterFinalize(PetscDSFinalizePackage));
381:   PetscFunctionReturn(PETSC_SUCCESS);
382: }

384: #if defined(PETSC_HAVE_DYNAMIC_LIBRARIES)
385: /*
386:   PetscDLLibraryRegister - This function is called when the dynamic library it is in is opened.

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

391: */
392: PETSC_EXTERN PetscErrorCode PetscDLLibraryRegister_petscdm(void)
393: {
394:   PetscFunctionBegin;
395:   PetscCall(AOInitializePackage());
396:   PetscCall(PetscPartitionerInitializePackage());
397:   PetscCall(DMInitializePackage());
398:   PetscCall(PetscFEInitializePackage());
399:   PetscCall(PetscFVInitializePackage());
400:   PetscCall(DMFieldInitializePackage());
401:   PetscFunctionReturn(PETSC_SUCCESS);
402: }

404: #endif /* PETSC_HAVE_DYNAMIC_LIBRARIES */