Actual source code: plexpoint.c

      1: #include <petsc/private/dmpleximpl.h>

      3: /*@
      4:    DMPlexGetPointLocal - get location of point data in local Vec

      6:    Not Collective

      8:    Input Arguments:
      9: +  dm - DM defining the topological space
     10: -  point - topological point

     12:    Output Arguments:
     13: +  start - start of point data
     14: -  end - end of point data

     16:    Note: This is a half open interval [start, end)

     18:    Level: intermediate

     20: .seealso: DMPlexGetPointLocalField(), DMGetLocalSection(), PetscSectionGetOffset(), PetscSectionGetDof(), DMPlexPointLocalRead(), DMPlexPointLocalRead(), DMPlexPointLocalRef()
     21: @*/
     22: PetscErrorCode DMPlexGetPointLocal(DM dm, PetscInt point, PetscInt *start, PetscInt *end)
     23: {
     24:   PetscInt       s, e;

     31:   DMGetLocalOffset_Private(dm, point, &s, &e);
     32:   if (start) *start = s;
     33:   if (end)   *end   = e;
     34:   return(0);
     35: }

     37: /*@
     38:    DMPlexPointLocalRead - return read access to a point in local array

     40:    Not Collective

     42:    Input Arguments:
     43: +  dm - DM defining topological space
     44: .  point - topological point
     45: -  array - array to index into

     47:    Output Arguments:
     48: .  ptr - address of read reference to point data, type generic so user can place in structure

     50:    Level: intermediate

     52:    Note:
     53:    A common usage when data sizes are known statically:

     55: $  const struct { PetscScalar foo,bar,baz; } *ptr;
     56: $  DMPlexPointLocalRead(dm,point,array,&ptr);
     57: $  x = 2*ptr->foo + 3*ptr->bar + 5*ptr->baz;

     59: .seealso: DMGetLocalSection(), PetscSectionGetOffset(), PetscSectionGetDof(), DMPlexGetPointLocal(), DMPlexPointGlobalRead()
     60: @*/
     61: PetscErrorCode DMPlexPointLocalRead(DM dm,PetscInt point,const PetscScalar *array,void *ptr)
     62: {
     64:   PetscInt       start, end;

     70:   DMGetLocalOffset_Private(dm,point,&start,&end);
     71:   *(const PetscScalar**)ptr = (start < end) ? array + start : NULL;
     72:   return(0);
     73: }

     75: /*@
     76:    DMPlexPointLocalRef - return read/write access to a point in local array

     78:    Not Collective

     80:    Input Arguments:
     81: +  dm - DM defining topological space
     82: .  point - topological point
     83: -  array - array to index into

     85:    Output Arguments:
     86: .  ptr - address of reference to point data, type generic so user can place in structure

     88:    Level: intermediate

     90:    Note:
     91:    A common usage when data sizes are known statically:

     93: $  struct { PetscScalar foo,bar,baz; } *ptr;
     94: $  DMPlexPointLocalRef(dm,point,array,&ptr);
     95: $  ptr->foo = 2; ptr->bar = 3; ptr->baz = 5;

     97: .seealso: DMGetLocalSection(), PetscSectionGetOffset(), PetscSectionGetDof(), DMPlexGetPointLocal(), DMPlexPointGlobalRef()
     98: @*/
     99: PetscErrorCode DMPlexPointLocalRef(DM dm,PetscInt point,PetscScalar *array,void *ptr)
    100: {
    102:   PetscInt       start, end;

    108:   DMGetLocalOffset_Private(dm,point,&start,&end);
    109:   *(PetscScalar**)ptr = (start < end) ? array + start : NULL;
    110:   return(0);
    111: }

    113: /*@
    114:   DMPlexGetPointLocalField - get location of point field data in local Vec

    116:   Not Collective

    118:   Input Arguments:
    119: + dm - DM defining the topological space
    120: . point - topological point
    121: - field - the field number

    123:   Output Arguments:
    124: + start - start of point data
    125: - end - end of point data

    127:   Note: This is a half open interval [start, end)

    129:   Level: intermediate

    131: .seealso: DMPlexGetPointLocal(), DMGetLocalSection(), PetscSectionGetOffset(), PetscSectionGetDof(), DMPlexPointLocalRead(), DMPlexPointLocalRead(), DMPlexPointLocalRef()
    132: @*/
    133: PetscErrorCode DMPlexGetPointLocalField(DM dm, PetscInt point, PetscInt field, PetscInt *start, PetscInt *end)
    134: {
    135:   PetscInt       s, e;

    142:   DMGetLocalFieldOffset_Private(dm, point, field, &s, &e);
    143:   if (start) *start = s;
    144:   if (end)   *end   = e;
    145:   return(0);
    146: }

    148: /*@
    149:    DMPlexPointLocalFieldRead - return read access to a field on a point in local array

    151:    Not Collective

    153:    Input Arguments:
    154: +  dm - DM defining topological space
    155: .  point - topological point
    156: .  field - field number
    157: -  array - array to index into

    159:    Output Arguments:
    160: .  ptr - address of read reference to point data, type generic so user can place in structure

    162:    Level: intermediate

    164: .seealso: DMGetLocalSection(), PetscSectionGetOffset(), PetscSectionGetDof(), DMPlexGetPointLocal(), DMPlexPointGlobalRef()
    165: @*/
    166: PetscErrorCode DMPlexPointLocalFieldRead(DM dm, PetscInt point,PetscInt field,const PetscScalar *array,void *ptr)
    167: {
    169:   PetscInt       start, end;

    175:   DMGetLocalFieldOffset_Private(dm, point, field, &start, &end);
    176:   *(const PetscScalar**)ptr = array + start;
    177:   return(0);
    178: }

    180: /*@
    181:    DMPlexPointLocalFieldRef - return read/write access to a field on a point in local array

    183:    Not Collective

    185:    Input Arguments:
    186: +  dm - DM defining topological space
    187: .  point - topological point
    188: .  field - field number
    189: -  array - array to index into

    191:    Output Arguments:
    192: .  ptr - address of reference to point data, type generic so user can place in structure

    194:    Level: intermediate

    196: .seealso: DMGetLocalSection(), PetscSectionGetOffset(), PetscSectionGetDof(), DMPlexGetPointLocal(), DMPlexPointGlobalRef()
    197: @*/
    198: PetscErrorCode DMPlexPointLocalFieldRef(DM dm,PetscInt point,PetscInt field,PetscScalar *array,void *ptr)
    199: {
    201:   PetscInt       start, end;

    207:   DMGetLocalFieldOffset_Private(dm, point, field, &start, &end);
    208:   *(PetscScalar**)ptr = array + start;
    209:   return(0);
    210: }

    212: /*@
    213:   DMPlexGetPointGlobal - get location of point data in global Vec

    215:   Not Collective

    217:   Input Arguments:
    218: + dm - DM defining the topological space
    219: - point - topological point

    221:   Output Arguments:
    222: + start - start of point data; returns -(globalStart+1) if point is not owned
    223: - end - end of point data; returns -(globalEnd+1) if point is not owned

    225:   Note: This is a half open interval [start, end)

    227:   Level: intermediate

    229: .seealso: DMPlexGetPointGlobalField(), DMGetLocalSection(), PetscSectionGetOffset(), PetscSectionGetDof(), DMPlexPointGlobalRead(), DMPlexGetPointLocal(), DMPlexPointGlobalRead(), DMPlexPointGlobalRef()
    230: @*/
    231: PetscErrorCode DMPlexGetPointGlobal(DM dm, PetscInt point, PetscInt *start, PetscInt *end)
    232: {
    233:   PetscInt       s, e;

    240:   DMGetGlobalOffset_Private(dm, point, &s, &e);
    241:   if (start) *start = s;
    242:   if (end)   *end   = e;
    243:   return(0);
    244: }

    246: /*@
    247:    DMPlexPointGlobalRead - return read access to a point in global array

    249:    Not Collective

    251:    Input Arguments:
    252: +  dm - DM defining topological space
    253: .  point - topological point
    254: -  array - array to index into

    256:    Output Arguments:
    257: .  ptr - address of read reference to point data, type generic so user can place in structure; returns NULL if global point is not owned

    259:    Level: intermediate

    261:    Note:
    262:    A common usage when data sizes are known statically:

    264: $  const struct { PetscScalar foo,bar,baz; } *ptr;
    265: $  DMPlexPointGlobalRead(dm,point,array,&ptr);
    266: $  x = 2*ptr->foo + 3*ptr->bar + 5*ptr->baz;

    268: .seealso: DMGetLocalSection(), PetscSectionGetOffset(), PetscSectionGetDof(), DMPlexGetPointGlobal(), DMPlexPointLocalRead(), DMPlexPointGlobalRef()
    269: @*/
    270: PetscErrorCode DMPlexPointGlobalRead(DM dm,PetscInt point,const PetscScalar *array,const void *ptr)
    271: {
    272:   PetscInt       start, end;

    279:   DMGetGlobalOffset_Private(dm, point, &start, &end);
    280:   *(const PetscScalar**) ptr = (start < end) ? array + start - dm->map->rstart : NULL;
    281:   return(0);
    282: }

    284: /*@
    285:    DMPlexPointGlobalRef - return read/write access to a point in global array

    287:    Not Collective

    289:    Input Arguments:
    290: +  dm - DM defining topological space
    291: .  point - topological point
    292: -  array - array to index into

    294:    Output Arguments:
    295: .  ptr - address of reference to point data, type generic so user can place in structure; returns NULL if global point is not owned

    297:    Level: intermediate

    299:    Note:
    300:    A common usage when data sizes are known statically:

    302: $  struct { PetscScalar foo,bar,baz; } *ptr;
    303: $  DMPlexPointGlobalRef(dm,point,array,&ptr);
    304: $  ptr->foo = 2; ptr->bar = 3; ptr->baz = 5;

    306: .seealso: DMGetLocalSection(), PetscSectionGetOffset(), PetscSectionGetDof(), DMPlexGetPointGlobal(), DMPlexPointLocalRef(), DMPlexPointGlobalRead()
    307: @*/
    308: PetscErrorCode DMPlexPointGlobalRef(DM dm,PetscInt point,PetscScalar *array,void *ptr)
    309: {
    310:   PetscInt       start, end;

    317:   DMGetGlobalOffset_Private(dm, point, &start, &end);
    318:   *(PetscScalar**) ptr = (start < end) ? array + start - dm->map->rstart : NULL;
    319:   return(0);
    320: }

    322: /*@
    323:   DMPlexGetPointGlobalField - get location of point field data in global Vec

    325:   Not Collective

    327:   Input Arguments:
    328: + dm - DM defining the topological space
    329: . point - topological point
    330: - field - the field number

    332:   Output Arguments:
    333: + start - start of point data; returns -(globalStart+1) if point is not owned
    334: - end - end of point data; returns -(globalEnd+1) if point is not owned

    336:   Note: This is a half open interval [start, end)

    338:   Level: intermediate

    340: .seealso: DMPlexGetPointGlobal(), DMGetLocalSection(), PetscSectionGetOffset(), PetscSectionGetDof(), DMPlexPointGlobalRead(), DMPlexGetPointLocal(), DMPlexPointGlobalRead(), DMPlexPointGlobalRef()
    341: @*/
    342: PetscErrorCode DMPlexGetPointGlobalField(DM dm, PetscInt point, PetscInt field, PetscInt *start, PetscInt *end)
    343: {
    344:   PetscInt       s, e;

    351:   DMGetGlobalFieldOffset_Private(dm, point, field, &s, &e);
    352:   if (start) *start = s;
    353:   if (end)   *end   = e;
    354:   return(0);
    355: }

    357: /*@
    358:    DMPlexPointGlobalFieldRead - return read access to a field on a point in global array

    360:    Not Collective

    362:    Input Arguments:
    363: +  dm - DM defining topological space
    364: .  point - topological point
    365: .  field - field number
    366: -  array - array to index into

    368:    Output Arguments:
    369: .  ptr - address of read reference to point data, type generic so user can place in structure; returns NULL if global point is not owned

    371:    Level: intermediate

    373: .seealso: DMGetLocalSection(), PetscSectionGetOffset(), PetscSectionGetDof(), DMPlexGetPointGlobal(), DMPlexPointLocalRead(), DMPlexPointGlobalRef()
    374: @*/
    375: PetscErrorCode DMPlexPointGlobalFieldRead(DM dm,PetscInt point,PetscInt field,const PetscScalar *array,void *ptr)
    376: {
    377:   PetscInt       start, end;

    384:   DMGetGlobalFieldOffset_Private(dm, point, field, &start, &end);
    385:   *(const PetscScalar**) ptr = (start < end) ? array + start - dm->map->rstart : NULL;
    386:   return(0);
    387: }

    389: /*@
    390:    DMPlexPointGlobalFieldRef - return read/write access to a field on a point in global array

    392:    Not Collective

    394:    Input Arguments:
    395: +  dm - DM defining topological space
    396: .  point - topological point
    397: .  field - field number
    398: -  array - array to index into

    400:    Output Arguments:
    401: .  ptr - address of reference to point data, type generic so user can place in structure; returns NULL if global point is not owned

    403:    Level: intermediate

    405: .seealso: DMGetLocalSection(), PetscSectionGetOffset(), PetscSectionGetDof(), DMPlexGetPointGlobal(), DMPlexPointLocalRef(), DMPlexPointGlobalRead()
    406: @*/
    407: PetscErrorCode DMPlexPointGlobalFieldRef(DM dm,PetscInt point,PetscInt field,PetscScalar *array,void *ptr)
    408: {
    409:   PetscInt       start, end;

    416:   DMGetGlobalFieldOffset_Private(dm, point, field, &start, &end);
    417:   *(PetscScalar**) ptr = (start < end) ? array + start - dm->map->rstart : NULL;
    418:   return(0);
    419: }