Actual source code: forest.c
petsc-3.7.1 2016-05-15
Report Typos and Errors

      1: #include <petsc/private/dmforestimpl.h> /*I "petscdmforest.h" I*/
      2: #include <petsc/private/dmimpl.h>       /*I "petscdm.h" I*/
      3: #include <petscsf.h>

      5: PetscBool DMForestPackageInitialized = PETSC_FALSE;

      7: typedef struct _DMForestTypeLink *DMForestTypeLink;

      9: struct _DMForestTypeLink
     10: {
     11:   char *name;
     12:   DMForestTypeLink next;
     13: };

     15: DMForestTypeLink DMForestTypeList;

     19: static PetscErrorCode DMForestPackageFinalize(void)
     20: {
     21:   DMForestTypeLink oldLink, link = DMForestTypeList;

     25:   while (link) {
     26:     oldLink = link;
     27:     PetscFree(oldLink->name);
     28:     link = oldLink->next;
     29:     PetscFree(oldLink);
     30:   }
     31:   return(0);
     32: }

     36: static PetscErrorCode DMForestPackageInitialize(void)
     37: {

     41:   if (DMForestPackageInitialized) return(0);
     42:   DMForestPackageInitialized = PETSC_TRUE;
     43:   DMForestRegisterType(DMFOREST);
     44:   PetscRegisterFinalize(DMForestPackageFinalize);
     45:   return(0);
     46: }

     50: /*@C
     51:   DMForestRegisterType - Registers a DMType as a subtype of DMFOREST (so that DMIsForest() will be correct)

     53:   Not Collective

     55:   Input parameter:
     56: . name - the name of the type

     58:   Level: advanced

     60: .seealso: DMFOREST, DMIsForest()
     61: @*/
     62: PetscErrorCode DMForestRegisterType(DMType name)
     63: {
     64:   DMForestTypeLink link;

     68:   DMForestPackageInitialize();
     69:   PetscNew(&link);
     70:   PetscStrallocpy(name,&link->name);
     71:   link->next = DMForestTypeList;
     72:   DMForestTypeList = link;
     73:   return(0);
     74: }

     78: /*@
     79:   DMIsForest - Check whether a DM uses the DMFOREST interface for hierarchically-refined meshes

     81:   Not Collective

     83:   Input parameter:
     84: . dm - the DM object

     86:   Output parameter:
     87: . isForest - whether dm is a subtype of DMFOREST

     89:   Level: intermediate

     91: .seealso: DMFOREST, DMForestRegisterType()
     92: @*/
     93: PetscErrorCode DMIsForest(DM dm, PetscBool *isForest)
     94: {
     95:   DMForestTypeLink link = DMForestTypeList;

     99:   while (link) {
    100:     PetscBool sameType;
    101:     PetscObjectTypeCompare((PetscObject)dm,link->name,&sameType);
    102:     if (sameType) {
    103:       *isForest = PETSC_TRUE;
    104:       return(0);
    105:     }
    106:     link = link->next;
    107:   }
    108:   *isForest = PETSC_FALSE;
    109:   return(0);
    110: }

    114: /*@
    115:   DMForestTemplate - Create a new DM that will be adapted from a source DM.  The new DM reproduces the configuration
    116:   of the source, but is not yet setup, so that the user can then define only the ways that the new DM should differ
    117:   (by, e.g., refinement or repartitioning).  The source DM is also set as the adaptivity source DM of the new DM (see
    118:   DMForestSetAdaptivityForest()).

    120:   Collective on dm

    122:   Input Parameters:
    123: + dm - the source DM object
    124: - comm - the communicator for the new DM (this communicator is currently ignored, but is present so that DMForestTemplate() can be used within DMCoarsen())

    126:   Output Parameter:
    127: . tdm - the new DM object

    129:   Level: intermediate

    131: .seealso: DMForestSetAdaptivityForest()
    132: @*/
    133: PetscErrorCode DMForestTemplate(DM dm, MPI_Comm comm, DM *tdm)
    134: {
    135:   DM_Forest        *forest = (DM_Forest *) dm->data;
    136:   DMType           type;
    137:   DM               base;
    138:   DMForestTopology topology;
    139:   PetscInt         dim, overlap, ref, factor;
    140:   DMForestAdaptivityStrategy strat;
    141:   PetscDS          ds;
    142:   void             *ctx;
    143:   PetscErrorCode   ierr;

    147:   DMCreate(PetscObjectComm((PetscObject)dm),tdm);
    148:   DMGetType(dm,&type);
    149:   DMSetType(*tdm,type);
    150:   DMForestGetBaseDM(dm,&base);
    151:   DMForestSetBaseDM(*tdm,base);
    152:   DMForestGetTopology(dm,&topology);
    153:   DMForestSetTopology(*tdm,topology);
    154:   DMForestGetAdjacencyDimension(dm,&dim);
    155:   DMForestSetAdjacencyDimension(*tdm,dim);
    156:   DMForestGetPartitionOverlap(dm,&overlap);
    157:   DMForestSetPartitionOverlap(*tdm,overlap);
    158:   DMForestGetMinimumRefinement(dm,&ref);
    159:   DMForestSetMinimumRefinement(*tdm,ref);
    160:   DMForestGetMaximumRefinement(dm,&ref);
    161:   DMForestSetMaximumRefinement(*tdm,ref);
    162:   DMForestGetAdaptivityStrategy(dm,&strat);
    163:   DMForestSetAdaptivityStrategy(*tdm,strat);
    164:   DMForestGetGradeFactor(dm,&factor);
    165:   DMForestSetGradeFactor(*tdm,factor);
    166:   if (forest->ftemplate) {
    167:     (forest->ftemplate) (dm, *tdm);
    168:   }
    169:   DMForestSetAdaptivityForest(*tdm,dm);
    170:   DMGetDS(dm,&ds);
    171:   DMSetDS(*tdm,ds);
    172:   DMGetApplicationContext(dm,&ctx);
    173:   DMSetApplicationContext(*tdm,&ctx);
    174:   if (dm->maxCell) {
    175:     const PetscReal *maxCell, *L;
    176:     const DMBoundaryType *bd;

    178:     DMGetPeriodicity(dm,&maxCell,&L,&bd);
    179:     DMSetPeriodicity(*tdm,maxCell,L,bd);
    180:   }
    181:   return(0);
    182: }

    184: static PetscErrorCode DMInitialize_Forest(DM dm);

    188: PETSC_EXTERN PetscErrorCode DMClone_Forest(DM dm, DM *newdm)
    189: {
    190:   DM_Forest        *forest = (DM_Forest *) dm->data;
    191:   const char       *type;

    195:   forest->refct++;
    196:   (*newdm)->data = forest;
    197:   PetscObjectGetType((PetscObject) dm, &type);
    198:   PetscObjectChangeTypeName((PetscObject) *newdm, type);
    199:   DMInitialize_Forest(*newdm);
    200:   return(0);
    201: }

    205: static PetscErrorCode DMDestroy_Forest(DM dm)
    206: {
    207:   DM_Forest     *forest = (DM_Forest*) dm->data;

    211:   if (--forest->refct > 0) return(0);
    212:   if (forest->destroy) {forest->destroy(dm);}
    213:   PetscSFDestroy(&forest->cellSF);
    214:   PetscSFDestroy(&forest->preCoarseToFine);
    215:   PetscSFDestroy(&forest->coarseToPreFine);
    216:   PetscFree(forest->adaptLabel);
    217:   PetscFree(forest->adaptStrategy);
    218:   DMDestroy(&forest->base);
    219:   DMDestroy(&forest->adapt);
    220:   PetscFree(forest->topology);
    221:   PetscFree(forest);
    222:   return(0);
    223: }

    227: /*@C
    228:   DMForestSetTopology - Set the topology of a DMForest during the pre-setup phase.  The topology is a string (e.g.
    229:   "cube", "shell") and can be interpreted by subtypes of DMFOREST) to construct the base DM of a forest durint
    230:   DMSetUp().

    232:   Logically collective on dm

    234:   Input parameters:
    235: + dm - the forest
    236: - topology - the topology of the forest

    238:   Level: intermediate

    240: .seealso(): DMForestGetTopology(), DMForestSetBaseDM()
    241: @*/
    242: PetscErrorCode DMForestSetTopology(DM dm, DMForestTopology topology)
    243: {
    244:   DM_Forest      *forest = (DM_Forest *) dm->data;

    249:   if (dm->setupcalled) SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_ARG_WRONGSTATE,"Cannot change the topology after setup");
    250:   PetscFree(forest->topology);
    251:   PetscStrallocpy((const char *)topology,(char **) &forest->topology);
    252:   return(0);
    253: }

    257: /*@C
    258:   DMForestGetTopology - Get a string describing the topology of a DMForest.

    260:   Not collective

    262:   Input parameter:
    263: . dm - the forest

    265:   Output parameter:
    266: . topology - the topology of the forest (e.g., 'cube', 'shell')

    268:   Level: intermediate

    270: .seealso: DMForestSetTopology()
    271: @*/
    272: PetscErrorCode DMForestGetTopology(DM dm, DMForestTopology *topology)
    273: {
    274:   DM_Forest      *forest = (DM_Forest *) dm->data;

    279:   *topology = forest->topology;
    280:   return(0);
    281: }

    285: /*@
    286:   DMForestSetBaseDM - During the pre-setup phase, set the DM that defines the base mesh of a DMForest forest.  The
    287:   forest will be hierarchically refined from the base, and all refinements/coarsenings of the forest will share its
    288:   base.  In general, two forest must share a bse to be comparable, to do things like construct interpolators.

    290:   Logically collective on dm

    292:   Input Parameters:
    293: + dm - the forest
    294: - base - the base DM of the forest

    296:   Level: intermediate

    298: .seealso(): DMForestGetBaseDM()
    299: @*/
    300: PetscErrorCode DMForestSetBaseDM(DM dm, DM base)
    301: {
    302:   DM_Forest      *forest = (DM_Forest *) dm->data;
    303:   PetscInt       dim, dimEmbed;

    308:   if (dm->setupcalled) SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_ARG_WRONGSTATE,"Cannot change the base after setup");
    309:   PetscObjectReference((PetscObject)base);
    310:   DMDestroy(&forest->base);
    311:   forest->base = base;
    312:   if (base) {
    314:     DMGetDimension(base,&dim);
    315:     DMSetDimension(dm,dim);
    316:     DMGetCoordinateDim(base,&dimEmbed);
    317:     DMSetCoordinateDim(dm,dimEmbed);
    318:   }
    319:   return(0);
    320: }

    324: /*@
    325:   DMForestGetBaseDM - Get the base DM of a DMForest forest.  The forest will be hierarchically refined from the base,
    326:   and all refinements/coarsenings of the forest will share its base.  In general, two forest must share a bse to be
    327:   comparable, to do things like construct interpolators.

    329:   Not collective

    331:   Input Parameter:
    332: . dm - the forest

    334:   Output Parameter:
    335: . base - the base DM of the forest

    337:   Level: intermediate

    339: .seealso(); DMForestSetBaseDM()
    340: @*/
    341: PetscErrorCode DMForestGetBaseDM(DM dm, DM *base)
    342: {
    343:   DM_Forest      *forest = (DM_Forest *) dm->data;

    348:   *base = forest->base;
    349:   return(0);
    350: }

    354: /*@
    355:   DMForestSetAdaptivityForest - During the pre-setup phase, set the forest from which the current forest will be
    356:   adapted (e.g., the current forest will be refined/coarsened/repartitioned from it) im DMSetUp().  Usually not needed
    357:   by users directly: DMForestTemplate() constructs a new forest to be adapted from an old forest and calls this
    358:   routine.

    360:   Logically collective on dm

    362:   Input Parameter:
    363: + dm - the new forest, which will be constructed from adapt
    364: - adapt - the old forest

    366:   Level: intermediate

    368: .seealso: DMForestGetAdaptivityForest(), DMForestSetAdaptivityPurpose()
    369: @*/
    370: PetscErrorCode DMForestSetAdaptivityForest(DM dm,DM adapt)
    371: {
    372:   DM_Forest        *forest;
    373:   PetscErrorCode   ierr;

    378:   forest = (DM_Forest *) dm->data;
    379:   if (dm->setupcalled) SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_ARG_WRONGSTATE,"Cannot change the adaptation forest after setup");
    380:   switch (forest->adaptPurpose) {
    381:   case DM_FOREST_KEEP:
    382:     PetscObjectReference((PetscObject)adapt);
    383:     DMDestroy(&(forest->adapt));
    384:     forest->adapt = adapt;
    385:     break;
    386:   case DM_FOREST_REFINE:
    387:     DMSetCoarseDM(dm,adapt);
    388:     break;
    389:   case DM_FOREST_COARSEN:
    390:     DMSetFineDM(dm,adapt);
    391:     break;
    392:   default:
    393:     SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"invalid adaptivity purpose");
    394:   }
    395:   return(0);
    396: }

    400: /*@
    401:   DMForestGetAdaptivityForest - Get the forest from which the current forest is adapted.

    403:   Not collective

    405:   Input Parameter:
    406: . dm - the forest

    408:   Output Parameter:
    409: . adapt - the forest from which dm is/was adapted

    411:   Level: intermediate

    413: .seealso: DMForestSetAdaptivityForest(), DMForestSetAdaptivityPurpose()
    414: @*/
    415: PetscErrorCode DMForestGetAdaptivityForest(DM dm, DM *adapt)
    416: {
    417:   DM_Forest        *forest;
    418:   PetscErrorCode   ierr;

    422:   forest = (DM_Forest *) dm->data;
    423:   switch (forest->adaptPurpose) {
    424:   case DM_FOREST_KEEP:
    425:     *adapt = forest->adapt;
    426:     break;
    427:   case DM_FOREST_REFINE:
    428:     DMGetCoarseDM(dm,adapt);
    429:     break;
    430:   case DM_FOREST_COARSEN:
    431:     DMGetFineDM(dm,adapt);
    432:     break;
    433:   default:
    434:     SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"invalid adaptivity purpose");
    435:   }
    436:   return(0);
    437: }

    441: /*@
    442:   DMForestSetAdaptivityPurpose - During the pre-setup phase, set whether the current DM is being adapted from its
    443:   source (set with DMForestSetAdaptivityForest()) for the purpose of refinement (DM_FOREST_REFINE), coarsening
    444:   (DM_FOREST_COARSEN), or undefined (DM_FOREST_NONE).  This only matters for the purposes of reference counting:
    445:   during DMDestroy(), cyclic references can be found between DMs only if the cyclic reference is due to a fine/coarse
    446:   relationship (see DMSetFineDM()/DMSetCoarseDM()).  If the purpose is not refinement or coarsening, and the user does
    447:   not maintain a reference to the post-adaptation forest (i.e., the one created by DMForestTemplate()), then this can
    448:   cause a memory leak.  This method is used by subtypes of DMForest when automatically constructing mesh hierarchies.

    450:   Logically collective on dm

    452:   Input Parameters:
    453: + dm - the forest
    454: - purpose - the adaptivity purpose (DM_FOREST_NONE/DM_FOREST_REFINE/DM_FOREST_COARSEN)

    456:   Level: advanced

    458: .seealso: DMForestTemplate(), DMForestSetAdaptivityForest(), DMForestGetAdaptivityForest()
    459: @*/
    460: PetscErrorCode DMForestSetAdaptivityPurpose(DM dm, DMForestAdaptivityPurpose purpose)
    461: {
    462:   DM_Forest      *forest;

    466:   forest = (DM_Forest *) dm->data;
    467:   if (dm->setupcalled) SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_ARG_WRONGSTATE,"Cannot change the adaptation forest after setup");
    468:   if (purpose != forest->adaptPurpose) {
    469:     DM adapt;

    471:     DMForestGetAdaptivityForest(dm,&adapt);
    472:     PetscObjectReference((PetscObject)adapt);
    473:     DMForestSetAdaptivityForest(dm,NULL);
    474:     forest->adaptPurpose = purpose;
    475:     DMForestSetAdaptivityForest(dm,adapt);
    476:     DMDestroy(&adapt);
    477:   }
    478:   return(0);
    479: }

    483: /*@
    484:   DMForestGetAdaptivityPurpose - Get whether the current DM is being adapted from its source (set with
    485:   DMForestSetAdaptivityForest()) for the purpose of refinement (DM_FOREST_REFINE), coarsening (DM_FOREST_COARSEN), or
    486:   undefined (DM_FOREST_NONE).  This only matters for the purposes of reference counting: during DMDestroy(), cyclic
    487:   references can be found between DMs only if the cyclic reference is due to a fine/coarse relationship (see
    488:   DMSetFineDM()/DMSetCoarseDM()).  If the purpose is not refinement or coarsening, and the user does not maintain a
    489:   reference to the post-adaptation forest (i.e., the one created by DMForestTemplate()), then this can cause a memory
    490:   leak.  This method is used by subtypes of DMForest when automatically constructing mesh hierarchies.

    492:   Not collective

    494:   Input Parameter:
    495: . dm - the forest

    497:   Output Parameter:
    498: . purpose - the adaptivity purpose (DM_FOREST_NONE/DM_FOREST_REFINE/DM_FOREST_COARSEN)

    500:   Level: advanced

    502: .seealso: DMForestTemplate(), DMForestSetAdaptivityForest(), DMForestGetAdaptivityForest()
    503: @*/
    504: PetscErrorCode DMForestGetAdaptivityPurpose(DM dm, DMForestAdaptivityPurpose *purpose)
    505: {
    506:   DM_Forest      *forest;

    509:   forest = (DM_Forest *) dm->data;
    510:   *purpose = forest->adaptPurpose;
    511:   return(0);
    512: }

    516: /*@
    517:   DMForestSetAdjacencyDimension - During the pre-setup phase, set the dimension of interface points that determine
    518:   cell adjacency (for the purposes of partitioning and overlap).

    520:   Logically collective on dm

    522:   Input Parameters:
    523: + dm - the forest
    524: - adjDim - default 0 (i.e., vertices determine adjacency)

    526:   Level: intermediate

    528: .seealso: DMForestGetAdjacencyDimension(), DMForestSetAdjacencyCodimension(), DMForestSetPartitionOverlap()
    529: @*/
    530: PetscErrorCode DMForestSetAdjacencyDimension(DM dm, PetscInt adjDim)
    531: {
    532:   PetscInt        dim;
    533:   DM_Forest      *forest = (DM_Forest *) dm->data;
    534:   PetscErrorCode  ierr;

    538:   if (dm->setupcalled) SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_ARG_WRONGSTATE,"Cannot change the adjacency dimension after setup");
    539:   if (adjDim < 0) SETERRQ1(PetscObjectComm((PetscObject)dm),PETSC_ERR_ARG_OUTOFRANGE,"adjacency dim cannot be < 0: %d", adjDim);
    540:   DMGetDimension(dm,&dim);
    541:   if (adjDim > dim) SETERRQ2(PetscObjectComm((PetscObject)dm),PETSC_ERR_ARG_OUTOFRANGE,"adjacency dim cannot be > %d: %d", dim, adjDim);
    542:   forest->adjDim = adjDim;
    543:   return(0);
    544: }

    548: /*@
    549:   DMForestSetAdjacencyCodimension - Like DMForestSetAdjacencyDimension(), but specified as a co-dimension (so that,
    550:   e.g., adjacency based on facets can be specified by codimension 1 in all cases)

    552:   Logically collective on dm

    554:   Input Parameters:
    555: + dm - the forest
    556: - adjCodim - default isthe dimension of the forest (see DMGetDimension()), since this is the codimension of vertices

    558:   Level: intermediate

    560: .seealso: DMForestGetAdjacencyCodimension(), DMForestSetAdjacencyDimension()
    561: @*/
    562: PetscErrorCode DMForestSetAdjacencyCodimension(DM dm, PetscInt adjCodim)
    563: {
    564:   PetscInt        dim;
    565:   PetscErrorCode  ierr;

    569:   DMGetDimension(dm,&dim);
    570:   DMForestSetAdjacencyDimension(dm,dim-adjCodim);
    571:   return(0);
    572: }

    576: /*@
    577:   DMForestGetAdjacencyDimension - Get the dimension of interface points that determine cell adjacency (for the
    578:   purposes of partitioning and overlap).

    580:   Not collective

    582:   Input Parameter:
    583: . dm - the forest

    585:   Output Parameter:
    586: . adjDim - default 0 (i.e., vertices determine adjacency)

    588:   Level: intermediate

    590: .seealso: DMForestSetAdjacencyDimension(), DMForestGetAdjacencyCodimension(), DMForestSetPartitionOverlap()
    591: @*/
    592: PetscErrorCode DMForestGetAdjacencyDimension(DM dm, PetscInt *adjDim)
    593: {
    594:   DM_Forest      *forest = (DM_Forest *) dm->data;

    599:   *adjDim = forest->adjDim;
    600:   return(0);
    601: }

    605: /*@
    606:   DMForestGetAdjacencyCodimension - Like DMForestGetAdjacencyDimension(), but specified as a co-dimension (so that,
    607:   e.g., adjacency based on facets can be specified by codimension 1 in all cases)

    609:   Not collective

    611:   Input Parameter:
    612: . dm - the forest

    614:   Output Parameter:
    615: . adjCodim - default isthe dimension of the forest (see DMGetDimension()), since this is the codimension of vertices

    617:   Level: intermediate

    619: .seealso: DMForestSetAdjacencyCodimension(), DMForestGetAdjacencyDimension()
    620: @*/
    621: PetscErrorCode DMForestGetAdjacencyCodimension(DM dm, PetscInt *adjCodim)
    622: {
    623:   DM_Forest      *forest = (DM_Forest *) dm->data;
    624:   PetscInt       dim;

    630:   DMGetDimension(dm,&dim);
    631:   *adjCodim = dim - forest->adjDim;
    632:   return(0);
    633: }

    637: /*@
    638:   DMForestSetPartitionOverlap - During the pre-setup phase, set the amount of cell-overlap present in parallel
    639:   partitions of a forest, with values > 0 indicating subdomains that are expanded by that many iterations of adding
    640:   adjacent cells

    642:   Logically collective on dm

    644:   Input Parameters:
    645: + dm - the forest
    646: - overlap - default 0

    648:   Level: intermediate

    650: .seealso: DMForestGetPartitionOverlap(), DMForestSetAdjacencyDimension(), DMForestSetAdjacencyCodimension()
    651: @*/
    652: PetscErrorCode DMForestSetPartitionOverlap(DM dm, PetscInt overlap)
    653: {
    654:   DM_Forest      *forest = (DM_Forest *) dm->data;

    658:   if (dm->setupcalled) SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_ARG_WRONGSTATE,"Cannot change the overlap after setup");
    659:   if (overlap < 0) SETERRQ1(PetscObjectComm((PetscObject)dm),PETSC_ERR_ARG_OUTOFRANGE,"overlap cannot be < 0: %d", overlap);
    660:   forest->overlap = overlap;
    661:   return(0);
    662: }

    666: /*@
    667:   DMForestGetPartitionOverlap - Get the amount of cell-overlap present in parallel partitions of a forest, with values
    668:   > 0 indicating subdomains that are expanded by that many iterations of adding adjacent cells

    670:   Not collective

    672:   Input Parameter:
    673: . dm - the forest

    675:   Output Parameter:
    676: . overlap - default 0

    678:   Level: intermediate

    680: .seealso: DMForestGetPartitionOverlap(), DMForestSetAdjacencyDimension(), DMForestSetAdjacencyCodimension()
    681: @*/
    682: PetscErrorCode DMForestGetPartitionOverlap(DM dm, PetscInt *overlap)
    683: {
    684:   DM_Forest      *forest = (DM_Forest *) dm->data;

    689:   *overlap = forest->overlap;
    690:   return(0);
    691: }

    695: /*@
    696:   DMForestSetMinimumRefinement - During the pre-setup phase, set the minimum level of refinement (relative to the base
    697:   DM, see DMForestGetBaseDM()) allowed in the forest.  If the forest is being created by coarsening a previous forest
    698:   (see DMForestGetAdaptivityForest()) this limits the amount of coarsening.

    700:   Logically collective on dm

    702:   Input Parameters:
    703: + dm - the forest
    704: - minRefinement - default PETSC_DEFAULT (interpreted by the subtype of DMForest)

    706:   Level: intermediate

    708: .seealso: DMForestGetMinimumRefinement(), DMForestSetMaximumRefinement(), DMForestSetInitialRefinement(), DMForestGetBaseDM(), DMForestGetAdaptivityForest()
    709: @*/
    710: PetscErrorCode DMForestSetMinimumRefinement(DM dm, PetscInt minRefinement)
    711: {
    712:   DM_Forest      *forest = (DM_Forest *) dm->data;

    716:   if (dm->setupcalled) SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_ARG_WRONGSTATE,"Cannot change the minimum refinement after setup");
    717:   forest->minRefinement = minRefinement;
    718:   return(0);
    719: }

    723: /*@
    724:   DMForestGetMinimumRefinement - Get the minimum level of refinement (relative to the base DM, see
    725:   DMForestGetBaseDM()) allowed in the forest.  If the forest is being created by coarsening a previous forest (see
    726:   DMForestGetAdaptivityForest()), this limits the amount of coarsening.

    728:   Not collective

    730:   Input Parameter:
    731: . dm - the forest

    733:   Output Parameter:
    734: . minRefinement - default PETSC_DEFAULT (interpreted by the subtype of DMForest)

    736:   Level: intermediate

    738: .seealso: DMForestSetMinimumRefinement(), DMForestGetMaximumRefinement(), DMForestGetInitialRefinement(), DMForestGetBaseDM(), DMForestGetAdaptivityForest()
    739: @*/
    740: PetscErrorCode DMForestGetMinimumRefinement(DM dm, PetscInt *minRefinement)
    741: {
    742:   DM_Forest      *forest = (DM_Forest *) dm->data;

    747:   *minRefinement = forest->minRefinement;
    748:   return(0);
    749: }

    753: /*@
    754:   DMForestSetInitialRefinement - During the pre-setup phase, set the initial level of refinement (relative to the base
    755:   DM, see DMForestGetBaseDM()) allowed in the forest.

    757:   Logically collective on dm

    759:   Input Parameters:
    760: + dm - the forest
    761: - initefinement - default PETSC_DEFAULT (interpreted by the subtype of DMForest)

    763:   Level: intermediate

    765: .seealso: DMForestSetMinimumRefinement(), DMForestSetMaximumRefinement(), DMForestGetBaseDM()
    766: @*/
    767: PetscErrorCode DMForestSetInitialRefinement(DM dm, PetscInt initRefinement)
    768: {
    769:   DM_Forest      *forest = (DM_Forest *) dm->data;

    773:   if (dm->setupcalled) SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_ARG_WRONGSTATE,"Cannot change the initial refinement after setup");
    774:   forest->initRefinement = initRefinement;
    775:   return(0);
    776: }

    780: /*@
    781:   DMForestGetInitialRefinement - Get the initial level of refinement (relative to the base DM, see
    782:   DMForestGetBaseDM()) allowed in the forest.

    784:   Not collective

    786:   Input Parameter:
    787: . dm - the forest

    789:   Output Paramater:
    790: . initefinement - default PETSC_DEFAULT (interpreted by the subtype of DMForest)

    792:   Level: intermediate

    794: .seealso: DMForestSetMinimumRefinement(), DMForestSetMaximumRefinement(), DMForestGetBaseDM()
    795: @*/
    796: PetscErrorCode DMForestGetInitialRefinement(DM dm, PetscInt *initRefinement)
    797: {
    798:   DM_Forest      *forest = (DM_Forest *) dm->data;

    803:   *initRefinement = forest->initRefinement;
    804:   return(0);
    805: }

    809: /*@
    810:   DMForestSetMaximumRefinement - During the pre-setup phase, set the maximum level of refinement (relative to the base
    811:   DM, see DMForestGetBaseDM()) allowed in the forest.  If the forest is being created by refining a previous forest
    812:   (see DMForestGetAdaptivityForest()), this limits the amount of refinement.

    814:   Logically collective on dm

    816:   Input Parameters:
    817: + dm - the forest
    818: - maxRefinement - default PETSC_DEFAULT (interpreted by the subtype of DMForest)

    820:   Level: intermediate

    822: .seealso: DMForestGetMinimumRefinement(), DMForestSetMaximumRefinement(), DMForestSetInitialRefinement(), DMForestGetBaseDM(), DMForestGetAdaptivityDM()
    823: @*/
    824: PetscErrorCode DMForestSetMaximumRefinement(DM dm, PetscInt maxRefinement)
    825: {
    826:   DM_Forest      *forest = (DM_Forest *) dm->data;

    830:   if (dm->setupcalled) SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_ARG_WRONGSTATE,"Cannot change the maximum refinement after setup");
    831:   forest->maxRefinement = maxRefinement;
    832:   return(0);
    833: }

    837: /*@
    838:   DMForestGetMaximumRefinement - Get the maximum level of refinement (relative to the base DM, see
    839:   DMForestGetBaseDM()) allowed in the forest.  If the forest is being created by refining a previous forest (see
    840:   DMForestGetAdaptivityForest()), this limits the amount of refinement.

    842:   Not collective

    844:   Input Parameter:
    845: . dm - the forest

    847:   Output Parameter:
    848: . maxRefinement - default PETSC_DEFAULT (interpreted by the subtype of DMForest)

    850:   Level: intermediate

    852: .seealso: DMForestSetMaximumRefinement(), DMForestGetMinimumRefinement(), DMForestGetInitialRefinement(), DMForestGetBaseDM(), DMForestGetAdaptivityForest()
    853: @*/
    854: PetscErrorCode DMForestGetMaximumRefinement(DM dm, PetscInt *maxRefinement)
    855: {
    856:   DM_Forest      *forest = (DM_Forest *) dm->data;

    861:   *maxRefinement = forest->maxRefinement;
    862:   return(0);
    863: }

    867: /*@C
    868:   DMForestSetAdaptivityStrategy - During the pre-setup phase, set the strategy for combining adaptivity labels from multiple processes.
    869:   Subtypes of DMForest may define their own strategies.  Two default strategies are DMFORESTADAPTALL, which indicates that all processes must agree
    870:   for a refinement/coarsening flag to be valid, and DMFORESTADAPTANY, which indicates that only one process needs to
    871:   specify refinement/coarsening.

    873:   Logically collective on dm

    875:   Input Parameters:
    876: + dm - the forest
    877: - adaptStrategy - default DMFORESTADAPTALL

    879:   Level: advanced

    881: .seealso: DMForestGetAdaptivityStrategy()
    882: @*/
    883: PetscErrorCode DMForestSetAdaptivityStrategy(DM dm, DMForestAdaptivityStrategy adaptStrategy)
    884: {
    885:   DM_Forest      *forest = (DM_Forest *) dm->data;

    890:   PetscFree(forest->adaptStrategy);
    891:   PetscStrallocpy((const char *) adaptStrategy,(char **)&forest->adaptStrategy);
    892:   return(0);
    893: }

    897: /*@C
    898:   DMForestSetAdaptivityStrategy - Get the strategy for combining adaptivity labels from multiple processes.  Subtypes
    899:   of DMForest may define their own strategies.  Two default strategies are DMFORESTADAPTALL, which indicates that all
    900:   processes must agree for a refinement/coarsening flag to be valid, and DMFORESTADAPTANY, which indicates that only
    901:   one process needs to specify refinement/coarsening.

    903:   Not collective

    905:   Input Parameter:
    906: . dm - the forest

    908:   Output Parameter:
    909: . adaptStrategy - the adaptivity strategy (default DMFORESTADAPTALL)

    911:   Level: advanced

    913: .seealso: DMForestSetAdaptivityStrategy()
    914: @*/
    915: PetscErrorCode DMForestGetAdaptivityStrategy(DM dm, DMForestAdaptivityStrategy *adaptStrategy)
    916: {
    917:   DM_Forest      *forest = (DM_Forest *) dm->data;

    922:   *adaptStrategy = forest->adaptStrategy;
    923:   return(0);
    924: }

    928: /*@
    929:   DMForestSetComputeAdaptivitySF - During the pre-setup phase, set whether transfer PetscSFs should be computed
    930:   relating the cells of the pre-adaptation forest to the post-adaptiation forest.  After DMSetUp() is called, these transfer PetscSFs can be accessed with DMForestGetAdaptivitySF().

    932:   Logically collective on dm

    934:   Input Parameters:
    935: + dm - the post-adaptation forest
    936: - computeSF - default PETSC_TRUE

    938:   Level: advanced

    940: .seealso: DMForestGetComputeAdaptivitySF(), DMForestGetAdaptivitySF()
    941: @*/
    942: PetscErrorCode DMForestSetComputeAdaptivitySF(DM dm, PetscBool computeSF)
    943: {
    944:   DM_Forest *forest;

    948:   if (dm->setupcalled) SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_ARG_WRONGSTATE,"Cannot compute adaptivity PetscSFs after setup is called");
    949:   forest = (DM_Forest *) dm->data;
    950:   forest->computeAdaptSF = computeSF;
    951:   return(0);
    952: }

    956: /*@
    957:   DMForestGetComputeAdaptivitySF - Get whether transfer PetscSFs should be computed relating the cells of the
    958:   pre-adaptation forest to the post-adaptiation forest.  After DMSetUp() is called, these transfer PetscSFs can be
    959:   accessed with DMForestGetAdaptivitySF().

    961:   Not collective

    963:   Input Parameter:
    964: . dm - the post-adaptation forest

    966:   Output Parameter:
    967: . computeSF - default PETSC_TRUE

    969:   Level: advanced

    971: .seealso: DMForestSetComputeAdaptivitySF(), DMForestGetAdaptivitySF()
    972: @*/
    973: PetscErrorCode DMForestGetComputeAdaptivitySF(DM dm, PetscBool *computeSF)
    974: {
    975:   DM_Forest *forest;

    979:   forest = (DM_Forest *) dm->data;
    980:   *computeSF = forest->computeAdaptSF;
    981:   return(0);
    982: }

    986: /*@
    987:   DMForestGetAdaptivitySF - Get PetscSFs that relate the pre-adaptation forest to the post-adaptation forest.
    988:   Adaptation can be any combination of refinement, coarsening, repartition, and change of overlap, so there may be
    989:   some cells of the pre-adaptation that are parents of post-adaptation cells, and vice versa.  Therefore there are two
    990:   PetscSFs: one that relates pre-adaptation coarse cells to post-adaptation fine cells, and one that relates
    991:   pre-adaptation fine cells to post-adaptation coarse cells.

    993:   Not collective

    995:   Input Parameter:
    996:   dm - the post-adaptation forest

    998:   Output Parameter:
    999:   preCoarseToFine - pre-adaptation coarse cells to post-adaptation fine cells: BCast goes from pre- to post-
    1000:   coarseToPreFine - post-adaptation coarse cells to pre-adaptation fine cells: BCast goes from post- to pre-

    1002:   Level: advanced

    1004: .seealso: DMForestGetComputeAdaptivitySF(), DMForestSetComputeAdaptivitySF()
    1005: @*/
    1006: PetscErrorCode DMForestGetAdaptivitySF(DM dm, PetscSF *preCoarseToFine, PetscSF *coarseToPreFine)
    1007: {
    1008:   DM_Forest      *forest;

    1013:   DMSetUp(dm);
    1014:   forest = (DM_Forest *) dm->data;
    1015:   if (preCoarseToFine) {
    1016:     *preCoarseToFine = forest->preCoarseToFine;
    1017:   }
    1018:   if (coarseToPreFine) {
    1019:     *coarseToPreFine = forest->coarseToPreFine;
    1020:   }
    1021:   return(0);
    1022: }

    1026: /*@
    1027:   DMForestSetGradeFactor - During the pre-setup phase, set the desired amount of grading in the mesh, e.g. give 2 to
    1028:   indicate that the diameter of neighboring cells should differ by at most a factor of 2.  Subtypes of DMForest may
    1029:   only support one particular choice of grading factor.

    1031:   Logically collective on dm

    1033:   Input Parameters:
    1034: + dm - the forest
    1035: - grade - the grading factor

    1037:   Level: advanced

    1039: .seealso: DMForestGetGradeFactor()
    1040: @*/
    1041: PetscErrorCode DMForestSetGradeFactor(DM dm, PetscInt grade)
    1042: {
    1043:   DM_Forest      *forest = (DM_Forest *) dm->data;

    1047:   if (dm->setupcalled) SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_ARG_WRONGSTATE,"Cannot change the grade factor after setup");
    1048:   forest->gradeFactor = grade;
    1049:   return(0);
    1050: }

    1054: /*@
    1055:   DMForestGetGradeFactor - Get the desired amount of grading in the mesh, e.g. give 2 to indicate that the diameter of
    1056:   neighboring cells should differ by at most a factor of 2.  Subtypes of DMForest may only support one particular
    1057:   choice of grading factor.

    1059:   Not collective

    1061:   Input Parameter:
    1062: . dm - the forest

    1064:   Output Parameter:
    1065: . grade - the grading factor

    1067:   Level: advanced

    1069: .seealso: DMForestSetGradeFactor()
    1070: @*/
    1071: PetscErrorCode DMForestGetGradeFactor(DM dm, PetscInt *grade)
    1072: {
    1073:   DM_Forest      *forest = (DM_Forest *) dm->data;

    1078:   *grade = forest->gradeFactor;
    1079:   return(0);
    1080: }

    1084: /*@
    1085:   DMForestSetCellWeightFactor - During the pre-setup phase, set the factor by which the level of refinement changes
    1086:   the cell weight (see DMForestSetCellWeights()) when calculating partitions.  The final weight of a cell will be
    1087:   (cellWeight) * (weightFactor^refinementLevel).  A factor of 1 indicates that the weight of a cell does not depend on
    1088:   its level; a factor of 2, for example, might be appropriate for sub-cycling time-stepping methods, when the
    1089:   computation associated with a cell is multiplied by a factor of 2 for each additional level of refinement.

    1091:   Logically collective on dm

    1093:   Input Parameters:
    1094: + dm - the forest
    1095: - weightsFactors - default 1.

    1097:   Level: advanced

    1099: .seealso: DMForestGetCellWeightFactor(), DMForestSetCellWeights()
    1100: @*/
    1101: PetscErrorCode DMForestSetCellWeightFactor(DM dm, PetscReal weightsFactor)
    1102: {
    1103:   DM_Forest      *forest = (DM_Forest *) dm->data;

    1107:   if (dm->setupcalled) SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_ARG_WRONGSTATE,"Cannot change the weights factor after setup");
    1108:   forest->weightsFactor = weightsFactor;
    1109:   return(0);
    1110: }

    1114: /*@
    1115:   DMForestGetCellWeightFactor - Get the factor by which the level of refinement changes the cell weight (see
    1116:   DMForestSetCellWeights()) when calculating partitions.  The final weight of a cell will be (cellWeight) *
    1117:   (weightFactor^refinementLevel).  A factor of 1 indicates that the weight of a cell does not depend on its level; a
    1118:   factor of 2, for example, might be appropriate for sub-cycling time-stepping methods, when the computation
    1119:   associated with a cell is multiplied by a factor of 2 for each additional level of refinement.

    1121:   Not collective

    1123:   Input Parameter:
    1124: . dm - the forest

    1126:   Output Parameter:
    1127: . weightsFactors - default 1.

    1129:   Level: advanced

    1131: .seealso: DMForestSetCellWeightFactor(), DMForestSetCellWeights()
    1132: @*/
    1133: PetscErrorCode DMForestGetCellWeightFactor(DM dm, PetscReal *weightsFactor)
    1134: {
    1135:   DM_Forest      *forest = (DM_Forest *) dm->data;

    1140:   *weightsFactor = forest->weightsFactor;
    1141:   return(0);
    1142: }

    1146: /*@
    1147:   DMForestGetCellChart - After the setup phase, get the local half-open interval of the chart of cells on this process

    1149:   Not collective

    1151:   Input Parameter:
    1152: . dm - the forest

    1154:   Output Parameters:
    1155: + cStart - the first cell on this process
    1156: - cEnd - one after the final cell on this process

    1158:   Level: intermediate

    1160: .seealso: DMForestGetCellSF()
    1161: @*/
    1162: PetscErrorCode DMForestGetCellChart(DM dm, PetscInt *cStart, PetscInt *cEnd)
    1163: {
    1164:   DM_Forest      *forest = (DM_Forest *) dm->data;

    1171:   if (((forest->cStart == PETSC_DETERMINE) || (forest->cEnd == PETSC_DETERMINE)) && forest->createcellchart) {
    1172:     forest->createcellchart(dm,&forest->cStart,&forest->cEnd);
    1173:   }
    1174:   *cStart =  forest->cStart;
    1175:   *cEnd   =  forest->cEnd;
    1176:   return(0);
    1177: }

    1181: /*@
    1182:   DMForestGetCellSF - After the setup phase, get the PetscSF for overlapping cells between processes

    1184:   Not collective

    1186:   Input Parameter:
    1187: . dm - the forest

    1189:   Output Parameter:
    1190: . cellSF - the PetscSF

    1192:   Level: intermediate

    1194: .seealso: DMForestGetCellChart()
    1195: @*/
    1196: PetscErrorCode DMForestGetCellSF(DM dm, PetscSF *cellSF)
    1197: {
    1198:   DM_Forest      *forest = (DM_Forest *) dm->data;

    1204:   if ((!forest->cellSF) && forest->createcellsf) {
    1205:     forest->createcellsf(dm,&forest->cellSF);
    1206:   }
    1207:   *cellSF = forest->cellSF;
    1208:   return(0);
    1209: }

    1213: /*@C
    1214:   DMForestSetAdaptivityLabel - During the pre-setup phase, set the label of the pre-adaptation forest (see
    1215:   DMForestGetAdaptivityForest()) that holds the adaptation flags (refinement, coarsening, or some combination).  The
    1216:   interpretation of the label values is up to the subtype of DMForest, but DM_FOREST_KEEP, DM_FOREST_REFINE, and
    1217:   DM_FOREST_COARSEN have been reserved as choices that should be accepted by all subtypes.

    1219:   Logically collective on dm

    1221:   Input Parameters:
    1222: - dm - the forest
    1223: + adaptLabel - the name of the label in the pre-adaptation forest

    1225:   Level: intermediate

    1227: .seealso DMForestGetAdaptivityLabel()
    1228: @*/
    1229: PetscErrorCode DMForestSetAdaptivityLabel(DM dm, const char * adaptLabel)
    1230: {
    1231:   DM_Forest      *forest = (DM_Forest *) dm->data;

    1236:   PetscFree(forest->adaptLabel);
    1237:   PetscStrallocpy(adaptLabel,&forest->adaptLabel);
    1238:   return(0);
    1239: }

    1243: /*@C
    1244:   DMForestGetAdaptivityLabel - Get the label of the pre-adaptation forest (see DMForestGetAdaptivityForest()) that
    1245:   holds the adaptation flags (refinement, coarsening, or some combination).  The interpretation of the label values is
    1246:   up to the subtype of DMForest, but DM_FOREST_KEEP, DM_FOREST_REFINE, and DM_FOREST_COARSEN have been reserved as
    1247:   choices that should be accepted by all subtypes.

    1249:   Not collective

    1251:   Input Parameter:
    1252: . dm - the forest

    1254:   Output Parameter:
    1255: . adaptLabel - the name of the label in the pre-adaptation forest

    1257:   Level: intermediate

    1259: .seealso DMForestSetAdaptivityLabel()
    1260: @*/
    1261: PetscErrorCode DMForestGetAdaptivityLabel(DM dm, const char ** adaptLabel)
    1262: {
    1263:   DM_Forest      *forest = (DM_Forest *) dm->data;

    1267:   *adaptLabel = forest->adaptLabel;
    1268:   return(0);
    1269: }

    1273: /*@
    1274:   DMForestSetCellWeights - Set the weights assigned to each of the cells (see DMForestGetCellChart()) of the current
    1275:   process: weights are used to determine parallel partitioning.  Partitions will be created so that each process's
    1276:   ratio of weight to capacity (see DMForestSetWeightCapacity()) is roughly equal. If NULL, each cell receives a weight
    1277:   of 1.

    1279:   Logically collective on dm

    1281:   Input Parameters:
    1282: + dm - the forest
    1283: . weights - the array of weights for all cells, or NULL to indicate each cell has weight 1.
    1284: - copyMode - how weights should reference weights

    1286:   Level: advanced

    1288: .seealso: DMForestGetCellWeights(), DMForestSetWeightCapacity()
    1289: @*/
    1290: PetscErrorCode DMForestSetCellWeights(DM dm, PetscReal weights[], PetscCopyMode copyMode)
    1291: {
    1292:   DM_Forest      *forest = (DM_Forest *) dm->data;
    1293:   PetscInt       cStart, cEnd;

    1298:   DMForestGetCellChart(dm,&cStart,&cEnd);
    1299:   if (cEnd < cStart) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"cell chart [%d,%d) is not valid",cStart,cEnd);
    1300:   if (copyMode == PETSC_COPY_VALUES) {
    1301:     if (forest->cellWeightsCopyMode != PETSC_OWN_POINTER || forest->cellWeights == weights) {
    1302:       PetscMalloc1(cEnd-cStart,&forest->cellWeights);
    1303:     }
    1304:     PetscMemcpy(forest->cellWeights,weights,(cEnd-cStart)*sizeof(*weights));
    1305:     forest->cellWeightsCopyMode = PETSC_OWN_POINTER;
    1306:     return(0);
    1307:   }
    1308:   if (forest->cellWeightsCopyMode == PETSC_OWN_POINTER) {
    1309:     PetscFree(forest->cellWeights);
    1310:   }
    1311:   forest->cellWeights  = weights;
    1312:   forest->cellWeightsCopyMode = copyMode;
    1313:   return(0);
    1314: }

    1318: /*@
    1319:   DMForestGetCellWeights - Get the weights assigned to each of the cells (see DMForestGetCellChart()) of the current
    1320:   process: weights are used to determine parallel partitioning.  Partitions will be created so that each process's
    1321:   ratio of weight to capacity (see DMForestSetWeightCapacity()) is roughly equal. If NULL, each cell receives a weight
    1322:   of 1.

    1324:   Not collective

    1326:   Input Parameter:
    1327: . dm - the forest

    1329:   Output Parameter:
    1330: . weights - the array of weights for all cells, or NULL to indicate each cell has weight 1.

    1332:   Level: advanced

    1334: .seealso: DMForestSetCellWeights(), DMForestSetWeightCapacity()
    1335: @*/
    1336: PetscErrorCode DMForestGetCellWeights(DM dm, PetscReal **weights)
    1337: {
    1338:   DM_Forest      *forest = (DM_Forest *) dm->data;

    1343:   *weights = forest->cellWeights;
    1344:   return(0);
    1345: }

    1349: /*@
    1350:   DMForestSetWeightCapacity - During the pre-setup phase, set the capacity of the current process when repartitioning
    1351:   a pre-adaptation forest (see DMForestGetAdaptivityForest()).  After partitioning, the ratio of the weight of each
    1352:   process's cells to the process's capacity will be roughly equal for all processes.  A capacity of 0 indicates that
    1353:   the current process should not have any cells after repartitioning.

    1355:   Logically Collective on dm

    1357:   Input parameters:
    1358: + dm - the forest
    1359: - capacity - this process's capacity

    1361:   Level: advanced

    1363: .seealso DMForestGetWeightCapacity(), DMForestSetCellWeights(), DMForestSetCellWeightFactor()
    1364: @*/
    1365: PetscErrorCode DMForestSetWeightCapacity(DM dm, PetscReal capacity)
    1366: {
    1367:   DM_Forest      *forest = (DM_Forest *) dm->data;

    1371:   if (dm->setupcalled) SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_ARG_WRONGSTATE,"Cannot change the weight capacity after setup");
    1372:   if (capacity < 0.) SETERRQ1(PetscObjectComm((PetscObject)dm),PETSC_ERR_ARG_OUTOFRANGE,"Cannot have negative weight capacity; %f",capacity);
    1373:   forest->weightCapacity = capacity;
    1374:   return(0);
    1375: }

    1379: /*@
    1380:   DMForestGetWeightCapacity - Set the capacity of the current process when repartitioning a pre-adaptation forest (see
    1381:   DMForestGetAdaptivityForest()).  After partitioning, the ratio of the weight of each process's cells to the
    1382:   process's capacity will be roughly equal for all processes.  A capacity of 0 indicates that the current process
    1383:   should not have any cells after repartitioning.

    1385:   Not collective

    1387:   Input parameter:
    1388: . dm - the forest

    1390:   Output parameter:
    1391: . capacity - this process's capacity

    1393:   Level: advanced

    1395: .seealso DMForestSetWeightCapacity(), DMForestSetCellWeights(), DMForestSetCellWeightFactor()
    1396: @*/
    1397: PetscErrorCode DMForestGetWeightCapacity(DM dm, PetscReal *capacity)
    1398: {
    1399:   DM_Forest      *forest = (DM_Forest *) dm->data;

    1404:   *capacity = forest->weightCapacity;
    1405:   return(0);
    1406: }

    1410: PETSC_EXTERN PetscErrorCode DMSetFromOptions_Forest(PetscOptionItems *PetscOptionsObject,DM dm)
    1411: {
    1412:   DM_Forest                  *forest = (DM_Forest *) dm->data;
    1413:   PetscBool                  flg, flg1, flg2, flg3, flg4;
    1414:   DMForestTopology           oldTopo;
    1415:   char                       stringBuffer[256];
    1416:   PetscViewer                viewer;
    1417:   PetscViewerFormat          format;
    1418:   PetscInt                   adjDim, adjCodim, overlap, minRefinement, initRefinement, maxRefinement, grade;
    1419:   PetscReal                  weightsFactor;
    1420:   DMForestAdaptivityStrategy adaptStrategy;
    1421:   PetscErrorCode             ierr;

    1425:   forest->setfromoptionscalled = PETSC_TRUE;
    1426:   DMForestGetTopology(dm, &oldTopo);
    1427:   PetscOptionsHead(PetscOptionsObject,"DMForest Options");
    1428:   PetscOptionsString("-dm_forest_topology","the topology of the forest's base mesh","DMForestSetTopology",oldTopo,stringBuffer,256,&flg1);
    1429:   PetscOptionsViewer("-dm_forest_base_dm","load the base DM from a viewer specification","DMForestSetBaseDM",&viewer,&format,&flg2);
    1430:   PetscOptionsViewer("-dm_forest_coarse_forest","load the coarse forest from a viewer specification","DMForestSetCoarseForest",&viewer,&format,&flg3);
    1431:   PetscOptionsViewer("-dm_forest_fine_forest","load the fine forest from a viewer specification","DMForestSetFineForest",&viewer,&format,&flg4);
    1432:   if ((PetscInt) flg1 + (PetscInt) flg2 + (PetscInt) flg3 + (PetscInt) flg4 > 1) {
    1433:     SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_ARG_INCOMP,"Specify only one of -dm_forest_{topology,base_dm,coarse_forest,fine_forest}");
    1434:   }
    1435:   if (flg1) {
    1436:     DMForestSetTopology(dm,(DMForestTopology)stringBuffer);
    1437:     DMForestSetBaseDM(dm,NULL);
    1438:     DMForestSetAdaptivityForest(dm,NULL);
    1439:   }
    1440:   if (flg2) {
    1441:     DM         base;

    1443:     DMCreate(PetscObjectComm((PetscObject)dm),&base);
    1444:     PetscViewerPushFormat(viewer,format);
    1445:     DMLoad(base,viewer);
    1446:     PetscViewerDestroy(&viewer);
    1447:     DMForestSetBaseDM(dm,base);
    1448:     DMDestroy(&base);
    1449:     DMForestSetTopology(dm,NULL);
    1450:     DMForestSetAdaptivityForest(dm,NULL);
    1451:   }
    1452:   if (flg3) {
    1453:     DM         coarse;

    1455:     DMCreate(PetscObjectComm((PetscObject)dm),&coarse);
    1456:     PetscViewerPushFormat(viewer,format);
    1457:     DMLoad(coarse,viewer);
    1458:     PetscViewerDestroy(&viewer);
    1459:     DMForestSetAdaptivityForest(dm,coarse);
    1460:     DMDestroy(&coarse);
    1461:     DMForestSetTopology(dm,NULL);
    1462:     DMForestSetBaseDM(dm,NULL);
    1463:   }
    1464:   if (flg4) {
    1465:     DM         fine;

    1467:     DMCreate(PetscObjectComm((PetscObject)dm),&fine);
    1468:     PetscViewerPushFormat(viewer,format);
    1469:     DMLoad(fine,viewer);
    1470:     PetscViewerDestroy(&viewer);
    1471:     DMForestSetAdaptivityForest(dm,fine);
    1472:     DMDestroy(&fine);
    1473:     DMForestSetTopology(dm,NULL);
    1474:     DMForestSetBaseDM(dm,NULL);
    1475:   }
    1476:   DMForestGetAdjacencyDimension(dm,&adjDim);
    1477:   PetscOptionsInt("-dm_forest_adjacency_dimension","set the dimension of points that define adjacency in the forest","DMForestSetAdjacencyDimension",adjDim,&adjDim,&flg);
    1478:   if (flg) {
    1479:     DMForestSetAdjacencyDimension(dm,adjDim);
    1480:   }
    1481:   else {
    1482:     DMForestGetAdjacencyCodimension(dm,&adjCodim);
    1483:     PetscOptionsInt("-dm_forest_adjacency_codimension","set the codimension of points that define adjacency in the forest","DMForestSetAdjacencyCodimension",adjCodim,&adjCodim,&flg);
    1484:     if (flg) {
    1485:       DMForestSetAdjacencyCodimension(dm,adjCodim);
    1486:     }
    1487:   }
    1488:   DMForestGetPartitionOverlap(dm,&overlap);
    1489:   PetscOptionsInt("-dm_forest_partition_overlap","set the degree of partition overlap","DMForestSetPartitionOverlap",overlap,&overlap,&flg);
    1490:   if (flg) {
    1491:     DMForestSetPartitionOverlap(dm,overlap);
    1492:   }
    1493: #if 0
    1494:   PetscOptionsInt("-dm_refine","equivalent to -dm_forest_set_minimum_refinement and -dm_forest_set_initial_refinement with the same value",NULL,minRefinement,&minRefinement,&flg);
    1495:   if (flg) {
    1496:     DMForestSetMinimumRefinement(dm,minRefinement);
    1497:     DMForestSetInitialRefinement(dm,minRefinement);
    1498:   }
    1499:   PetscOptionsInt("-dm_refine_hierarchy","equivalent to -dm_forest_set_minimum_refinement 0 and -dm_forest_set_initial_refinement",NULL,initRefinement,&initRefinement,&flg);
    1500:   if (flg) {
    1501:     DMForestSetMinimumRefinement(dm,0);
    1502:     DMForestSetInitialRefinement(dm,initRefinement);
    1503:   }
    1504: #endif
    1505:   DMForestGetMinimumRefinement(dm,&minRefinement);
    1506:   PetscOptionsInt("-dm_forest_minimum_refinement","set the minimum level of refinement in the forest","DMForestSetMinimumRefinement",minRefinement,&minRefinement,&flg);
    1507:   if (flg) {
    1508:     DMForestSetMinimumRefinement(dm,minRefinement);
    1509:   }
    1510:   DMForestGetInitialRefinement(dm,&initRefinement);
    1511:   PetscOptionsInt("-dm_forest_initial_refinement","set the initial level of refinement in the forest","DMForestSetInitialRefinement",initRefinement,&initRefinement,&flg);
    1512:   if (flg) {
    1513:     DMForestSetInitialRefinement(dm,initRefinement);
    1514:   }
    1515:   DMForestGetMaximumRefinement(dm,&maxRefinement);
    1516:   PetscOptionsInt("-dm_forest_maximum_refinement","set the maximum level of refinement in the forest","DMForestSetMaximumRefinement",maxRefinement,&maxRefinement,&flg);
    1517:   if (flg) {
    1518:     DMForestSetMaximumRefinement(dm,maxRefinement);
    1519:   }
    1520:   DMForestGetAdaptivityStrategy(dm,&adaptStrategy);
    1521:   PetscOptionsString("-dm_forest_adaptivity_strategy","the forest's adaptivity-flag resolution strategy","DMForestSetAdaptivityStrategy",adaptStrategy,stringBuffer,256,&flg);
    1522:   if (flg) {
    1523:     DMForestSetAdaptivityStrategy(dm,(DMForestAdaptivityStrategy)stringBuffer);
    1524:   }
    1525:   DMForestGetGradeFactor(dm,&grade);
    1526:   PetscOptionsInt("-dm_forest_grade_factor","grade factor between neighboring cells","DMForestSetGradeFactor",grade,&grade,&flg);
    1527:   if (flg) {
    1528:     DMForestSetGradeFactor(dm,grade);
    1529:   }
    1530:   DMForestGetCellWeightFactor(dm,&weightsFactor);
    1531:   PetscOptionsReal("-dm_forest_cell_weight_factor","multiplying weight factor for cell refinement","DMForestSetCellWeightFactor",weightsFactor,&weightsFactor,&flg);
    1532:   if (flg) {
    1533:     DMForestSetCellWeightFactor(dm,weightsFactor);
    1534:   }
    1535:   PetscOptionsTail();
    1536:   return(0);
    1537: }

    1541: PetscErrorCode DMCreateSubDM_Forest(DM dm, PetscInt numFields, PetscInt fields[], IS *is, DM *subdm)
    1542: {

    1546:   if (subdm) {DMClone(dm, subdm);}
    1547:   DMCreateSubDM_Section_Private(dm, numFields, fields, is, subdm);
    1548:   return(0);
    1549: }

    1553: PetscErrorCode DMRefine_Forest(DM dm, MPI_Comm comm, DM *dmRefined)
    1554: {
    1555:   DMLabel        refine;
    1556:   DM             fineDM;

    1560:   DMGetFineDM(dm,&fineDM);
    1561:   if (fineDM) {
    1562:     PetscObjectReference((PetscObject)fineDM);
    1563:     *dmRefined = fineDM;
    1564:     return(0);
    1565:   }
    1566:   DMForestTemplate(dm,comm,dmRefined);
    1567:   DMGetLabel(dm,"refine",&refine);
    1568:   if (!refine) {
    1569:     DMCreateLabel(dm,"refine");
    1570:     DMGetLabel(dm,"refine",&refine);
    1571:     DMLabelSetDefaultValue(refine,DM_FOREST_REFINE);
    1572:   }
    1573:   DMForestSetAdaptivityLabel(*dmRefined,"refine");
    1574:   return(0);
    1575: }

    1579: PetscErrorCode DMCoarsen_Forest(DM dm, MPI_Comm comm, DM *dmCoarsened)
    1580: {
    1581:   DMLabel        coarsen;
    1582:   DM             coarseDM;

    1586:   {
    1587:     PetscMPIInt mpiComparison;
    1588:     MPI_Comm    dmcomm = PetscObjectComm((PetscObject)dm);

    1590:     MPI_Comm_compare(comm, dmcomm, &mpiComparison);
    1591:     if (mpiComparison != MPI_IDENT && mpiComparison != MPI_CONGRUENT) {
    1592:       SETERRQ(dmcomm,PETSC_ERR_SUP,"No support for different communicators yet");
    1593:     }
    1594:   }
    1595:   DMGetCoarseDM(dm,&coarseDM);
    1596:   if (coarseDM) {
    1597:     PetscObjectReference((PetscObject)coarseDM);
    1598:     *dmCoarsened = coarseDM;
    1599:     return(0);
    1600:   }
    1601:   DMForestTemplate(dm,comm,dmCoarsened);
    1602:   DMForestSetAdaptivityPurpose(coarseDM,DM_FOREST_COARSEN);
    1603:   DMGetLabel(dm,"coarsen",&coarsen);
    1604:   if (!coarsen) {
    1605:     DMCreateLabel(dm,"coarsen");
    1606:     DMGetLabel(dm,"coarsen",&coarsen);
    1607:     DMLabelSetDefaultValue(coarsen,DM_FOREST_COARSEN);
    1608:   }
    1609:   DMForestSetAdaptivityLabel(*dmCoarsened,"coarsen");
    1610:   return(0);
    1611: }

    1615: static PetscErrorCode DMInitialize_Forest(DM dm)
    1616: {

    1620:   PetscMemzero(dm->ops,sizeof(*(dm->ops)));

    1622:   dm->ops->clone          = DMClone_Forest;
    1623:   dm->ops->setfromoptions = DMSetFromOptions_Forest;
    1624:   dm->ops->destroy        = DMDestroy_Forest;
    1625:   dm->ops->createsubdm    = DMCreateSubDM_Forest;
    1626:   dm->ops->refine         = DMRefine_Forest;
    1627:   dm->ops->coarsen        = DMCoarsen_Forest;
    1628:   return(0);
    1629: }

    1631: /*MC
    1632:   DMFOREST = "forest" - A DM object that encapsulates a hierarchically refined mesh.  Forests usually have a base DM (see DMForestGetBaseDM()), from which it is refined.  The refinement and partitioning of forests is considered immutable after DMSetUp() is called.  To adapt a mesh, one should call DMForestTemplate() to create a new mesh that will default to being identical to it, specify how that mesh should differ, and then calling DMSetUp() on the new mesh.

    1634:   To specify that a mesh should be refined or coarsened from the previous mesh, a label should be defined on the previous mesh whose values indicate which cells should be refined (DM_FOREST_REFINE) or coarsened (DM_FOREST_COARSEN) and how (subtypes are free to allow additional values for things like anisotropic refinement).  The name of the label should be given to the *new* mesh with DMForestSetAdaptivityLabel().

    1636:   Level: advanced

    1638: .seealso: DMType, DMCreate(), DMSetType(), DMForestGetBaseDM(), DMForestSetBaseDM(), DMForestTemplate(), DMForestSetAdaptivityLabel()
    1639: M*/

    1643: PETSC_EXTERN PetscErrorCode DMCreate_Forest(DM dm)
    1644: {
    1645:   DM_Forest      *forest;

    1650:   PetscNewLog(dm,&forest);
    1651:   dm->dim                     = 0;
    1652:   dm->data                    = forest;
    1653:   forest->refct               = 1;
    1654:   forest->data                = NULL;
    1655:   forest->setfromoptionscalled      = PETSC_FALSE;
    1656:   forest->topology            = NULL;
    1657:   forest->base                = NULL;
    1658:   forest->adjDim              = PETSC_DEFAULT;
    1659:   forest->overlap             = PETSC_DEFAULT;
    1660:   forest->minRefinement       = PETSC_DEFAULT;
    1661:   forest->maxRefinement       = PETSC_DEFAULT;
    1662:   forest->initRefinement      = PETSC_DEFAULT;
    1663:   forest->cStart              = PETSC_DETERMINE;
    1664:   forest->cEnd                = PETSC_DETERMINE;
    1665:   forest->cellSF              = 0;
    1666:   forest->adaptLabel          = NULL;
    1667:   forest->gradeFactor         = 2;
    1668:   forest->cellWeights         = NULL;
    1669:   forest->cellWeightsCopyMode = PETSC_USE_POINTER;
    1670:   forest->weightsFactor       = 1.;
    1671:   forest->weightCapacity      = 1.;
    1672:   DMForestSetAdaptivityStrategy(dm,DMFORESTADAPTALL);
    1673:   DMInitialize_Forest(dm);
    1674:   return(0);
    1675: }