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: }