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>

 12: static PetscBool DMPackageInitialized = PETSC_FALSE;
 13: /*@C
 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:   PetscFunctionListDestroy(&DMList);
 24:   DMPackageInitialized = PETSC_FALSE;
 25:   DMRegisterAllCalled  = PETSC_FALSE;
 26:   return 0;
 27: }

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

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

 39:   Level: developer

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

 48:   if (DMPackageInitialized) return 0;
 49:   DMPackageInitialized = PETSC_TRUE;

 51:   /* Register Classes */
 52:   PetscClassIdRegister("Distributed Mesh",&DM_CLASSID);
 53:   PetscClassIdRegister("DM Label",&DMLABEL_CLASSID);
 54:   PetscClassIdRegister("Quadrature",&PETSCQUADRATURE_CLASSID);
 55:   PetscClassIdRegister("Mesh Transform",&DMPLEXTRANSFORM_CLASSID);

 57: #if defined(PETSC_HAVE_HYPRE)
 58:   MatRegister(MATHYPRESTRUCT, MatCreate_HYPREStruct);
 59:   MatRegister(MATHYPRESSTRUCT, MatCreate_HYPRESStruct);
 60: #endif
 61:   PetscSectionSymRegister(PETSCSECTIONSYMLABEL,PetscSectionSymCreate_Label);

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

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

130:   PetscLogEventRegister("DMSwarmMigrate",         DM_CLASSID,&DMSWARM_Migrate);
131:   PetscLogEventRegister("DMSwarmDETSetup",        DM_CLASSID,&DMSWARM_DataExchangerTopologySetup);
132:   PetscLogEventRegister("DMSwarmDExBegin",        DM_CLASSID,&DMSWARM_DataExchangerBegin);
133:   PetscLogEventRegister("DMSwarmDExEnd",          DM_CLASSID,&DMSWARM_DataExchangerEnd);
134:   PetscLogEventRegister("DMSwarmDESendCnt",       DM_CLASSID,&DMSWARM_DataExchangerSendCount);
135:   PetscLogEventRegister("DMSwarmDEPack",          DM_CLASSID,&DMSWARM_DataExchangerPack);
136:   PetscLogEventRegister("DMSwarmAddPnts",         DM_CLASSID,&DMSWARM_AddPoints);
137:   PetscLogEventRegister("DMSwarmRmvPnts",         DM_CLASSID,&DMSWARM_RemovePoints);
138:   PetscLogEventRegister("DMSwarmSort",            DM_CLASSID,&DMSWARM_Sort);
139:   PetscLogEventRegister("DMSwarmSetSizes",        DM_CLASSID,&DMSWARM_SetSizes);
140:   /* Process Info */
141:   {
142:     PetscClassId  classids[1];

144:     classids[0] = DM_CLASSID;
145:     PetscInfoProcessClass("dm", 1, classids);
146:   }

148:   /* Process summary exclusions */
149:   PetscOptionsGetString(NULL,NULL,"-log_exclude",logList,sizeof(logList),&opt);
150:   if (opt) {
151:     PetscStrInList("dm",logList,',',&pkg);
152:     if (pkg) PetscLogEventExcludeClass(DM_CLASSID);
153:   }

155:   DMGenerateRegisterAll();
156:   PetscRegisterFinalize(DMGenerateRegisterDestroy);
157:   DMPlexTransformRegisterAll();
158:   PetscRegisterFinalize(DMPlexTransformRegisterDestroy);
159:   PetscRegisterFinalize(DMFinalizePackage);
160:   return 0;
161: }
162: #include <petscfe.h>

164: static PetscBool PetscFEPackageInitialized = PETSC_FALSE;
165: /*@C
166:   PetscFEFinalizePackage - This function finalizes everything in the PetscFE package. It is called
167:   from PetscFinalize().

169:   Level: developer

171: .seealso: PetscInitialize()
172: @*/
173: PetscErrorCode PetscFEFinalizePackage(void)
174: {
175:   PetscFunctionListDestroy(&PetscSpaceList);
176:   PetscFunctionListDestroy(&PetscDualSpaceList);
177:   PetscFunctionListDestroy(&PetscFEList);
178:   PetscFEPackageInitialized       = PETSC_FALSE;
179:   PetscSpaceRegisterAllCalled     = PETSC_FALSE;
180:   PetscDualSpaceRegisterAllCalled = PETSC_FALSE;
181:   PetscFERegisterAllCalled        = PETSC_FALSE;
182:   return 0;
183: }

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

190:   Level: developer

192: .seealso: PetscInitialize()
193: @*/
194: PetscErrorCode PetscFEInitializePackage(void)
195: {
196:   char           logList[256];
197:   PetscBool      opt,pkg;

199:   if (PetscFEPackageInitialized) return 0;
200:   PetscFEPackageInitialized = PETSC_TRUE;

202:   /* Register Classes */
203:   PetscClassIdRegister("Linear Space", &PETSCSPACE_CLASSID);
204:   PetscClassIdRegister("Dual Space",   &PETSCDUALSPACE_CLASSID);
205:   PetscClassIdRegister("FE Space",     &PETSCFE_CLASSID);
206:   /* Register Constructors */
207:   PetscSpaceRegisterAll();
208:   PetscDualSpaceRegisterAll();
209:   PetscFERegisterAll();
210:   /* Register Events */
211:   PetscLogEventRegister("DualSpaceSetUp", PETSCDUALSPACE_CLASSID, &PETSCDUALSPACE_SetUp);
212:   PetscLogEventRegister("FESetUp",        PETSCFE_CLASSID,        &PETSCFE_SetUp);
213:   /* Process Info */
214:   {
215:     PetscClassId  classids[3];

217:     classids[0] = PETSCFE_CLASSID;
218:     classids[1] = PETSCSPACE_CLASSID;
219:     classids[2] = PETSCDUALSPACE_CLASSID;
220:     PetscInfoProcessClass("fe", 1, classids);
221:     PetscInfoProcessClass("space", 1, &classids[1]);
222:     PetscInfoProcessClass("dualspace", 1, &classids[2]);
223:   }
224:   /* Process summary exclusions */
225:   PetscOptionsGetString(NULL,NULL,"-log_exclude",logList,sizeof(logList),&opt);
226:   if (opt) {
227:     PetscStrInList("fe",logList,',',&pkg);
228:     if (pkg) PetscLogEventExcludeClass(PETSCFE_CLASSID);
229:   }
230:   /* Register package finalizer */
231:   PetscRegisterFinalize(PetscFEFinalizePackage);
232:   return 0;
233: }
234: #include <petscfv.h>

236: static PetscBool PetscFVPackageInitialized = PETSC_FALSE;
237: /*@C
238:   PetscFVFinalizePackage - This function finalizes everything in the PetscFV package. It is called
239:   from PetscFinalize().

241:   Level: developer

243: .seealso: PetscInitialize()
244: @*/
245: PetscErrorCode PetscFVFinalizePackage(void)
246: {
247:   PetscFunctionListDestroy(&PetscLimiterList);
248:   PetscFunctionListDestroy(&PetscFVList);
249:   PetscFVPackageInitialized     = PETSC_FALSE;
250:   PetscFVRegisterAllCalled      = PETSC_FALSE;
251:   PetscLimiterRegisterAllCalled = PETSC_FALSE;
252:   return 0;
253: }

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

260:   Level: developer

262: .seealso: PetscInitialize()
263: @*/
264: PetscErrorCode PetscFVInitializePackage(void)
265: {
266:   char           logList[256];
267:   PetscBool      opt,pkg;

269:   if (PetscFVPackageInitialized) return 0;
270:   PetscFVPackageInitialized = PETSC_TRUE;

272:   /* Register Classes */
273:   PetscClassIdRegister("FV Space", &PETSCFV_CLASSID);
274:   PetscClassIdRegister("Limiter",  &PETSCLIMITER_CLASSID);
275:   /* Register Constructors */
276:   PetscFVRegisterAll();
277:   /* Register Events */
278:   /* Process Info */
279:   {
280:     PetscClassId  classids[2];

282:     classids[0] = PETSCFV_CLASSID;
283:     classids[1] = PETSCLIMITER_CLASSID;
284:     PetscInfoProcessClass("fv", 1, classids);
285:     PetscInfoProcessClass("limiter", 1, &classids[1]);
286:   }
287:   /* Process summary exclusions */
288:   PetscOptionsGetString(NULL,NULL,"-log_exclude",logList,sizeof(logList),&opt);
289:   if (opt) {
290:     PetscStrInList("fv",logList,',',&pkg);
291:     if (pkg) PetscLogEventExcludeClass(PETSCFV_CLASSID);
292:     PetscStrInList("limiter",logList,',',&pkg);
293:     if (pkg) PetscLogEventExcludeClass(PETSCLIMITER_CLASSID);
294:   }
295:   /* Register package finalizer */
296:   PetscRegisterFinalize(PetscFVFinalizePackage);
297:   return 0;
298: }
299: #include <petscds.h>

301: static PetscBool PetscDSPackageInitialized = PETSC_FALSE;
302: /*@C
303:   PetscDSFinalizePackage - This function finalizes everything in the PetscDS package. It is called
304:   from PetscFinalize().

306:   Level: developer

308: .seealso: PetscInitialize()
309: @*/
310: PetscErrorCode PetscDSFinalizePackage(void)
311: {
312:   PetscFunctionListDestroy(&PetscDSList);
313:   PetscDSPackageInitialized = PETSC_FALSE;
314:   PetscDSRegisterAllCalled  = PETSC_FALSE;
315:   return 0;
316: }

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

323:   Level: developer

325: .seealso: PetscInitialize()
326: @*/
327: PetscErrorCode PetscDSInitializePackage(void)
328: {
329:   char           logList[256];
330:   PetscBool      opt,pkg;

332:   if (PetscDSPackageInitialized) return 0;
333:   PetscDSPackageInitialized = PETSC_TRUE;

335:   /* Register Classes */
336:   PetscClassIdRegister("Discrete System", &PETSCDS_CLASSID);
337:   PetscClassIdRegister("Weak Form",       &PETSCWEAKFORM_CLASSID);
338:   /* Register Constructors */
339:   PetscDSRegisterAll();
340:   /* Register Events */
341:   /* Process Info */
342:   {
343:     PetscClassId  classids[1];

345:     classids[0] = PETSCDS_CLASSID;
346:     PetscInfoProcessClass("ds", 1, classids);
347:   }
348:   /* Process summary exclusions */
349:   PetscOptionsGetString(NULL,NULL,"-log_exclude",logList,sizeof(logList),&opt);
350:   if (opt) {
351:     PetscStrInList("ds",logList,',',&pkg);
352:     if (pkg) PetscLogEventExcludeClass(PETSCDS_CLASSID);
353:   }
354:   /* Register package finalizer */
355:   PetscRegisterFinalize(PetscDSFinalizePackage);
356:   return 0;
357: }

359: #if defined(PETSC_HAVE_DYNAMIC_LIBRARIES)
360: /*
361:   PetscDLLibraryRegister - This function is called when the dynamic library it is in is opened.

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

366: */
367: PETSC_EXTERN PetscErrorCode PetscDLLibraryRegister_petscdm(void)
368: {
369:   AOInitializePackage();
370:   PetscPartitionerInitializePackage();
371:   DMInitializePackage();
372:   PetscFEInitializePackage();
373:   PetscFVInitializePackage();
374:   DMFieldInitializePackage();
375:   return 0;
376: }

378: #endif /* PETSC_HAVE_DYNAMIC_LIBRARIES */