Actual source code: dlregisdmdm.c
petsc-3.7.1 2016-05-15
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_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_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_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_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 */