Actual source code: dlregisdmdm.c

petsc-dev 2014-02-02
Report Typos and Errors
  2: #include <petsc-private/dmdaimpl.h>
  3: #include <petsc-private/dmpleximpl.h>

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

 12:   Level: developer

 14: .keywords: AO, initialize, package
 15: .seealso: PetscInitialize()
 16: @*/
 17: PetscErrorCode  DMFinalizePackage(void)
 18: {

 22:   PetscFunctionListDestroy(&DMList);
 23:   DMPackageInitialized = PETSC_FALSE;
 24:   DMRegisterAllCalled  = PETSC_FALSE;
 25:   return(0);
 26: }

 28: #if defined(PETSC_HAVE_HYPRE)
 29: PETSC_EXTERN PetscErrorCode MatCreate_HYPREStruct(Mat);
 30: #endif

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

 39:   Level: developer

 41: .keywords: AO, initialize, package
 42: .seealso: PetscInitialize()
 43: @*/
 44: PetscErrorCode  DMInitializePackage(void)
 45: {
 46:   char           logList[256];
 47:   char           *className;
 48:   PetscBool      opt;

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

 55:   /* Register Classes */
 56:   PetscClassIdRegister("Distributed Mesh",&DM_CLASSID);

 58: #if defined(PETSC_HAVE_HYPRE)
 59:   MatRegister(MATHYPRESTRUCT, MatCreate_HYPREStruct);
 60: #endif

 62:   /* Register Constructors */
 63:   DMRegisterAll();
 64:   /* Register Events */
 65:   PetscLogEventRegister("DMConvert",              DM_CLASSID,&DM_Convert);
 66:   PetscLogEventRegister("DMGlobalToLocal",        DM_CLASSID,&DM_GlobalToLocal);
 67:   PetscLogEventRegister("DMLocalToGlobal",        DM_CLASSID,&DM_LocalToGlobal);

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

 71:   PetscLogEventRegister("DMPlexInterpolate",      DM_CLASSID,&DMPLEX_Interpolate);
 72:   PetscLogEventRegister("DMPlexPartition",        DM_CLASSID,&DMPLEX_Partition);
 73:   PetscLogEventRegister("DMPlexDistribute",       DM_CLASSID,&DMPLEX_Distribute);
 74:   PetscLogEventRegister("DMPlexDistribCones",     DM_CLASSID,&DMPLEX_DistributeCones);
 75:   PetscLogEventRegister("DMPlexDistribLabels",    DM_CLASSID,&DMPLEX_DistributeLabels);
 76:   PetscLogEventRegister("DMPlexDistribSF",        DM_CLASSID,&DMPLEX_DistributeSF);
 77:   PetscLogEventRegister("DMPlexDistribField",     DM_CLASSID,&DMPLEX_DistributeField);
 78:   PetscLogEventRegister("DMPlexDistribData",      DM_CLASSID,&DMPLEX_DistributeData);
 79:   PetscLogEventRegister("DMPlexStratify",         DM_CLASSID,&DMPLEX_Stratify);
 80:   PetscLogEventRegister("DMPlexPreallocate",      DM_CLASSID,&DMPLEX_Preallocate);
 81:   PetscLogEventRegister("DMPlexResidualFEM",      DM_CLASSID,&DMPLEX_ResidualFEM);
 82:   PetscLogEventRegister("DMPlexJacobianFEM",      DM_CLASSID,&DMPLEX_JacobianFEM);
 83:   /* Process info exclusions */
 84:   PetscOptionsGetString(NULL, "-info_exclude", logList, 256, &opt);
 85:   if (opt) {
 86:     PetscStrstr(logList, "da", &className);
 87:     if (className) {
 88:       PetscInfoDeactivateClass(DM_CLASSID);
 89:     }
 90:   }
 91:   /* Process summary exclusions */
 92:   PetscOptionsGetString(NULL, "-log_summary_exclude", logList, 256, &opt);
 93:   if (opt) {
 94:     PetscStrstr(logList, "da", &className);
 95:     if (className) {
 96:       PetscLogEventDeactivateClass(DM_CLASSID);
 97:     }
 98:   }
 99:   PetscRegisterFinalize(DMFinalizePackage);
100:   return(0);
101: }
102: #include <petscfe.h>

104: static PetscBool PetscFEPackageInitialized = PETSC_FALSE;
107: /*@C
108:   PetscFEFinalizePackage - This function finalizes everything in the PetscFE package. It is called
109:   from PetscFinalize().

111:   Level: developer

113: .keywords: PetscFE, initialize, package
114: .seealso: PetscInitialize()
115: @*/
116: PetscErrorCode PetscFEFinalizePackage(void)
117: {

121:   PetscFunctionListDestroy(&PetscSpaceList);
122:   PetscFunctionListDestroy(&PetscDualSpaceList);
123:   PetscFunctionListDestroy(&PetscFEList);
124:   PetscFEPackageInitialized       = PETSC_FALSE;
125:   PetscSpaceRegisterAllCalled     = PETSC_FALSE;
126:   PetscDualSpaceRegisterAllCalled = PETSC_FALSE;
127:   PetscFERegisterAllCalled        = PETSC_FALSE;
128:   return(0);
129: }

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

138:   Level: developer

140: .keywords: PetscFE, initialize, package
141: .seealso: PetscInitialize()
142: @*/
143: PetscErrorCode PetscFEInitializePackage(void)
144: {
145:   char           logList[256];
146:   char          *className;
147:   PetscBool      opt;

151:   if (PetscFEPackageInitialized) return(0);
152:   PetscFEPackageInitialized = PETSC_TRUE;

154:   /* Register Classes */
155:   PetscClassIdRegister("Linear Space", &PETSCSPACE_CLASSID);
156:   PetscClassIdRegister("Dual Space",   &PETSCDUALSPACE_CLASSID);
157:   PetscClassIdRegister("FE Space",     &PETSCFE_CLASSID);

159:   /* Register Constructors */
160:   PetscSpaceRegisterAll();
161:   PetscDualSpaceRegisterAll();
162:   PetscFERegisterAll();
163:   /* Register Events */
164:   /* Process info exclusions */
165:   PetscOptionsGetString(NULL, "-info_exclude", logList, 256, &opt);
166:   if (opt) {
167:     PetscStrstr(logList, "fe", &className);
168:     if (className) {
169:       PetscInfoDeactivateClass(PETSCFE_CLASSID);
170:     }
171:   }
172:   /* Process summary exclusions */
173:   PetscOptionsGetString(NULL, "-log_summary_exclude", logList, 256, &opt);
174:   if (opt) {
175:     PetscStrstr(logList, "da", &className);
176:     if (className) {
177:       PetscLogEventDeactivateClass(DM_CLASSID);
178:     }
179:   }
180:   PetscRegisterFinalize(PetscFEFinalizePackage);
181:   return(0);
182: }

184: #if defined(PETSC_HAVE_DYNAMIC_LIBRARIES)
187: /*
188:   PetscDLLibraryRegister - This function is called when the dynamic library it is in is opened.

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

193: */
194: PETSC_EXTERN PetscErrorCode PetscDLLibraryRegister_petscdm(void)
195: {

199:   AOInitializePackage();
200:   DMInitializePackage();
201:   PetscFEInitializePackage();
202:   return(0);
203: }

205: #endif /* PETSC_HAVE_DYNAMIC_LIBRARIES */