/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c

Bug Summary

File:	dm/impls/plex/plexinterpolate.c
Warning:	line 196, column 10 Array access (via field 'flags') results in a null pointer dereference

Annotated Source Code

[?] Use j/k keys for keyboard navigation

/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c

→

#include <petsc/private/dmpleximpl.h> /*I "petscdmplex.h" I*/

#include <petsc/private/hashmapi.h>

#include <petsc/private/hashmapij.h>

/* HashIJKL */

#include <petsc/private/hashmap.h>

typedef struct _PetscHashIJKLKey { PetscInt i, j, k, l; } PetscHashIJKLKey;

#define PetscHashIJKLKeyHash(key)PetscHashCombine(PetscHashCombine(PetscHashInt((key).i),PetscHashInt
((key).j)), PetscHashCombine(PetscHashInt((key).k),PetscHashInt
((key).l))) \

PetscHashCombine(PetscHashCombine(PetscHashInt((key).i),PetscHashInt((key).j)), \

PetscHashCombine(PetscHashInt((key).k),PetscHashInt((key).l)))

#define PetscHashIJKLKeyEqual(k1,k2)(((k1).i==(k2).i) ? ((k1).j==(k2).j) ? ((k1).k==(k2).k) ? ((k1
).l==(k2).l) : 0 : 0 : 0) \

(((k1).i==(k2).i) ? ((k1).j==(k2).j) ? ((k1).k==(k2).k) ? ((k1).l==(k2).l) : 0 : 0 : 0)

PETSC_HASH_MAP(HashIJKL, PetscHashIJKLKey, PetscInt, PetscHashIJKLKeyHash, PetscHashIJKLKeyEqual, -1)typedef struct kh_HashIJKL_s { khint_t n_buckets, size, n_occupied
, upper_bound; khint32_t *flags; PetscHashIJKLKey *keys; PetscInt
*vals; } kh_HashIJKL_t; static inline __attribute((unused)) kh_HashIJKL_t
*kh_init_HashIJKL(void) { return (kh_HashIJKL_t*)calloc(1,sizeof
(kh_HashIJKL_t)); } static inline __attribute((unused)) void kh_destroy_HashIJKL
(kh_HashIJKL_t *h) { if (h) { free((void *)h->keys); free(
h->flags); free((void *)h->vals); free(h); } } static inline
__attribute((unused)) void kh_clear_HashIJKL(kh_HashIJKL_t *
h) { if (h && h->flags) { memset(h->flags, 0xaa
, ((h->n_buckets) < 16? 1 : (h->n_buckets)>>4)
* sizeof(khint32_t)); h->size = h->n_occupied = 0; } }
static inline __attribute((unused)) khint_t kh_get_HashIJKL(
const kh_HashIJKL_t *h, PetscHashIJKLKey key) { if (h->n_buckets
) { khint_t k, i, last, mask, step = 0; mask = h->n_buckets
- 1; k = PetscHashCombine(PetscHashCombine(PetscHashInt((key
).i),PetscHashInt((key).j)), PetscHashCombine(PetscHashInt((key
).k),PetscHashInt((key).l))); i = k & mask; last = i; while
(!((h->flags[i>>4]>>((i&0xfU)<<1))&
2) && (((h->flags[i>>4]>>((i&0xfU)
<<1))&1) || !(((h->keys[i]).i==(key).i) ? ((h->
keys[i]).j==(key).j) ? ((h->keys[i]).k==(key).k) ? ((h->
keys[i]).l==(key).l) : 0 : 0 : 0))) { i = (i + (++step)) &
mask; if (i == last) return h->n_buckets; } return ((h->
flags[i>>4]>>((i&0xfU)<<1))&3)? h->
n_buckets : i; } else return 0; } static inline __attribute((
unused)) int kh_resize_HashIJKL(kh_HashIJKL_t *h, khint_t new_n_buckets
) { khint32_t *new_flags = 0; khint_t j = 1; { (--(new_n_buckets
), (new_n_buckets)|=(new_n_buckets)>>1, (new_n_buckets)
|=(new_n_buckets)>>2, (new_n_buckets)|=(new_n_buckets)>>
4, (new_n_buckets)|=(new_n_buckets)>>8, (new_n_buckets)
|=(new_n_buckets)>>16, ++(new_n_buckets)); if (new_n_buckets
< 4) new_n_buckets = 4; if (h->size >= (khint_t)(new_n_buckets
* __ac_HASH_UPPER + 0.5)) j = 0; else { new_flags = (khint32_t
*)malloc(((new_n_buckets) < 16? 1 : (new_n_buckets)>>
4) * sizeof(khint32_t)); if (!new_flags) return -1; memset(new_flags
, 0xaa, ((new_n_buckets) < 16? 1 : (new_n_buckets)>>
4) * sizeof(khint32_t)); if (h->n_buckets < new_n_buckets
) { PetscHashIJKLKey *new_keys = (PetscHashIJKLKey*)realloc((
void *)h->keys,new_n_buckets * sizeof(PetscHashIJKLKey)); if
(!new_keys) { free(new_flags); return -1; } h->keys = new_keys
; if (1) { PetscInt *new_vals = (PetscInt*)realloc((void *)h->
vals,new_n_buckets * sizeof(PetscInt)); if (!new_vals) { free
(new_flags); return -1; } h->vals = new_vals; } } } } if (
j) { for (j = 0; j != h->n_buckets; ++j) { if (((h->flags
[j>>4]>>((j&0xfU)<<1))&3) == 0) { PetscHashIJKLKey
key = h->keys[j]; PetscInt val; khint_t new_mask; new_mask
= new_n_buckets - 1; if (1) val = h->vals[j]; (h->flags
[j>>4]|=1ul<<((j&0xfU)<<1)); while (1) {
khint_t k, i, step = 0; k = PetscHashCombine(PetscHashCombine
(PetscHashInt((key).i),PetscHashInt((key).j)), PetscHashCombine
(PetscHashInt((key).k),PetscHashInt((key).l))); i = k & new_mask
; while (!((new_flags[i>>4]>>((i&0xfU)<<
1))&2)) i = (i + (++step)) & new_mask; (new_flags[i>>
4]&=~(2ul<<((i&0xfU)<<1))); if (i < h->
n_buckets && ((h->flags[i>>4]>>((i&
0xfU)<<1))&3) == 0) { { PetscHashIJKLKey tmp = h->
keys[i]; h->keys[i] = key; key = tmp; } if (1) { PetscInt tmp
= h->vals[i]; h->vals[i] = val; val = tmp; } (h->flags
[i>>4]|=1ul<<((i&0xfU)<<1)); } else { h
->keys[i] = key; if (1) h->vals[i] = val; break; } } } }
if (h->n_buckets > new_n_buckets) { h->keys = (PetscHashIJKLKey
*)realloc((void *)h->keys,new_n_buckets * sizeof(PetscHashIJKLKey
)); if (1) h->vals = (PetscInt*)realloc((void *)h->vals
,new_n_buckets * sizeof(PetscInt)); } free(h->flags); h->
flags = new_flags; h->n_buckets = new_n_buckets; h->n_occupied
= h->size; h->upper_bound = (khint_t)(h->n_buckets *
__ac_HASH_UPPER + 0.5); } return 0; } static inline __attribute
((unused)) khint_t kh_put_HashIJKL(kh_HashIJKL_t *h, PetscHashIJKLKey
key, int *ret) { khint_t x; if (h->n_occupied >= h->
upper_bound) { if (h->n_buckets > (h->size<<1)
) { if (kh_resize_HashIJKL(h, h->n_buckets - 1) < 0) { *
ret = -1; return h->n_buckets; } } else if (kh_resize_HashIJKL
(h, h->n_buckets + 1) < 0) { *ret = -1; return h->n_buckets
; } } { khint_t k, i, site, last, mask = h->n_buckets - 1,
step = 0; x = site = h->n_buckets; k = PetscHashCombine(PetscHashCombine
(PetscHashInt((key).i),PetscHashInt((key).j)), PetscHashCombine
(PetscHashInt((key).k),PetscHashInt((key).l))); i = k & mask
; if (((h->flags[i>>4]>>((i&0xfU)<<1
))&2)) x = i; else { last = i; while (!((h->flags[i>>
4]>>((i&0xfU)<<1))&2) && (((h->
flags[i>>4]>>((i&0xfU)<<1))&1) || !
(((h->keys[i]).i==(key).i) ? ((h->keys[i]).j==(key).j) ?
((h->keys[i]).k==(key).k) ? ((h->keys[i]).l==(key).l) :
0 : 0 : 0))) { if (((h->flags[i>>4]>>((i&
0xfU)<<1))&1)) site = i; i = (i + (++step)) & mask
; if (i == last) { x = site; break; } } if (x == h->n_buckets
) { if (((h->flags[i>>4]>>((i&0xfU)<<
1))&2) && site != h->n_buckets) x = site; else
x = i; } } } if (((h->flags[x>>4]>>((x&0xfU
)<<1))&2)) { h->keys[x] = key; (h->flags[x>>
4]&=~(3ul<<((x&0xfU)<<1))); ++h->size;
++h->n_occupied; *ret = 1; } else if (((h->flags[x>>
4]>>((x&0xfU)<<1))&1)) { h->keys[x] = key
; (h->flags[x>>4]&=~(3ul<<((x&0xfU)<<
1))); ++h->size; *ret = 2; } else *ret = 0; return x; } static
inline __attribute((unused)) void kh_del_HashIJKL(kh_HashIJKL_t
*h, khint_t x) { if (x != h->n_buckets && !((h->
flags[x>>4]>>((x&0xfU)<<1))&3)) { (
h->flags[x>>4]|=1ul<<((x&0xfU)<<1));
--h->size; } } typedef kh_HashIJKL_t *PetscHashIJKL; static
inline __attribute((unused)) PetscErrorCode PetscHashIJKLCreate
(PetscHashIJKL *ht) { do { do { ; if (petscstack && (
petscstack->currentsize < 64)) { petscstack->function
[petscstack->currentsize] = __func__; petscstack->file[
petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 18; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); *ht = kh_init_HashIJKL(); do { if (__builtin_expect
(!!(!(*ht!=((void*)0))),0)) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","*ht!=((void*)0)"
); } while(0); do { do { ; if (petscstack && petscstack
->currentsize > 0) { petscstack->currentsize--; petscstack
->function[petscstack->currentsize] = 0; petscstack->
file[petscstack->currentsize] = 0; petscstack->line[petscstack
->currentsize] = 0; petscstack->petscroutine[petscstack
->currentsize] = PETSC_FALSE; } if (petscstack) { petscstack
->hotdepth = (((petscstack->hotdepth-1)<(0)) ? (0) :
(petscstack->hotdepth-1)); } ; } while (0); return(0);} while
(0); } static inline __attribute((unused)) PetscErrorCode PetscHashIJKLDestroy
(PetscHashIJKL *ht) { do { do { ; if (petscstack && (
petscstack->currentsize < 64)) { petscstack->function
[petscstack->currentsize] = __func__; petscstack->file[
petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 18; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); if (!*ht) do { do { ; if (petscstack &&
petscstack->currentsize > 0) { petscstack->currentsize
--; petscstack->function[petscstack->currentsize] = 0; petscstack
->file[petscstack->currentsize] = 0; petscstack->line
[petscstack->currentsize] = 0; petscstack->petscroutine
[petscstack->currentsize] = PETSC_FALSE; } if (petscstack)
{ petscstack->hotdepth = (((petscstack->hotdepth-1)<
(0)) ? (0) : (petscstack->hotdepth-1)); } ; } while (0); return
(0);} while (0); kh_destroy_HashIJKL(*ht); *ht = ((void*)0); do
{ do { ; if (petscstack && petscstack->currentsize
> 0) { petscstack->currentsize--; petscstack->function
[petscstack->currentsize] = 0; petscstack->file[petscstack
->currentsize] = 0; petscstack->line[petscstack->currentsize
] = 0; petscstack->petscroutine[petscstack->currentsize
] = PETSC_FALSE; } if (petscstack) { petscstack->hotdepth =
(((petscstack->hotdepth-1)<(0)) ? (0) : (petscstack->
hotdepth-1)); } ; } while (0); return(0);} while (0); } static
inline __attribute((unused)) PetscErrorCode PetscHashIJKLReset
(PetscHashIJKL ht) { do { do { ; if (petscstack && (petscstack
->currentsize < 64)) { petscstack->function[petscstack
->currentsize] = __func__; petscstack->file[petscstack->
currentsize] = "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 18; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); { if (ht) { free((ht)->keys); free((ht)->
flags); free((ht)->vals); memset((ht), 0x00, sizeof(*(ht))
); } }; do { do { ; if (petscstack && petscstack->
currentsize > 0) { petscstack->currentsize--; petscstack
->function[petscstack->currentsize] = 0; petscstack->
file[petscstack->currentsize] = 0; petscstack->line[petscstack
->currentsize] = 0; petscstack->petscroutine[petscstack
->currentsize] = PETSC_FALSE; } if (petscstack) { petscstack
->hotdepth = (((petscstack->hotdepth-1)<(0)) ? (0) :
(petscstack->hotdepth-1)); } ; } while (0); return(0);} while
(0); } static inline __attribute((unused)) PetscErrorCode PetscHashIJKLDuplicate
(PetscHashIJKL ht,PetscHashIJKL *hd) { int ret; PetscHashIJKLKey
key; PetscInt val; do { do { ; if (petscstack && (petscstack
->currentsize < 64)) { petscstack->function[petscstack
->currentsize] = __func__; petscstack->file[petscstack->
currentsize] = "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 18; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!hd) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",2); if
(!PetscCheckPointer(hd,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",2);
} while (0); *hd = kh_init_HashIJKL(); do { if (__builtin_expect
(!!(!(*hd!=((void*)0))),0)) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","*hd!=((void*)0)"
); } while(0); ret = kh_resize_HashIJKL(*hd, ((ht)->size))
; do { if (__builtin_expect(!!(!(ret==0)),0)) return PetscError
(((MPI_Comm)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","ret==0"
); } while(0); { khint_t __i; for (__i = (khint_t)(0); __i !=
((ht)->n_buckets); ++__i) { if (!(!(((ht)->flags[(__i)
>>4]>>(((__i)&0xfU)<<1))&3))) continue
; (key) = ((ht)->keys[__i]); (val) = ((ht)->vals[__i]);
{ khiter_t i; i = kh_put_HashIJKL(*hd, key, &ret); do { if
(__builtin_expect(!!(!(ret>=0)),0)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","ret>=0"
); } while(0); ((*hd)->vals[i]) = val;}; } } do { do { ; if
(petscstack && petscstack->currentsize > 0) { petscstack
->currentsize--; petscstack->function[petscstack->currentsize
] = 0; petscstack->file[petscstack->currentsize] = 0; petscstack
->line[petscstack->currentsize] = 0; petscstack->petscroutine
[petscstack->currentsize] = PETSC_FALSE; } if (petscstack)
{ petscstack->hotdepth = (((petscstack->hotdepth-1)<
(0)) ? (0) : (petscstack->hotdepth-1)); } ; } while (0); return
(0);} while (0); } static inline __attribute((unused)) PetscErrorCode
PetscHashIJKLClear(PetscHashIJKL ht) { do { do { ; if (petscstack
&& (petscstack->currentsize < 64)) { petscstack
->function[petscstack->currentsize] = __func__; petscstack
->file[petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 18; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); kh_clear_HashIJKL(ht); do { do { ; if (petscstack
&& petscstack->currentsize > 0) { petscstack->
currentsize--; petscstack->function[petscstack->currentsize
] = 0; petscstack->file[petscstack->currentsize] = 0; petscstack
->line[petscstack->currentsize] = 0; petscstack->petscroutine
[petscstack->currentsize] = PETSC_FALSE; } if (petscstack)
{ petscstack->hotdepth = (((petscstack->hotdepth-1)<
(0)) ? (0) : (petscstack->hotdepth-1)); } ; } while (0); return
(0);} while (0); } static inline __attribute((unused)) PetscErrorCode
PetscHashIJKLResize(PetscHashIJKL ht,PetscInt nb) { int ret;
do { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 18; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); ret = kh_resize_HashIJKL(ht, (khint_t)nb); do {
if (__builtin_expect(!!(!(ret>=0)),0)) return PetscError(
((MPI_Comm)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","ret>=0"
); } while(0); do { do { ; if (petscstack && petscstack
->currentsize > 0) { petscstack->currentsize--; petscstack
->function[petscstack->currentsize] = 0; petscstack->
file[petscstack->currentsize] = 0; petscstack->line[petscstack
->currentsize] = 0; petscstack->petscroutine[petscstack
->currentsize] = PETSC_FALSE; } if (petscstack) { petscstack
->hotdepth = (((petscstack->hotdepth-1)<(0)) ? (0) :
(petscstack->hotdepth-1)); } ; } while (0); return(0);} while
(0); } static inline __attribute((unused)) PetscErrorCode PetscHashIJKLGetSize
(PetscHashIJKL ht,PetscInt *n) { do { do { ; if (petscstack &&
(petscstack->currentsize < 64)) { petscstack->function
[petscstack->currentsize] = __func__; petscstack->file[
petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 18; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!n) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",2); if
(!PetscCheckPointer(n,PETSC_INT)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer to Int: Parameter # %d"
,2); } while (0); *n = (PetscInt)((ht)->size); do { do { ;
if (petscstack && petscstack->currentsize > 0)
{ petscstack->currentsize--; petscstack->function[petscstack
->currentsize] = 0; petscstack->file[petscstack->currentsize
] = 0; petscstack->line[petscstack->currentsize] = 0; petscstack
->petscroutine[petscstack->currentsize] = PETSC_FALSE; }
if (petscstack) { petscstack->hotdepth = (((petscstack->
hotdepth-1)<(0)) ? (0) : (petscstack->hotdepth-1)); } ;
} while (0); return(0);} while (0); } static inline __attribute
((unused)) PetscErrorCode PetscHashIJKLHas(PetscHashIJKL ht,PetscHashIJKLKey
key,PetscBool *has) { khiter_t iter; do { do { ; if (petscstack
&& (petscstack->currentsize < 64)) { petscstack
->function[petscstack->currentsize] = __func__; petscstack
->file[petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 18; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!has) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",3); if
(!PetscCheckPointer(has,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",3);
} while (0); iter = kh_get_HashIJKL(ht, key); *has = (iter !=
((ht)->n_buckets)) ? PETSC_TRUE : PETSC_FALSE; do { do { ;
if (petscstack && petscstack->currentsize > 0)
{ petscstack->currentsize--; petscstack->function[petscstack
->currentsize] = 0; petscstack->file[petscstack->currentsize
] = 0; petscstack->line[petscstack->currentsize] = 0; petscstack
->petscroutine[petscstack->currentsize] = PETSC_FALSE; }
if (petscstack) { petscstack->hotdepth = (((petscstack->
hotdepth-1)<(0)) ? (0) : (petscstack->hotdepth-1)); } ;
} while (0); return(0);} while (0); } static inline __attribute
((unused)) PetscErrorCode PetscHashIJKLGet(PetscHashIJKL ht,PetscHashIJKLKey
key,PetscInt *val) { khiter_t iter; do { do { ; if (petscstack
&& (petscstack->currentsize < 64)) { petscstack
->function[petscstack->currentsize] = __func__; petscstack
->file[petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 18; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!val) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",3); if
(!PetscCheckPointer(val,PETSC_INT)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer to Int: Parameter # %d"
,3); } while (0); iter = kh_get_HashIJKL(ht, key); *val = (iter
!= ((ht)->n_buckets)) ? ((ht)->vals[iter]) : (-1); do {
do { ; if (petscstack && petscstack->currentsize >
0) { petscstack->currentsize--; petscstack->function[petscstack
->currentsize] = 0; petscstack->file[petscstack->currentsize
] = 0; petscstack->line[petscstack->currentsize] = 0; petscstack
->petscroutine[petscstack->currentsize] = PETSC_FALSE; }
if (petscstack) { petscstack->hotdepth = (((petscstack->
hotdepth-1)<(0)) ? (0) : (petscstack->hotdepth-1)); } ;
} while (0); return(0);} while (0); } static inline __attribute
((unused)) PetscErrorCode PetscHashIJKLSet(PetscHashIJKL ht,PetscHashIJKLKey
key,PetscInt val) { int ret; khiter_t iter; do { do { ; if (
petscstack && (petscstack->currentsize < 64)) {
petscstack->function[petscstack->currentsize] = __func__
; petscstack->file[petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 18; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); iter = kh_put_HashIJKL(ht, key, &ret); do {
if (__builtin_expect(!!(!(ret>=0)),0)) return PetscError(
((MPI_Comm)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","ret>=0"
); } while(0); ((ht)->vals[iter]) = val; do { do { ; if (petscstack
&& petscstack->currentsize > 0) { petscstack->
currentsize--; petscstack->function[petscstack->currentsize
] = 0; petscstack->file[petscstack->currentsize] = 0; petscstack
->line[petscstack->currentsize] = 0; petscstack->petscroutine
[petscstack->currentsize] = PETSC_FALSE; } if (petscstack)
{ petscstack->hotdepth = (((petscstack->hotdepth-1)<
(0)) ? (0) : (petscstack->hotdepth-1)); } ; } while (0); return
(0);} while (0); } static inline __attribute((unused)) PetscErrorCode
PetscHashIJKLDel(PetscHashIJKL ht,PetscHashIJKLKey key) { khiter_t
iter; do { do { ; if (petscstack && (petscstack->
currentsize < 64)) { petscstack->function[petscstack->
currentsize] = __func__; petscstack->file[petscstack->currentsize
] = "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 18; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); iter = kh_get_HashIJKL(ht, key); kh_del_HashIJKL
(ht, iter); do { do { ; if (petscstack && petscstack->
currentsize > 0) { petscstack->currentsize--; petscstack
->function[petscstack->currentsize] = 0; petscstack->
file[petscstack->currentsize] = 0; petscstack->line[petscstack
->currentsize] = 0; petscstack->petscroutine[petscstack
->currentsize] = PETSC_FALSE; } if (petscstack) { petscstack
->hotdepth = (((petscstack->hotdepth-1)<(0)) ? (0) :
(petscstack->hotdepth-1)); } ; } while (0); return(0);} while
(0); } static inline __attribute((unused)) PetscErrorCode PetscHashIJKLQuerySet
(PetscHashIJKL ht,PetscHashIJKLKey key,PetscInt val,PetscBool
*missing) { int ret; khiter_t iter; do { do { ; if (petscstack
&& (petscstack->currentsize < 64)) { petscstack
->function[petscstack->currentsize] = __func__; petscstack
->file[petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 18; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!missing) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",3); if
(!PetscCheckPointer(missing,PETSC_CHAR)) return PetscError((
(MPI_Comm)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",3);
} while (0); iter = kh_put_HashIJKL(ht, key, &ret); do {
if (__builtin_expect(!!(!(ret>=0)),0)) return PetscError(
((MPI_Comm)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","ret>=0"
); } while(0); ((ht)->vals[iter]) = val; *missing = ret ? PETSC_TRUE
: PETSC_FALSE; do { do { ; if (petscstack && petscstack
->currentsize > 0) { petscstack->currentsize--; petscstack
->function[petscstack->currentsize] = 0; petscstack->
file[petscstack->currentsize] = 0; petscstack->line[petscstack
->currentsize] = 0; petscstack->petscroutine[petscstack
->currentsize] = PETSC_FALSE; } if (petscstack) { petscstack
->hotdepth = (((petscstack->hotdepth-1)<(0)) ? (0) :
(petscstack->hotdepth-1)); } ; } while (0); return(0);} while
(0); } static inline __attribute((unused)) PetscErrorCode PetscHashIJKLQueryDel
(PetscHashIJKL ht,PetscHashIJKLKey key,PetscBool *present) { khiter_t
iter; do { do { ; if (petscstack && (petscstack->
currentsize < 64)) { petscstack->function[petscstack->
currentsize] = __func__; petscstack->file[petscstack->currentsize
] = "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 18; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!present) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",3); if
(!PetscCheckPointer(present,PETSC_CHAR)) return PetscError((
(MPI_Comm)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",3);
} while (0); iter = kh_get_HashIJKL(ht, key); if (iter != ((
ht)->n_buckets)) { kh_del_HashIJKL(ht, iter); *present = PETSC_TRUE
; } else { *present = PETSC_FALSE; } do { do { ; if (petscstack
&& petscstack->currentsize > 0) { petscstack->
currentsize--; petscstack->function[petscstack->currentsize
] = 0; petscstack->file[petscstack->currentsize] = 0; petscstack
->line[petscstack->currentsize] = 0; petscstack->petscroutine
[petscstack->currentsize] = PETSC_FALSE; } if (petscstack)
{ petscstack->hotdepth = (((petscstack->hotdepth-1)<
(0)) ? (0) : (petscstack->hotdepth-1)); } ; } while (0); return
(0);} while (0); } static inline __attribute((unused)) PetscErrorCode
PetscHashIJKLFind(PetscHashIJKL ht,PetscHashIJKLKey key,PetscHashIter
*iter,PetscBool *found) { do { do { ; if (petscstack &&
(petscstack->currentsize < 64)) { petscstack->function
[petscstack->currentsize] = __func__; petscstack->file[
petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 18; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!iter) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",2); if
(!PetscCheckPointer(iter,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",2);
} while (0); do { if (!found) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",3); if
(!PetscCheckPointer(found,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",3);
} while (0); *iter = kh_get_HashIJKL(ht, key); *found = (*iter
!= ((ht)->n_buckets)) ? PETSC_TRUE : PETSC_FALSE; do { do
{ ; if (petscstack && petscstack->currentsize >
0) { petscstack->currentsize--; petscstack->function[petscstack
->currentsize] = 0; petscstack->file[petscstack->currentsize
] = 0; petscstack->line[petscstack->currentsize] = 0; petscstack
->petscroutine[petscstack->currentsize] = PETSC_FALSE; }
if (petscstack) { petscstack->hotdepth = (((petscstack->
hotdepth-1)<(0)) ? (0) : (petscstack->hotdepth-1)); } ;
} while (0); return(0);} while (0); } static inline __attribute
((unused)) PetscErrorCode PetscHashIJKLPut(PetscHashIJKL ht,PetscHashIJKLKey
key,PetscHashIter *iter,PetscBool *missing) { int ret; do { do
{ ; if (petscstack && (petscstack->currentsize <
64)) { petscstack->function[petscstack->currentsize] =
__func__; petscstack->file[petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 18; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!iter) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",2); if
(!PetscCheckPointer(iter,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",2);
} while (0); do { if (!missing) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",3); if
(!PetscCheckPointer(missing,PETSC_CHAR)) return PetscError((
(MPI_Comm)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",3);
} while (0); *iter = kh_put_HashIJKL(ht, key, &ret); do {
if (__builtin_expect(!!(!(ret>=0)),0)) return PetscError(
((MPI_Comm)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","ret>=0"
); } while(0); *missing = ret ? PETSC_TRUE : PETSC_FALSE; do {
do { ; if (petscstack && petscstack->currentsize >
0) { petscstack->currentsize--; petscstack->function[petscstack
->currentsize] = 0; petscstack->file[petscstack->currentsize
] = 0; petscstack->line[petscstack->currentsize] = 0; petscstack
->petscroutine[petscstack->currentsize] = PETSC_FALSE; }
if (petscstack) { petscstack->hotdepth = (((petscstack->
hotdepth-1)<(0)) ? (0) : (petscstack->hotdepth-1)); } ;
} while (0); return(0);} while (0); } static inline __attribute
((unused)) PetscErrorCode PetscHashIJKLIterGet(PetscHashIJKL ht
,PetscHashIter iter,PetscInt *val) { do { do { ; if (petscstack
&& (petscstack->currentsize < 64)) { petscstack
->function[petscstack->currentsize] = __func__; petscstack
->file[petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 18; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!val) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",3); if
(!PetscCheckPointer(val,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",3);
} while (0); *val = __builtin_expect(!!(iter < ((ht)->
n_buckets) && (!(((ht)->flags[(iter)>>4]>>
(((iter)&0xfU)<<1))&3))),1) ? ((ht)->vals[iter
]) : (-1); do { do { ; if (petscstack && petscstack->
currentsize > 0) { petscstack->currentsize--; petscstack
->function[petscstack->currentsize] = 0; petscstack->
file[petscstack->currentsize] = 0; petscstack->line[petscstack
->currentsize] = 0; petscstack->petscroutine[petscstack
->currentsize] = PETSC_FALSE; } if (petscstack) { petscstack
->hotdepth = (((petscstack->hotdepth-1)<(0)) ? (0) :
(petscstack->hotdepth-1)); } ; } while (0); return(0);} while
(0); } static inline __attribute((unused)) PetscErrorCode PetscHashIJKLIterSet
(PetscHashIJKL ht,PetscHashIter iter,PetscInt val) { do { do {
; if (petscstack && (petscstack->currentsize <
64)) { petscstack->function[petscstack->currentsize] =
__func__; petscstack->file[petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 18; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); if (__builtin_expect(!!(iter < ((ht)->n_buckets
) && (!(((ht)->flags[(iter)>>4]>>(((iter
)&0xfU)<<1))&3))),1)) ((ht)->vals[iter]) = val
; do { do { ; if (petscstack && petscstack->currentsize
> 0) { petscstack->currentsize--; petscstack->function
[petscstack->currentsize] = 0; petscstack->file[petscstack
->currentsize] = 0; petscstack->line[petscstack->currentsize
] = 0; petscstack->petscroutine[petscstack->currentsize
] = PETSC_FALSE; } if (petscstack) { petscstack->hotdepth =
(((petscstack->hotdepth-1)<(0)) ? (0) : (petscstack->
hotdepth-1)); } ; } while (0); return(0);} while (0); } static
inline __attribute((unused)) PetscErrorCode PetscHashIJKLIterDel
(PetscHashIJKL ht,PetscHashIter iter) { do { do { ; if (petscstack
&& (petscstack->currentsize < 64)) { petscstack
->function[petscstack->currentsize] = __func__; petscstack
->file[petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 18; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); if (__builtin_expect(!!(iter < ((ht)->n_buckets
)),1)) kh_del_HashIJKL(ht, iter); do { do { ; if (petscstack &&
petscstack->currentsize > 0) { petscstack->currentsize
--; petscstack->function[petscstack->currentsize] = 0; petscstack
->file[petscstack->currentsize] = 0; petscstack->line
[petscstack->currentsize] = 0; petscstack->petscroutine
[petscstack->currentsize] = PETSC_FALSE; } if (petscstack)
{ petscstack->hotdepth = (((petscstack->hotdepth-1)<
(0)) ? (0) : (petscstack->hotdepth-1)); } ; } while (0); return
(0);} while (0); } static inline __attribute((unused)) PetscErrorCode
PetscHashIJKLGetKeys(PetscHashIJKL ht,PetscInt *off,PetscHashIJKLKey
array[]) { PetscHashIJKLKey key; PetscInt pos; do { do { ; if
(petscstack && (petscstack->currentsize < 64))
{ petscstack->function[petscstack->currentsize] = __func__
; petscstack->file[petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 18; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!off) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",2); if
(!PetscCheckPointer(off,PETSC_INT)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer to Int: Parameter # %d"
,2); } while (0); pos = *off; { khint_t __i; for (__i = (khint_t
)(0); __i != ((ht)->n_buckets); ++__i) { if (!(!(((ht)->
flags[(__i)>>4]>>(((__i)&0xfU)<<1))&
3))) continue; (key) = ((ht)->keys[__i]); array[pos++] = key
; } }; *off = pos; do { do { ; if (petscstack && petscstack
->currentsize > 0) { petscstack->currentsize--; petscstack
->function[petscstack->currentsize] = 0; petscstack->
file[petscstack->currentsize] = 0; petscstack->line[petscstack
->currentsize] = 0; petscstack->petscroutine[petscstack
->currentsize] = PETSC_FALSE; } if (petscstack) { petscstack
->hotdepth = (((petscstack->hotdepth-1)<(0)) ? (0) :
(petscstack->hotdepth-1)); } ; } while (0); return(0);} while
(0); } static inline __attribute((unused)) PetscErrorCode PetscHashIJKLGetVals
(PetscHashIJKL ht,PetscInt *off,PetscInt array[]) { PetscInt val
; PetscInt pos; do { do { ; if (petscstack && (petscstack
->currentsize < 64)) { petscstack->function[petscstack
->currentsize] = __func__; petscstack->file[petscstack->
currentsize] = "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 18; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!off) return PetscError(((MPI_Comm)0x44000001
),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",2); if
(!PetscCheckPointer(off,PETSC_INT)) return PetscError(((MPI_Comm
)0x44000001),18,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer to Int: Parameter # %d"
,2); } while (0); pos = *off; { khint_t __i; for (__i = (khint_t
)(0); __i != ((ht)->n_buckets); ++__i) { if (!(!(((ht)->
flags[(__i)>>4]>>(((__i)&0xfU)<<1))&
3))) continue; (val) = ((ht)->vals[__i]); array[pos++] = val
; } }; *off = pos; do { do { ; if (petscstack && petscstack
->currentsize > 0) { petscstack->currentsize--; petscstack
->function[petscstack->currentsize] = 0; petscstack->
file[petscstack->currentsize] = 0; petscstack->line[petscstack
->currentsize] = 0; petscstack->petscroutine[petscstack
->currentsize] = PETSC_FALSE; } if (petscstack) { petscstack
->hotdepth = (((petscstack->hotdepth-1)<(0)) ? (0) :
(petscstack->hotdepth-1)); } ; } while (0); return(0);} while
(0); }

DMPlexGetFaces_Internal - Gets groups of vertices that correspond to faces for the given cell

This assumes that the mesh is not interpolated from the depth of point p to the vertices

PetscErrorCode DMPlexGetFaces_Internal(DM dm, PetscInt dim, PetscInt p, PetscInt *numFaces, PetscInt *faceSize, const PetscInt *faces[])

{

const PetscInt *cone = NULL((void*)0);

PetscInt coneSize;

PetscErrorCode ierr;

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 31; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

PetscValidHeaderSpecific(dm, DM_CLASSID, 1)do { if (!dm) return PetscError(((MPI_Comm)0x44000001),32,__func__
,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Object: Parameter # %d",1); if (
!PetscCheckPointer(dm,PETSC_OBJECT)) return PetscError(((MPI_Comm
)0x44000001),32,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,64,PETSC_ERROR_INITIAL,"Invalid Pointer to Object: Parameter # %d"
,1); if (((PetscObject)(dm))->classid != DM_CLASSID) { if (
((PetscObject)(dm))->classid == -1) return PetscError(((MPI_Comm
)0x44000001),32,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,64,PETSC_ERROR_INITIAL,"Object already free: Parameter # %d"
,1); else return PetscError(((MPI_Comm)0x44000001),32,__func__
,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,62,PETSC_ERROR_INITIAL,"Wrong type of object: Parameter # %d"
,1); } } while (0);

ierr = DMPlexGetConeSize(dm, p, &coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),33,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

ierr = DMPlexGetCone(dm, p, &cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),34,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

ierr = DMPlexGetRawFaces_Internal(dm, dim, coneSize, cone, numFaces, faceSize, faces);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),35,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

PetscFunctionReturn(0)do { do { ; if (petscstack && petscstack->currentsize
> 0) { petscstack->currentsize--; petscstack->function
[petscstack->currentsize] = 0; petscstack->file[petscstack
->currentsize] = 0; petscstack->line[petscstack->currentsize
] = 0; petscstack->petscroutine[petscstack->currentsize
] = PETSC_FALSE; } if (petscstack) { petscstack->hotdepth =
(((petscstack->hotdepth-1)<(0)) ? (0) : (petscstack->
hotdepth-1)); } ; } while (0); return(0);} while (0);

}

DMPlexRestoreFaces_Internal - Restores the array

PetscErrorCode DMPlexRestoreFaces_Internal(DM dm, PetscInt dim, PetscInt p, PetscInt *numFaces, PetscInt *faceSize, const PetscInt *faces[])

{

PetscErrorCode ierr;

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 46; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

if (faces) { ierr = DMRestoreWorkArray(dm, 0, MPIU_INT((MPI_Datatype)0x4c000405), (void *) faces);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),47,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); }

}

DMPlexGetRawFaces_Internal - Gets groups of vertices that correspond to faces for the given cone

PetscErrorCode DMPlexGetRawFaces_Internal(DM dm, PetscInt dim, PetscInt coneSize, const PetscInt cone[], PetscInt *numFaces, PetscInt *faceSize, const PetscInt *faces[])

{

PetscInt *facesTmp;

PetscInt maxConeSize, maxSupportSize;

PetscErrorCode ierr;

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 60; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

PetscValidHeaderSpecific(dm, DM_CLASSID, 1)do { if (!dm) return PetscError(((MPI_Comm)0x44000001),61,__func__
,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Object: Parameter # %d",1); if (
!PetscCheckPointer(dm,PETSC_OBJECT)) return PetscError(((MPI_Comm
)0x44000001),61,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,64,PETSC_ERROR_INITIAL,"Invalid Pointer to Object: Parameter # %d"
,1); if (((PetscObject)(dm))->classid != DM_CLASSID) { if (
((PetscObject)(dm))->classid == -1) return PetscError(((MPI_Comm
)0x44000001),61,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,64,PETSC_ERROR_INITIAL,"Object already free: Parameter # %d"
,1); else return PetscError(((MPI_Comm)0x44000001),61,__func__
,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,62,PETSC_ERROR_INITIAL,"Wrong type of object: Parameter # %d"
,1); } } while (0);

if (faces && coneSize) PetscValidIntPointer(cone,4)do { if (!cone) return PetscError(((MPI_Comm)0x44000001),62,__func__
,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",4); if
(!PetscCheckPointer(cone,PETSC_INT)) return PetscError(((MPI_Comm
)0x44000001),62,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer to Int: Parameter # %d"
,4); } while (0);

ierr = DMPlexGetMaxSizes(dm, &maxConeSize, &maxSupportSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),63,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

if (faces) {ierr = DMGetWorkArray(dm, PetscSqr(PetscMax(maxConeSize, maxSupportSize))(((((maxConeSize)<(maxSupportSize)) ? (maxSupportSize) : (
maxConeSize)))*((((maxConeSize)<(maxSupportSize)) ? (maxSupportSize
) : (maxConeSize)))), MPIU_INT((MPI_Datatype)0x4c000405), &facesTmp);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),64,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

switch (dim) {

case 1:

switch (coneSize) {

case 2:

if (faces) {

facesTmp[0] = cone[0]; facesTmp[1] = cone[1];

*faces = facesTmp;

}

if (numFaces) *numFaces = 2;

if (faceSize) *faceSize = 1;

break;

default:

SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Cone size %D not supported for dimension %D", coneSize, dim)return PetscError(((MPI_Comm)0x44000001),77,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,63,PETSC_ERROR_INITIAL,"Cone size %D not supported for dimension %D"
,coneSize,dim);

}

break;

case 2:

switch (coneSize) {

case 3:

if (faces) {

facesTmp[0] = cone[0]; facesTmp[1] = cone[1];

facesTmp[2] = cone[1]; facesTmp[3] = cone[2];

facesTmp[4] = cone[2]; facesTmp[5] = cone[0];

*faces = facesTmp;

}

if (numFaces) *numFaces = 3;

if (faceSize) *faceSize = 2;

break;

case 4:

/* Vertices follow right hand rule */

if (faces) {

facesTmp[0] = cone[0]; facesTmp[1] = cone[1];

facesTmp[2] = cone[1]; facesTmp[3] = cone[2];

facesTmp[4] = cone[2]; facesTmp[5] = cone[3];

facesTmp[6] = cone[3]; facesTmp[7] = cone[0];

*faces = facesTmp;

100

}

101

if (numFaces) *numFaces = 4;

102

if (faceSize) *faceSize = 2;

103

break;

104

default:

105

SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Cone size %D not supported for dimension %D", coneSize, dim)return PetscError(((MPI_Comm)0x44000001),105,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,63,PETSC_ERROR_INITIAL,"Cone size %D not supported for dimension %D"
,coneSize,dim);

106

}

107

break;

108

case 3:

109

switch (coneSize) {

110

case 3:

111

if (faces) {

112

facesTmp[0] = cone[0]; facesTmp[1] = cone[1];

113

facesTmp[2] = cone[1]; facesTmp[3] = cone[2];

114

facesTmp[4] = cone[2]; facesTmp[5] = cone[0];

115

*faces = facesTmp;

116

}

117

if (numFaces) *numFaces = 3;

118

if (faceSize) *faceSize = 2;

119

break;

120

case 4:

121

/* Vertices of first face follow right hand rule and normal points away from last vertex */

122

if (faces) {

123

facesTmp[0] = cone[0]; facesTmp[1] = cone[1]; facesTmp[2] = cone[2];

124

facesTmp[3] = cone[0]; facesTmp[4] = cone[3]; facesTmp[5] = cone[1];

125

facesTmp[6] = cone[0]; facesTmp[7] = cone[2]; facesTmp[8] = cone[3];

126

facesTmp[9] = cone[2]; facesTmp[10] = cone[1]; facesTmp[11] = cone[3];

127

*faces = facesTmp;

128

}

129

if (numFaces) *numFaces = 4;

130

if (faceSize) *faceSize = 3;

131

break;

132

case 8:

133

/* 7--------6

134

/| /|

135

/ | / |

136

4--------5 |

137

| | | |

138

| | | |

139

| 1--------2

140

| / | /

141

|/ |/

142

0--------3

143

144

if (faces) {

145

facesTmp[0] = cone[0]; facesTmp[1] = cone[1]; facesTmp[2] = cone[2]; facesTmp[3] = cone[3]; /* Bottom */

146

facesTmp[4] = cone[4]; facesTmp[5] = cone[5]; facesTmp[6] = cone[6]; facesTmp[7] = cone[7]; /* Top */

147

facesTmp[8] = cone[0]; facesTmp[9] = cone[3]; facesTmp[10] = cone[5]; facesTmp[11] = cone[4]; /* Front */

148

facesTmp[12] = cone[2]; facesTmp[13] = cone[1]; facesTmp[14] = cone[7]; facesTmp[15] = cone[6]; /* Back */

149

facesTmp[16] = cone[3]; facesTmp[17] = cone[2]; facesTmp[18] = cone[6]; facesTmp[19] = cone[5]; /* Right */

150

facesTmp[20] = cone[0]; facesTmp[21] = cone[4]; facesTmp[22] = cone[7]; facesTmp[23] = cone[1]; /* Left */

151

*faces = facesTmp;

152

}

153

if (numFaces) *numFaces = 6;

154

if (faceSize) *faceSize = 4;

155

break;

156

default:

157

SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Cone size %D not supported for dimension %D", coneSize, dim)return PetscError(((MPI_Comm)0x44000001),157,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,63,PETSC_ERROR_INITIAL,"Cone size %D not supported for dimension %D"
,coneSize,dim);

158

}

159

break;

160

default:

161

SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Dimension %D not supported", dim)return PetscError(((MPI_Comm)0x44000001),161,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,63,PETSC_ERROR_INITIAL,"Dimension %D not supported",dim);

162

}

163

164

}

165

166

167

DMPlexGetRawFacesHybrid_Internal - Gets groups of vertices that correspond to faces for the given cone using hybrid ordering (prisms)

168

169

static PetscErrorCode DMPlexGetRawFacesHybrid_Internal(DM dm, PetscInt dim, PetscInt coneSize, const PetscInt cone[], PetscInt *numFaces, PetscInt *numFacesNotH, PetscInt *faceSize, const PetscInt *faces[])

170

{

171

PetscInt *facesTmp;

172

PetscInt maxConeSize, maxSupportSize;

173

PetscErrorCode ierr;

174

175

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 175; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

176

PetscValidHeaderSpecific(dm, DM_CLASSID, 1)do { if (!dm) return PetscError(((MPI_Comm)0x44000001),176,__func__
,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Object: Parameter # %d",1); if (
!PetscCheckPointer(dm,PETSC_OBJECT)) return PetscError(((MPI_Comm
)0x44000001),176,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,64,PETSC_ERROR_INITIAL,"Invalid Pointer to Object: Parameter # %d"
,1); if (((PetscObject)(dm))->classid != DM_CLASSID) { if (
((PetscObject)(dm))->classid == -1) return PetscError(((MPI_Comm
)0x44000001),176,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,64,PETSC_ERROR_INITIAL,"Object already free: Parameter # %d"
,1); else return PetscError(((MPI_Comm)0x44000001),176,__func__
,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,62,PETSC_ERROR_INITIAL,"Wrong type of object: Parameter # %d"
,1); } } while (0);

177

if (faces && coneSize) PetscValidIntPointer(cone,4)do { if (!cone) return PetscError(((MPI_Comm)0x44000001),177,
__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",4); if
(!PetscCheckPointer(cone,PETSC_INT)) return PetscError(((MPI_Comm
)0x44000001),177,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer to Int: Parameter # %d"
,4); } while (0);

178

ierr = DMPlexGetMaxSizes(dm, &maxConeSize, &maxSupportSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),178,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

179

if (faces) {ierr = DMGetWorkArray(dm, PetscSqr(PetscMax(maxConeSize, maxSupportSize))(((((maxConeSize)<(maxSupportSize)) ? (maxSupportSize) : (
maxConeSize)))*((((maxConeSize)<(maxSupportSize)) ? (maxSupportSize
) : (maxConeSize)))), MPIU_INT((MPI_Datatype)0x4c000405), &facesTmp);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),179,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

180

switch (dim) {

181

case 1:

182

switch (coneSize) {

183

case 2:

184

if (faces) {

185

facesTmp[0] = cone[0]; facesTmp[1] = cone[1];

186

*faces = facesTmp;

187

}

188

if (numFaces) *numFaces = 2;

189

if (numFacesNotH) *numFacesNotH = 2;

190

if (faceSize) *faceSize = 1;

191

break;

192

default:

193

SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Cone size %D not supported for dimension %D", coneSize, dim)return PetscError(((MPI_Comm)0x44000001),193,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,63,PETSC_ERROR_INITIAL,"Cone size %D not supported for dimension %D"
,coneSize,dim);

194

}

195

break;

196

case 2:

197

switch (coneSize) {

198

case 4:

199

if (faces) {

200

facesTmp[0] = cone[0]; facesTmp[1] = cone[1];

201

facesTmp[2] = cone[2]; facesTmp[3] = cone[3];

202

facesTmp[4] = cone[0]; facesTmp[5] = cone[2];

203

facesTmp[6] = cone[1]; facesTmp[7] = cone[3];

204

*faces = facesTmp;

205

}

206

if (numFaces) *numFaces = 4;

207

if (numFacesNotH) *numFacesNotH = 2;

208

if (faceSize) *faceSize = 2;

209

break;

210

default:

211

SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Cone size %D not supported for dimension %D", coneSize, dim)return PetscError(((MPI_Comm)0x44000001),211,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,63,PETSC_ERROR_INITIAL,"Cone size %D not supported for dimension %D"
,coneSize,dim);

212

}

213

break;

214

case 3:

215

switch (coneSize) {

216

case 6: /* triangular prism */

217

if (faces) {

218

facesTmp[0] = cone[0]; facesTmp[1] = cone[1]; facesTmp[2] = cone[2]; facesTmp[3] = -1; /* Bottom */

219

facesTmp[4] = cone[3]; facesTmp[5] = cone[4]; facesTmp[6] = cone[5]; facesTmp[7] = -1; /* Top */

220

facesTmp[8] = cone[0]; facesTmp[9] = cone[1]; facesTmp[10] = cone[3]; facesTmp[11] = cone[4]; /* Back left */

221

facesTmp[12] = cone[1]; facesTmp[13] = cone[2]; facesTmp[14] = cone[4]; facesTmp[15] = cone[5]; /* Back right */

222

facesTmp[16] = cone[2]; facesTmp[17] = cone[0]; facesTmp[18] = cone[5]; facesTmp[19] = cone[3]; /* Front */

223

*faces = facesTmp;

224

}

225

if (numFaces) *numFaces = 5;

226

if (numFacesNotH) *numFacesNotH = 2;

227

if (faceSize) *faceSize = -4;

228

break;

229

default:

230

SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Cone size %D not supported for dimension %D", coneSize, dim)return PetscError(((MPI_Comm)0x44000001),230,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,63,PETSC_ERROR_INITIAL,"Cone size %D not supported for dimension %D"
,coneSize,dim);

231

}

232

break;

233

default:

234

SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Dimension %D not supported", dim)return PetscError(((MPI_Comm)0x44000001),234,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,63,PETSC_ERROR_INITIAL,"Dimension %D not supported",dim);

235

}

236

237

}

238

239

static PetscErrorCode DMPlexRestoreRawFacesHybrid_Internal(DM dm, PetscInt dim, PetscInt coneSize, const PetscInt cone[], PetscInt *numFaces, PetscInt *numFacesNotH, PetscInt *faceSize, const PetscInt *faces[])

240

{

241

PetscErrorCode ierr;

242

243

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 243; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

244

if (faces) { ierr = DMRestoreWorkArray(dm, 0, MPIU_INT((MPI_Datatype)0x4c000405), (void *) faces);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),244,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0); }

245

246

}

247

248

static PetscErrorCode DMPlexGetFacesHybrid_Internal(DM dm, PetscInt dim, PetscInt p, PetscInt *numFaces, PetscInt *numFacesNotH, PetscInt *faceSize, const PetscInt *faces[])

249

{

250

const PetscInt *cone = NULL((void*)0);

251

PetscInt coneSize;

252

PetscErrorCode ierr;

253

254

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 254; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

255

PetscValidHeaderSpecific(dm, DM_CLASSID, 1)do { if (!dm) return PetscError(((MPI_Comm)0x44000001),255,__func__
,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Object: Parameter # %d",1); if (
!PetscCheckPointer(dm,PETSC_OBJECT)) return PetscError(((MPI_Comm
)0x44000001),255,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,64,PETSC_ERROR_INITIAL,"Invalid Pointer to Object: Parameter # %d"
,1); if (((PetscObject)(dm))->classid != DM_CLASSID) { if (
((PetscObject)(dm))->classid == -1) return PetscError(((MPI_Comm
)0x44000001),255,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,64,PETSC_ERROR_INITIAL,"Object already free: Parameter # %d"
,1); else return PetscError(((MPI_Comm)0x44000001),255,__func__
,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,62,PETSC_ERROR_INITIAL,"Wrong type of object: Parameter # %d"
,1); } } while (0);

256

ierr = DMPlexGetConeSize(dm, p, &coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),256,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

257

ierr = DMPlexGetCone(dm, p, &cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),257,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

258

ierr = DMPlexGetRawFacesHybrid_Internal(dm, dim, coneSize, cone, numFaces, numFacesNotH, faceSize, faces);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),258,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

259

260

}

261

262

/* This interpolates faces for cells at some stratum */

263

static PetscErrorCode DMPlexInterpolateFaces_Internal(DM dm, PetscInt cellDepth, DM idm)

264

{

265

DMLabel subpointMap;

266

PetscHashIJKL faceTable;

267

PetscInt *pStart, *pEnd;

268

PetscInt cellDim, depth, faceDepth = cellDepth, numPoints = 0, faceSizeAll = 0, face, c, d;

269

PetscInt coneSizeH = 0, faceSizeAllH = 0, numCellFacesH = 0, faceH, pMax = -1, dim, outerloop;

270

PetscInt cMax, fMax, eMax, vMax;

271

PetscErrorCode ierr;

272

273

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 273; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

274

ierr = DMGetDimension(dm, &cellDim);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),274,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

275

/* HACK: I need a better way to determine face dimension, or an alternative to GetFaces() */

276

ierr = DMPlexGetSubpointMap(dm, &subpointMap);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),276,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

277

if (subpointMap) ++cellDim;

278

ierr = DMPlexGetDepth(dm, &depth);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),278,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

279

++depth;

280

++cellDepth;

281

cellDim -= depth - cellDepth;

282

ierr = PetscMalloc2(depth+1,&pStart,depth+1,&pEnd)PetscMallocA(2,PETSC_FALSE,282,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,(size_t)(depth+1)*sizeof(**(&pStart)),(&pStart),(size_t
)(depth+1)*sizeof(**(&pEnd)),(&pEnd));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),282,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

283

for (d = depth-1; d >= faceDepth; --d) {

284

ierr = DMPlexGetDepthStratum(dm, d, &pStart[d+1], &pEnd[d+1]);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),284,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

285

}

286

ierr = DMPlexGetDepthStratum(dm, -1, NULL((void*)0), &pStart[faceDepth]);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),286,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

287

pEnd[faceDepth] = pStart[faceDepth];

288

for (d = faceDepth-1; d >= 0; --d) {

289

ierr = DMPlexGetDepthStratum(dm, d, &pStart[d], &pEnd[d]);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),289,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

290

}

291

cMax = fMax = eMax = vMax = PETSC_DETERMINE-1;

292

ierr = DMGetDimension(dm, &dim);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),292,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

293

if (cellDim == dim) {

294

ierr = DMPlexGetHybridBounds(dm, &cMax, NULL((void*)0), NULL((void*)0), NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),294,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

295

pMax = cMax;

296

} else if (cellDim == dim -1) {

297

ierr = DMPlexGetHybridBounds(dm, &cMax, &fMax, NULL((void*)0), NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),297,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

298

pMax = fMax;

299

}

300

pMax = pMax < 0 ? pEnd[cellDepth] : pMax;

301

if (pMax < pEnd[cellDepth]) {

302

const PetscInt *cellFaces, *cone;

303

PetscInt numCellFacesT, faceSize, cf;

304

305

ierr = DMPlexGetConeSize(dm, pMax, &coneSizeH);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),305,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

306

ierr = DMPlexGetCone(dm, pMax, &cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),306,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

307

ierr = DMPlexGetRawFacesHybrid_Internal(dm, cellDim, coneSizeH, cone, &numCellFacesH, &numCellFacesT, &faceSize, &cellFaces);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),307,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

308

if (faceSize < 0) {

309

PetscInt *sizes, minv, maxv;

310

311

/* count vertices of hybrid and non-hybrid faces */

312

ierr = PetscCalloc1(numCellFacesH, &sizes)PetscMallocA(1,PETSC_TRUE,312,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,(size_t)(numCellFacesH)*sizeof(**(&sizes)),(&sizes));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),312,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

313

for (cf = 0; cf < numCellFacesT; ++cf) { /* These are the non-hybrid faces */

314

const PetscInt *cellFace = &cellFaces[-cf*faceSize];

315

PetscInt f;

316

317

for (f = 0; f < -faceSize; ++f) sizes[cf] += (cellFace[f] >= 0 ? 1 : 0);

318

}

319

ierr = PetscSortInt(numCellFacesT, sizes);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),319,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

320

minv = sizes[0];

321

maxv = sizes[PetscMax(numCellFacesT-1, 0)(((numCellFacesT-1)<(0)) ? (0) : (numCellFacesT-1))];

322

if (minv != maxv) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_SUP, "Different number of vertices for non-hybrid face %D != %D", minv, maxv)return PetscError(((MPI_Comm)0x44000001),322,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,56,PETSC_ERROR_INITIAL,"Different number of vertices for non-hybrid face %D != %D"
,minv,maxv);

323

faceSizeAll = minv;

324

ierr = PetscMemzero(sizes, numCellFacesH*sizeof(PetscInt));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),324,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

325

for (cf = numCellFacesT; cf < numCellFacesH; ++cf) { /* These are the hybrid faces */

326

const PetscInt *cellFace = &cellFaces[-cf*faceSize];

327

PetscInt f;

328

329

for (f = 0; f < -faceSize; ++f) sizes[cf-numCellFacesT] += (cellFace[f] >= 0 ? 1 : 0);

330

}

331

ierr = PetscSortInt(numCellFacesH - numCellFacesT, sizes);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),331,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

332

minv = sizes[0];

333

maxv = sizes[PetscMax(numCellFacesH - numCellFacesT-1, 0)(((numCellFacesH - numCellFacesT-1)<(0)) ? (0) : (numCellFacesH
- numCellFacesT-1))];

334

ierr = PetscFree(sizes)((*PetscTrFree)((void*)(sizes),334,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
) || ((sizes) = 0,0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),334,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

335

if (minv != maxv) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_SUP, "Different number of vertices for hybrid face %D != %D", minv, maxv)return PetscError(((MPI_Comm)0x44000001),335,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,56,PETSC_ERROR_INITIAL,"Different number of vertices for hybrid face %D != %D"
,minv,maxv);

336

faceSizeAllH = minv;

337

} else { /* the size of the faces in hybrid cells is the same */

338

faceSizeAll = faceSizeAllH = faceSize;

339

}

340

ierr = DMPlexRestoreRawFacesHybrid_Internal(dm, cellDim, coneSizeH, cone, &numCellFacesH, &numCellFacesT, &faceSize, &cellFaces);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),340,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

341

} else if (pEnd[cellDepth] > pStart[cellDepth]) {

342

ierr = DMPlexGetFaces_Internal(dm, cellDim, pStart[cellDepth], NULL((void*)0), &faceSizeAll, NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),342,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

343

}

344

if (faceSizeAll > 4) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Do not support interpolation of meshes with faces of %D vertices", faceSizeAll)return PetscError(((MPI_Comm)0x44000001),344,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,62,PETSC_ERROR_INITIAL,"Do not support interpolation of meshes with faces of %D vertices"
,faceSizeAll);

345

346

/* With hybrid grids, we first iterate on hybrid cells and start numbering the non-hybrid faces

347

Then, faces for non-hybrid cells are numbered.

348

This is to guarantee consistent orientations (all 0) of all the points in the cone of the hybrid cells */

349

ierr = PetscHashIJKLCreate(&faceTable);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),349,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

350

for (outerloop = 0, face = pStart[faceDepth]; outerloop < 2; outerloop++) {

351

PetscInt start, end;

352

353

start = outerloop == 0 ? pMax : pStart[cellDepth];

354

end = outerloop == 0 ? pEnd[cellDepth] : pMax;

355

for (c = start; c < end; ++c) {

356

const PetscInt *cellFaces;

357

PetscInt numCellFaces, faceSize, faceSizeInc, cf;

358

359

if (c < pMax) {

360

ierr = DMPlexGetFaces_Internal(dm, cellDim, c, &numCellFaces, &faceSize, &cellFaces);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),360,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

361

if (faceSize != faceSizeAll) SETERRQ3(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Inconsistent face for cell %D of size %D != %D", c, faceSize, faceSizeAll)return PetscError(((MPI_Comm)0x44000001),361,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,77,PETSC_ERROR_INITIAL,"Inconsistent face for cell %D of size %D != %D"
,c,faceSize,faceSizeAll);

362

} else { /* Hybrid cell */

363

const PetscInt *cone;

364

PetscInt numCellFacesN, coneSize;

365

366

ierr = DMPlexGetConeSize(dm, c, &coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),366,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

367

if (coneSize != coneSizeH) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_SUP, "Unexpected hybrid coneSize %D != %D", coneSize, coneSizeH)return PetscError(((MPI_Comm)0x44000001),367,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,56,PETSC_ERROR_INITIAL,"Unexpected hybrid coneSize %D != %D"
,coneSize,coneSizeH);

368

ierr = DMPlexGetCone(dm, c, &cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),368,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

369

ierr = DMPlexGetRawFacesHybrid_Internal(dm, cellDim, coneSize, cone, &numCellFaces, &numCellFacesN, &faceSize, &cellFaces);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),369,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

370

if (numCellFaces != numCellFacesH) SETERRQ3(PETSC_COMM_SELF, PETSC_ERR_SUP, "Unexpected numCellFaces %D != %D for hybrid cell %D", numCellFaces, numCellFacesH, c)return PetscError(((MPI_Comm)0x44000001),370,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,56,PETSC_ERROR_INITIAL,"Unexpected numCellFaces %D != %D for hybrid cell %D"
,numCellFaces,numCellFacesH,c);

371

faceSize = PetscMax(faceSize, -faceSize)(((faceSize)<(-faceSize)) ? (-faceSize) : (faceSize));

372

if (faceSize > 4) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Do not support interpolation of meshes with faces of %D vertices", faceSize)return PetscError(((MPI_Comm)0x44000001),372,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,62,PETSC_ERROR_INITIAL,"Do not support interpolation of meshes with faces of %D vertices"
,faceSize);

373

numCellFaces = numCellFacesN; /* process only non-hybrid faces */

374

}

375

faceSizeInc = faceSize;

376

for (cf = 0; cf < numCellFaces; ++cf) {

377

const PetscInt *cellFace = &cellFaces[cf*faceSizeInc];

378

PetscInt faceSizeH = faceSize;

379

PetscHashIJKLKey key;

380

PetscHashIter iter;

381

PetscBool missing;

382

383

if (faceSizeInc == 2) {

384

key.i = PetscMin(cellFace[0], cellFace[1])(((cellFace[0])<(cellFace[1])) ? (cellFace[0]) : (cellFace
[1]));

385

key.j = PetscMax(cellFace[0], cellFace[1])(((cellFace[0])<(cellFace[1])) ? (cellFace[1]) : (cellFace
[0]));

386

key.k = PETSC_MAX_INT2147483647;

387

key.l = PETSC_MAX_INT2147483647;

388

} else {

389

key.i = cellFace[0];

390

key.j = cellFace[1];

391

key.k = cellFace[2];

392

key.l = faceSize > 3 ? (cellFace[3] < 0 ? faceSizeH = 3, PETSC_MAX_INT2147483647 : cellFace[3]) : PETSC_MAX_INT2147483647;

393

ierr = PetscSortInt(faceSize, (PetscInt *) &key);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),393,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

394

}

395

/* this check is redundant for non-hybrid meshes */

396

if (faceSizeH != faceSizeAll) SETERRQ4(PETSC_COMM_SELF, PETSC_ERR_SUP, "Unexpected number of vertices for face %D of point %D -> %D != %D", cf, c, faceSizeH, faceSizeAll)return PetscError(((MPI_Comm)0x44000001),396,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,56,PETSC_ERROR_INITIAL,"Unexpected number of vertices for face %D of point %D -> %D != %D"
,cf,c,faceSizeH,faceSizeAll);

397

ierr = PetscHashIJKLPut(faceTable, key, &iter, &missing);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),397,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

398

if (missing) {ierr = PetscHashIJKLIterSet(faceTable, iter, face++);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),398,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

399

}

400

if (c < pMax) {

401

ierr = DMPlexRestoreFaces_Internal(dm, cellDim, c, &numCellFaces, &faceSize, &cellFaces);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),401,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

402

} else {

403

ierr = DMPlexRestoreRawFacesHybrid_Internal(dm, cellDim, coneSizeH, NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), &cellFaces);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),403,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

404

}

405

}

406

}

407

pEnd[faceDepth] = face;

408

409

/* Second pass for hybrid meshes: number hybrid faces */

410

for (c = pMax; c < pEnd[cellDepth]; ++c) {

411

const PetscInt *cellFaces, *cone;

412

PetscInt numCellFaces, numCellFacesN, faceSize, cf, coneSize;

413

414

ierr = DMPlexGetConeSize(dm, c, &coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),414,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

415

ierr = DMPlexGetCone(dm, c, &cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),415,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

416

ierr = DMPlexGetRawFacesHybrid_Internal(dm, cellDim, coneSize, cone, &numCellFaces, &numCellFacesN, &faceSize, &cellFaces);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),416,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

417

if (numCellFaces != numCellFacesH) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_SUP, "Unexpected hybrid numCellFaces %D != %D", numCellFaces, numCellFacesH)return PetscError(((MPI_Comm)0x44000001),417,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,56,PETSC_ERROR_INITIAL,"Unexpected hybrid numCellFaces %D != %D"
,numCellFaces,numCellFacesH);

418

faceSize = PetscMax(faceSize, -faceSize)(((faceSize)<(-faceSize)) ? (-faceSize) : (faceSize));

419

for (cf = numCellFacesN; cf < numCellFaces; ++cf) { /* These are the hybrid faces */

420

const PetscInt *cellFace = &cellFaces[cf*faceSize];

421

PetscHashIJKLKey key;

422

PetscHashIter iter;

423

PetscBool missing;

424

PetscInt faceSizeH = faceSize;

425

426

if (faceSize == 2) {

427

key.i = PetscMin(cellFace[0], cellFace[1])(((cellFace[0])<(cellFace[1])) ? (cellFace[0]) : (cellFace
[1]));

428

key.j = PetscMax(cellFace[0], cellFace[1])(((cellFace[0])<(cellFace[1])) ? (cellFace[1]) : (cellFace
[0]));

429

key.k = PETSC_MAX_INT2147483647;

430

key.l = PETSC_MAX_INT2147483647;

431

} else {

432

key.i = cellFace[0];

433

key.j = cellFace[1];

434

key.k = cellFace[2];

435

key.l = faceSize > 3 ? (cellFace[3] < 0 ? faceSizeH = 3, PETSC_MAX_INT2147483647 : cellFace[3]) : PETSC_MAX_INT2147483647;

436

ierr = PetscSortInt(faceSize, (PetscInt *) &key);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),436,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

437

}

438

if (faceSizeH != faceSizeAllH) SETERRQ4(PETSC_COMM_SELF, PETSC_ERR_SUP, "Unexpected number of vertices for hybrid face %D of point %D -> %D != %D", cf, c, faceSizeH, faceSizeAllH)return PetscError(((MPI_Comm)0x44000001),438,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,56,PETSC_ERROR_INITIAL,"Unexpected number of vertices for hybrid face %D of point %D -> %D != %D"
,cf,c,faceSizeH,faceSizeAllH);

439

ierr = PetscHashIJKLPut(faceTable, key, &iter, &missing);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),439,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

440

if (missing) {ierr = PetscHashIJKLIterSet(faceTable, iter, face++);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),440,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

441

}

442

ierr = DMPlexRestoreRawFacesHybrid_Internal(dm, cellDim, coneSize, cone, &numCellFaces, &numCellFacesN, &faceSize, &cellFaces);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),442,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

443

}

444

faceH = face - pEnd[faceDepth];

445

if (faceH) {

446

if (fMax == PETSC_DETERMINE-1) fMax = pEnd[faceDepth];

447

else if (eMax == PETSC_DETERMINE-1) eMax = pEnd[faceDepth];

448

else SETERRQ3(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Number of unassigned hybrid facets %D for cellDim %D and dimension %D", faceH, cellDim, dim)return PetscError(((MPI_Comm)0x44000001),448,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,77,PETSC_ERROR_INITIAL,"Number of unassigned hybrid facets %D for cellDim %D and dimension %D"
,faceH,cellDim,dim);

449

}

450

pEnd[faceDepth] = face;

451

ierr = PetscHashIJKLDestroy(&faceTable);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),451,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

452

/* Count new points */

453

for (d = 0; d <= depth; ++d) {

454

numPoints += pEnd[d]-pStart[d];

455

}

456

ierr = DMPlexSetChart(idm, 0, numPoints);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),456,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

457

/* Set cone sizes */

458

for (d = 0; d <= depth; ++d) {

459

PetscInt coneSize, p;

460

461

if (d == faceDepth) {

462

/* I see no way to do this if we admit faces of different shapes */

463

for (p = pStart[d]; p < pEnd[d]-faceH; ++p) {

464

ierr = DMPlexSetConeSize(idm, p, faceSizeAll);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),464,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

465

}

466

for (p = pEnd[d]-faceH; p < pEnd[d]; ++p) {

467

ierr = DMPlexSetConeSize(idm, p, faceSizeAllH);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),467,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

468

}

469

} else if (d == cellDepth) {

470

for (p = pStart[d]; p < pEnd[d]; ++p) {

471

/* Number of cell faces may be different from number of cell vertices*/

472

if (p < pMax) {

473

ierr = DMPlexGetFaces_Internal(dm, cellDim, p, &coneSize, NULL((void*)0), NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),473,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

474

} else {

475

ierr = DMPlexGetFacesHybrid_Internal(dm, cellDim, p, &coneSize, NULL((void*)0), NULL((void*)0), NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),475,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

476

}

477

ierr = DMPlexSetConeSize(idm, p, coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),477,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

478

}

479

} else {

480

for (p = pStart[d]; p < pEnd[d]; ++p) {

481

ierr = DMPlexGetConeSize(dm, p, &coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),481,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

482

ierr = DMPlexSetConeSize(idm, p, coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),482,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

483

}

484

}

485

}

486

ierr = DMSetUp(idm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),486,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

487

/* Get face cones from subsets of cell vertices */

488

if (faceSizeAll > 4) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Do not support interpolation of meshes with faces of %D vertices", faceSizeAll)return PetscError(((MPI_Comm)0x44000001),488,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,62,PETSC_ERROR_INITIAL,"Do not support interpolation of meshes with faces of %D vertices"
,faceSizeAll);

489

ierr = PetscHashIJKLCreate(&faceTable);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),489,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

490

for (d = depth; d > cellDepth; --d) {

491

const PetscInt *cone;

492

PetscInt p;

493

494

for (p = pStart[d]; p < pEnd[d]; ++p) {

495

ierr = DMPlexGetCone(dm, p, &cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),495,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

496

ierr = DMPlexSetCone(idm, p, cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),496,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

497

ierr = DMPlexGetConeOrientation(dm, p, &cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),497,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

498

ierr = DMPlexSetConeOrientation(idm, p, cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),498,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

499

}

500

}

501

for (outerloop = 0, face = pStart[faceDepth]; outerloop < 2; outerloop++) {

502

PetscInt start, end;

503

504

start = outerloop == 0 ? pMax : pStart[cellDepth];

505

end = outerloop == 0 ? pEnd[cellDepth] : pMax;

506

for (c = start; c < end; ++c) {

507

const PetscInt *cellFaces;

508

PetscInt numCellFaces, faceSize, faceSizeInc, cf;

509

510

if (c < pMax) {

511

ierr = DMPlexGetFaces_Internal(dm, cellDim, c, &numCellFaces, &faceSize, &cellFaces);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),511,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

512

if (faceSize != faceSizeAll) SETERRQ3(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Inconsistent face for cell %D of size %D != %D", c, faceSize, faceSizeAll)return PetscError(((MPI_Comm)0x44000001),512,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,77,PETSC_ERROR_INITIAL,"Inconsistent face for cell %D of size %D != %D"
,c,faceSize,faceSizeAll);

513

} else {

514

const PetscInt *cone;

515

PetscInt numCellFacesN, coneSize;

516

517

ierr = DMPlexGetConeSize(dm, c, &coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),517,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

518

if (coneSize != coneSizeH) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_SUP, "Unexpected hybrid coneSize %D != %D", coneSize, coneSizeH)return PetscError(((MPI_Comm)0x44000001),518,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,56,PETSC_ERROR_INITIAL,"Unexpected hybrid coneSize %D != %D"
,coneSize,coneSizeH);

519

ierr = DMPlexGetCone(dm, c, &cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),519,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

520

ierr = DMPlexGetRawFacesHybrid_Internal(dm, cellDim, coneSize, cone, &numCellFaces, &numCellFacesN, &faceSize, &cellFaces);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),520,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

521

if (numCellFaces != numCellFacesH) SETERRQ3(PETSC_COMM_SELF, PETSC_ERR_SUP, "Unexpected numCellFaces %D != %D for hybrid cell %D", numCellFaces, numCellFacesH, c)return PetscError(((MPI_Comm)0x44000001),521,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,56,PETSC_ERROR_INITIAL,"Unexpected numCellFaces %D != %D for hybrid cell %D"
,numCellFaces,numCellFacesH,c);

522

faceSize = PetscMax(faceSize, -faceSize)(((faceSize)<(-faceSize)) ? (-faceSize) : (faceSize));

523

if (faceSize > 4) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Do not support interpolation of meshes with faces of %D vertices", faceSize)return PetscError(((MPI_Comm)0x44000001),523,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,62,PETSC_ERROR_INITIAL,"Do not support interpolation of meshes with faces of %D vertices"
,faceSize);

524

numCellFaces = numCellFacesN; /* process only non-hybrid faces */

525

}

526

faceSizeInc = faceSize;

527

for (cf = 0; cf < numCellFaces; ++cf) {

528

const PetscInt *cellFace = &cellFaces[cf*faceSizeInc];

529

PetscHashIJKLKey key;

530

PetscHashIter iter;

531

PetscBool missing;

532

533

if (faceSizeInc == 2) {

534

key.i = PetscMin(cellFace[0], cellFace[1])(((cellFace[0])<(cellFace[1])) ? (cellFace[0]) : (cellFace
[1]));

535

key.j = PetscMax(cellFace[0], cellFace[1])(((cellFace[0])<(cellFace[1])) ? (cellFace[1]) : (cellFace
[0]));

536

key.k = PETSC_MAX_INT2147483647;

537

key.l = PETSC_MAX_INT2147483647;

538

} else {

539

key.i = cellFace[0];

540

key.j = cellFace[1];

541

key.k = cellFace[2];

542

key.l = faceSizeInc > 3 ? (cellFace[3] < 0 ? faceSize = 3, PETSC_MAX_INT2147483647 : cellFace[3]) : PETSC_MAX_INT2147483647;

543

ierr = PetscSortInt(faceSizeInc, (PetscInt *) &key);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),543,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

544

}

545

ierr = PetscHashIJKLPut(faceTable, key, &iter, &missing);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),545,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

546

if (missing) {

547

ierr = DMPlexSetCone(idm, face, cellFace);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),547,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

548

ierr = PetscHashIJKLIterSet(faceTable, iter, face);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),548,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

549

ierr = DMPlexInsertCone(idm, c, cf, face++);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),549,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

550

} else {

551

const PetscInt *cone;

552

PetscInt coneSize, ornt, i, j, f;

553

554

ierr = PetscHashIJKLIterGet(faceTable, iter, &f);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),554,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

555

ierr = DMPlexInsertCone(idm, c, cf, f);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),555,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

556

/* Orient face: Do not allow reverse orientation at the first vertex */

557

ierr = DMPlexGetConeSize(idm, f, &coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),557,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

558

ierr = DMPlexGetCone(idm, f, &cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),558,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

559

if (coneSize != faceSize) SETERRQ3(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid number of face vertices %D for face %D should be %D", coneSize, f, faceSize)return PetscError(((MPI_Comm)0x44000001),559,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,77,PETSC_ERROR_INITIAL,"Invalid number of face vertices %D for face %D should be %D"
,coneSize,f,faceSize);

560

/* - First find the initial vertex */

561

for (i = 0; i < faceSize; ++i) if (cellFace[0] == cone[i]) break;

562

/* - Try forward comparison */

563

for (j = 0; j < faceSize; ++j) if (cellFace[j] != cone[(i+j)%faceSize]) break;

564

if (j == faceSize) {

565

if ((faceSize == 2) && (i == 1)) ornt = -2;

566

else ornt = i;

567

} else {

568

/* - Try backward comparison */

569

for (j = 0; j < faceSize; ++j) if (cellFace[j] != cone[(i+faceSize-j)%faceSize]) break;

570

if (j == faceSize) {

571

if (i == 0) ornt = -faceSize;

572

else ornt = -i;

573

} else SETERRQ(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Could not determine face orientation")return PetscError(((MPI_Comm)0x44000001),573,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,77,PETSC_ERROR_INITIAL,"Could not determine face orientation"
);

574

}

575

ierr = DMPlexInsertConeOrientation(idm, c, cf, ornt);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),575,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

576

}

577

}

578

if (c < pMax) {

579

ierr = DMPlexRestoreFaces_Internal(dm, cellDim, c, &numCellFaces, &faceSize, &cellFaces);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),579,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

580

} else {

581

ierr = DMPlexRestoreRawFacesHybrid_Internal(dm, cellDim, coneSizeH, NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), &cellFaces);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),581,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

582

}

583

}

584

}

585

/* Second pass for hybrid meshes: orient hybrid faces */

586

for (c = pMax; c < pEnd[cellDepth]; ++c) {

587

const PetscInt *cellFaces, *cone;

588

PetscInt numCellFaces, numCellFacesN, faceSize, cf, coneSize;

589

590

ierr = DMPlexGetConeSize(dm, c, &coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),590,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

591

ierr = DMPlexGetCone(dm, c, &cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),591,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

592

ierr = DMPlexGetRawFacesHybrid_Internal(dm, cellDim, coneSize, cone, &numCellFaces, &numCellFacesN, &faceSize, &cellFaces);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),592,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

593

if (numCellFaces != numCellFacesH) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_SUP, "Unexpected hybrid numCellFaces %D != %D", numCellFaces, numCellFacesH)return PetscError(((MPI_Comm)0x44000001),593,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,56,PETSC_ERROR_INITIAL,"Unexpected hybrid numCellFaces %D != %D"
,numCellFaces,numCellFacesH);

594

faceSize = PetscMax(faceSize, -faceSize)(((faceSize)<(-faceSize)) ? (-faceSize) : (faceSize));

595

for (cf = numCellFacesN; cf < numCellFaces; ++cf) { /* These are the hybrid faces */

596

const PetscInt *cellFace = &cellFaces[cf*faceSize];

597

PetscHashIJKLKey key;

598

PetscHashIter iter;

599

PetscBool missing;

600

PetscInt faceSizeH = faceSize;

601

602

if (faceSize == 2) {

603

key.i = PetscMin(cellFace[0], cellFace[1])(((cellFace[0])<(cellFace[1])) ? (cellFace[0]) : (cellFace
[1]));

604

key.j = PetscMax(cellFace[0], cellFace[1])(((cellFace[0])<(cellFace[1])) ? (cellFace[1]) : (cellFace
[0]));

605

key.k = PETSC_MAX_INT2147483647;

606

key.l = PETSC_MAX_INT2147483647;

607

} else {

608

key.i = cellFace[0];

609

key.j = cellFace[1];

610

key.k = cellFace[2];

611

key.l = faceSize > 3 ? (cellFace[3] < 0 ? faceSizeH = 3, PETSC_MAX_INT2147483647 : cellFace[3]) : PETSC_MAX_INT2147483647;

612

ierr = PetscSortInt(faceSize, (PetscInt *) &key);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),612,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

613

}

614

if (faceSizeH != faceSizeAllH) SETERRQ4(PETSC_COMM_SELF, PETSC_ERR_SUP, "Unexpected number of vertices for hybrid face %D of point %D -> %D != %D", cf, c, faceSizeH, faceSizeAllH)return PetscError(((MPI_Comm)0x44000001),614,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,56,PETSC_ERROR_INITIAL,"Unexpected number of vertices for hybrid face %D of point %D -> %D != %D"
,cf,c,faceSizeH,faceSizeAllH);

615

ierr = PetscHashIJKLPut(faceTable, key, &iter, &missing);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),615,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

616

if (missing) {

617

ierr = DMPlexSetCone(idm, face, cellFace);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),617,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

618

ierr = PetscHashIJKLIterSet(faceTable, iter, face);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),618,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

619

ierr = DMPlexInsertCone(idm, c, cf, face++);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),619,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

620

} else {

621

const PetscInt *cone;

622

PetscInt coneSize, ornt, i, j, f;

623

624

ierr = PetscHashIJKLIterGet(faceTable, iter, &f);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),624,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

625

ierr = DMPlexInsertCone(idm, c, cf, f);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),625,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

626

/* Orient face: Do not allow reverse orientation at the first vertex */

627

ierr = DMPlexGetConeSize(idm, f, &coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),627,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

628

ierr = DMPlexGetCone(idm, f, &cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),628,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

629

if (coneSize != faceSizeH) SETERRQ3(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid number of face vertices %D for face %D should be %D", coneSize, f, faceSizeH)return PetscError(((MPI_Comm)0x44000001),629,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,77,PETSC_ERROR_INITIAL,"Invalid number of face vertices %D for face %D should be %D"
,coneSize,f,faceSizeH);

630

/* - First find the initial vertex */

631

for (i = 0; i < faceSizeH; ++i) if (cellFace[0] == cone[i]) break;

632

/* - Try forward comparison */

633

for (j = 0; j < faceSizeH; ++j) if (cellFace[j] != cone[(i+j)%faceSizeH]) break;

634

if (j == faceSizeH) {

635

if ((faceSizeH == 2) && (i == 1)) ornt = -2;

636

else ornt = i;

637

} else {

638

/* - Try backward comparison */

639

for (j = 0; j < faceSizeH; ++j) if (cellFace[j] != cone[(i+faceSizeH-j)%faceSizeH]) break;

640

if (j == faceSizeH) {

641

if (i == 0) ornt = -faceSizeH;

642

else ornt = -i;

643

} else SETERRQ(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Could not determine face orientation")return PetscError(((MPI_Comm)0x44000001),643,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,77,PETSC_ERROR_INITIAL,"Could not determine face orientation"
);

644

}

645

ierr = DMPlexInsertConeOrientation(idm, c, cf, ornt);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),645,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

646

}

647

}

648

ierr = DMPlexRestoreRawFacesHybrid_Internal(dm, cellDim, coneSize, cone, &numCellFaces, &numCellFacesN, &faceSize, &cellFaces);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),648,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

649

}

650

if (face != pEnd[faceDepth]) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid number of faces %D should be %D", face-pStart[faceDepth], pEnd[faceDepth]-pStart[faceDepth])return PetscError(((MPI_Comm)0x44000001),650,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,77,PETSC_ERROR_INITIAL,"Invalid number of faces %D should be %D"
,face-pStart[faceDepth],pEnd[faceDepth]-pStart[faceDepth]);

651

ierr = PetscFree2(pStart,pEnd)PetscFreeA(2,651,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,&(pStart),&(pEnd));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),651,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

652

ierr = PetscHashIJKLDestroy(&faceTable);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),652,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

653

ierr = PetscFree2(pStart,pEnd)PetscFreeA(2,653,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,&(pStart),&(pEnd));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),653,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

654

ierr = DMPlexSetHybridBounds(idm, cMax, fMax, eMax, vMax);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),654,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

655

ierr = DMPlexSymmetrize(idm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),655,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

656

ierr = DMPlexStratify(idm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),656,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

657

658

}

659

660

PetscErrorCode DMPlexOrientCell(DM dm, PetscInt p, PetscInt masterConeSize, const PetscInt masterCone[])

661

{

662

PetscInt coneSize;

663

PetscInt start1=0;

664

PetscBool reverse1=PETSC_FALSE;

665

const PetscInt *cone=NULL((void*)0);

666

PetscErrorCode ierr;

667

668

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 668; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

669

ierr = DMPlexGetConeSize(dm, p, &coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),669,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

670

if (!coneSize) PetscFunctionReturn(0)do { do { ; if (petscstack && petscstack->currentsize
> 0) { petscstack->currentsize--; petscstack->function
[petscstack->currentsize] = 0; petscstack->file[petscstack
->currentsize] = 0; petscstack->line[petscstack->currentsize
] = 0; petscstack->petscroutine[petscstack->currentsize
] = PETSC_FALSE; } if (petscstack) { petscstack->hotdepth =
(((petscstack->hotdepth-1)<(0)) ? (0) : (petscstack->
hotdepth-1)); } ; } while (0); return(0);} while (0); /* do nothing for points with no cone */

671

ierr = DMPlexGetCone(dm, p, &cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),671,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

672

ierr = DMPlexFixFaceOrientations_Orient_Private(coneSize, masterConeSize, masterCone, cone, &start1, &reverse1);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),672,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

673

#if defined(PETSC_USE_DEBUG1)

674

if (PetscUnlikely(cone[start1] != masterCone[0])__builtin_expect(!!(cone[start1] != masterCone[0]),0)) SETERRQ3(PETSC_COMM_SELF, PETSC_ERR_PLIB, "The algorithm above is wrong as cone[%d] = %d != %d = masterCone[0]", start1, cone[start1], masterCone[0])return PetscError(((MPI_Comm)0x44000001),674,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,77,PETSC_ERROR_INITIAL,"The algorithm above is wrong as cone[%d] = %d != %d = masterCone[0]"
,start1,cone[start1],masterCone[0]);

675

#endif

676

ierr = DMPlexOrientCell_Internal(dm, p, start1, reverse1);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),676,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

677

#if defined(PETSC_USE_DEBUG1)

678

{

679

PetscInt c;

680

ierr = DMPlexGetCone(dm, p, &cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),680,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

681

for (c = 0; c < 2; c++) {

682

if (PetscUnlikely(cone[c] != masterCone[c])__builtin_expect(!!(cone[c] != masterCone[c]),0)) SETERRQ4(PETSC_COMM_SELF, PETSC_ERR_PLIB, "The algorithm above is wrong as cone[%d] = %d != %d = masterCone[%d]", c, cone[c], masterCone[c], c)return PetscError(((MPI_Comm)0x44000001),682,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,77,PETSC_ERROR_INITIAL,"The algorithm above is wrong as cone[%d] = %d != %d = masterCone[%d]"
,c,cone[c],masterCone[c],c);

683

}

684

}

685

#endif

686

687

}

688

689

PetscErrorCode DMPlexOrientCell_Internal(DM dm, PetscInt p, PetscInt start1, PetscBool reverse1)

690

{

691

PetscInt i, j, k, maxConeSize, coneSize, coneConeSize, supportSize, supportConeSize;

692

PetscInt start0, start;

693

PetscBool reverse0, reverse;

694

PetscInt newornt;

695

const PetscInt *cone=NULL((void*)0), *support=NULL((void*)0), *supportCone=NULL((void*)0), *ornts=NULL((void*)0);

696

PetscInt *newcone=NULL((void*)0), *newornts=NULL((void*)0);

697

PetscErrorCode ierr;

698

699

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 699; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

700

if (!start1 && !reverse1) PetscFunctionReturn(0)do { do { ; if (petscstack && petscstack->currentsize
> 0) { petscstack->currentsize--; petscstack->function
[petscstack->currentsize] = 0; petscstack->file[petscstack
->currentsize] = 0; petscstack->line[petscstack->currentsize
] = 0; petscstack->petscroutine[petscstack->currentsize
] = PETSC_FALSE; } if (petscstack) { petscstack->hotdepth =
(((petscstack->hotdepth-1)<(0)) ? (0) : (petscstack->
hotdepth-1)); } ; } while (0); return(0);} while (0);

701

ierr = DMPlexGetConeSize(dm, p, &coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),701,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

702

703

ierr = DMPlexGetCone(dm, p, &cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),703,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

704

ierr = DMPlexGetMaxSizes(dm, &maxConeSize, NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),704,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

705

/* permute p's cone and orientations */

706

ierr = DMPlexGetConeOrientation(dm, p, &ornts);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),706,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

707

ierr = DMGetWorkArray(dm, maxConeSize, MPIU_INT((MPI_Datatype)0x4c000405), &newcone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),707,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

708

ierr = DMGetWorkArray(dm, maxConeSize, MPIU_INT((MPI_Datatype)0x4c000405), &newornts);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),708,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

709

ierr = DMPlexFixFaceOrientations_Permute_Private(coneSize, cone, start1, reverse1, newcone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),709,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

710

ierr = DMPlexFixFaceOrientations_Permute_Private(coneSize, ornts, start1, reverse1, newornts);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),710,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

711

/* if direction of p (face) is flipped, flip also p's cone points (edges) */

712

if (reverse1) {

713

for (i=0; i<coneSize; i++) {

714

ierr = DMPlexGetConeSize(dm, cone[i], &coneConeSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),714,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

715

ierr = DMPlexFixFaceOrientations_Translate_Private(newornts[i], &start0, &reverse0);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),715,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

716

ierr = DMPlexFixFaceOrientations_Combine_Private(coneConeSize, start0, reverse0, 1, PETSC_FALSE, &start, &reverse);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),716,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

717

ierr = DMPlexFixFaceOrientations_TranslateBack_Private(coneConeSize, start, reverse, &newornts[i]);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),717,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

718

}

719

}

720

ierr = DMPlexSetConeOrientation(dm, p, newornts);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),720,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

721

/* fix oriention of p within cones of p's support points */

722

ierr = DMPlexGetSupport(dm, p, &support);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),722,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

723

ierr = DMPlexGetSupportSize(dm, p, &supportSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),723,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

724

for (j=0; j<supportSize; j++) {

725

ierr = DMPlexGetCone(dm, support[j], &supportCone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),725,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

726

ierr = DMPlexGetConeSize(dm, support[j], &supportConeSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),726,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

727

ierr = DMPlexGetConeOrientation(dm, support[j], &ornts);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),727,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

728

for (k=0; k<supportConeSize; k++) {

729

if (supportCone[k] != p) continue;

730

ierr = DMPlexFixFaceOrientations_Translate_Private(ornts[k], &start0, &reverse0);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),730,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

731

ierr = DMPlexFixFaceOrientations_Combine_Private(coneSize, start0, reverse0, start1, reverse1, &start, &reverse);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),731,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

732

ierr = DMPlexFixFaceOrientations_TranslateBack_Private(coneSize, start, reverse, &newornt);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),732,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

733

ierr = DMPlexInsertConeOrientation(dm, support[j], k, newornt);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),733,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

734

}

735

}

736

/* rewrite cone */

737

ierr = DMPlexSetCone(dm, p, newcone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),737,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

738

ierr = DMRestoreWorkArray(dm, maxConeSize, MPIU_INT((MPI_Datatype)0x4c000405), &newcone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),738,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

739

ierr = DMRestoreWorkArray(dm, maxConeSize, MPIU_INT((MPI_Datatype)0x4c000405), &newornts);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),739,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

740

741

}

742

743

static PetscErrorCode SortRmineRremoteByRemote_Private(PetscSF sf, PetscInt *rmine1[], PetscInt *rremote1[])

744

{

745

PetscInt nleaves;

746

PetscInt nranks;

747

const PetscMPIInt *ranks=NULL((void*)0);

748

const PetscInt *roffset=NULL((void*)0), *rmine=NULL((void*)0), *rremote=NULL((void*)0);

749

PetscInt n, o, r;

750

PetscErrorCode ierr;

751

752

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 752; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

753

ierr = PetscSFGetRanks(sf, &nranks, &ranks, &roffset, &rmine, &rremote);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),753,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

754

nleaves = roffset[nranks];

755

ierr = PetscMalloc2(nleaves, rmine1, nleaves, rremote1)PetscMallocA(2,PETSC_FALSE,755,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,(size_t)(nleaves)*sizeof(**(rmine1)),(rmine1),(size_t)(nleaves
)*sizeof(**(rremote1)),(rremote1));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),755,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

756

for (r=0; r<nranks; r++) {

757

/* simultaneously sort rank-wise portions of rmine & rremote by values in rremote

758

- to unify order with the other side */

759

o = roffset[r];

760

n = roffset[r+1] - o;

761

ierr = PetscMemcpy(&(*rmine1)[o], &rmine[o], n*sizeof(PetscInt));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),761,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

762

ierr = PetscMemcpy(&(*rremote1)[o], &rremote[o], n*sizeof(PetscInt));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),762,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

763

ierr = PetscSortIntWithArray(n, &(*rremote1)[o], &(*rmine1)[o]);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),763,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

764

}

765

766

}

767

768

PetscErrorCode DMPlexOrientInterface(DM dm)

769

{

770

PetscSF sf=NULL((void*)0);

771

PetscInt (*roots)[2], (*leaves)[2];

772

PetscMPIInt (*rootsRanks)[2], (*leavesRanks)[2];

773

const PetscInt *locals=NULL((void*)0);

774

const PetscSFNode *remotes=NULL((void*)0);

775

PetscInt nroots, nleaves, p, c;

776

PetscInt nranks, n, o, r;

777

const PetscMPIInt *ranks=NULL((void*)0);

778

const PetscInt *roffset=NULL((void*)0);

779

PetscInt *rmine1=NULL((void*)0), *rremote1=NULL((void*)0); /* rmine and rremote copies simultaneously sorted by rank and rremote */

780

const PetscInt *cone=NULL((void*)0);

781

PetscInt coneSize, ind0;

782

MPI_Comm comm;

783

PetscMPIInt rank;

784

PetscInt debug = 0;

785

PetscErrorCode ierr;

786

787

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 787; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

788

ierr = DMGetPointSF(dm, &sf);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),788,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

789

ierr = PetscSFGetGraph(sf, &nroots, &nleaves, &locals, &remotes);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),789,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

790

if (nroots < 0) PetscFunctionReturn(0)do { do { ; if (petscstack && petscstack->currentsize
> 0) { petscstack->currentsize--; petscstack->function
[petscstack->currentsize] = 0; petscstack->file[petscstack
->currentsize] = 0; petscstack->line[petscstack->currentsize
] = 0; petscstack->petscroutine[petscstack->currentsize
] = PETSC_FALSE; } if (petscstack) { petscstack->hotdepth =
(((petscstack->hotdepth-1)<(0)) ? (0) : (petscstack->
hotdepth-1)); } ; } while (0); return(0);} while (0);

791

ierr = PetscSFSetUp(sf);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),791,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

792

ierr = PetscSFGetRanks(sf, &nranks, &ranks, &roffset, NULL((void*)0), NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),792,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

793

#if defined(PETSC_USE_DEBUG1)

794

ierr = DMViewFromOptions(dm, NULL((void*)0), "-before_fix_dm_view");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),794,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

795

ierr = DMPlexCheckPointSF(dm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),795,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

796

#endif

797

ierr = SortRmineRremoteByRemote_Private(sf, &rmine1, &rremote1);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),797,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

798

ierr = PetscMalloc4(nroots, &roots, nroots, &leaves, nroots, &rootsRanks, nroots, &leavesRanks)PetscMallocA(4,PETSC_FALSE,798,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,(size_t)(nroots)*sizeof(**(&roots)),(&roots),(size_t
)(nroots)*sizeof(**(&leaves)),(&leaves),(size_t)(nroots
)*sizeof(**(&rootsRanks)),(&rootsRanks),(size_t)(nroots
)*sizeof(**(&leavesRanks)),(&leavesRanks));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),798,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

799

ierr = PetscObjectGetComm((PetscObject) dm, &comm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),799,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

800

ierr = MPI_Comm_rank(comm, &rank);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),800,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

801

if (debug && rank == 0) {ierr = PetscSynchronizedPrintf(comm, "Roots\n");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),801,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

802

for (p = 0; p < nroots; ++p) {

803

ierr = DMPlexGetConeSize(dm, p, &coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),803,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

804

ierr = DMPlexGetCone(dm, p, &cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),804,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

805

/* Translate all points to root numbering */

806

for (c = 0; c < 2; c++) {

807

if (coneSize > 1) {

808

ierr = PetscFindInt(cone[c], nleaves, locals, &ind0);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),808,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

809

if (ind0 < 0) {

810

roots[p][c] = cone[c];

811

rootsRanks[p][c] = rank;

812

} else {

813

roots[p][c] = remotes[ind0].index;

814

rootsRanks[p][c] = remotes[ind0].rank;

815

}

816

} else {

817

roots[p][c] = -1;

818

rootsRanks[p][c] = -1;

819

}

820

}

821

}

822

if (debug) {

823

for (p = 0; p < nroots; ++p) {

824

ierr = DMPlexGetConeSize(dm, p, &coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),824,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

825

ierr = DMPlexGetCone(dm, p, &cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),825,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

826

if (coneSize > 1) {

827

ierr = PetscSynchronizedPrintf(comm, "[%d] %D: cone=[%D %D] roots=[%D %D] rootsRanks=[%D %D]\n", rank, p, cone[0], cone[1], roots[p][0], roots[p][1], rootsRanks[p][0], rootsRanks[p][1]);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),827,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

828

}

829

}

830

ierr = PetscSynchronizedFlush(comm, NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),830,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

831

}

832

for (p = 0; p < nroots; ++p) {

833

for (c = 0; c < 2; c++) {

834

leaves[p][c] = -2;

835

leavesRanks[p][c] = -2;

836

}

837

}

838

ierr = PetscSFBcastBegin(sf, MPIU_2INT((MPI_Datatype)0x4c000816), roots, leaves);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),838,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

839

ierr = PetscSFBcastBegin(sf, MPI_2INT((MPI_Datatype)0x4c000816), rootsRanks, leavesRanks);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),839,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

840

ierr = PetscSFBcastEnd(sf, MPIU_2INT((MPI_Datatype)0x4c000816), roots, leaves);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),840,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

841

ierr = PetscSFBcastEnd(sf, MPI_2INT((MPI_Datatype)0x4c000816), rootsRanks, leavesRanks);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),841,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

842

if (debug) {ierr = PetscSynchronizedFlush(comm, NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),842,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

843

if (debug && rank == 0) {ierr = PetscSynchronizedPrintf(comm, "Referred leaves\n");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),843,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

844

for (p = 0; p < nroots; ++p) {

845

if (leaves[p][0] < 0) continue;

846

ierr = DMPlexGetConeSize(dm, p, &coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),846,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

847

ierr = DMPlexGetCone(dm, p, &cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),847,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

848

if (debug) {ierr = PetscSynchronizedPrintf(comm, "[%d] %D: cone=[%D %D] leaves=[%D %D] roots=[%D %D] leavesRanks=[%D %D] rootsRanks=[%D %D]\n", rank, p, cone[0], cone[1], leaves[p][0], leaves[p][1], roots[p][0], roots[p][1], leavesRanks[p][0], leavesRanks[p][1], rootsRanks[p][0], rootsRanks[p][1]);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),848,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

849

if ((leaves[p][0] != roots[p][0]) || (leaves[p][1] != roots[p][1]) || (leavesRanks[p][0] != rootsRanks[p][0]) || (leavesRanks[p][0] != rootsRanks[p][0])) {

850

PetscInt masterCone[2];

851

/* Translate these two cone points back to leave numbering */

852

for (c = 0; c < 2; c++) {

853

if (leavesRanks[p][c] == rank) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_PLIB, "this should never happen - remote rank of point %D is the same rank",leavesRanks[p][c])return PetscError(((MPI_Comm)0x44000001),853,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,77,PETSC_ERROR_INITIAL,"this should never happen - remote rank of point %D is the same rank"
,leavesRanks[p][c]);

854

/* Find index of rank leavesRanks[p][c] among remote ranks */

855

/* No need for PetscMPIIntCast because these integers were originally cast from PetscMPIInt. */

856

ierr = PetscFindMPIInt((PetscMPIInt)leavesRanks[p][c], nranks, ranks, &r);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),856,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

857

if (PetscUnlikely(r < 0)__builtin_expect(!!(r < 0),0)) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_PLIB, "this should never happen - rank %D not found among remote ranks",leavesRanks[p][c])return PetscError(((MPI_Comm)0x44000001),857,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,77,PETSC_ERROR_INITIAL,"this should never happen - rank %D not found among remote ranks"
,leavesRanks[p][c]);

858

/* Find point leaves[p][c] among remote points aimed at rank leavesRanks[p][c] */

859

o = roffset[r];

860

n = roffset[r+1] - o;

861

ierr = PetscFindInt(leaves[p][c], n, &rremote1[o], &ind0);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),861,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

862

if (PetscUnlikely(ind0 < 0)__builtin_expect(!!(ind0 < 0),0)) SETERRQ3(PETSC_COMM_SELF, PETSC_ERR_PLIB, "No cone point of %D is connected to (%D, %D) - it seems there is missing connection in point SF!",p,ranks[r],leaves[p][c])return PetscError(((MPI_Comm)0x44000001),862,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,77,PETSC_ERROR_INITIAL,"No cone point of %D is connected to (%D, %D) - it seems there is missing connection in point SF!"
,p,ranks[r],leaves[p][c]);

863

/* Get the corresponding local point */

864

masterCone[c] = rmine1[o+ind0];CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),864,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

865

}

866

if (debug) {ierr = PetscSynchronizedPrintf(comm, "[%d] %D: masterCone=[%D %D]\n", rank, p, masterCone[0], masterCone[1]);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),866,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

867

/* Vaclav's note: Here we only compare first 2 points of the cone. Full cone size would lead to stronger self-checking. */

868

ierr = DMPlexOrientCell(dm, p, 2, masterCone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),868,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

869

}

870

}

871

#if defined(PETSC_USE_DEBUG1)

872

ierr = DMViewFromOptions(dm, NULL((void*)0), "-after_fix_dm_view");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),872,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

873

for (r = 0; r < nleaves; ++r) {

874

p = locals[r];

875

ierr = DMPlexGetConeSize(dm, p, &coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),875,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

876

if (!coneSize) continue;

877

ierr = DMPlexGetCone(dm, p, &cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),877,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

878

for (c = 0; c < 2; c++) {

879

ierr = PetscFindInt(cone[c], nleaves, locals, &ind0);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),879,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

880

if (ind0 < 0) SETERRQ3(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Point SF contains %D but is missing its cone point cone[%D] = %D!", p, c, cone[c])return PetscError(((MPI_Comm)0x44000001),880,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,77,PETSC_ERROR_INITIAL,"Point SF contains %D but is missing its cone point cone[%D] = %D!"
,p,c,cone[c]);

881

if (leaves[p][c] != remotes[ind0].index || leavesRanks[p][c] != remotes[ind0].rank) {

882

if (leavesRanks[p][c] == rank) {

883

PetscInt ind1;

884

ierr = PetscFindInt(leaves[p][c], nleaves, locals, &ind1);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),884,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

885

if (ind1 < 0) {

886

SETERRQ8(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Point %D = locals[%d]: cone[%D]=%D --> (%D, %D) differs from the enforced (%D, %D). The latter was not even found among the local SF points - it is probably broken!", p, r, c, cone[c], remotes[ind0].rank, remotes[ind0].index, leavesRanks[p][c], leaves[p][c])return PetscError(((MPI_Comm)0x44000001),886,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,77,PETSC_ERROR_INITIAL,"Point %D = locals[%d]: cone[%D]=%D --> (%D, %D) differs from the enforced (%D, %D). The latter was not even found among the local SF points - it is probably broken!"
,p,r,c,cone[c],remotes[ind0].rank,remotes[ind0].index,leavesRanks
[p][c],leaves[p][c]);

887

} else {

888

SETERRQ9(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Point %D = locals[%d]: cone[%D]=%D --> (%D, %D) differs from the enforced %D --> (%D, %D). Is the algorithm above or the point SF broken?", p, r, c, cone[c], remotes[ind0].rank, remotes[ind0].index, leaves[p][c], remotes[ind1].rank, remotes[ind1].index)return PetscError(((MPI_Comm)0x44000001),888,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,77,PETSC_ERROR_INITIAL,"Point %D = locals[%d]: cone[%D]=%D --> (%D, %D) differs from the enforced %D --> (%D, %D). Is the algorithm above or the point SF broken?"
,p,r,c,cone[c],remotes[ind0].rank,remotes[ind0].index,leaves[
p][c],remotes[ind1].rank,remotes[ind1].index);

889

}

890

} else {

891

SETERRQ8(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Point %D = locals[%d]: cone[%D]=%D --> (%D, %D) differs from the enforced (%D, %D). Is the algorithm above or the point SF broken?", p, r, c, cone[c], remotes[ind0].rank, remotes[ind0].index, leavesRanks[p][c], leaves[p][c])return PetscError(((MPI_Comm)0x44000001),891,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,77,PETSC_ERROR_INITIAL,"Point %D = locals[%d]: cone[%D]=%D --> (%D, %D) differs from the enforced (%D, %D). Is the algorithm above or the point SF broken?"
,p,r,c,cone[c],remotes[ind0].rank,remotes[ind0].index,leavesRanks
[p][c],leaves[p][c]);

892

}

893

}

894

}

895

}

896

#endif

897

if (debug) {ierr = PetscSynchronizedFlush(comm, NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),897,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

898

ierr = PetscFree4(roots, leaves, rootsRanks, leavesRanks)PetscFreeA(4,898,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,&(roots),&(leaves),&(rootsRanks),&(leavesRanks
));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),898,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

899

ierr = PetscFree2(rmine1, rremote1)PetscFreeA(2,899,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,&(rmine1),&(rremote1));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),899,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

900

901

}

902

903

static PetscErrorCode IntArrayViewFromOptions(MPI_Comm comm, const char opt[], const char name[], const char idxname[], const char valname[], PetscInt n, const PetscInt a[])

904

{

905

PetscInt idx;

906

PetscMPIInt rank;

907

PetscBool flg;

908

PetscErrorCode ierr;

909

910

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 910; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

911

ierr = PetscOptionsHasName(NULL((void*)0), NULL((void*)0), opt, &flg);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),911,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

912

if (!flg) PetscFunctionReturn(0)do { do { ; if (petscstack && petscstack->currentsize
> 0) { petscstack->currentsize--; petscstack->function
[petscstack->currentsize] = 0; petscstack->file[petscstack
->currentsize] = 0; petscstack->line[petscstack->currentsize
] = 0; petscstack->petscroutine[petscstack->currentsize
] = PETSC_FALSE; } if (petscstack) { petscstack->hotdepth =
(((petscstack->hotdepth-1)<(0)) ? (0) : (petscstack->
hotdepth-1)); } ; } while (0); return(0);} while (0);

913

ierr = MPI_Comm_rank(comm, &rank);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),913,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

914

ierr = PetscSynchronizedPrintf(comm, "[%d]%s:\n", rank, name);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),914,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

915

for (idx = 0; idx < n; ++idx) {ierr = PetscSynchronizedPrintf(comm, "[%d]%s %D %s %D\n", rank, idxname, idx, valname, a[idx]);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),915,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

916

ierr = PetscSynchronizedFlush(comm, NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),916,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

917

918

}

919

920

static PetscErrorCode SFNodeArrayViewFromOptions(MPI_Comm comm, const char opt[], const char name[], const char idxname[], PetscInt n, const PetscSFNode a[])

921

{

922

PetscInt idx;

923

PetscMPIInt rank;

924

PetscBool flg;

925

PetscErrorCode ierr;

926

927

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 927; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

928

ierr = PetscOptionsHasName(NULL((void*)0), NULL((void*)0), opt, &flg);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),928,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

929

930

ierr = MPI_Comm_rank(comm, &rank);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),930,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

931

ierr = PetscSynchronizedPrintf(comm, "[%d]%s:\n", rank, name);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),931,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

932

if (idxname) {

933

for (idx = 0; idx < n; ++idx) {ierr = PetscSynchronizedPrintf(comm, "[%d]%s %D rank %D index %D\n", rank, idxname, idx, a[idx].rank, a[idx].index);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),933,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

934

} else {

935

for (idx = 0; idx < n; ++idx) {ierr = PetscSynchronizedPrintf(comm, "[%d]rank %D index %D\n", rank, a[idx].rank, a[idx].index);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),935,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

936

}

937

ierr = PetscSynchronizedFlush(comm, NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),937,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

938

939

}

940

941

static PetscErrorCode DMPlexMapToLocalPoint(PetscHMapIJ roothash, const PetscInt localPoints[], PetscMPIInt rank, PetscSFNode remotePoint, PetscInt *localPoint)

942

{

943

PetscErrorCode ierr;

944

945

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 945; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

946

if (remotePoint.rank == rank) {

947

*localPoint = remotePoint.index;

948

} else {

949

PetscHashIJKey key;

950

PetscInt root;

951

952

key.i = remotePoint.index;

953

key.j = remotePoint.rank;

954

ierr = PetscHMapIJGet(roothash, key, &root);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),954,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

955

if (root >= 0) {

956

*localPoint = localPoints[root];

957

} else PetscFunctionReturn(1)do { do { ; if (petscstack && petscstack->currentsize
> 0) { petscstack->currentsize--; petscstack->function
[petscstack->currentsize] = 0; petscstack->file[petscstack
->currentsize] = 0; petscstack->line[petscstack->currentsize
] = 0; petscstack->petscroutine[petscstack->currentsize
] = PETSC_FALSE; } if (petscstack) { petscstack->hotdepth =
(((petscstack->hotdepth-1)<(0)) ? (0) : (petscstack->
hotdepth-1)); } ; } while (0); return(1);} while (0);

958

}

959

960

}

961

962

/*@

963

DMPlexInterpolatePointSF - Insert interpolated points in the overlap into the PointSF in parallel, following local interpolation

964

965

Collective on DM

966

967

Input Parameters:

968

+ dm - The interpolated DM

969

- pointSF - The initial SF without interpolated points

970

971

Output Parameter:

972

. pointSF - The SF including interpolated points

973

974

Level: intermediate

975

976

Note: All debugging for this process can be turned on with the options: -dm_interp_pre_view -petscsf_interp_pre_view -petscsection_interp_candidate_view -petscsection_interp_candidate_remote_view -petscsection_interp_claim_view -petscsf_interp_pre_view -dmplex_interp_debug

977

978

.keywords: mesh

979

.seealso: DMPlexInterpolate(), DMPlexUninterpolate()

980

@*/

981

PetscErrorCode DMPlexInterpolatePointSF(DM dm, PetscSF pointSF)

982

{

983

984

Okay, the algorithm is:

985

- Take each point in the overlap (root)

986

- Look at the neighboring points in the overlap (candidates)

987

- Send these candidate points to neighbors

988

- Neighbor checks for edge between root and candidate

989

- If edge is found, it replaces candidate point with edge point

990

- Send back the overwritten candidates (claims)

991

- Original guy checks for edges, different from original candidate, and gets its own edge

992

- This pair is put into SF

993

994

We need a new algorithm that tolerates groups larger than 2.

995

- Take each point in the overlap (root)

996

- Find all collections of points in the overlap which make faces (do early join)

997

- Send collections as candidates (add size as first number)

998

- Make sure to send collection to all owners of all overlap points in collection

999

- Neighbor check for face in collections

1000

- If face is found, it replaces candidate point with face point

1001

- Send back the overwritten candidates (claims)

1002

- Original guy checks for faces, different from original candidate, and gets its own face

1003

- This pair is put into SF

1004

1005

PetscHMapI leafhash;

1006

PetscHMapIJ roothash;

1007

const PetscInt *localPoints, *rootdegree;

1008

const PetscSFNode *remotePoints;

1009

PetscSFNode *candidates, *candidatesRemote, *claims;

1010

PetscSection candidateSection, candidateSectionRemote, claimSection;

1011

PetscInt numLeaves, l, numRoots, r, candidatesSize, candidatesRemoteSize;

1012

PetscMPIInt size, rank;

1013

PetscHashIJKey key;

1014

PetscBool debug = PETSC_FALSE;

1015

PetscErrorCode ierr;

1016

1017

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 1017; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

1018

ierr = PetscOptionsHasName(NULL((void*)0), ((PetscObject) dm)->prefix, "-dmplex_interp_debug", &debug);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1018,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1019

ierr = MPI_Comm_size(PetscObjectComm((PetscObject) dm), &size);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1019,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1020

ierr = MPI_Comm_rank(PetscObjectComm((PetscObject) dm), &rank);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1020,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1021

ierr = PetscSFGetGraph(pointSF, &numRoots, &numLeaves, &localPoints, &remotePoints);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1021,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1022

if (size < 2 || numRoots < 0) PetscFunctionReturn(0)do { do { ; if (petscstack && petscstack->currentsize
> 0) { petscstack->currentsize--; petscstack->function
[petscstack->currentsize] = 0; petscstack->file[petscstack
->currentsize] = 0; petscstack->line[petscstack->currentsize
] = 0; petscstack->petscroutine[petscstack->currentsize
] = PETSC_FALSE; } if (petscstack) { petscstack->hotdepth =
(((petscstack->hotdepth-1)<(0)) ? (0) : (petscstack->
hotdepth-1)); } ; } while (0); return(0);} while (0);

Assuming 'size' is >= 2

→

←

Assuming 'numRoots' is >= 0

→

←

Taking false branch

→

1023

ierr = PetscObjectViewFromOptions((PetscObject) dm, NULL((void*)0), "-dm_interp_pre_view");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1023,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1024

ierr = PetscObjectViewFromOptions((PetscObject) pointSF, NULL((void*)0), "-petscsf_interp_pre_view");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1024,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1025

ierr = PetscLogEventBegin(DMPLEX_InterpolateSF,dm,0,0,0)(((PetscLogPLB && petsc_stageLog->stageInfo[petsc_stageLog
->curStage].perfInfo.active && petsc_stageLog->
stageInfo[petsc_stageLog->curStage].eventLog->eventInfo
[DMPLEX_InterpolateSF].active) ? (*PetscLogPLB)((DMPLEX_InterpolateSF
),0,(PetscObject)(dm),(PetscObject)(0),(PetscObject)(0),(PetscObject
)(0)) : 0 ));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1025,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1026

/* Build hashes of points in the SF for efficient lookup */

1027

ierr = PetscHMapICreate(&leafhash);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1027,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1028

ierr = PetscHMapIJCreate(&roothash);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1028,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1029

for (l = 0; l < numLeaves; ++l) {

←

Assuming 'l' is >= 'numLeaves'

→

←

Loop condition is false. Execution continues on line 1036

→

1030

key.i = remotePoints[l].index;

1031

key.j = remotePoints[l].rank;

1032

ierr = PetscHMapISet(leafhash, localPoints[l], l);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1032,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1033

ierr = PetscHMapIJSet(roothash, key, l);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1033,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1034

}

1035

/* Compute root degree to identify shared points */

1036

ierr = PetscSFComputeDegreeBegin(pointSF, &rootdegree);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1036,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1037

ierr = PetscSFComputeDegreeEnd(pointSF, &rootdegree);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1037,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1038

ierr = IntArrayViewFromOptions(PetscObjectComm((PetscObject) dm), "-interp_root_degree_view", "Root degree", "point", "degree", numRoots, rootdegree);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1038,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1039

/* Build a section / SFNode array of candidate points (face bd points) in the cone(support(leaf)),

1040

where each candidate is defined by a set of remote points (roots) for the other points that define the face. */

1041

ierr = PetscSectionCreate(PetscObjectComm((PetscObject) dm), &candidateSection);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1041,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1042

ierr = PetscSectionSetChart(candidateSection, 0, numRoots);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1042,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1043

{

1044

PetscHMapIJ facehash;

1045

1046

ierr = PetscHMapIJCreate(&facehash);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1046,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1047

for (l = 0; l < numLeaves; ++l) {

←

Loop condition is false. Execution continues on line 1082

→

1048

const PetscInt localPoint = localPoints[l];

1049

const PetscInt *support;

1050

PetscInt supportSize, s;

1051

1052

if (debug) {ierr = PetscSynchronizedPrintf(PetscObjectComm((PetscObject) dm), "[%d] Checking local point %D\n", rank, localPoint);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1052,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

1053

ierr = DMPlexGetSupportSize(dm, localPoint, &supportSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1053,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1054

ierr = DMPlexGetSupport(dm, localPoint, &support);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1054,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1055

for (s = 0; s < supportSize; ++s) {

1056

const PetscInt face = support[s];

1057

const PetscInt *cone;

1058

PetscInt coneSize, c, f, root;

1059

PetscBool isFace = PETSC_TRUE;

1060

1061

/* Only add face once */

1062

if (debug) {ierr = PetscSynchronizedPrintf(PetscObjectComm((PetscObject) dm), "[%d] Support point %D\n", rank, face);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1062,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

1063

key.i = localPoint;

1064

key.j = face;

1065

ierr = PetscHMapIJGet(facehash, key, &f);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1065,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1066

if (f >= 0) continue;

1067

ierr = DMPlexGetConeSize(dm, face, &coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1067,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1068

ierr = DMPlexGetCone(dm, face, &cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1068,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1069

/* If a cone point does not map to leaves on any proc, then do not put face in SF */

1070

for (c = 0; c < coneSize; ++c) {

1071

if (debug) {ierr = PetscSynchronizedPrintf(PetscObjectComm((PetscObject) dm), "[%d] Cone point %D\n", rank, cone[c]);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1071,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

1072

ierr = PetscHMapIGet(leafhash, cone[c], &root);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1072,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1073

if (!rootdegree[cone[c]] && (root < 0)) {isFace = PETSC_FALSE; break;}

1074

}

1075

if (isFace) {

1076

if (debug) {ierr = PetscSynchronizedPrintf(PetscObjectComm((PetscObject) dm), "[%d] Found shared face %D\n", rank, face);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1076,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

1077

ierr = PetscHMapIJSet(facehash, key, l);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1077,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1078

ierr = PetscSectionAddDof(candidateSection, localPoint, coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1078,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1079

}

1080

}

1081

}

1082

if (debug) {ierr = PetscSynchronizedFlush(PetscObjectComm((PetscObject) dm), NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1082,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

←

Assuming 'debug' is 0

→

←

Taking false branch

→

1083

ierr = PetscHMapIJClear(facehash);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1083,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1084

ierr = PetscSectionSetUp(candidateSection);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1084,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1085

ierr = PetscSectionGetStorageSize(candidateSection, &candidatesSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1085,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1086

ierr = PetscMalloc1(candidatesSize, &candidates)PetscMallocA(1,PETSC_FALSE,1086,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,(size_t)(candidatesSize)*sizeof(**(&candidates)),(&candidates
));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1086,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1087

for (l = 0; l < numLeaves; ++l) {

←

Loop condition is false. Execution continues on line 1135

→

1088

const PetscInt localPoint = localPoints[l];

1089

const PetscInt *support;

1090

PetscInt supportSize, s, offset, idx = 0;

1091

1092

if (debug) {ierr = PetscSynchronizedPrintf(PetscObjectComm((PetscObject) dm), "[%d] Checking local point %D\n", rank, localPoint);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1092,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

1093

ierr = PetscSectionGetOffset(candidateSection, localPoint, &offset);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1093,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1094

ierr = DMPlexGetSupportSize(dm, localPoint, &supportSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1094,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1095

ierr = DMPlexGetSupport(dm, localPoint, &support);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1095,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1096

for (s = 0; s < supportSize; ++s) {

1097

const PetscInt face = support[s];

1098

const PetscInt *cone;

1099

PetscInt coneSize, c, f, root;

1100

PetscBool isFace = PETSC_TRUE;

1101

1102

/* Only add face once */

1103

if (debug) {ierr = PetscSynchronizedPrintf(PetscObjectComm((PetscObject) dm), "[%d] Support point %D\n", rank, face);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1103,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

1104

key.i = localPoint;

1105

key.j = face;

1106

ierr = PetscHMapIJGet(facehash, key, &f);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1106,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1107

if (f >= 0) continue;

1108

ierr = DMPlexGetConeSize(dm, face, &coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1108,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1109

ierr = DMPlexGetCone(dm, face, &cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1109,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1110

/* If a cone point does not map to leaves on any proc, then do not put face in SF */

1111

for (c = 0; c < coneSize; ++c) {

1112

if (debug) {ierr = PetscSynchronizedPrintf(PetscObjectComm((PetscObject) dm), "[%d] Cone point %D\n", rank, cone[c]);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1112,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

1113

ierr = PetscHMapIGet(leafhash, cone[c], &root);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1113,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1114

if (!rootdegree[cone[c]] && (root < 0)) {isFace = PETSC_FALSE; break;}

1115

}

1116

if (isFace) {

1117

if (debug) {ierr = PetscSynchronizedPrintf(PetscObjectComm((PetscObject) dm), "[%d] Adding shared face %D at idx %D\n", rank, face, idx);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1117,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

1118

ierr = PetscHMapIJSet(facehash, key, l);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1118,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1119

candidates[offset+idx].rank = -1;

1120

candidates[offset+idx++].index = coneSize-1;

1121

for (c = 0; c < coneSize; ++c) {

1122

if (cone[c] == localPoint) continue;

1123

if (rootdegree[cone[c]]) {

1124

candidates[offset+idx].rank = rank;

1125

candidates[offset+idx++].index = cone[c];

1126

} else {

1127

ierr = PetscHMapIGet(leafhash, cone[c], &root);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1127,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1128

if (root < 0) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Cannot locate local point %D in SF", cone[c])return PetscError(((MPI_Comm)0x44000001),1128,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,77,PETSC_ERROR_INITIAL,"Cannot locate local point %D in SF",
cone[c]);

1129

candidates[offset+idx++] = remotePoints[root];

1130

}

1131

}

1132

}

1133

}

1134

}

1135

if (debug) {ierr = PetscSynchronizedFlush(PetscObjectComm((PetscObject) dm), NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1135,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

←

Taking false branch

→

1136

ierr = PetscHMapIJDestroy(&facehash);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1136,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1137

ierr = PetscObjectViewFromOptions((PetscObject) candidateSection, NULL((void*)0), "-petscsection_interp_candidate_view");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1137,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1138

ierr = SFNodeArrayViewFromOptions(PetscObjectComm((PetscObject) dm), "-petscsection_interp_candidate_view", "Candidates", NULL((void*)0), candidatesSize, candidates);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1138,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1139

}

1140

/* Gather candidate section / array pair into the root partition via inverse(multi(pointSF)). */

1141

/* Note that this section is indexed by offsets into leaves, not by point number */

1142

{

1143

PetscSF sfMulti, sfInverse, sfCandidates;

1144

PetscInt *remoteOffsets;

1145

1146

ierr = PetscSFGetMultiSF(pointSF, &sfMulti);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1146,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1147

ierr = PetscSFCreateInverseSF(sfMulti, &sfInverse);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1147,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1148

ierr = PetscSectionCreate(PetscObjectComm((PetscObject) dm), &candidateSectionRemote);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1148,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1149

ierr = PetscSFDistributeSection(sfInverse, candidateSection, &remoteOffsets, candidateSectionRemote);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1149,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1150

ierr = PetscSFCreateSectionSF(sfInverse, candidateSection, remoteOffsets, candidateSectionRemote, &sfCandidates);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1150,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1151

ierr = PetscSectionGetStorageSize(candidateSectionRemote, &candidatesRemoteSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1151,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1152

ierr = PetscMalloc1(candidatesRemoteSize, &candidatesRemote)PetscMallocA(1,PETSC_FALSE,1152,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,(size_t)(candidatesRemoteSize)*sizeof(**(&candidatesRemote
)),(&candidatesRemote));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1152,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1153

ierr = PetscSFBcastBegin(sfCandidates, MPIU_2INT((MPI_Datatype)0x4c000816), candidates, candidatesRemote);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1153,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1154

ierr = PetscSFBcastEnd(sfCandidates, MPIU_2INT((MPI_Datatype)0x4c000816), candidates, candidatesRemote);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1154,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1155

ierr = PetscSFDestroy(&sfInverse);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1155,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1156

ierr = PetscSFDestroy(&sfCandidates);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1156,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1157

ierr = PetscFree(remoteOffsets)((*PetscTrFree)((void*)(remoteOffsets),1157,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
) || ((remoteOffsets) = 0,0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1157,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1158

1159

ierr = PetscObjectViewFromOptions((PetscObject) candidateSectionRemote, NULL((void*)0), "-petscsection_interp_candidate_remote_view");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1159,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1160

ierr = SFNodeArrayViewFromOptions(PetscObjectComm((PetscObject) dm), "-petscsection_interp_candidate_remote_view", "Remote Candidates", NULL((void*)0), candidatesRemoteSize, candidatesRemote);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1160,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1161

}

1162

/* */

1163

{

1164

PetscInt idx;

1165

/* There is a section point for every leaf attached to a given root point */

1166

for (r = 0, idx = 0; r < numRoots; ++r) {

←

Loop condition is true. Entering loop body

→

←

Loop condition is false. Execution continues on line 1196

→

1167

PetscInt deg;

1168

for (deg = 0; deg < rootdegree[r]; ++deg, ++idx) {

←

Assuming the condition is false

→

←

Loop condition is false. Execution continues on line 1166

→

1169

PetscInt offset, dof, d;

1170

1171

ierr = PetscSectionGetDof(candidateSectionRemote, idx, &dof);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1171,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1172

ierr = PetscSectionGetOffset(candidateSectionRemote, idx, &offset);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1172,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1173

for (d = 0; d < dof; ++d) {

1174

const PetscInt sizeInd = offset+d;

1175

const PetscInt numPoints = candidatesRemote[sizeInd].index;

1176

const PetscInt *join = NULL((void*)0);

1177

PetscInt points[1024], p, joinSize;

1178

1179

points[0] = r;

1180

for (p = 0; p < numPoints; ++p) {

1181

ierr = DMPlexMapToLocalPoint(roothash, localPoints, rank, candidatesRemote[offset+(++d)], &points[p+1]);

1182

if (ierr) {d += numPoints-1 - p; break;} /* We got a point not in our overlap */

1183

if (debug) {ierr = PetscSynchronizedPrintf(PetscObjectComm((PetscObject) dm), "[%d] Checking local candidate %D\n", rank, points[p+1]);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1183,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

1184

}

1185

if (ierr) continue;

1186

ierr = DMPlexGetJoin(dm, numPoints+1, points, &joinSize, &join);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1186,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1187

if (joinSize == 1) {

1188

if (debug) {ierr = PetscSynchronizedPrintf(PetscObjectComm((PetscObject) dm), "[%d] Adding face %D at idx %D\n", rank, join[0], sizeInd);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1188,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

1189

candidatesRemote[sizeInd].rank = rank;

1190

candidatesRemote[sizeInd].index = join[0];

1191

}

1192

ierr = DMPlexRestoreJoin(dm, numPoints+1, points, &joinSize, &join);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1192,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1193

}

1194

}

1195

}

1196

if (debug) {ierr = PetscSynchronizedFlush(PetscObjectComm((PetscObject) dm), NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1196,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

←

Taking false branch

→

1197

}

1198

/* Push claims back to receiver via the MultiSF and derive new pointSF mapping on receiver */

1199

{

1200

PetscSF sfMulti, sfClaims, sfPointNew;

1201

PetscSFNode *remotePointsNew;

1202

PetscHMapI claimshash;

1203

PetscInt *remoteOffsets, *localPointsNew;

1204

PetscInt claimsSize, pStart, pEnd, root, numLocalNew, p, d;

1205

1206

ierr = PetscSFGetMultiSF(pointSF, &sfMulti);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1206,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1207

ierr = PetscSectionCreate(PetscObjectComm((PetscObject) dm), &claimSection);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1207,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1208

ierr = PetscSFDistributeSection(sfMulti, candidateSectionRemote, &remoteOffsets, claimSection);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1208,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1209

ierr = PetscSFCreateSectionSF(sfMulti, candidateSectionRemote, remoteOffsets, claimSection, &sfClaims);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1209,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1210

ierr = PetscSectionGetStorageSize(claimSection, &claimsSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1210,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1211

ierr = PetscMalloc1(claimsSize, &claims)PetscMallocA(1,PETSC_FALSE,1211,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,(size_t)(claimsSize)*sizeof(**(&claims)),(&claims));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1211,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1212

ierr = PetscSFBcastBegin(sfClaims, MPIU_2INT((MPI_Datatype)0x4c000816), candidatesRemote, claims);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1212,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1213

ierr = PetscSFBcastEnd(sfClaims, MPIU_2INT((MPI_Datatype)0x4c000816), candidatesRemote, claims);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1213,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1214

ierr = PetscSFDestroy(&sfClaims);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1214,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1215

ierr = PetscFree(remoteOffsets)((*PetscTrFree)((void*)(remoteOffsets),1215,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
) || ((remoteOffsets) = 0,0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1215,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1216

ierr = PetscObjectViewFromOptions((PetscObject) claimSection, NULL((void*)0), "-petscsection_interp_claim_view");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1216,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1217

ierr = SFNodeArrayViewFromOptions(PetscObjectComm((PetscObject) dm), "-petscsection_interp_claim_view", "Claims", NULL((void*)0), claimsSize, claims);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1217,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1218

/* Walk the original section of local supports and add an SF entry for each updated item */

1219

ierr = PetscHMapICreate(&claimshash);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1219,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

←

Calling 'PetscHMapICreate'

→

←

Returning from 'PetscHMapICreate'

→

1220

for (p = 0; p < numRoots; ++p) {

←

Loop condition is true. Entering loop body

→

1221

PetscInt dof, offset;

1222

1223

if (debug) {ierr = PetscSynchronizedPrintf(PetscObjectComm((PetscObject) dm), "[%d] Checking root for claims %D\n", rank, p);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1223,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

←

Taking false branch

→

1224

ierr = PetscSectionGetDof(candidateSection, p, &dof);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1224,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1225

ierr = PetscSectionGetOffset(candidateSection, p, &offset);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1225,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1226

for (d = 0; d < dof;) {

←

Assuming 'd' is < 'dof'

→

←

Loop condition is true. Entering loop body

→

←

Loop condition is true. Entering loop body

→

←

Loop condition is true. Entering loop body

→

←

Loop condition is true. Entering loop body

→

1227

if (claims[offset+d].rank >= 0) {

←

Assuming the condition is false

Taking false branch

Taking false branch

Taking false branch

Taking true branch

1228

const PetscInt faceInd = offset+d;

1229

const PetscInt numPoints = candidates[faceInd].index;

1230

const PetscInt *join = NULL((void*)0);

1231

PetscInt joinSize, points[1024], c;

1232

1233

if (debug) {ierr = PetscSynchronizedPrintf(PetscObjectComm((PetscObject) dm), "[%d] Found claim for remote point (%D, %D)\n", rank, claims[faceInd].rank, claims[faceInd].index);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1233,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

←

Taking false branch

→

1234

points[0] = p;

1235

if (debug) {ierr = PetscSynchronizedPrintf(PetscObjectComm((PetscObject) dm), "[%d] point %D\n", rank, points[0]);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1235,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

←

Taking false branch

→

1236

for (c = 0, ++d; c < numPoints; ++c, ++d) {

←

Assuming 'c' is >= 'numPoints'

→

←

Loop condition is false. Execution continues on line 1243

→

1237

key.i = candidates[offset+d].index;

1238

key.j = candidates[offset+d].rank;

1239

ierr = PetscHMapIJGet(roothash, key, &root);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1239,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1240

points[c+1] = localPoints[root];

1241

if (debug) {ierr = PetscSynchronizedPrintf(PetscObjectComm((PetscObject) dm), "[%d] point %D\n", rank, points[c+1]);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1241,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

1242

}

1243

ierr = DMPlexGetJoin(dm, numPoints+1, points, &joinSize, &join);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1243,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1244

if (joinSize == 1) {

←

Assuming 'joinSize' is equal to 1

→

←

Taking true branch

→

1245

if (debug) {ierr = PetscSynchronizedPrintf(PetscObjectComm((PetscObject) dm), "[%d] Found local face %D\n", rank, join[0]);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1245,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

←

Taking false branch

→

1246

ierr = PetscHMapISet(claimshash, join[0], faceInd);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1246,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

←

Calling 'PetscHMapISet'

→

1247

}

1248

ierr = DMPlexRestoreJoin(dm, numPoints+1, points, &joinSize, &join);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1248,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1249

} else d += claims[offset+d].index+1;

1250

}

1251

}

1252

if (debug) {ierr = PetscSynchronizedFlush(PetscObjectComm((PetscObject) dm), NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1252,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

1253

/* Create new pointSF from hashed claims */

1254

ierr = PetscHMapIGetSize(claimshash, &numLocalNew);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1254,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1255

ierr = DMPlexGetChart(dm, &pStart, &pEnd);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1255,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1256

ierr = PetscMalloc1(numLeaves + numLocalNew, &localPointsNew)PetscMallocA(1,PETSC_FALSE,1256,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,(size_t)(numLeaves + numLocalNew)*sizeof(**(&localPointsNew
)),(&localPointsNew));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1256,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1257

ierr = PetscMalloc1(numLeaves + numLocalNew, &remotePointsNew)PetscMallocA(1,PETSC_FALSE,1257,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,(size_t)(numLeaves + numLocalNew)*sizeof(**(&remotePointsNew
)),(&remotePointsNew));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1257,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1258

for (p = 0; p < numLeaves; ++p) {

1259

localPointsNew[p] = localPoints[p];

1260

remotePointsNew[p].index = remotePoints[p].index;

1261

remotePointsNew[p].rank = remotePoints[p].rank;

1262

}

1263

p = numLeaves;

1264

ierr = PetscHMapIGetKeys(claimshash, &p, localPointsNew);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1264,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1265

ierr = PetscSortInt(numLocalNew, &localPointsNew[numLeaves]);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1265,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1266

for (p = numLeaves; p < numLeaves + numLocalNew; ++p) {

1267

PetscInt offset;

1268

ierr = PetscHMapIGet(claimshash, localPointsNew[p], &offset);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1268,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1269

remotePointsNew[p] = claims[offset];

1270

}

1271

ierr = PetscSFCreate(PetscObjectComm((PetscObject) dm), &sfPointNew);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1271,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1272

ierr = PetscSFSetGraph(sfPointNew, pEnd-pStart, numLeaves+numLocalNew, localPointsNew, PETSC_OWN_POINTER, remotePointsNew, PETSC_OWN_POINTER);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1272,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1273

ierr = DMSetPointSF(dm, sfPointNew);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1273,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1274

ierr = PetscSFDestroy(&sfPointNew);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1274,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1275

ierr = PetscHMapIDestroy(&claimshash);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1275,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1276

}

1277

ierr = PetscHMapIDestroy(&leafhash);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1277,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1278

ierr = PetscHMapIJDestroy(&roothash);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1278,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1279

ierr = PetscSectionDestroy(&candidateSection);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1279,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1280

ierr = PetscSectionDestroy(&candidateSectionRemote);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1280,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1281

ierr = PetscSectionDestroy(&claimSection);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1281,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1282

ierr = PetscFree(candidates)((*PetscTrFree)((void*)(candidates),1282,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
) || ((candidates) = 0,0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1282,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1283

ierr = PetscFree(candidatesRemote)((*PetscTrFree)((void*)(candidatesRemote),1283,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
) || ((candidatesRemote) = 0,0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1283,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1284

ierr = PetscFree(claims)((*PetscTrFree)((void*)(claims),1284,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
) || ((claims) = 0,0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1284,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1285

ierr = PetscLogEventEnd(DMPLEX_InterpolateSF,dm,0,0,0)(((PetscLogPLE && petsc_stageLog->stageInfo[petsc_stageLog
->curStage].perfInfo.active && petsc_stageLog->
stageInfo[petsc_stageLog->curStage].eventLog->eventInfo
[DMPLEX_InterpolateSF].active) ? (*PetscLogPLE)((DMPLEX_InterpolateSF
),0,(PetscObject)(dm),(PetscObject)(0),(PetscObject)(0),(PetscObject
)(0)) : 0 ));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1285,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1286

1287

}

1288

1289

/*@C

1290

DMPlexInterpolate - Take in a cell-vertex mesh and return one with all intermediate faces, edges, etc.

1291

1292

Collective on DM

1293

1294

Input Parameters:

1295

+ dm - The DMPlex object with only cells and vertices

1296

- dmInt - The interpolated DM

1297

1298

Output Parameter:

1299

. dmInt - The complete DMPlex object

1300

1301

Level: intermediate

1302

1303

Notes:

1304

It does not copy over the coordinates.

1305

1306

.keywords: mesh

1307

.seealso: DMPlexUninterpolate(), DMPlexCreateFromCellList(), DMPlexCopyCoordinates()

1308

@*/

1309

PetscErrorCode DMPlexInterpolate(DM dm, DM *dmInt)

1310

{

1311

DM idm, odm = dm;

1312

PetscSF sfPoint;

1313

PetscInt depth, dim, d;

1314

const char *name;

1315

PetscBool flg=PETSC_TRUE;

1316

PetscErrorCode ierr;

1317

1318

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 1318; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

1319

PetscValidHeaderSpecific(dm, DM_CLASSID, 1)do { if (!dm) return PetscError(((MPI_Comm)0x44000001),1319,__func__
,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Object: Parameter # %d",1); if (
!PetscCheckPointer(dm,PETSC_OBJECT)) return PetscError(((MPI_Comm
)0x44000001),1319,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,64,PETSC_ERROR_INITIAL,"Invalid Pointer to Object: Parameter # %d"
,1); if (((PetscObject)(dm))->classid != DM_CLASSID) { if (
((PetscObject)(dm))->classid == -1) return PetscError(((MPI_Comm
)0x44000001),1319,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,64,PETSC_ERROR_INITIAL,"Object already free: Parameter # %d"
,1); else return PetscError(((MPI_Comm)0x44000001),1319,__func__
,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,62,PETSC_ERROR_INITIAL,"Wrong type of object: Parameter # %d"
,1); } } while (0);

1320

PetscValidPointer(dmInt, 2)do { if (!dmInt) return PetscError(((MPI_Comm)0x44000001),1320
,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",2); if
(!PetscCheckPointer(dmInt,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),1320,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",2);
} while (0);

1321

ierr = PetscLogEventBegin(DMPLEX_Interpolate,dm,0,0,0)(((PetscLogPLB && petsc_stageLog->stageInfo[petsc_stageLog
->curStage].perfInfo.active && petsc_stageLog->
stageInfo[petsc_stageLog->curStage].eventLog->eventInfo
[DMPLEX_Interpolate].active) ? (*PetscLogPLB)((DMPLEX_Interpolate
),0,(PetscObject)(dm),(PetscObject)(0),(PetscObject)(0),(PetscObject
)(0)) : 0 ));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1321,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1322

ierr = DMPlexGetDepth(dm, &depth);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1322,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1323

ierr = DMGetDimension(dm, &dim);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1323,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1324

if ((depth == dim) || (dim <= 1)) {

1325

ierr = PetscObjectReference((PetscObject) dm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1325,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1326

idm = dm;

1327

} else {

1328

for (d = 1; d < dim; ++d) {

1329

/* Create interpolated mesh */

1330

ierr = DMCreate(PetscObjectComm((PetscObject)dm), &idm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1330,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1331

ierr = DMSetType(idm, DMPLEX"plex");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1331,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1332

ierr = DMSetDimension(idm, dim);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1332,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1333

if (depth > 0) {

1334

ierr = DMPlexInterpolateFaces_Internal(odm, 1, idm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1334,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1335

ierr = DMGetPointSF(odm, &sfPoint);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1335,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1336

ierr = DMPlexInterpolatePointSF(idm, sfPoint);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1336,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1337

}

1338

if (odm != dm) {ierr = DMDestroy(&odm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1338,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

1339

odm = idm;

1340

}

1341

ierr = PetscObjectGetName((PetscObject) dm, &name);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1341,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1342

ierr = PetscObjectSetName((PetscObject) idm, name);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1342,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1343

ierr = DMPlexCopyCoordinates(dm, idm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1343,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1344

ierr = DMCopyLabels(dm, idm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1344,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1345

ierr = PetscOptionsGetBool(((PetscObject)dm)->options, ((PetscObject)dm)->prefix, "-dm_plex_interpolate_orient_interfaces", &flg, NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1345,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1346

if (flg) {ierr = DMPlexOrientInterface(idm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1346,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);}

1347

}

1348

{

1349

PetscBool isper;

1350

const PetscReal *maxCell, *L;

1351

const DMBoundaryType *bd;

1352

1353

ierr = DMGetPeriodicity(dm,&isper,&maxCell,&L,&bd);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1353,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1354

ierr = DMSetPeriodicity(idm,isper,maxCell,L,bd);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1354,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1355

}

1356

*dmInt = idm;

1357

ierr = PetscLogEventEnd(DMPLEX_Interpolate,dm,0,0,0)(((PetscLogPLE && petsc_stageLog->stageInfo[petsc_stageLog
->curStage].perfInfo.active && petsc_stageLog->
stageInfo[petsc_stageLog->curStage].eventLog->eventInfo
[DMPLEX_Interpolate].active) ? (*PetscLogPLE)((DMPLEX_Interpolate
),0,(PetscObject)(dm),(PetscObject)(0),(PetscObject)(0),(PetscObject
)(0)) : 0 ));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1357,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1358

1359

}

1360

1361

/*@

1362

DMPlexCopyCoordinates - Copy coordinates from one mesh to another with the same vertices

1363

1364

Collective on DM

1365

1366

Input Parameter:

1367

. dmA - The DMPlex object with initial coordinates

1368

1369

Output Parameter:

1370

. dmB - The DMPlex object with copied coordinates

1371

1372

Level: intermediate

1373

1374

Note: This is typically used when adding pieces other than vertices to a mesh

1375

1376

.keywords: mesh

1377

.seealso: DMCopyLabels(), DMGetCoordinates(), DMGetCoordinatesLocal(), DMGetCoordinateDM(), DMGetCoordinateSection()

1378

@*/

1379

PetscErrorCode DMPlexCopyCoordinates(DM dmA, DM dmB)

1380

{

1381

Vec coordinatesA, coordinatesB;

1382

VecType vtype;

1383

PetscSection coordSectionA, coordSectionB;

1384

PetscScalar *coordsA, *coordsB;

1385

PetscInt spaceDim, Nf, vStartA, vStartB, vEndA, vEndB, coordSizeB, v, d;

1386

PetscInt cStartA, cEndA, cStartB, cEndB, cS, cE;

1387

PetscBool lc = PETSC_FALSE;

1388

PetscErrorCode ierr;

1389

1390

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 1390; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

1391

PetscValidHeaderSpecific(dmA, DM_CLASSID, 1)do { if (!dmA) return PetscError(((MPI_Comm)0x44000001),1391,
__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Object: Parameter # %d",1); if (
!PetscCheckPointer(dmA,PETSC_OBJECT)) return PetscError(((MPI_Comm
)0x44000001),1391,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,64,PETSC_ERROR_INITIAL,"Invalid Pointer to Object: Parameter # %d"
,1); if (((PetscObject)(dmA))->classid != DM_CLASSID) { if
(((PetscObject)(dmA))->classid == -1) return PetscError((
(MPI_Comm)0x44000001),1391,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,64,PETSC_ERROR_INITIAL,"Object already free: Parameter # %d"
,1); else return PetscError(((MPI_Comm)0x44000001),1391,__func__
,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,62,PETSC_ERROR_INITIAL,"Wrong type of object: Parameter # %d"
,1); } } while (0);

1392

PetscValidHeaderSpecific(dmB, DM_CLASSID, 2)do { if (!dmB) return PetscError(((MPI_Comm)0x44000001),1392,
__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Object: Parameter # %d",2); if (
!PetscCheckPointer(dmB,PETSC_OBJECT)) return PetscError(((MPI_Comm
)0x44000001),1392,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,64,PETSC_ERROR_INITIAL,"Invalid Pointer to Object: Parameter # %d"
,2); if (((PetscObject)(dmB))->classid != DM_CLASSID) { if
(((PetscObject)(dmB))->classid == -1) return PetscError((
(MPI_Comm)0x44000001),1392,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,64,PETSC_ERROR_INITIAL,"Object already free: Parameter # %d"
,2); else return PetscError(((MPI_Comm)0x44000001),1392,__func__
,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,62,PETSC_ERROR_INITIAL,"Wrong type of object: Parameter # %d"
,2); } } while (0);

1393

if (dmA == dmB) PetscFunctionReturn(0)do { do { ; if (petscstack && petscstack->currentsize
> 0) { petscstack->currentsize--; petscstack->function
[petscstack->currentsize] = 0; petscstack->file[petscstack
->currentsize] = 0; petscstack->line[petscstack->currentsize
] = 0; petscstack->petscroutine[petscstack->currentsize
] = PETSC_FALSE; } if (petscstack) { petscstack->hotdepth =
(((petscstack->hotdepth-1)<(0)) ? (0) : (petscstack->
hotdepth-1)); } ; } while (0); return(0);} while (0);

1394

ierr = DMPlexGetDepthStratum(dmA, 0, &vStartA, &vEndA);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1394,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1395

ierr = DMPlexGetDepthStratum(dmB, 0, &vStartB, &vEndB);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1395,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1396

if ((vEndA-vStartA) != (vEndB-vStartB)) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_SIZ, "The number of vertices in first DM %d != %d in the second DM", vEndA-vStartA, vEndB-vStartB)return PetscError(((MPI_Comm)0x44000001),1396,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,60,PETSC_ERROR_INITIAL,"The number of vertices in first DM %d != %d in the second DM"
,vEndA-vStartA,vEndB-vStartB);

1397

ierr = DMPlexGetHeightStratum(dmA, 0, &cStartA, &cEndA);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1397,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1398

ierr = DMPlexGetHeightStratum(dmB, 0, &cStartB, &cEndB);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1398,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1399

ierr = DMGetCoordinateSection(dmA, &coordSectionA);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1399,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1400

ierr = DMGetCoordinateSection(dmB, &coordSectionB);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1400,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1401

if (coordSectionA == coordSectionB) PetscFunctionReturn(0)do { do { ; if (petscstack && petscstack->currentsize
> 0) { petscstack->currentsize--; petscstack->function
[petscstack->currentsize] = 0; petscstack->file[petscstack
->currentsize] = 0; petscstack->line[petscstack->currentsize
] = 0; petscstack->petscroutine[petscstack->currentsize
] = PETSC_FALSE; } if (petscstack) { petscstack->hotdepth =
(((petscstack->hotdepth-1)<(0)) ? (0) : (petscstack->
hotdepth-1)); } ; } while (0); return(0);} while (0);

1402

ierr = PetscSectionGetNumFields(coordSectionA, &Nf);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1402,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1403

if (!Nf) PetscFunctionReturn(0)do { do { ; if (petscstack && petscstack->currentsize
> 0) { petscstack->currentsize--; petscstack->function
[petscstack->currentsize] = 0; petscstack->file[petscstack
->currentsize] = 0; petscstack->line[petscstack->currentsize
] = 0; petscstack->petscroutine[petscstack->currentsize
] = PETSC_FALSE; } if (petscstack) { petscstack->hotdepth =
(((petscstack->hotdepth-1)<(0)) ? (0) : (petscstack->
hotdepth-1)); } ; } while (0); return(0);} while (0);

1404

if (Nf > 1) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_SIZ, "The number of coordinate fields must be 1, not %D", Nf)return PetscError(((MPI_Comm)0x44000001),1404,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,60,PETSC_ERROR_INITIAL,"The number of coordinate fields must be 1, not %D"
,Nf);

1405

if (!coordSectionB) {

1406

PetscInt dim;

1407

1408

ierr = PetscSectionCreate(PetscObjectComm((PetscObject) coordSectionA), &coordSectionB);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1408,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1409

ierr = DMGetCoordinateDim(dmA, &dim);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1409,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1410

ierr = DMSetCoordinateSection(dmB, dim, coordSectionB);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1410,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1411

ierr = PetscObjectDereference((PetscObject) coordSectionB);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1411,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1412

}

1413

ierr = PetscSectionSetNumFields(coordSectionB, 1);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1413,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1414

ierr = PetscSectionGetFieldComponents(coordSectionA, 0, &spaceDim);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1414,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1415

ierr = PetscSectionSetFieldComponents(coordSectionB, 0, spaceDim);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1415,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1416

ierr = PetscSectionGetChart(coordSectionA, &cS, &cE);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1416,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1417

if (cStartA <= cS && cS < cEndA) { /* localized coordinates */

1418

if ((cEndA-cStartA) != (cEndB-cStartB)) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_SIZ, "The number of cells in first DM %D != %D in the second DM", cEndA-cStartA, cEndB-cStartB)return PetscError(((MPI_Comm)0x44000001),1418,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,60,PETSC_ERROR_INITIAL,"The number of cells in first DM %D != %D in the second DM"
,cEndA-cStartA,cEndB-cStartB);

1419

cS = cS - cStartA + cStartB;

1420

cE = vEndB;

1421

lc = PETSC_TRUE;

1422

} else {

1423

cS = vStartB;

1424

cE = vEndB;

1425

}

1426

ierr = PetscSectionSetChart(coordSectionB, cS, cE);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1426,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1427

for (v = vStartB; v < vEndB; ++v) {

1428

ierr = PetscSectionSetDof(coordSectionB, v, spaceDim);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1428,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1429

ierr = PetscSectionSetFieldDof(coordSectionB, v, 0, spaceDim);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1429,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1430

}

1431

if (lc) { /* localized coordinates */

1432

PetscInt c;

1433

1434

for (c = cS-cStartB; c < cEndB-cStartB; c++) {

1435

PetscInt dof;

1436

1437

ierr = PetscSectionGetDof(coordSectionA, c + cStartA, &dof);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1437,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1438

ierr = PetscSectionSetDof(coordSectionB, c + cStartB, dof);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1438,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1439

ierr = PetscSectionSetFieldDof(coordSectionB, c + cStartB, 0, dof);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1439,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1440

}

1441

}

1442

ierr = PetscSectionSetUp(coordSectionB);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1442,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1443

ierr = PetscSectionGetStorageSize(coordSectionB, &coordSizeB);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1443,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1444

ierr = DMGetCoordinatesLocal(dmA, &coordinatesA);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1444,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1445

ierr = VecCreate(PETSC_COMM_SELF((MPI_Comm)0x44000001), &coordinatesB);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1445,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1446

ierr = PetscObjectSetName((PetscObject) coordinatesB, "coordinates");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1446,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1447

ierr = VecSetSizes(coordinatesB, coordSizeB, PETSC_DETERMINE-1);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1447,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1448

ierr = VecGetBlockSize(coordinatesA, &d);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1448,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1449

ierr = VecSetBlockSize(coordinatesB, d);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1449,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1450

ierr = VecGetType(coordinatesA, &vtype);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1450,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1451

ierr = VecSetType(coordinatesB, vtype);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1451,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1452

ierr = VecGetArray(coordinatesA, &coordsA);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1452,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1453

ierr = VecGetArray(coordinatesB, &coordsB);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1453,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1454

for (v = 0; v < vEndB-vStartB; ++v) {

1455

PetscInt offA, offB;

1456

1457

ierr = PetscSectionGetOffset(coordSectionA, v + vStartA, &offA);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1457,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1458

ierr = PetscSectionGetOffset(coordSectionB, v + vStartB, &offB);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1458,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1459

for (d = 0; d < spaceDim; ++d) {

1460

coordsB[offB+d] = coordsA[offA+d];

1461

}

1462

}

1463

if (lc) { /* localized coordinates */

1464

PetscInt c;

1465

1466

for (c = cS-cStartB; c < cEndB-cStartB; c++) {

1467

PetscInt dof, offA, offB;

1468

1469

ierr = PetscSectionGetOffset(coordSectionA, c + cStartA, &offA);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1469,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1470

ierr = PetscSectionGetOffset(coordSectionB, c + cStartB, &offB);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1470,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1471

ierr = PetscSectionGetDof(coordSectionA, c + cStartA, &dof);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1471,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1472

ierr = PetscMemcpy(coordsB + offB,coordsA + offA,dof*sizeof(*coordsB));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1472,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1473

}

1474

}

1475

ierr = VecRestoreArray(coordinatesA, &coordsA);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1475,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1476

ierr = VecRestoreArray(coordinatesB, &coordsB);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1476,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1477

ierr = DMSetCoordinatesLocal(dmB, coordinatesB);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1477,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1478

ierr = VecDestroy(&coordinatesB);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1478,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1479

1480

}

1481

1482

/*@

1483

DMPlexUninterpolate - Take in a mesh with all intermediate faces, edges, etc. and return a cell-vertex mesh

1484

1485

Collective on DM

1486

1487

Input Parameter:

1488

. dm - The complete DMPlex object

1489

1490

Output Parameter:

1491

. dmUnint - The DMPlex object with only cells and vertices

1492

1493

Level: intermediate

1494

1495

Notes:

1496

It does not copy over the coordinates.

1497

1498

.keywords: mesh

1499

.seealso: DMPlexInterpolate(), DMPlexCreateFromCellList(), DMPlexCopyCoordinates()

1500

@*/

1501

PetscErrorCode DMPlexUninterpolate(DM dm, DM *dmUnint)

1502

{

1503

DM udm;

1504

PetscInt dim, vStart, vEnd, cStart, cEnd, cMax, c, maxConeSize = 0, *cone;

1505

PetscErrorCode ierr;

1506

1507

PetscFunctionBegindo { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
; petscstack->line[petscstack->currentsize] = 1507; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0);

1508

PetscValidHeaderSpecific(dm, DM_CLASSID, 1)do { if (!dm) return PetscError(((MPI_Comm)0x44000001),1508,__func__
,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Object: Parameter # %d",1); if (
!PetscCheckPointer(dm,PETSC_OBJECT)) return PetscError(((MPI_Comm
)0x44000001),1508,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,64,PETSC_ERROR_INITIAL,"Invalid Pointer to Object: Parameter # %d"
,1); if (((PetscObject)(dm))->classid != DM_CLASSID) { if (
((PetscObject)(dm))->classid == -1) return PetscError(((MPI_Comm
)0x44000001),1508,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,64,PETSC_ERROR_INITIAL,"Object already free: Parameter # %d"
,1); else return PetscError(((MPI_Comm)0x44000001),1508,__func__
,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,62,PETSC_ERROR_INITIAL,"Wrong type of object: Parameter # %d"
,1); } } while (0);

1509

PetscValidPointer(dmUnint, 2)do { if (!dmUnint) return PetscError(((MPI_Comm)0x44000001),1509
,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",2); if
(!PetscCheckPointer(dmUnint,PETSC_CHAR)) return PetscError((
(MPI_Comm)0x44000001),1509,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",2);
} while (0);

1510

ierr = DMGetDimension(dm, &dim);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1510,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1511

if (dim <= 1) {

1512

ierr = PetscObjectReference((PetscObject) dm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1512,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1513

*dmUnint = dm;

1514

1515

}

1516

ierr = DMPlexGetDepthStratum(dm, 0, &vStart, &vEnd);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1516,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1517

ierr = DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1517,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1518

ierr = DMPlexGetHybridBounds(dm, &cMax, NULL((void*)0), NULL((void*)0), NULL((void*)0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1518,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1519

ierr = DMCreate(PetscObjectComm((PetscObject) dm), &udm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1519,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1520

ierr = DMSetType(udm, DMPLEX"plex");CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1520,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1521

ierr = DMSetDimension(udm, dim);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1521,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1522

ierr = DMPlexSetChart(udm, cStart, vEnd);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1522,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1523

for (c = cStart; c < cEnd; ++c) {

1524

PetscInt *closure = NULL((void*)0), closureSize, cl, coneSize = 0;

1525

1526

ierr = DMPlexGetTransitiveClosure(dm, c, PETSC_TRUE, &closureSize, &closure);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1526,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1527

for (cl = 0; cl < closureSize*2; cl += 2) {

1528

const PetscInt p = closure[cl];

1529

1530

if ((p >= vStart) && (p < vEnd)) ++coneSize;

1531

}

1532

ierr = DMPlexRestoreTransitiveClosure(dm, c, PETSC_TRUE, &closureSize, &closure);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1532,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1533

ierr = DMPlexSetConeSize(udm, c, coneSize);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1533,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1534

maxConeSize = PetscMax(maxConeSize, coneSize)(((maxConeSize)<(coneSize)) ? (coneSize) : (maxConeSize));

1535

}

1536

ierr = DMSetUp(udm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1536,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1537

ierr = PetscMalloc1(maxConeSize, &cone)PetscMallocA(1,PETSC_FALSE,1537,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,(size_t)(maxConeSize)*sizeof(**(&cone)),(&cone));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1537,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1538

for (c = cStart; c < cEnd; ++c) {

1539

PetscInt *closure = NULL((void*)0), closureSize, cl, coneSize = 0;

1540

1541

ierr = DMPlexGetTransitiveClosure(dm, c, PETSC_TRUE, &closureSize, &closure);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1541,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1542

for (cl = 0; cl < closureSize*2; cl += 2) {

1543

const PetscInt p = closure[cl];

1544

1545

if ((p >= vStart) && (p < vEnd)) cone[coneSize++] = p;

1546

}

1547

ierr = DMPlexRestoreTransitiveClosure(dm, c, PETSC_TRUE, &closureSize, &closure);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1547,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1548

ierr = DMPlexSetCone(udm, c, cone);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1548,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1549

}

1550

ierr = PetscFree(cone)((*PetscTrFree)((void*)(cone),1550,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
) || ((cone) = 0,0));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1550,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1551

ierr = DMPlexSetHybridBounds(udm, cMax, PETSC_DETERMINE-1, PETSC_DETERMINE-1, PETSC_DETERMINE-1);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1551,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1552

ierr = DMPlexSymmetrize(udm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1552,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1553

ierr = DMPlexStratify(udm);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1553,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1554

/* Reduce SF */

1555

{

1556

PetscSF sfPoint, sfPointUn;

1557

const PetscSFNode *remotePoints;

1558

const PetscInt *localPoints;

1559

PetscSFNode *remotePointsUn;

1560

PetscInt *localPointsUn;

1561

PetscInt vEnd, numRoots, numLeaves, l;

1562

PetscInt numLeavesUn = 0, n = 0;

1563

PetscErrorCode ierr;

1564

1565

/* Get original SF information */

1566

ierr = DMGetPointSF(dm, &sfPoint);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1566,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1567

ierr = DMGetPointSF(udm, &sfPointUn);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1567,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1568

ierr = DMPlexGetDepthStratum(dm, 0, NULL((void*)0), &vEnd);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1568,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1569

ierr = PetscSFGetGraph(sfPoint, &numRoots, &numLeaves, &localPoints, &remotePoints);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1569,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1570

/* Allocate space for cells and vertices */

1571

for (l = 0; l < numLeaves; ++l) if (localPoints[l] < vEnd) numLeavesUn++;

1572

/* Fill in leaves */

1573

if (vEnd >= 0) {

1574

ierr = PetscMalloc1(numLeavesUn, &remotePointsUn)PetscMallocA(1,PETSC_FALSE,1574,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,(size_t)(numLeavesUn)*sizeof(**(&remotePointsUn)),(&
remotePointsUn));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1574,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1575

ierr = PetscMalloc1(numLeavesUn, &localPointsUn)PetscMallocA(1,PETSC_FALSE,1575,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,(size_t)(numLeavesUn)*sizeof(**(&localPointsUn)),(&localPointsUn
));CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1575,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1576

for (l = 0; l < numLeaves; l++) {

1577

if (localPoints[l] < vEnd) {

1578

localPointsUn[n] = localPoints[l];

1579

remotePointsUn[n].rank = remotePoints[l].rank;

1580

remotePointsUn[n].index = remotePoints[l].index;

1581

++n;

1582

}

1583

}

1584

if (n != numLeavesUn) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Inconsistent number of leaves %d != %d", n, numLeavesUn)return PetscError(((MPI_Comm)0x44000001),1584,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,77,PETSC_ERROR_INITIAL,"Inconsistent number of leaves %d != %d"
,n,numLeavesUn);

1585

ierr = PetscSFSetGraph(sfPointUn, vEnd, numLeavesUn, localPointsUn, PETSC_OWN_POINTER, remotePointsUn, PETSC_OWN_POINTER);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1585,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1586

}

1587

}

1588

{

1589

PetscBool isper;

1590

const PetscReal *maxCell, *L;

1591

const DMBoundaryType *bd;

1592

1593

ierr = DMGetPeriodicity(dm,&isper,&maxCell,&L,&bd);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1593,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1594

ierr = DMSetPeriodicity(udm,isper,maxCell,L,bd);CHKERRQ(ierr)do {if (__builtin_expect(!!(ierr),0)) return PetscError(((MPI_Comm
)0x44000001),1594,__func__,"/sandbox/petsc/petsc.next-tmp/src/dm/impls/plex/plexinterpolate.c"
,ierr,PETSC_ERROR_REPEAT," ");} while (0);

1595

}

1596

1597

*dmUnint = udm;

1598

1599

}

←

/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h

→

#if !defined(PETSC_HASHMAPI_H)

#define PETSC_HASHMAPI_H

#include <petsc/private/hashmap.h>

PETSC_HASH_MAP(HMapI, PetscInt, PetscInt, PetscHashInt, PetscHashEqual, -1)typedef struct kh_HMapI_s { khint_t n_buckets, size, n_occupied
, upper_bound; khint32_t *flags; PetscInt *keys; PetscInt *vals
; } kh_HMapI_t; static inline __attribute((unused)) kh_HMapI_t
*kh_init_HMapI(void) { return (kh_HMapI_t*)calloc(1,sizeof(kh_HMapI_t
)); } static inline __attribute((unused)) void kh_destroy_HMapI
(kh_HMapI_t *h) { if (h) { free((void *)h->keys); free(h->
flags); free((void *)h->vals); free(h); } } static inline __attribute
((unused)) void kh_clear_HMapI(kh_HMapI_t *h) { if (h &&
h->flags) { memset(h->flags, 0xaa, ((h->n_buckets) <
16? 1 : (h->n_buckets)>>4) * sizeof(khint32_t)); h->
size = h->n_occupied = 0; } } static inline __attribute((unused
)) khint_t kh_get_HMapI(const kh_HMapI_t *h, PetscInt key) { if
(h->n_buckets) { khint_t k, i, last, mask, step = 0; mask
= h->n_buckets - 1; k = PetscHashInt(key); i = k & mask
; last = i; while (!((h->flags[i>>4]>>((i&
0xfU)<<1))&2) && (((h->flags[i>>4]
>>((i&0xfU)<<1))&1) || !((h->keys[i]) ==
(key)))) { i = (i + (++step)) & mask; if (i == last) return
h->n_buckets; } return ((h->flags[i>>4]>>(
(i&0xfU)<<1))&3)? h->n_buckets : i; } else return
0; } static inline __attribute((unused)) int kh_resize_HMapI
(kh_HMapI_t *h, khint_t new_n_buckets) { khint32_t *new_flags
= 0; khint_t j = 1; { (--(new_n_buckets), (new_n_buckets)|=(
new_n_buckets)>>1, (new_n_buckets)|=(new_n_buckets)>>
2, (new_n_buckets)|=(new_n_buckets)>>4, (new_n_buckets)
|=(new_n_buckets)>>8, (new_n_buckets)|=(new_n_buckets)>>
16, ++(new_n_buckets)); if (new_n_buckets < 4) new_n_buckets
= 4; if (h->size >= (khint_t)(new_n_buckets * __ac_HASH_UPPER
+ 0.5)) j = 0; else { new_flags = (khint32_t*)malloc(((new_n_buckets
) < 16? 1 : (new_n_buckets)>>4) * sizeof(khint32_t))
; if (!new_flags) return -1; memset(new_flags, 0xaa, ((new_n_buckets
) < 16? 1 : (new_n_buckets)>>4) * sizeof(khint32_t))
; if (h->n_buckets < new_n_buckets) { PetscInt *new_keys
= (PetscInt*)realloc((void *)h->keys,new_n_buckets * sizeof
(PetscInt)); if (!new_keys) { free(new_flags); return -1; } h
->keys = new_keys; if (1) { PetscInt *new_vals = (PetscInt
*)realloc((void *)h->vals,new_n_buckets * sizeof(PetscInt)
); if (!new_vals) { free(new_flags); return -1; } h->vals =
new_vals; } } } } if (j) { for (j = 0; j != h->n_buckets;
++j) { if (((h->flags[j>>4]>>((j&0xfU)<<
1))&3) == 0) { PetscInt key = h->keys[j]; PetscInt val
; khint_t new_mask; new_mask = new_n_buckets - 1; if (1) val =
h->vals[j]; (h->flags[j>>4]|=1ul<<((j&
0xfU)<<1)); while (1) { khint_t k, i, step = 0; k = PetscHashInt
(key); i = k & new_mask; while (!((new_flags[i>>4]>>
((i&0xfU)<<1))&2)) i = (i + (++step)) & new_mask
; (new_flags[i>>4]&=~(2ul<<((i&0xfU)<<
1))); if (i < h->n_buckets && ((h->flags[i>>
4]>>((i&0xfU)<<1))&3) == 0) { { PetscInt tmp
= h->keys[i]; h->keys[i] = key; key = tmp; } if (1) { PetscInt
tmp = h->vals[i]; h->vals[i] = val; val = tmp; } (h->
flags[i>>4]|=1ul<<((i&0xfU)<<1)); } else
{ h->keys[i] = key; if (1) h->vals[i] = val; break; } }
} } if (h->n_buckets > new_n_buckets) { h->keys = (
PetscInt*)realloc((void *)h->keys,new_n_buckets * sizeof(PetscInt
)); if (1) h->vals = (PetscInt*)realloc((void *)h->vals
,new_n_buckets * sizeof(PetscInt)); } free(h->flags); h->
flags = new_flags; h->n_buckets = new_n_buckets; h->n_occupied
= h->size; h->upper_bound = (khint_t)(h->n_buckets *
__ac_HASH_UPPER + 0.5); } return 0; } static inline __attribute
((unused)) khint_t kh_put_HMapI(kh_HMapI_t *h, PetscInt key, int
*ret) { khint_t x; if (h->n_occupied >= h->upper_bound
) { if (h->n_buckets > (h->size<<1)) { if (kh_resize_HMapI
(h, h->n_buckets - 1) < 0) { *ret = -1; return h->n_buckets
; } } else if (kh_resize_HMapI(h, h->n_buckets + 1) < 0
) { *ret = -1; return h->n_buckets; } } { khint_t k, i, site
, last, mask = h->n_buckets - 1, step = 0; x = site = h->
n_buckets; k = PetscHashInt(key); i = k & mask; if (((h->
flags[i>>4]>>((i&0xfU)<<1))&2)) x =
i; else { last = i; while (!((h->flags[i>>4]>>
((i&0xfU)<<1))&2) && (((h->flags[i>>
4]>>((i&0xfU)<<1))&1) || !((h->keys[i]
) == (key)))) { if (((h->flags[i>>4]>>((i&
0xfU)<<1))&1)) site = i; i = (i + (++step)) & mask
; if (i == last) { x = site; break; } } if (x == h->n_buckets
) { if (((h->flags[i>>4]>>((i&0xfU)<<
1))&2) && site != h->n_buckets) x = site; else
x = i; } } } if (((h->flags[x>>4]>>((x&0xfU
)<<1))&2)) { h->keys[x] = key; (h->flags[x>>
4]&=~(3ul<<((x&0xfU)<<1))); ++h->size;
++h->n_occupied; *ret = 1; } else if (((h->flags[x>>
4]>>((x&0xfU)<<1))&1)) { h->keys[x] = key
; (h->flags[x>>4]&=~(3ul<<((x&0xfU)<<
1))); ++h->size; *ret = 2; } else *ret = 0; return x; } static
inline __attribute((unused)) void kh_del_HMapI(kh_HMapI_t *h
, khint_t x) { if (x != h->n_buckets && !((h->flags
[x>>4]>>((x&0xfU)<<1))&3)) { (h->
flags[x>>4]|=1ul<<((x&0xfU)<<1)); --h->
size; } } typedef kh_HMapI_t *PetscHMapI; static inline __attribute
((unused)) PetscErrorCode PetscHMapICreate(PetscHMapI *ht) { do
{ do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
; petscstack->line[petscstack->currentsize] = 6; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); *ht = kh_init_HMapI(); do { if (__builtin_expect
(!!(!(*ht!=((void*)0))),0)) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","*ht!=((void*)0)"
); } while(0); do { do { ; if (petscstack && petscstack
->currentsize > 0) { petscstack->currentsize--; petscstack
->function[petscstack->currentsize] = 0; petscstack->
file[petscstack->currentsize] = 0; petscstack->line[petscstack
->currentsize] = 0; petscstack->petscroutine[petscstack
->currentsize] = PETSC_FALSE; } if (petscstack) { petscstack
->hotdepth = (((petscstack->hotdepth-1)<(0)) ? (0) :
(petscstack->hotdepth-1)); } ; } while (0); return(0);} while
(0); } static inline __attribute((unused)) PetscErrorCode PetscHMapIDestroy
(PetscHMapI *ht) { do { do { ; if (petscstack && (petscstack
->currentsize < 64)) { petscstack->function[petscstack
->currentsize] = __func__; petscstack->file[petscstack->
currentsize] = "/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
; petscstack->line[petscstack->currentsize] = 6; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); if (!*ht) do { do { ; if (petscstack &&
petscstack->currentsize > 0) { petscstack->currentsize
--; petscstack->function[petscstack->currentsize] = 0; petscstack
->file[petscstack->currentsize] = 0; petscstack->line
[petscstack->currentsize] = 0; petscstack->petscroutine
[petscstack->currentsize] = PETSC_FALSE; } if (petscstack)
{ petscstack->hotdepth = (((petscstack->hotdepth-1)<
(0)) ? (0) : (petscstack->hotdepth-1)); } ; } while (0); return
(0);} while (0); kh_destroy_HMapI(*ht); *ht = ((void*)0); do {
do { ; if (petscstack && petscstack->currentsize >
0) { petscstack->currentsize--; petscstack->function[petscstack
->currentsize] = 0; petscstack->file[petscstack->currentsize
] = 0; petscstack->line[petscstack->currentsize] = 0; petscstack
->petscroutine[petscstack->currentsize] = PETSC_FALSE; }
if (petscstack) { petscstack->hotdepth = (((petscstack->
hotdepth-1)<(0)) ? (0) : (petscstack->hotdepth-1)); } ;
} while (0); return(0);} while (0); } static inline __attribute
((unused)) PetscErrorCode PetscHMapIReset(PetscHMapI ht) { do
{ do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
; petscstack->line[petscstack->currentsize] = 6; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); { if (ht) { free((ht)->keys); free((ht)->
flags); free((ht)->vals); memset((ht), 0x00, sizeof(*(ht))
); } }; do { do { ; if (petscstack && petscstack->
currentsize > 0) { petscstack->currentsize--; petscstack
->function[petscstack->currentsize] = 0; petscstack->
file[petscstack->currentsize] = 0; petscstack->line[petscstack
->currentsize] = 0; petscstack->petscroutine[petscstack
->currentsize] = PETSC_FALSE; } if (petscstack) { petscstack
->hotdepth = (((petscstack->hotdepth-1)<(0)) ? (0) :
(petscstack->hotdepth-1)); } ; } while (0); return(0);} while
(0); } static inline __attribute((unused)) PetscErrorCode PetscHMapIDuplicate
(PetscHMapI ht,PetscHMapI *hd) { int ret; PetscInt key; PetscInt
val; do { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
; petscstack->line[petscstack->currentsize] = 6; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!hd) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",2); if
(!PetscCheckPointer(hd,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",2);
} while (0); *hd = kh_init_HMapI(); do { if (__builtin_expect
(!!(!(*hd!=((void*)0))),0)) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","*hd!=((void*)0)"
); } while(0); ret = kh_resize_HMapI(*hd, ((ht)->size)); do
{ if (__builtin_expect(!!(!(ret==0)),0)) return PetscError((
(MPI_Comm)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","ret==0"
); } while(0); { khint_t __i; for (__i = (khint_t)(0); __i !=
((ht)->n_buckets); ++__i) { if (!(!(((ht)->flags[(__i)
>>4]>>(((__i)&0xfU)<<1))&3))) continue
; (key) = ((ht)->keys[__i]); (val) = ((ht)->vals[__i]);
{ khiter_t i; i = kh_put_HMapI(*hd, key, &ret); do { if (
__builtin_expect(!!(!(ret>=0)),0)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","ret>=0"
); } while(0); ((*hd)->vals[i]) = val;}; } } do { do { ; if
(petscstack && petscstack->currentsize > 0) { petscstack
->currentsize--; petscstack->function[petscstack->currentsize
] = 0; petscstack->file[petscstack->currentsize] = 0; petscstack
->line[petscstack->currentsize] = 0; petscstack->petscroutine
[petscstack->currentsize] = PETSC_FALSE; } if (petscstack)
{ petscstack->hotdepth = (((petscstack->hotdepth-1)<
(0)) ? (0) : (petscstack->hotdepth-1)); } ; } while (0); return
(0);} while (0); } static inline __attribute((unused)) PetscErrorCode
PetscHMapIClear(PetscHMapI ht) { do { do { ; if (petscstack &&
(petscstack->currentsize < 64)) { petscstack->function
[petscstack->currentsize] = __func__; petscstack->file[
petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
; petscstack->line[petscstack->currentsize] = 6; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); kh_clear_HMapI(ht); do { do { ; if (petscstack &&
petscstack->currentsize > 0) { petscstack->currentsize
--; petscstack->function[petscstack->currentsize] = 0; petscstack
->file[petscstack->currentsize] = 0; petscstack->line
[petscstack->currentsize] = 0; petscstack->petscroutine
[petscstack->currentsize] = PETSC_FALSE; } if (petscstack)
{ petscstack->hotdepth = (((petscstack->hotdepth-1)<
(0)) ? (0) : (petscstack->hotdepth-1)); } ; } while (0); return
(0);} while (0); } static inline __attribute((unused)) PetscErrorCode
PetscHMapIResize(PetscHMapI ht,PetscInt nb) { int ret; do { do
{ ; if (petscstack && (petscstack->currentsize <
64)) { petscstack->function[petscstack->currentsize] =
__func__; petscstack->file[petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
; petscstack->line[petscstack->currentsize] = 6; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); ret = kh_resize_HMapI(ht, (khint_t)nb); do { if
(__builtin_expect(!!(!(ret>=0)),0)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","ret>=0"
); } while(0); do { do { ; if (petscstack && petscstack
->currentsize > 0) { petscstack->currentsize--; petscstack
->function[petscstack->currentsize] = 0; petscstack->
file[petscstack->currentsize] = 0; petscstack->line[petscstack
->currentsize] = 0; petscstack->petscroutine[petscstack
->currentsize] = PETSC_FALSE; } if (petscstack) { petscstack
->hotdepth = (((petscstack->hotdepth-1)<(0)) ? (0) :
(petscstack->hotdepth-1)); } ; } while (0); return(0);} while
(0); } static inline __attribute((unused)) PetscErrorCode PetscHMapIGetSize
(PetscHMapI ht,PetscInt *n) { do { do { ; if (petscstack &&
(petscstack->currentsize < 64)) { petscstack->function
[petscstack->currentsize] = __func__; petscstack->file[
petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
; petscstack->line[petscstack->currentsize] = 6; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!n) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",2); if
(!PetscCheckPointer(n,PETSC_INT)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer to Int: Parameter # %d"
,2); } while (0); *n = (PetscInt)((ht)->size); do { do { ;
if (petscstack && petscstack->currentsize > 0)
{ petscstack->currentsize--; petscstack->function[petscstack
->currentsize] = 0; petscstack->file[petscstack->currentsize
] = 0; petscstack->line[petscstack->currentsize] = 0; petscstack
->petscroutine[petscstack->currentsize] = PETSC_FALSE; }
if (petscstack) { petscstack->hotdepth = (((petscstack->
hotdepth-1)<(0)) ? (0) : (petscstack->hotdepth-1)); } ;
} while (0); return(0);} while (0); } static inline __attribute
((unused)) PetscErrorCode PetscHMapIHas(PetscHMapI ht,PetscInt
key,PetscBool *has) { khiter_t iter; do { do { ; if (petscstack
&& (petscstack->currentsize < 64)) { petscstack
->function[petscstack->currentsize] = __func__; petscstack
->file[petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
; petscstack->line[petscstack->currentsize] = 6; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!has) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",3); if
(!PetscCheckPointer(has,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",3);
} while (0); iter = kh_get_HMapI(ht, key); *has = (iter != (
(ht)->n_buckets)) ? PETSC_TRUE : PETSC_FALSE; do { do { ; if
(petscstack && petscstack->currentsize > 0) { petscstack
->currentsize--; petscstack->function[petscstack->currentsize
] = 0; petscstack->file[petscstack->currentsize] = 0; petscstack
->line[petscstack->currentsize] = 0; petscstack->petscroutine
[petscstack->currentsize] = PETSC_FALSE; } if (petscstack)
{ petscstack->hotdepth = (((petscstack->hotdepth-1)<
(0)) ? (0) : (petscstack->hotdepth-1)); } ; } while (0); return
(0);} while (0); } static inline __attribute((unused)) PetscErrorCode
PetscHMapIGet(PetscHMapI ht,PetscInt key,PetscInt *val) { khiter_t
iter; do { do { ; if (petscstack && (petscstack->
currentsize < 64)) { petscstack->function[petscstack->
currentsize] = __func__; petscstack->file[petscstack->currentsize
] = "/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
; petscstack->line[petscstack->currentsize] = 6; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!val) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",3); if
(!PetscCheckPointer(val,PETSC_INT)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer to Int: Parameter # %d"
,3); } while (0); iter = kh_get_HMapI(ht, key); *val = (iter !=
((ht)->n_buckets)) ? ((ht)->vals[iter]) : (-1); do { do
{ ; if (petscstack && petscstack->currentsize >
0) { petscstack->currentsize--; petscstack->function[petscstack
->currentsize] = 0; petscstack->file[petscstack->currentsize
] = 0; petscstack->line[petscstack->currentsize] = 0; petscstack
->petscroutine[petscstack->currentsize] = PETSC_FALSE; }
if (petscstack) { petscstack->hotdepth = (((petscstack->
hotdepth-1)<(0)) ? (0) : (petscstack->hotdepth-1)); } ;
} while (0); return(0);} while (0); } static inline __attribute
((unused)) PetscErrorCode PetscHMapISet(PetscHMapI ht,PetscInt
key,PetscInt val) { int ret; khiter_t iter; do { do { ; if (
petscstack && (petscstack->currentsize < 64)) {
petscstack->function[petscstack->currentsize] = __func__
; petscstack->file[petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
; petscstack->line[petscstack->currentsize] = 6; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); iter = kh_put_HMapI(ht, key, &ret); do { if
(__builtin_expect(!!(!(ret>=0)),0)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","ret>=0"
); } while(0); ((ht)->vals[iter]) = val; do { do { ; if (petscstack
&& petscstack->currentsize > 0) { petscstack->
currentsize--; petscstack->function[petscstack->currentsize
] = 0; petscstack->file[petscstack->currentsize] = 0; petscstack
->line[petscstack->currentsize] = 0; petscstack->petscroutine
[petscstack->currentsize] = PETSC_FALSE; } if (petscstack)
{ petscstack->hotdepth = (((petscstack->hotdepth-1)<
(0)) ? (0) : (petscstack->hotdepth-1)); } ; } while (0); return
(0);} while (0); } static inline __attribute((unused)) PetscErrorCode
PetscHMapIDel(PetscHMapI ht,PetscInt key) { khiter_t iter; do
{ do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
; petscstack->line[petscstack->currentsize] = 6; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); iter = kh_get_HMapI(ht, key); kh_del_HMapI(ht, iter
); do { do { ; if (petscstack && petscstack->currentsize
> 0) { petscstack->currentsize--; petscstack->function
[petscstack->currentsize] = 0; petscstack->file[petscstack
->currentsize] = 0; petscstack->line[petscstack->currentsize
] = 0; petscstack->petscroutine[petscstack->currentsize
] = PETSC_FALSE; } if (petscstack) { petscstack->hotdepth =
(((petscstack->hotdepth-1)<(0)) ? (0) : (petscstack->
hotdepth-1)); } ; } while (0); return(0);} while (0); } static
inline __attribute((unused)) PetscErrorCode PetscHMapIQuerySet
(PetscHMapI ht,PetscInt key,PetscInt val,PetscBool *missing) {
int ret; khiter_t iter; do { do { ; if (petscstack &&
(petscstack->currentsize < 64)) { petscstack->function
[petscstack->currentsize] = __func__; petscstack->file[
petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
; petscstack->line[petscstack->currentsize] = 6; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!missing) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",3); if
(!PetscCheckPointer(missing,PETSC_CHAR)) return PetscError((
(MPI_Comm)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",3);
} while (0); iter = kh_put_HMapI(ht, key, &ret); do { if
(__builtin_expect(!!(!(ret>=0)),0)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","ret>=0"
); } while(0); ((ht)->vals[iter]) = val; *missing = ret ? PETSC_TRUE
: PETSC_FALSE; do { do { ; if (petscstack && petscstack
->currentsize > 0) { petscstack->currentsize--; petscstack
->function[petscstack->currentsize] = 0; petscstack->
file[petscstack->currentsize] = 0; petscstack->line[petscstack
->currentsize] = 0; petscstack->petscroutine[petscstack
->currentsize] = PETSC_FALSE; } if (petscstack) { petscstack
->hotdepth = (((petscstack->hotdepth-1)<(0)) ? (0) :
(petscstack->hotdepth-1)); } ; } while (0); return(0);} while
(0); } static inline __attribute((unused)) PetscErrorCode PetscHMapIQueryDel
(PetscHMapI ht,PetscInt key,PetscBool *present) { khiter_t iter
; do { do { ; if (petscstack && (petscstack->currentsize
< 64)) { petscstack->function[petscstack->currentsize
] = __func__; petscstack->file[petscstack->currentsize]
= "/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
; petscstack->line[petscstack->currentsize] = 6; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!present) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",3); if
(!PetscCheckPointer(present,PETSC_CHAR)) return PetscError((
(MPI_Comm)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",3);
} while (0); iter = kh_get_HMapI(ht, key); if (iter != ((ht)
->n_buckets)) { kh_del_HMapI(ht, iter); *present = PETSC_TRUE
; } else { *present = PETSC_FALSE; } do { do { ; if (petscstack
&& petscstack->currentsize > 0) { petscstack->
currentsize--; petscstack->function[petscstack->currentsize
] = 0; petscstack->file[petscstack->currentsize] = 0; petscstack
->line[petscstack->currentsize] = 0; petscstack->petscroutine
[petscstack->currentsize] = PETSC_FALSE; } if (petscstack)
{ petscstack->hotdepth = (((petscstack->hotdepth-1)<
(0)) ? (0) : (petscstack->hotdepth-1)); } ; } while (0); return
(0);} while (0); } static inline __attribute((unused)) PetscErrorCode
PetscHMapIFind(PetscHMapI ht,PetscInt key,PetscHashIter *iter
,PetscBool *found) { do { do { ; if (petscstack && (petscstack
->currentsize < 64)) { petscstack->function[petscstack
->currentsize] = __func__; petscstack->file[petscstack->
currentsize] = "/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
; petscstack->line[petscstack->currentsize] = 6; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!iter) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",2); if
(!PetscCheckPointer(iter,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",2);
} while (0); do { if (!found) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",3); if
(!PetscCheckPointer(found,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",3);
} while (0); *iter = kh_get_HMapI(ht, key); *found = (*iter !=
((ht)->n_buckets)) ? PETSC_TRUE : PETSC_FALSE; do { do { ;
if (petscstack && petscstack->currentsize > 0)
{ petscstack->currentsize--; petscstack->function[petscstack
->currentsize] = 0; petscstack->file[petscstack->currentsize
] = 0; petscstack->line[petscstack->currentsize] = 0; petscstack
->petscroutine[petscstack->currentsize] = PETSC_FALSE; }
if (petscstack) { petscstack->hotdepth = (((petscstack->
hotdepth-1)<(0)) ? (0) : (petscstack->hotdepth-1)); } ;
} while (0); return(0);} while (0); } static inline __attribute
((unused)) PetscErrorCode PetscHMapIPut(PetscHMapI ht,PetscInt
key,PetscHashIter *iter,PetscBool *missing) { int ret; do { do
{ ; if (petscstack && (petscstack->currentsize <
64)) { petscstack->function[petscstack->currentsize] =
__func__; petscstack->file[petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
; petscstack->line[petscstack->currentsize] = 6; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!iter) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",2); if
(!PetscCheckPointer(iter,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",2);
} while (0); do { if (!missing) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",3); if
(!PetscCheckPointer(missing,PETSC_CHAR)) return PetscError((
(MPI_Comm)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",3);
} while (0); *iter = kh_put_HMapI(ht, key, &ret); do { if
(__builtin_expect(!!(!(ret>=0)),0)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","ret>=0"
); } while(0); *missing = ret ? PETSC_TRUE : PETSC_FALSE; do {
do { ; if (petscstack && petscstack->currentsize >
0) { petscstack->currentsize--; petscstack->function[petscstack
->currentsize] = 0; petscstack->file[petscstack->currentsize
] = 0; petscstack->line[petscstack->currentsize] = 0; petscstack
->petscroutine[petscstack->currentsize] = PETSC_FALSE; }
if (petscstack) { petscstack->hotdepth = (((petscstack->
hotdepth-1)<(0)) ? (0) : (petscstack->hotdepth-1)); } ;
} while (0); return(0);} while (0); } static inline __attribute
((unused)) PetscErrorCode PetscHMapIIterGet(PetscHMapI ht,PetscHashIter
iter,PetscInt *val) { do { do { ; if (petscstack && (
petscstack->currentsize < 64)) { petscstack->function
[petscstack->currentsize] = __func__; petscstack->file[
petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
; petscstack->line[petscstack->currentsize] = 6; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!val) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",3); if
(!PetscCheckPointer(val,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",3);
} while (0); *val = __builtin_expect(!!(iter < ((ht)->
n_buckets) && (!(((ht)->flags[(iter)>>4]>>
(((iter)&0xfU)<<1))&3))),1) ? ((ht)->vals[iter
]) : (-1); do { do { ; if (petscstack && petscstack->
currentsize > 0) { petscstack->currentsize--; petscstack
->function[petscstack->currentsize] = 0; petscstack->
file[petscstack->currentsize] = 0; petscstack->line[petscstack
->currentsize] = 0; petscstack->petscroutine[petscstack
->currentsize] = PETSC_FALSE; } if (petscstack) { petscstack
->hotdepth = (((petscstack->hotdepth-1)<(0)) ? (0) :
(petscstack->hotdepth-1)); } ; } while (0); return(0);} while
(0); } static inline __attribute((unused)) PetscErrorCode PetscHMapIIterSet
(PetscHMapI ht,PetscHashIter iter,PetscInt val) { do { do { ;
if (petscstack && (petscstack->currentsize < 64
)) { petscstack->function[petscstack->currentsize] = __func__
; petscstack->file[petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
; petscstack->line[petscstack->currentsize] = 6; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); if (__builtin_expect(!!(iter < ((ht)->n_buckets
) && (!(((ht)->flags[(iter)>>4]>>(((iter
)&0xfU)<<1))&3))),1)) ((ht)->vals[iter]) = val
; do { do { ; if (petscstack && petscstack->currentsize
> 0) { petscstack->currentsize--; petscstack->function
[petscstack->currentsize] = 0; petscstack->file[petscstack
->currentsize] = 0; petscstack->line[petscstack->currentsize
] = 0; petscstack->petscroutine[petscstack->currentsize
] = PETSC_FALSE; } if (petscstack) { petscstack->hotdepth =
(((petscstack->hotdepth-1)<(0)) ? (0) : (petscstack->
hotdepth-1)); } ; } while (0); return(0);} while (0); } static
inline __attribute((unused)) PetscErrorCode PetscHMapIIterDel
(PetscHMapI ht,PetscHashIter iter) { do { do { ; if (petscstack
&& (petscstack->currentsize < 64)) { petscstack
->function[petscstack->currentsize] = __func__; petscstack
->file[petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
; petscstack->line[petscstack->currentsize] = 6; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_TRUE || petscstack->hotdepth); } ; } while (0);
; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); if (__builtin_expect(!!(iter < ((ht)->n_buckets
)),1)) kh_del_HMapI(ht, iter); do { do { ; if (petscstack &&
petscstack->currentsize > 0) { petscstack->currentsize
--; petscstack->function[petscstack->currentsize] = 0; petscstack
->file[petscstack->currentsize] = 0; petscstack->line
[petscstack->currentsize] = 0; petscstack->petscroutine
[petscstack->currentsize] = PETSC_FALSE; } if (petscstack)
{ petscstack->hotdepth = (((petscstack->hotdepth-1)<
(0)) ? (0) : (petscstack->hotdepth-1)); } ; } while (0); return
(0);} while (0); } static inline __attribute((unused)) PetscErrorCode
PetscHMapIGetKeys(PetscHMapI ht,PetscInt *off,PetscInt array
[]) { PetscInt key; PetscInt pos; do { do { ; if (petscstack &&
(petscstack->currentsize < 64)) { petscstack->function
[petscstack->currentsize] = __func__; petscstack->file[
petscstack->currentsize] = "/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
; petscstack->line[petscstack->currentsize] = 6; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!off) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",2); if
(!PetscCheckPointer(off,PETSC_INT)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer to Int: Parameter # %d"
,2); } while (0); pos = *off; { khint_t __i; for (__i = (khint_t
)(0); __i != ((ht)->n_buckets); ++__i) { if (!(!(((ht)->
flags[(__i)>>4]>>(((__i)&0xfU)<<1))&
3))) continue; (key) = ((ht)->keys[__i]); array[pos++] = key
; } }; *off = pos; do { do { ; if (petscstack && petscstack
->currentsize > 0) { petscstack->currentsize--; petscstack
->function[petscstack->currentsize] = 0; petscstack->
file[petscstack->currentsize] = 0; petscstack->line[petscstack
->currentsize] = 0; petscstack->petscroutine[petscstack
->currentsize] = PETSC_FALSE; } if (petscstack) { petscstack
->hotdepth = (((petscstack->hotdepth-1)<(0)) ? (0) :
(petscstack->hotdepth-1)); } ; } while (0); return(0);} while
(0); } static inline __attribute((unused)) PetscErrorCode PetscHMapIGetVals
(PetscHMapI ht,PetscInt *off,PetscInt array[]) { PetscInt val
; PetscInt pos; do { do { ; if (petscstack && (petscstack
->currentsize < 64)) { petscstack->function[petscstack
->currentsize] = __func__; petscstack->file[petscstack->
currentsize] = "/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
; petscstack->line[petscstack->currentsize] = 6; petscstack
->petscroutine[petscstack->currentsize] = PETSC_TRUE; petscstack
->currentsize++; } if (petscstack) { petscstack->hotdepth
+= (PETSC_FALSE || petscstack->hotdepth); } ; } while (0)
; ; } while (0); do { if (!ht) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,85,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",1); if
(!PetscCheckPointer(ht,PETSC_CHAR)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer: Parameter # %d",1);
} while (0); do { if (!off) return PetscError(((MPI_Comm)0x44000001
),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Null Pointer: Parameter # %d",2); if
(!PetscCheckPointer(off,PETSC_INT)) return PetscError(((MPI_Comm
)0x44000001),6,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashmapi.h"
,68,PETSC_ERROR_INITIAL,"Invalid Pointer to Int: Parameter # %d"
,2); } while (0); pos = *off; { khint_t __i; for (__i = (khint_t
)(0); __i != ((ht)->n_buckets); ++__i) { if (!(!(((ht)->
flags[(__i)>>4]>>(((__i)&0xfU)<<1))&
3))) continue; (val) = ((ht)->vals[__i]); array[pos++] = val
; } }; *off = pos; do { do { ; if (petscstack && petscstack
->currentsize > 0) { petscstack->currentsize--; petscstack
->function[petscstack->currentsize] = 0; petscstack->
file[petscstack->currentsize] = 0; petscstack->line[petscstack
->currentsize] = 0; petscstack->petscroutine[petscstack
->currentsize] = PETSC_FALSE; } if (petscstack) { petscstack
->hotdepth = (((petscstack->hotdepth-1)<(0)) ? (0) :
(petscstack->hotdepth-1)); } ; } while (0); return(0);} while
(0); }

←

Within the expansion of the macro 'PETSC_HASH_MAP':

→

a	Assuming 'petscstack' is null

b	Assuming the condition is false

c	Calling 'kh_init_HMapI'

d	Returning from 'kh_init_HMapI'

e	Assuming the condition is true

f	Assuming 'petscstack' is null

←

Within the expansion of the macro 'PETSC_HASH_MAP':

→

a	Null pointer value stored to field 'flags'

←

Within the expansion of the macro 'PETSC_HASH_MAP':

→

a	Assuming 'petscstack' is null

b	Assuming the condition is false

c	Calling 'kh_put_HMapI'

←

Within the expansion of the macro 'PETSC_HASH_MAP':

→

a	Calling 'kh_resize_HMapI'

b	Returning from 'kh_resize_HMapI'

c	Calling 'PetscHashInt'

d	Returning from 'PetscHashInt'

e	Array access (via field 'flags') results in a null pointer dereference

←

Within the expansion of the macro 'PETSC_HASH_MAP':

→

#endif /* PETSC_HASHMAPI_H */

←

/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashtable.h

#if !defined(PETSC_HASHTABLE_H)

#define PETSC_HASHTABLE_H

#include <petsc/private/petscimpl.h>

#define kh_inlineinline PETSC_INLINEinline

#define klib_unused__attribute((unused)) PETSC_UNUSED__attribute((unused))

#include <petsc/private/kernels/khash.h>

/* Required for khash <= 0.2.5 */

#if !defined(kcalloc)

#define kcalloc(N,Z)calloc(N,Z) calloc(N,Z)

#endif

#if !defined(kmalloc)

#define kmalloc(Z)malloc(Z) malloc(Z)

#endif

#if !defined(krealloc)

#define krealloc(P,Z)realloc(P,Z) realloc(P,Z)

#endif

#if !defined(kfree)

#define kfree(P)free(P) free(P)

#endif

/* --- Useful extensions to khash --- */

#if !defined(kh_reset)

/*! @function

@abstract Reset a hash table to initial state.

@param name Name of the hash table [symbol]

@param h Pointer to the hash table [khash_t(name)*]

#define kh_reset(name, h){ if (h) { free((h)->keys); free((h)->flags); free((h)->
vals); memset((h), 0x00, sizeof(*(h))); } } { \

if (h) { \

kfree((h)->keys)free((h)->keys); kfree((h)->flags)free((h)->flags); \

kfree((h)->vals)free((h)->vals); \

memset((h), 0x00, sizeof(*(h))); \

} }

#endif /*kh_reset*/

#if !defined(kh_foreach)

/*! @function

@abstract Iterate over the entries in the hash table

@param h Pointer to the hash table [khash_t(name)*]

@param kvar Variable to which key will be assigned

@param vvar Variable to which value will be assigned

@param code Block of code to execute

#define kh_foreach(h, kvar, vvar, code){ khint_t __i; for (__i = (khint_t)(0); __i != ((h)->n_buckets
); ++__i) { if (!(!(((h)->flags[(__i)>>4]>>(((
__i)&0xfU)<<1))&3))) continue; (kvar) = ((h)->
keys[__i]); (vvar) = ((h)->vals[__i]); code; } } { khint_t __i; \

for (__i = kh_begin(h)(khint_t)(0); __i != kh_end(h)((h)->n_buckets); ++__i) { \

if (!kh_exist(h,__i)(!(((h)->flags[(__i)>>4]>>(((__i)&0xfU)<<
1))&3))) continue; \

(kvar) = kh_key(h,__i)((h)->keys[__i]); \

(vvar) = kh_val(h,__i)((h)->vals[__i]); \

code; \

} }

#endif /*kh_foreach*/

#if !defined(kh_foreach_key)

/*! @function

@abstract Iterate over the keys in the hash table

@param h Pointer to the hash table [khash_t(name)*]

@param kvar Variable to which key will be assigned

@param code Block of code to execute

#define kh_foreach_key(h, kvar, code){ khint_t __i; for (__i = (khint_t)(0); __i != ((h)->n_buckets
); ++__i) { if (!(!(((h)->flags[(__i)>>4]>>(((
__i)&0xfU)<<1))&3))) continue; (kvar) = ((h)->
keys[__i]); code; } } { khint_t __i; \

for (__i = kh_begin(h)(khint_t)(0); __i != kh_end(h)((h)->n_buckets); ++__i) { \

if (!kh_exist(h,__i)(!(((h)->flags[(__i)>>4]>>(((__i)&0xfU)<<
1))&3))) continue; \

(kvar) = kh_key(h,__i)((h)->keys[__i]); \

code; \

} }

#endif /*kh_foreach_key*/

#if !defined(kh_foreach_value)

/*! @function

@abstract Iterate over the values in the hash table

@param h Pointer to the hash table [khash_t(name)*]

@param vvar Variable to which value will be assigned

@param code Block of code to execute

#define kh_foreach_value(h, vvar, code){ khint_t __i; for (__i = (khint_t)(0); __i != ((h)->n_buckets
); ++__i) { if (!(!(((h)->flags[(__i)>>4]>>(((
__i)&0xfU)<<1))&3))) continue; (vvar) = ((h)->
vals[__i]); code; } } { khint_t __i; \

for (__i = kh_begin(h)(khint_t)(0); __i != kh_end(h)((h)->n_buckets); ++__i) { \

if (!kh_exist(h,__i)(!(((h)->flags[(__i)>>4]>>(((__i)&0xfU)<<
1))&3))) continue; \

(vvar) = kh_val(h,__i)((h)->vals[__i]); \

code; \

} }

#endif /*kh_foreach_value*/

/* --- Helper macro for error checking --- */

#if defined(PETSC_USE_DEBUG1)

#define PetscHashAssert(expr)do { if (__builtin_expect(!!(!(expr)),0)) return PetscError((
(MPI_Comm)0x44000001),91,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashtable.h"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","expr"
); } while(0) do { \

if (PetscUnlikely(!(expr))__builtin_expect(!!(!(expr)),0)) \

SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB, \return PetscError(((MPI_Comm)0x44000001),95,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashtable.h"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","expr"
)

"[khash] Assertion: `%s' failed.", \return PetscError(((MPI_Comm)0x44000001),95,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashtable.h"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","expr"
)

PetscStringize(expr))return PetscError(((MPI_Comm)0x44000001),95,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashtable.h"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","expr"
); \

} while(0)

#else

#define PetscHashAssert(expr)do { if (__builtin_expect(!!(!(expr)),0)) return PetscError((
(MPI_Comm)0x44000001),98,__func__,"/sandbox/petsc/petsc.next-tmp/include/petsc/private/hashtable.h"
,76,PETSC_ERROR_INITIAL,"[khash] Assertion: `%s' failed.","expr"
); } while(0) ((void)(expr))

#endif

100

101

102

/* --- Low level iterator API --- */

103

104

typedef khiter_t PetscHashIter;

105

106

#define PetscHashIterBegin(ht,i)do { (i) = (khint_t)(0); if ((i) != (((ht))->n_buckets) &&
!(!((((ht))->flags[((i))>>4]>>((((i))&0xfU
)<<1))&3))) do { ++((i)); } while (((i)) != ((((ht)
))->n_buckets) && !(!(((((ht)))->flags[(((i)))>>
4]>>(((((i)))&0xfU)<<1))&3))); } while (0
) do { \

107

(i) = kh_begin((ht))(khint_t)(0); \

108

if ((i) != kh_end((ht))(((ht))->n_buckets) && !kh_exist((ht),(i))(!((((ht))->flags[((i))>>4]>>((((i))&0xfU)
<<1))&3))) \

109

PetscHashIterNext((ht),(i))do { ++((i)); } while (((i)) != ((((ht)))->n_buckets) &&
!(!(((((ht)))->flags[(((i)))>>4]>>(((((i)))&
0xfU)<<1))&3))); \

110

} while (0)

111

112

#define PetscHashIterNext(ht,i)do { ++(i); } while ((i) != (((ht))->n_buckets) &&
!(!((((ht))->flags[((i))>>4]>>((((i))&0xfU
)<<1))&3))) \

113

do { ++(i); } while ((i) != kh_end((ht))(((ht))->n_buckets) && !kh_exist((ht),(i))(!((((ht))->flags[((i))>>4]>>((((i))&0xfU)
<<1))&3)))

114

115

#define PetscHashIterAtEnd(ht,i)((i) == (((ht))->n_buckets)) ((i) == kh_end((ht))(((ht))->n_buckets))

116

117

#define PetscHashIterGetKey(ht,i,k)((k) = (((ht))->keys[(i)])) ((k) = kh_key((ht),(i))(((ht))->keys[(i)]))

118

119

#define PetscHashIterGetVal(ht,i,v)((v) = (((ht))->vals[(i)])) ((v) = kh_val((ht),(i))(((ht))->vals[(i)]))

120

121

#define PetscHashIterSetVal(ht,i,v)((((ht))->vals[(i)]) = (v)) (kh_val((ht),(i))(((ht))->vals[(i)]) = (v))

122

123

124

/* --- Thomas Wang integer hash functions --- */

125

126

typedef khint32_t PetscHash32_t;

127

typedef khint64_t PetscHash64_t;

128

typedef khint_t PetscHash_t;

129

130

/* Thomas Wang's first version for 32bit integers */

131

PETSC_STATIC_INLINEstatic inline PetscHash_t PetscHash_UInt32_v0(PetscHash32_t key)

132

{

133

key += ~(key << 15);

134

key ^= (key >> 10);

135

key += (key << 3);

136

key ^= (key >> 6);

137

key += ~(key << 11);

138

key ^= (key >> 16);

139

return key;

140

}

141

142

/* Thomas Wang's second version for 32bit integers */

143

PETSC_STATIC_INLINEstatic inline PetscHash_t PetscHash_UInt32_v1(PetscHash32_t key)

144

{

145

key = ~key + (key << 15); /* key = (key << 15) - key - 1; */

146

key = key ^ (key >> 12);

147

key = key + (key << 2);

148

key = key ^ (key >> 4);

149

key = key * 2057; /* key = (key + (key << 3)) + (key << 11); */

150

key = key ^ (key >> 16);

151

return key;

152

}

153

154

PETSC_STATIC_INLINEstatic inline PetscHash_t PetscHash_UInt32(PetscHash32_t key)

155

{

156

return PetscHash_UInt32_v1(key);

←

Calling 'PetscHash_UInt32_v1'

→

←

Returning from 'PetscHash_UInt32_v1'

→

157

}

158

159

/* Thomas Wang's version for 64bit integer -> 32bit hash */

160

PETSC_STATIC_INLINEstatic inline PetscHash32_t PetscHash_UInt64_32(PetscHash64_t key)

161

{

162

key = ~key + (key << 18); /* key = (key << 18) - key - 1; */

163

key = key ^ (key >> 31);

164

key = key * 21; /* key = (key + (key << 2)) + (key << 4); */

165

key = key ^ (key >> 11);

166

key = key + (key << 6);

167

key = key ^ (key >> 22);

168

return (PetscHash32_t)key;

169

}

170

171

/* Thomas Wang's version for 64bit integer -> 64bit hash */

172

PETSC_STATIC_INLINEstatic inline PetscHash64_t PetscHash_UInt64_64(PetscHash64_t key)

173

{

174

key = ~key + (key << 21); /* key = (key << 21) - key - 1; */

175

key = key ^ (key >> 24);

176

key = key * 265; /* key = (key + (key << 3)) + (key << 8); */

177

key = key ^ (key >> 14);

178

key = key * 21; /* key = (key + (key << 2)) + (key << 4); */

179

key = key ^ (key >> 28);

180

key = key + (key << 31);

181

return key;

182

}

183

184

PETSC_STATIC_INLINEstatic inline PetscHash_t PetscHash_UInt64(PetscHash64_t key)

185

{

186

return sizeof(PetscHash_t) < sizeof(PetscHash64_t)

187

? (PetscHash_t)PetscHash_UInt64_32(key)

188

: (PetscHash_t)PetscHash_UInt64_64(key);

189

}

190

191

PETSC_STATIC_INLINEstatic inline PetscHash_t PetscHashInt(PetscInt key)

192

{

193

#if defined(PETSC_USE_64BIT_INDICES)

194

return PetscHash_UInt64((PetscHash64_t)key);

195

#else

196

return PetscHash_UInt32((PetscHash32_t)key);

←

Calling 'PetscHash_UInt32'

→

←

Returning from 'PetscHash_UInt32'

197

#endif

198

}

199

200

PETSC_STATIC_INLINEstatic inline PetscHash_t PetscHashCombine(PetscHash_t seed, PetscHash_t hash)

201

{

202

/* https://doi.org/10.1002/asi.10170 */

203

/* https://dl.acm.org/citation.cfm?id=759509 */

204

return seed ^ (hash + (seed << 6) + (seed >> 2));

205

}

206

207

#define PetscHashEqual(a,b)((a) == (b)) ((a) == (b))

208

209

210

#endif /* PETSC_HASHTABLE_H */