Actual source code: dlregisdmdm.c

petsc-master 2020-09-26
Report Typos and Errors

  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/petscdsimpl.h>
  7: #include <petsc/private/petscfeimpl.h>
  8: #include <petsc/private/petscfvimpl.h>
  9: #include <petsc/private/dmswarmimpl.h>

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

 16:   Level: developer

 18: .seealso: PetscInitialize()
 19: @*/
 20: PetscErrorCode  DMFinalizePackage(void)
 21: {

 25:   PetscFunctionListDestroy(&DMList);
 26:   DMPackageInitialized = PETSC_FALSE;
 27:   DMRegisterAllCalled  = PETSC_FALSE;
 28:   return(0);
 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;

 52:   if (DMPackageInitialized) return(0);
 53:   DMPackageInitialized = PETSC_TRUE;

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

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

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

 81:   PetscLogEventRegister("DMPlexBuFrCeLi",         DM_CLASSID,&DMPLEX_BuildFromCellList);
 82:   PetscLogEventRegister("DMPlexBuCoFrCeLi",       DM_CLASSID,&DMPLEX_BuildCoordinatesFromCellList);
 83:   PetscLogEventRegister("DMPlexCreateGmsh",       DM_CLASSID,&DMPLEX_CreateGmsh);
 84:   PetscLogEventRegister("DMPlexCrFromFile",       DM_CLASSID,&DMPLEX_CreateFromFile);
 85:   PetscLogEventRegister("Mesh Partition",         DM_CLASSID,&DMPLEX_Partition);
 86:   PetscLogEventRegister("Mesh Migration",         DM_CLASSID,&DMPLEX_Migrate);
 87:   PetscLogEventRegister("DMPlexPartSelf",         DM_CLASSID,&DMPLEX_PartSelf);
 88:   PetscLogEventRegister("DMPlexPartLblInv",       DM_CLASSID,&DMPLEX_PartLabelInvert);
 89:   PetscLogEventRegister("DMPlexPartLblSF",        DM_CLASSID,&DMPLEX_PartLabelCreateSF);
 90:   PetscLogEventRegister("DMPlexPartStrtSF",       DM_CLASSID,&DMPLEX_PartStratSF);
 91:   PetscLogEventRegister("DMPlexPointSF",          DM_CLASSID,&DMPLEX_CreatePointSF);
 92:   PetscLogEventRegister("DMPlexInterp",           DM_CLASSID,&DMPLEX_Interpolate);
 93:   PetscLogEventRegister("DMPlexDistribute",       DM_CLASSID,&DMPLEX_Distribute);
 94:   PetscLogEventRegister("DMPlexDistCones",        DM_CLASSID,&DMPLEX_DistributeCones);
 95:   PetscLogEventRegister("DMPlexDistLabels",       DM_CLASSID,&DMPLEX_DistributeLabels);
 96:   PetscLogEventRegister("DMPlexDistSF",           DM_CLASSID,&DMPLEX_DistributeSF);
 97:   PetscLogEventRegister("DMPlexDistOvrlp",        DM_CLASSID,&DMPLEX_DistributeOverlap);
 98:   PetscLogEventRegister("DMPlexDistField",        DM_CLASSID,&DMPLEX_DistributeField);
 99:   PetscLogEventRegister("DMPlexDistData",         DM_CLASSID,&DMPLEX_DistributeData);
100:   PetscLogEventRegister("DMPlexInterpSF",         DM_CLASSID,&DMPLEX_InterpolateSF);
101:   PetscLogEventRegister("DMPlexGToNBegin",        DM_CLASSID,&DMPLEX_GlobalToNaturalBegin);
102:   PetscLogEventRegister("DMPlexGToNEnd",          DM_CLASSID,&DMPLEX_GlobalToNaturalEnd);
103:   PetscLogEventRegister("DMPlexNToGBegin",        DM_CLASSID,&DMPLEX_NaturalToGlobalBegin);
104:   PetscLogEventRegister("DMPlexNToGEnd",          DM_CLASSID,&DMPLEX_NaturalToGlobalEnd);
105:   PetscLogEventRegister("DMPlexStratify",         DM_CLASSID,&DMPLEX_Stratify);
106:   PetscLogEventRegister("DMPlexSymmetrize",       DM_CLASSID,&DMPLEX_Symmetrize);
107:   PetscLogEventRegister("DMPlexPrealloc",         DM_CLASSID,&DMPLEX_Preallocate);
108:   PetscLogEventRegister("DMPlexResidualFE",       DM_CLASSID,&DMPLEX_ResidualFEM);
109:   PetscLogEventRegister("DMPlexJacobianFE",       DM_CLASSID,&DMPLEX_JacobianFEM);
110:   PetscLogEventRegister("DMPlexInterpFE",         DM_CLASSID,&DMPLEX_InterpolatorFEM);
111:   PetscLogEventRegister("DMPlexInjectorFE",       DM_CLASSID,&DMPLEX_InjectorFEM);
112:   PetscLogEventRegister("DMPlexIntegralFEM",      DM_CLASSID,&DMPLEX_IntegralFEM);
113:   PetscLogEventRegister("DMPlexRebalance",        DM_CLASSID,&DMPLEX_RebalanceSharedPoints);
114:   PetscLogEventRegister("DMPlexLocatePoints",     DM_CLASSID,&DMPLEX_LocatePoints);

116:   PetscLogEventRegister("DMSwarmMigrate",         DM_CLASSID,&DMSWARM_Migrate);
117:   PetscLogEventRegister("DMSwarmDETSetup",        DM_CLASSID,&DMSWARM_DataExchangerTopologySetup);
118:   PetscLogEventRegister("DMSwarmDExBegin",        DM_CLASSID,&DMSWARM_DataExchangerBegin);
119:   PetscLogEventRegister("DMSwarmDExEnd",          DM_CLASSID,&DMSWARM_DataExchangerEnd);
120:   PetscLogEventRegister("DMSwarmDESendCnt",       DM_CLASSID,&DMSWARM_DataExchangerSendCount);
121:   PetscLogEventRegister("DMSwarmDEPack",          DM_CLASSID,&DMSWARM_DataExchangerPack);
122:   PetscLogEventRegister("DMSwarmAddPnts",         DM_CLASSID,&DMSWARM_AddPoints);
123:   PetscLogEventRegister("DMSwarmRmvPnts",         DM_CLASSID,&DMSWARM_RemovePoints);
124:   PetscLogEventRegister("DMSwarmSort",            DM_CLASSID,&DMSWARM_Sort);
125:   PetscLogEventRegister("DMSwarmSetSizes",        DM_CLASSID,&DMSWARM_SetSizes);
126:   /* Process Info */
127:   {
128:     PetscClassId  classids[1];

130:     classids[0] = DM_CLASSID;
131:     PetscInfoProcessClass("dm", 1, classids);
132:   }

134:   /* Process summary exclusions */
135:   PetscOptionsGetString(NULL,NULL,"-log_exclude",logList,sizeof(logList),&opt);
136:   if (opt) {
137:     PetscStrInList("dm",logList,',',&pkg);
138:     if (pkg) {PetscLogEventExcludeClass(DM_CLASSID);}
139:   }

141:   DMPlexGenerateRegisterAll();
142:   PetscRegisterFinalize(DMPlexGenerateRegisterDestroy);
143:   PetscRegisterFinalize(DMFinalizePackage);
144:   return(0);
145: }
146: #include <petscfe.h>

148: static PetscBool PetscFEPackageInitialized = PETSC_FALSE;
149: /*@C
150:   PetscFEFinalizePackage - This function finalizes everything in the PetscFE package. It is called
151:   from PetscFinalize().

153:   Level: developer

155: .seealso: PetscInitialize()
156: @*/
157: PetscErrorCode PetscFEFinalizePackage(void)
158: {

162:   PetscFunctionListDestroy(&PetscSpaceList);
163:   PetscFunctionListDestroy(&PetscDualSpaceList);
164:   PetscFunctionListDestroy(&PetscFEList);
165:   PetscFEPackageInitialized       = PETSC_FALSE;
166:   PetscSpaceRegisterAllCalled     = PETSC_FALSE;
167:   PetscDualSpaceRegisterAllCalled = PETSC_FALSE;
168:   PetscFERegisterAllCalled        = PETSC_FALSE;
169:   return(0);
170: }

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

177:   Level: developer

179: .seealso: PetscInitialize()
180: @*/
181: PetscErrorCode PetscFEInitializePackage(void)
182: {
183:   char           logList[256];
184:   PetscBool      opt,pkg;

188:   if (PetscFEPackageInitialized) return(0);
189:   PetscFEPackageInitialized = PETSC_TRUE;

191:   /* Register Classes */
192:   PetscClassIdRegister("Linear Space", &PETSCSPACE_CLASSID);
193:   PetscClassIdRegister("Dual Space",   &PETSCDUALSPACE_CLASSID);
194:   PetscClassIdRegister("FE Space",     &PETSCFE_CLASSID);
195:   /* Register Constructors */
196:   PetscSpaceRegisterAll();
197:   PetscDualSpaceRegisterAll();
198:   PetscFERegisterAll();
199:   /* Register Events */
200:   PetscLogEventRegister("DualSpaceSetUp", PETSCDUALSPACE_CLASSID, &PETSCDUALSPACE_SetUp);
201:   PetscLogEventRegister("FESetUp",        PETSCFE_CLASSID,        &PETSCFE_SetUp);
202:   /* Process Info */
203:   {
204:     PetscClassId  classids[3];

206:     classids[0] = PETSCFE_CLASSID;
207:     classids[1] = PETSCSPACE_CLASSID;
208:     classids[2] = PETSCDUALSPACE_CLASSID;
209:     PetscInfoProcessClass("fe", 1, classids);
210:     PetscInfoProcessClass("space", 1, &classids[1]);
211:     PetscInfoProcessClass("dualspace", 1, &classids[2]);
212:   }
213:   /* Process summary exclusions */
214:   PetscOptionsGetString(NULL,NULL,"-log_exclude",logList,sizeof(logList),&opt);
215:   if (opt) {
216:     PetscStrInList("fe",logList,',',&pkg);
217:     if (pkg) {PetscLogEventExcludeClass(PETSCFE_CLASSID);}
218:   }
219:   /* Register package finalizer */
220:   PetscRegisterFinalize(PetscFEFinalizePackage);
221:   return(0);
222: }
223: #include <petscfv.h>

225: static PetscBool PetscFVPackageInitialized = PETSC_FALSE;
226: /*@C
227:   PetscFVFinalizePackage - This function finalizes everything in the PetscFV package. It is called
228:   from PetscFinalize().

230:   Level: developer

232: .seealso: PetscInitialize()
233: @*/
234: PetscErrorCode PetscFVFinalizePackage(void)
235: {

239:   PetscFunctionListDestroy(&PetscLimiterList);
240:   PetscFunctionListDestroy(&PetscFVList);
241:   PetscFVPackageInitialized     = PETSC_FALSE;
242:   PetscFVRegisterAllCalled      = PETSC_FALSE;
243:   PetscLimiterRegisterAllCalled = PETSC_FALSE;
244:   return(0);
245: }

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

252:   Level: developer

254: .seealso: PetscInitialize()
255: @*/
256: PetscErrorCode PetscFVInitializePackage(void)
257: {
258:   char           logList[256];
259:   PetscBool      opt,pkg;

263:   if (PetscFVPackageInitialized) return(0);
264:   PetscFVPackageInitialized = PETSC_TRUE;

266:   /* Register Classes */
267:   PetscClassIdRegister("FV Space", &PETSCFV_CLASSID);
268:   PetscClassIdRegister("Limiter",  &PETSCLIMITER_CLASSID);
269:   /* Register Constructors */
270:   PetscFVRegisterAll();
271:   /* Register Events */
272:   /* Process Info */
273:   {
274:     PetscClassId  classids[2];

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

295: static PetscBool PetscDSPackageInitialized = PETSC_FALSE;
296: /*@C
297:   PetscDSFinalizePackage - This function finalizes everything in the PetscDS package. It is called
298:   from PetscFinalize().

300:   Level: developer

302: .seealso: PetscInitialize()
303: @*/
304: PetscErrorCode PetscDSFinalizePackage(void)
305: {

309:   PetscFunctionListDestroy(&PetscDSList);
310:   PetscDSPackageInitialized = PETSC_FALSE;
311:   PetscDSRegisterAllCalled  = PETSC_FALSE;
312:   return(0);
313: }

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

320:   Level: developer

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

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

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

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

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

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

364: */
365: PETSC_EXTERN PetscErrorCode PetscDLLibraryRegister_petscdm(void)
366: {

370:   AOInitializePackage();
371:   PetscPartitionerInitializePackage();
372:   DMInitializePackage();
373:   PetscFEInitializePackage();
374:   PetscFVInitializePackage();
375:   DMFieldInitializePackage();
376:   return(0);
377: }

379: #endif /* PETSC_HAVE_DYNAMIC_LIBRARIES */