Actual source code: map.c

      1: #define PETSCVEC_DLL
      2: /*
      3:      Provides the interface functions for all map operations.
      4:    These are the map functions the user calls.
      5: */
     6:  #include vecimpl.h

      8: /* Logging support */
      9: PetscCookie MAP_COOKIE = 0;

     13: /*
     14:   PetscMapSetTypeFromOptions_Private - Sets the type of map from user options. Defaults to a PETSc sequential map on one
     15:   processor and a PETSc MPI map on more than one processor.

     17:   Collective on PetscMap

     19:   Input Parameter:
     20: . map - The map

     22:   Level: intermediate

     24: .keywords: PetscMap, set, options, database, type
     25: .seealso: PetscMapSetFromOptions(), PetscMapSetType()
     26: */
     27: static PetscErrorCode PetscMapSetTypeFromOptions_Private(PetscMap map)
     28: {
     29:   PetscTruth     opt;
     30:   const char     *defaultType;
     31:   char           typeName[256];
     32:   PetscMPIInt    size;

     36:   if (map->type_name) {
     37:     defaultType = map->type_name;
     38:   } else {
     39:     MPI_Comm_size(map->comm, &size);
     40:     if (size > 1) {
     41:       defaultType = MAP_MPI;
     42:     } else {
     43:       defaultType = MAP_MPI;
     44:     }
     45:   }

     47:   if (!PetscMapRegisterAllCalled) {
     48:     PetscMapRegisterAll(PETSC_NULL);
     49:   }
     50:   PetscOptionsList("-map_type", "PetscMap type"," PetscMapSetType", PetscMapList, defaultType, typeName, 256, &opt);
     51:
     52:   if (opt) {
     53:     PetscMapSetType(map, typeName);
     54:   } else {
     55:     PetscMapSetType(map, defaultType);
     56:   }
     57:   return(0);
     58: }

     62: /*@C
     63:   PetscMapSetFromOptions - Configures the map from the options database.

     65:   Collective on PetscMap

     67:   Input Parameter:
     68: . map - The map

     70:   Notes:  To see all options, run your program with the -help option, or consult the users manual.
     71:           Must be called after PetscMapCreate() but before the map is used.

     73:   Level: intermediate

     75:   Concepts: maptors^setting options
     76:   Concepts: maptors^setting type

     78: .keywords: PetscMap, set, options, database
     79: .seealso: PetscMapCreate(), PetscMapPrintHelp(), PetscMaphSetOptionsPrefix()
     80: @*/
     81: PetscErrorCode PETSCVEC_DLLEXPORT PetscMapSetFromOptions(PetscMap map)
     82: {
     83:   PetscTruth opt;

     89:   PetscOptionsBegin(map->comm, map->prefix, "PetscMap options", "PetscMap");

     91:   /* Handle generic maptor options */
     92:   PetscOptionsHasName(PETSC_NULL, "-help", &opt);
     93:   if (opt) {
     94:     PetscMapPrintHelp(map);
     95:   }

     97:   /* Handle map type options */
     98:   PetscMapSetTypeFromOptions_Private(map);

    100:   /* Handle specific maptor options */
    101:   if (map->ops->setfromoptions) {
    102:     (*map->ops->setfromoptions)(map);
    103:   }

    105:   PetscOptionsEnd();

    107:   return(0);
    108: }

    112: /*@
    113:   PetscMapPrintHelp - Prints all options for the PetscMap.

    115:   Input Parameter:
    116: . map - The map

    118:   Options Database Keys:
    119: $  -help, -h

    121:   Level: intermediate

    123: .keywords: PetscMap, help
    124: .seealso: PetscMapSetFromOptions()
    125: @*/
    126: PetscErrorCode PETSCVEC_DLLEXPORT PetscMapPrintHelp(PetscMap map)
    127: {
    128:   char p[64];

    134:   PetscStrcpy(p, "-");
    135:   if (map->prefix) {
    136:     PetscStrcat(p, map->prefix);
    137:   }

    139:   (*PetscHelpPrintf)(map->comm, "PetscMap options ------------------------------------------------\n");
    140:   (*PetscHelpPrintf)(map->comm,"   %smap_type <typename> : Sets the map type\n", p);
    141:   return(0);
    142: }

    146: /*@C
    147:    PetscMapDestroy - Destroys a map object.

    149:    Not Collective

    151:    Input Parameter:
    152: .  m - the map object

    154:    Level: developer

    156: .seealso: PetscMapCreateMPI()

    158: @*/
    159: PetscErrorCode PETSCVEC_DLLEXPORT PetscMapDestroy(PetscMap map)
    160: {

    165:   if (--map->refct > 0) return(0);
    166:   if (map->range) {
    167:     PetscFree(map->range);
    168:   }
    169:   if (map->ops->destroy) {
    170:     (*map->ops->destroy)(map);
    171:   }
    172:   PetscHeaderDestroy(map);
    173:   return(0);
    174: }

    178: /*@C
    179:    PetscMapSetOptionsPrefix - Sets the prefix used for searching for all
    180:    PetscMap options in the database.

    182:    Collective on PetscMap

    184:    Input Parameter:
    185: +  map - the PetscMap context
    186: -  prefix - the prefix to prepend to all option names

    188:    Notes:
    189:    A hyphen (-) must NOT be given at the beginning of the prefix name.
    190:    The first character of all runtime options is AUTOMATICALLY the hyphen.

    192:    Level: advanced

    194: .keywords: PetscMap, set, options, prefix, database

    196: .seealso: PetscMapSetFromOptions()
    197: @*/
    198: PetscErrorCode PETSCVEC_DLLEXPORT PetscMapSetOptionsPrefix(PetscMap map,const char prefix[])
    199: {

    204:   PetscObjectSetOptionsPrefix((PetscObject)map,prefix);
    205:   return(0);
    206: }

    210: /*@C
    211:    PetscMapAppendOptionsPrefix - Appends to the prefix used for searching for all
    212:    PetscMap options in the database.

    214:    Collective on PetscMap

    216:    Input Parameters:
    217: +  map - the PetscMap context
    218: -  prefix - the prefix to prepend to all option names

    220:    Notes:
    221:    A hyphen (-) must NOT be given at the beginning of the prefix name.
    222:    The first character of all runtime options is AUTOMATICALLY the hyphen.

    224:    Level: advanced

    226: .keywords: PetscMap, append, options, prefix, database

    228: .seealso: PetscMapGetOptionsPrefix()
    229: @*/
    230: PetscErrorCode PETSCVEC_DLLEXPORT PetscMapAppendOptionsPrefix(PetscMap map,const char prefix[])
    231: {
    233:
    236:   PetscObjectAppendOptionsPrefix((PetscObject)map,prefix);
    237:   return(0);
    238: }

    242: /*@C
    243:    PetscMapGetOptionsPrefix - Sets the prefix used for searching for all
    244:    PetscMap options in the database.

    246:    Not Collective

    248:    Input Parameter:
    249: .  map - the PetscMap context

    251:    Output Parameter:
    252: .  prefix - pointer to the prefix string used

    254:    Notes: On the fortran side, the user should pass in a string 'prefix' of
    255:    sufficient length to hold the prefix.

    257:    Level: advanced

    259: .keywords: PetscMap, get, options, prefix, database

    261: .seealso: PetscMapAppendOptionsPrefix()
    262: @*/
    263: PetscErrorCode PETSCVEC_DLLEXPORT PetscMapGetOptionsPrefix(PetscMap map,const char *prefix[])
    264: {

    269:   PetscObjectGetOptionsPrefix((PetscObject)map,prefix);
    270:   return(0);
    271: }

    275: /*@
    276:    PetscMapSetUp - Sets up the internal map data structures for the later use.

    278:    Collective on PetscMap

    280:    Input Parameters:
    281: .  map - the PetscMap context

    283:    Notes:
    284:    For basic use of the PetscMap classes the user need not explicitly call
    285:    PetscMapSetUp(), since these actions will happen automatically.

    287:    Level: advanced

    289: .keywords: PetscMap, setup

    291: .seealso: PetscMapCreate(), PetscMapDestroy()
    292: @*/
    293: PetscErrorCode PETSCVEC_DLLEXPORT PetscMapSetUp(PetscMap map)
    294: {
    297:   return(0);
    298: }

    302: /*@C
    303:    PetscMapView - Visualizes a map object.

    305:    Collective on PetscMap

    307:    Input Parameters:
    308: +  map - the map
    309: -  viewer - visualization context

    311:   Notes:
    312:   The available visualization contexts include
    313: +    PETSC_VIEWER_STDOUT_SELF - standard output (default)
    314: .    PETSC_VIEWER_STDOUT_WORLD - synchronized standard
    315:         output where only the first processor opens
    316:         the file.  All other processors send their
    317:         data to the first processor to print.
    318: -     PETSC_VIEWER_DRAW_WORLD - graphical display of nonzero structure

    320:    Level: beginner

    322: .seealso: PetscViewerSetFormat(), PetscViewerASCIIOpen(), PetscViewerDrawOpen(),
    323:           PetscViewerSocketOpen(), PetscViewerBinaryOpen(), PetscMapLoad()
    324: @*/
    325: PetscErrorCode PETSCVEC_DLLEXPORT PetscMapView(PetscMap map,PetscViewer viewer)
    326: {
    327:   PetscErrorCode    ierr;
    328:   PetscInt          size;
    329:   PetscTruth        iascii;
    330:   const char        *cstr;
    331:   PetscViewerFormat format;

    336:   if (!viewer) viewer = PETSC_VIEWER_STDOUT_(map->comm);

    340:   PetscTypeCompare((PetscObject)viewer,PETSC_VIEWER_ASCII,&iascii);
    341:   if (iascii) {
    342:     PetscViewerGetFormat(viewer,&format);
    343:     if (format == PETSC_VIEWER_ASCII_INFO || format == PETSC_VIEWER_ASCII_INFO_DETAIL) {
    344:       if (map->prefix) {
    345:         PetscViewerASCIIPrintf(viewer,"PetscMap Object:(%s)\n",map->prefix);
    346:       } else {
    347:         PetscViewerASCIIPrintf(viewer,"PetscMap Object:\n");
    348:       }
    349:       PetscViewerASCIIPushTab(viewer);
    350:       PetscMapGetType(map,&cstr);
    351:       PetscMapGetSize(map,&size);
    352:       PetscViewerASCIIPrintf(viewer,"type=%s, size=%D\n",cstr,size);
    353:     }
    354:   }
    355:   if (!iascii) {
    356:     SETERRQ1(PETSC_ERR_SUP,"Viewer type %s not supported",((PetscObject)viewer)->type_name);
    357:   } else {
    358:     PetscViewerGetFormat(viewer,&format);
    359:     if (format == PETSC_VIEWER_ASCII_INFO || format == PETSC_VIEWER_ASCII_INFO_DETAIL) {
    360:       PetscViewerASCIIPopTab(viewer);
    361:     }
    362:   }
    363:   return(0);
    364: }

    368: /*@C
    369:   PetscMapSetLocalSize - Sets the number of elements associated with this processor.

    371:   Not Collective

    373:   Input Parameters:
    374: + m - the map object
    375: - n - the local size

    377:   Level: developer

    379: .seealso: PetscMapSetSize(), PetscMapGetLocalRange(), PetscMapGetGlobalRange()
    380: Concepts: PetscMap^local size
    381: @*/
    382: PetscErrorCode PETSCVEC_DLLEXPORT PetscMapSetLocalSize(PetscMap m,PetscInt n)
    383: {
    386:   m->n = n;
    387:   return(0);
    388: }

    392: /*@C
    393:    PetscMapGetLocalSize - Gets the number of elements associated with this processor.

    395:    Not Collective

    397:    Input Parameter:
    398: .  m - the map object

    400:    Output Parameter:
    401: .  n - the local size

    403:    Level: developer

    405: .seealso: PetscMapGetSize(), PetscMapGetLocalRange(), PetscMapGetGlobalRange()

    407:    Concepts: PetscMap^local size

    409: @*/
    410: PetscErrorCode PETSCVEC_DLLEXPORT PetscMapGetLocalSize(PetscMap m,PetscInt *n)
    411: {
    415:   *n = m->n;
    416:   return(0);
    417: }

    421: /*@C
    422:   PetscMapSetSize - Sets the total number of elements associated with this map.

    424:   Not Collective

    426:   Input Parameters:
    427: + m - the map object
    428: - N - the global size

    430:   Level: developer

    432: .seealso: PetscMapSetLocalSize(), PetscMapGetLocalRange(), PetscMapGetGlobalRange()
    433:  Concepts: PetscMap^size
    434: @*/
    435: PetscErrorCode PETSCVEC_DLLEXPORT PetscMapSetSize(PetscMap m,PetscInt N)
    436: {
    439:   m->N = N;
    440:   return(0);
    441: }

    445: /*@C
    446:    PetscMapGetSize - Gets the total number of elements associated with this map.

    448:    Not Collective

    450:    Input Parameter:
    451: .  m - the map object

    453:    Output Parameter:
    454: .  N - the global size

    456:    Level: developer

    458: .seealso: PetscMapGetLocalSize(), PetscMapGetLocalRange(), PetscMapGetGlobalRange()

    460:    Concepts: PetscMap^size
    461: @*/
    462: PetscErrorCode PETSCVEC_DLLEXPORT PetscMapGetSize(PetscMap m,PetscInt *N)
    463: {
    467:   *N = m->N;
    468:   return(0);
    469: }

    473: /*@C
    474:    PetscMapGetLocalRange - Gets the local ownership range for this procesor.

    476:    Not Collective

    478:    Input Parameter:
    479: .  m - the map object

    481:    Output Parameter:
    482: +  rstart - the first local index, pass in PETSC_NULL if not interested
    483: -  rend   - the last local index + 1, pass in PETSC_NULL if not interested

    485:    Level: developer

    487: .seealso: PetscMapGetLocalSize(), PetscMapGetGlobalRange()
    488: @*/
    489: PetscErrorCode PETSCVEC_DLLEXPORT PetscMapGetLocalRange(PetscMap m,PetscInt *rstart,PetscInt *rend)
    490: {
    495:   if (rstart) *rstart = m->rstart;
    496:   if (rend)   *rend   = m->rend;
    497:   return(0);
    498: }

    502: /*@C
    503:    PetscMapGetGlobalRange - Gets the ownership ranges for all processors.

    505:    Not Collective

    507:    Input Parameter:
    508: .  m - the map object

    510:    Output Parameter:
    511: .  range - array of size + 1 where size is the size of the communicator
    512:            associated with the map. range[rank], range[rank+1] is the
    513:            range for processor

    515:    Level: developer

    517: .seealso: PetscMapGetSize(), PetscMapGetLocalRange()

    519: @*/
    520: PetscErrorCode PETSCVEC_DLLEXPORT PetscMapGetGlobalRange(PetscMap m,PetscInt *range[])
    521: {
    525:   *range = m->range;
    526:   return(0);
    527: }