Actual source code: dlregisdmdm.c

petsc-3.7.0 2016-04-25
Report Typos and Errors
  2: #include <petsc/private/dmdaimpl.h>
  3: #include <petsc/private/dmpleximpl.h>
  4: #include <petsc/private/petscdsimpl.h>
  5: #include <petsc/private/petscfeimpl.h>
  6: #include <petsc/private/petscfvimpl.h>

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

 15:   Level: developer

 17: .keywords: AO, initialize, package
 18: .seealso: PetscInitialize()
 19: @*/
 20: PetscErrorCode  DMFinalizePackage(void)
 21: {

 25:   PetscFunctionListDestroy(&PetscPartitionerList);
 26:   PetscFunctionListDestroy(&DMList);
 27:   DMPackageInitialized = PETSC_FALSE;
 28:   DMRegisterAllCalled  = PETSC_FALSE;
 29:   PetscPartitionerRegisterAllCalled = PETSC_FALSE;
 30:   return(0);
 31: }

 33: #if defined(PETSC_HAVE_HYPRE)
 34: PETSC_EXTERN PetscErrorCode MatCreate_HYPREStruct(Mat);
 35: #endif

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

 44:   Level: developer

 46: .keywords: AO, initialize, package
 47: .seealso: PetscInitialize()
 48: @*/
 49: PetscErrorCode  DMInitializePackage(void)
 50: {
 51:   char           logList[256];
 52:   char           *className;
 53:   PetscBool      opt;

 57:   if (DMPackageInitialized) return(0);
 58:   DMPackageInitialized = PETSC_TRUE;

 60:   /* Register Classes */
 61:   PetscClassIdRegister("Distributed Mesh",&DM_CLASSID);
 62:   PetscClassIdRegister("GraphPartitioner",&PETSCPARTITIONER_CLASSID);

 64: #if defined(PETSC_HAVE_HYPRE)
 65:   MatRegister(MATHYPRESTRUCT, MatCreate_HYPREStruct);
 66: #endif

 68:   /* Register Constructors */
 69:   DMRegisterAll();
 70:   /* Register Events */
 71:   PetscLogEventRegister("DMConvert",              DM_CLASSID,&DM_Convert);
 72:   PetscLogEventRegister("DMGlobalToLocal",        DM_CLASSID,&DM_GlobalToLocal);
 73:   PetscLogEventRegister("DMLocalToGlobal",        DM_CLASSID,&DM_LocalToGlobal);
 74:   PetscLogEventRegister("DMLocatePoints",         DM_CLASSID,&DM_LocatePoints);
 75:   PetscLogEventRegister("DMCoarsen",              DM_CLASSID,&DM_Coarsen);
 76:   PetscLogEventRegister("DMCreateInterp",         DM_CLASSID,&DM_CreateInterpolation);
 77:   PetscLogEventRegister("DMCreateRestrict",       DM_CLASSID,&DM_CreateRestriction);

 79:   PetscLogEventRegister("DMDALocalADFunc",        DM_CLASSID,&DMDA_LocalADFunction);

 81:   PetscLogEventRegister("Mesh Partition",         PETSCPARTITIONER_CLASSID,&PETSCPARTITIONER_Partition);
 82:   PetscLogEventRegister("Mesh Migration",         DM_CLASSID,&DMPLEX_Migrate);
 83:   PetscLogEventRegister("DMPlexInterp",           DM_CLASSID,&DMPLEX_Interpolate);
 84:   PetscLogEventRegister("DMPlexDistribute",       DM_CLASSID,&DMPLEX_Distribute);
 85:   PetscLogEventRegister("DMPlexDistCones",        DM_CLASSID,&DMPLEX_DistributeCones);
 86:   PetscLogEventRegister("DMPlexDistLabels",       DM_CLASSID,&DMPLEX_DistributeLabels);
 87:   PetscLogEventRegister("DMPlexDistribSF",        DM_CLASSID,&DMPLEX_DistributeSF);
 88:   PetscLogEventRegister("DMPlexDistribOL",        DM_CLASSID,&DMPLEX_DistributeOverlap);
 89:   PetscLogEventRegister("DMPlexDistField",        DM_CLASSID,&DMPLEX_DistributeField);
 90:   PetscLogEventRegister("DMPlexDistData",         DM_CLASSID,&DMPLEX_DistributeData);
 91:   PetscLogEventRegister("DMPlexGToNBegin",        DM_CLASSID,&DMPLEX_GlobalToNaturalBegin);
 92:   PetscLogEventRegister("DMPlexGToNEnd",          DM_CLASSID,&DMPLEX_GlobalToNaturalEnd);
 93:   PetscLogEventRegister("DMPlexNToGBegin",        DM_CLASSID,&DMPLEX_NaturalToGlobalBegin);
 94:   PetscLogEventRegister("DMPlexNToGEnd",          DM_CLASSID,&DMPLEX_NaturalToGlobalEnd);
 95:   PetscLogEventRegister("DMPlexStratify",         DM_CLASSID,&DMPLEX_Stratify);
 96:   PetscLogEventRegister("DMPlexPrealloc",         DM_CLASSID,&DMPLEX_Preallocate);
 97:   PetscLogEventRegister("DMPlexResidualFE",       DM_CLASSID,&DMPLEX_ResidualFEM);
 98:   PetscLogEventRegister("DMPlexJacobianFE",       DM_CLASSID,&DMPLEX_JacobianFEM);
 99:   PetscLogEventRegister("DMPlexInterpFE",         DM_CLASSID,&DMPLEX_InterpolatorFEM);
100:   PetscLogEventRegister("DMPlexInjectorFE",       DM_CLASSID,&DMPLEX_InjectorFEM);
101:   PetscLogEventRegister("DMPlexIntegralFEM",      DM_CLASSID,&DMPLEX_IntegralFEM);
102:   PetscLogEventRegister("DMPlexCreateGmsh",       DM_CLASSID,&DMPLEX_CreateGmsh);
103:   /* Process info exclusions */
104:   PetscOptionsGetString(NULL,NULL, "-info_exclude", logList, 256, &opt);
105:   if (opt) {
106:     PetscStrstr(logList, "da", &className);
107:     if (className) {
108:       PetscInfoDeactivateClass(DM_CLASSID);
109:     }
110:   }
111:   /* Process summary exclusions */
112:   PetscOptionsGetString(NULL,NULL, "-log_summary_exclude", logList, 256, &opt);
113:   if (opt) {
114:     PetscStrstr(logList, "da", &className);
115:     if (className) {
116:       PetscLogEventDeactivateClass(DM_CLASSID);
117:     }
118:   }
119:   PetscRegisterFinalize(DMFinalizePackage);
120:   return(0);
121: }
122: #include <petscfe.h>

124: static PetscBool PetscFEPackageInitialized = PETSC_FALSE;
127: /*@C
128:   PetscFEFinalizePackage - This function finalizes everything in the PetscFE package. It is called
129:   from PetscFinalize().

131:   Level: developer

133: .keywords: PetscFE, initialize, package
134: .seealso: PetscInitialize()
135: @*/
136: PetscErrorCode PetscFEFinalizePackage(void)
137: {

141:   PetscFunctionListDestroy(&PetscSpaceList);
142:   PetscFunctionListDestroy(&PetscDualSpaceList);
143:   PetscFunctionListDestroy(&PetscFEList);
144:   PetscFEPackageInitialized       = PETSC_FALSE;
145:   PetscSpaceRegisterAllCalled     = PETSC_FALSE;
146:   PetscDualSpaceRegisterAllCalled = PETSC_FALSE;
147:   PetscFERegisterAllCalled        = PETSC_FALSE;
148:   return(0);
149: }

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

158:   Level: developer

160: .keywords: PetscFE, initialize, package
161: .seealso: PetscInitialize()
162: @*/
163: PetscErrorCode PetscFEInitializePackage(void)
164: {
165:   char           logList[256];
166:   char          *className;
167:   PetscBool      opt;

171:   if (PetscFEPackageInitialized) return(0);
172:   PetscFEPackageInitialized = PETSC_TRUE;

174:   /* Register Classes */
175:   PetscClassIdRegister("Linear Space", &PETSCSPACE_CLASSID);
176:   PetscClassIdRegister("Dual Space",   &PETSCDUALSPACE_CLASSID);
177:   PetscClassIdRegister("FE Space",     &PETSCFE_CLASSID);

179:   /* Register Constructors */
180:   PetscSpaceRegisterAll();
181:   PetscDualSpaceRegisterAll();
182:   PetscFERegisterAll();
183:   /* Register Events */
184:   /* Process info exclusions */
185:   PetscOptionsGetString(NULL,NULL, "-info_exclude", logList, 256, &opt);
186:   if (opt) {
187:     PetscStrstr(logList, "fe", &className);
188:     if (className) {PetscInfoDeactivateClass(PETSCFE_CLASSID);}
189:   }
190:   /* Process summary exclusions */
191:   PetscOptionsGetString(NULL,NULL, "-log_summary_exclude", logList, 256, &opt);
192:   if (opt) {
193:     PetscStrstr(logList, "fe", &className);
194:     if (className) {PetscLogEventDeactivateClass(PETSCFE_CLASSID);}
195:   }
196:   PetscRegisterFinalize(PetscFEFinalizePackage);
197:   return(0);
198: }
199: #include <petscfv.h>

201: static PetscBool PetscFVPackageInitialized = PETSC_FALSE;
204: /*@C
205:   PetscFVFinalizePackage - This function finalizes everything in the PetscFV package. It is called
206:   from PetscFinalize().

208:   Level: developer

210: .keywords: PetscFV, initialize, package
211: .seealso: PetscInitialize()
212: @*/
213: PetscErrorCode PetscFVFinalizePackage(void)
214: {

218:   PetscFunctionListDestroy(&PetscLimiterList);
219:   PetscFunctionListDestroy(&PetscFVList);
220:   PetscFVPackageInitialized     = PETSC_FALSE;
221:   PetscFVRegisterAllCalled      = PETSC_FALSE;
222:   PetscLimiterRegisterAllCalled = PETSC_FALSE;
223:   return(0);
224: }

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

233:   Level: developer

235: .keywords: PetscFV, initialize, package
236: .seealso: PetscInitialize()
237: @*/
238: PetscErrorCode PetscFVInitializePackage(void)
239: {
240:   char           logList[256];
241:   char          *className;
242:   PetscBool      opt;

246:   if (PetscFVPackageInitialized) return(0);
247:   PetscFVPackageInitialized = PETSC_TRUE;

249:   /* Register Classes */
250:   PetscClassIdRegister("FV Space", &PETSCFV_CLASSID);
251:   PetscClassIdRegister("Limiter",  &PETSCLIMITER_CLASSID);

253:   /* Register Constructors */
254:   PetscFVRegisterAll();
255:   /* Register Events */
256:   /* Process info exclusions */
257:   PetscOptionsGetString(NULL,NULL, "-info_exclude", logList, 256, &opt);
258:   if (opt) {
259:     PetscStrstr(logList, "fv", &className);
260:     if (className) {PetscInfoDeactivateClass(PETSCFV_CLASSID);}
261:     PetscStrstr(logList, "limiter", &className);
262:     if (className) {PetscInfoDeactivateClass(PETSCLIMITER_CLASSID);}
263:   }
264:   /* Process summary exclusions */
265:   PetscOptionsGetString(NULL,NULL, "-log_summary_exclude", logList, 256, &opt);
266:   if (opt) {
267:     PetscStrstr(logList, "fv", &className);
268:     if (className) {PetscLogEventDeactivateClass(PETSCFV_CLASSID);}
269:     PetscStrstr(logList, "limiter", &className);
270:     if (className) {PetscLogEventDeactivateClass(PETSCLIMITER_CLASSID);}
271:   }
272:   PetscRegisterFinalize(PetscFVFinalizePackage);
273:   return(0);
274: }
275: #include <petscds.h>

277: static PetscBool PetscDSPackageInitialized = PETSC_FALSE;
280: /*@C
281:   PetscDSFinalizePackage - This function finalizes everything in the PetscDS package. It is called
282:   from PetscFinalize().

284:   Level: developer

286: .keywords: PetscDS, initialize, package
287: .seealso: PetscInitialize()
288: @*/
289: PetscErrorCode PetscDSFinalizePackage(void)
290: {

294:   PetscFunctionListDestroy(&PetscDSList);
295:   PetscDSPackageInitialized = PETSC_FALSE;
296:   PetscDSRegisterAllCalled  = PETSC_FALSE;
297:   return(0);
298: }

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

307:   Level: developer

309: .keywords: PetscDS, initialize, package
310: .seealso: PetscInitialize()
311: @*/
312: PetscErrorCode PetscDSInitializePackage(void)
313: {
314:   char           logList[256];
315:   char          *className;
316:   PetscBool      opt;

320:   if (PetscDSPackageInitialized) return(0);
321:   PetscDSPackageInitialized = PETSC_TRUE;

323:   /* Register Classes */
324:   PetscClassIdRegister("Discrete System", &PETSCDS_CLASSID);

326:   /* Register Constructors */
327:   PetscDSRegisterAll();
328:   /* Register Events */
329:   /* Process info exclusions */
330:   PetscOptionsGetString(NULL,NULL, "-info_exclude", logList, 256, &opt);
331:   if (opt) {
332:     PetscStrstr(logList, "ds", &className);
333:     if (className) {PetscInfoDeactivateClass(PETSCDS_CLASSID);}
334:   }
335:   /* Process summary exclusions */
336:   PetscOptionsGetString(NULL,NULL, "-log_summary_exclude", logList, 256, &opt);
337:   if (opt) {
338:     PetscStrstr(logList, "ds", &className);
339:     if (className) {PetscLogEventDeactivateClass(PETSCDS_CLASSID);}
340:   }
341:   PetscRegisterFinalize(PetscDSFinalizePackage);
342:   return(0);
343: }

345: #if defined(PETSC_HAVE_DYNAMIC_LIBRARIES)
348: /*
349:   PetscDLLibraryRegister - This function is called when the dynamic library it is in is opened.

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

354: */
355: PETSC_EXTERN PetscErrorCode PetscDLLibraryRegister_petscdm(void)
356: {

360:   AOInitializePackage();
361:   DMInitializePackage();
362:   PetscFEInitializePackage();
363:   PetscFVInitializePackage();
364:   return(0);
365: }

367: #endif /* PETSC_HAVE_DYNAMIC_LIBRARIES */