PetscErrorCode MPIU_File_write_all(MPI_File fd,void *data,PetscMPIInt cnt,MPI_Datatype dtype,MPI_Status *status)
{
PetscErrorCode ierr;
PetscDataType pdtype;
PetscFunctionBegin;
ierr = PetscMPIDataTypeToPetscDataType(dtype,&pdtype);CHKERRQ(ierr);
ierr = PetscByteSwap(data,pdtype,cnt);CHKERRQ(ierr);
ierr = MPI_File_write_all(fd,data,cnt,dtype,status);CHKERRQ(ierr);
ierr = PetscByteSwap(data,pdtype,cnt);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode DMPlexCreateFluent_ReadValues(PetscViewer viewer, void *data, PetscInt count, PetscDataType dtype, PetscBool binary)
{
int fdes=0;
FILE *file;
PetscInt i;
PetscErrorCode ierr;
PetscFunctionBegin;
if (binary) {
/* Extract raw file descriptor to read binary block */
ierr = PetscViewerASCIIGetPointer(viewer, &file);CHKERRQ(ierr);
fflush(file); fdes = fileno(file);
}
if (!binary && dtype == PETSC_INT) {
char cbuf[256];
int ibuf, snum;
/* Parse hexadecimal ascii integers */
for (i = 0; i < count; i++) {
ierr = PetscViewerRead(viewer, cbuf, 1, NULL, PETSC_STRING);CHKERRQ(ierr);
snum = sscanf(cbuf, "%x", &ibuf);
if (snum != 1) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "File is not a valid Fluent file");
((PetscInt*)data)[i] = (PetscInt)ibuf;
}
} else if (binary && dtype == PETSC_INT) {
/* Always read 32-bit ints and cast to PetscInt */
int *ibuf;
ierr = PetscMalloc1(count, &ibuf);CHKERRQ(ierr);
ierr = PetscBinaryRead(fdes, ibuf, count, PETSC_ENUM);CHKERRQ(ierr);
ierr = PetscByteSwap(ibuf, PETSC_ENUM, count);CHKERRQ(ierr);
for (i = 0; i < count; i++) ((PetscInt*)data)[i] = (PetscInt)(ibuf[i]);
ierr = PetscFree(ibuf);CHKERRQ(ierr);
} else if (binary && dtype == PETSC_SCALAR) {
float *fbuf;
/* Always read 32-bit floats and cast to PetscScalar */
ierr = PetscMalloc1(count, &fbuf);CHKERRQ(ierr);
ierr = PetscBinaryRead(fdes, fbuf, count, PETSC_FLOAT);CHKERRQ(ierr);
ierr = PetscByteSwap(fbuf, PETSC_FLOAT, count);CHKERRQ(ierr);
for (i = 0; i < count; i++) ((PetscScalar*)data)[i] = (PetscScalar)(fbuf[i]);
ierr = PetscFree(fbuf);CHKERRQ(ierr);
} else {
ierr = PetscViewerASCIIRead(viewer, data, count, NULL, dtype);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
/*@
PetscBinaryWrite - Writes to a binary file.
Not Collective
Input Parameters:
+ fd - the file
. p - the buffer
. n - the number of items to write
. type - the type of items to read (PETSC_INT, PETSC_DOUBLE or PETSC_SCALAR)
- istemp - PETSC_FALSE if buffer data should be preserved, PETSC_TRUE otherwise.
Level: advanced
Notes:
PetscBinaryWrite() uses byte swapping to work on all machines; the files
are written using big-endian ordering to the file. On small-endian machines the numbers
are converted to the big-endian format when they are written to disk.
When PETSc is config/configure.py with --with-64bit-indices the integers are written to the
file as 64 bit integers, this means they can only be read back in when the option --with-64bit-indices
is used.
The Buffer p should be read-write buffer, and not static data.
This way, byte-swapping is done in-place, and then the buffer is
written to the file.
This routine restores the original contents of the buffer, after
it is written to the file. This is done by byte-swapping in-place
the second time. If the flag istemp is set to PETSC_TRUE, the second
byte-swapping operation is not done, thus saving some computation,
but the buffer corrupted is corrupted.
Because byte-swapping may be done on the values in data it cannot be declared const
Concepts: files^writing binary
Concepts: binary files^writing
.seealso: PetscBinaryRead(), PetscBinaryOpen(), PetscBinaryClose(), PetscViewerBinaryGetDescriptor(), PetscBinarySynchronizedWrite(),
PetscBinarySynchronizedRead(), PetscBinarySynchronizedSeek()
@*/
PetscErrorCode PETSC_DLLEXPORT PetscBinaryWrite(int fd,void *p,PetscInt n,PetscDataType type,PetscTruth istemp)
{
char *pp = (char*)p;
int err,wsize;
size_t m = (size_t)n,maxblock=65536;
#if !defined(PETSC_WORDS_BIGENDIAN)
PetscErrorCode ierr;
void *ptmp = p;
#endif
PetscFunctionBegin;
if (n < 0) SETERRQ1(PETSC_ERR_ARG_OUTOFRANGE,"Trying to write a negative amount of data %D",n);
if (!n) PetscFunctionReturn(0);
if (type == PETSC_INT) m *= sizeof(PetscInt);
else if (type == PETSC_SCALAR) m *= sizeof(PetscScalar);
else if (type == PETSC_DOUBLE) m *= sizeof(double);
else if (type == PETSC_SHORT) m *= sizeof(short);
else if (type == PETSC_CHAR) m *= sizeof(char);
else if (type == PETSC_ENUM) m *= sizeof(PetscEnum);
else if (type == PETSC_TRUTH) m *= sizeof(PetscTruth);
else if (type == PETSC_LOGICAL) m = PetscBTLength(m)*sizeof(char);
else SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Unknown type");
#if !defined(PETSC_WORDS_BIGENDIAN)
ierr = PetscByteSwap(ptmp,type,n);CHKERRQ(ierr);
#endif
while (m) {
wsize = (m < maxblock) ? m : maxblock;
err = write(fd,pp,wsize);
if (err < 0 && errno == EINTR) continue;
if (err != wsize) SETERRQ(PETSC_ERR_FILE_WRITE,"Error writing to file.");
m -= wsize;
pp += wsize;
}
#if !defined(PETSC_WORDS_BIGENDIAN)
if (!istemp) {
ierr = PetscByteSwap(ptmp,type,n);CHKERRQ(ierr);
}
#endif
PetscFunctionReturn(0);
}
PetscMPIInt PetscDataRep_write_conv_fn(void *userbuf, MPI_Datatype datatype,PetscMPIInt count,void *filebuf, MPI_Offset position,void *extra_state)
{
PetscDataType pdtype;
PetscMPIInt ierr;
size_t dsize;
ierr = PetscMPIDataTypeToPetscDataType(datatype,&pdtype);CHKERRQ(ierr);
ierr = PetscDataTypeGetSize(pdtype,&dsize);CHKERRQ(ierr);
/* offset is given in units of MPI_Datatype */
userbuf = ((char*)userbuf) + dsize*position;
ierr = PetscMemcpy(filebuf,userbuf,count*dsize);CHKERRQ(ierr);
if (!PetscBinaryBigEndian()) {ierr = PetscByteSwap(filebuf,pdtype,count);CHKERRQ(ierr);}
return ierr;
}
PETSC_EXTERN PetscMPIInt PetscDataRep_read_conv_fn(void *userbuf, MPI_Datatype datatype,PetscMPIInt count,void *filebuf, MPI_Offset position,void *extra_state)
{
PetscDataType pdtype;
PetscMPIInt ierr;
size_t dsize;
ierr = PetscMPIDataTypeToPetscDataType(datatype,&pdtype);CHKERRQ(ierr);
ierr = PetscDataTypeGetSize(pdtype,&dsize);CHKERRQ(ierr);
/* offset is given in units of MPI_Datatype */
userbuf = ((char*)userbuf) + dsize*position;
ierr = PetscMemcpy(userbuf,filebuf,count*dsize);CHKERRQ(ierr);
ierr = PetscByteSwap(userbuf,pdtype,count);CHKERRQ(ierr);
return ierr;
}
/*@
PetscBinaryRead - Reads from a binary file.
Not Collective
Input Parameters:
+ fd - the file
. n - the number of items to read
- type - the type of items to read (PETSC_INT, PETSC_DOUBLE or PETSC_SCALAR)
Output Parameters:
. p - the buffer
Level: developer
Notes:
PetscBinaryRead() uses byte swapping to work on all machines; the files
are written to file ALWAYS using big-endian ordering. On small-endian machines the numbers
are converted to the small-endian format when they are read in from the file.
When PETSc is config/configure.py with --with-64bit-indices the integers are written to the
file as 64 bit integers, this means they can only be read back in when the option --with-64bit-indices
is used.
Concepts: files^reading binary
Concepts: binary files^reading
.seealso: PetscBinaryWrite(), PetscBinaryOpen(), PetscBinaryClose(), PetscViewerBinaryGetDescriptor(), PetscBinarySynchronizedWrite(),
PetscBinarySynchronizedRead(), PetscBinarySynchronizedSeek()
@*/
PetscErrorCode PETSC_DLLEXPORT PetscBinaryRead(int fd,void *p,PetscInt n,PetscDataType type)
{
int wsize,err;
size_t m = (size_t) n,maxblock = 65536;
char *pp = (char*)p;
#if !defined(PETSC_WORDS_BIGENDIAN)
PetscErrorCode ierr;
void *ptmp = p;
#endif
PetscFunctionBegin;
if (!n) PetscFunctionReturn(0);
if (type == PETSC_INT) m *= sizeof(PetscInt);
else if (type == PETSC_SCALAR) m *= sizeof(PetscScalar);
else if (type == PETSC_DOUBLE) m *= sizeof(double);
else if (type == PETSC_SHORT) m *= sizeof(short);
else if (type == PETSC_CHAR) m *= sizeof(char);
else if (type == PETSC_ENUM) m *= sizeof(PetscEnum);
else if (type == PETSC_TRUTH) m *= sizeof(PetscTruth);
else if (type == PETSC_LOGICAL) m = PetscBTLength(m)*sizeof(char);
else SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Unknown type");
while (m) {
wsize = (m < maxblock) ? m : maxblock;
err = read(fd,pp,wsize);
if (err < 0 && errno == EINTR) continue;
if (!err && wsize > 0) SETERRQ(PETSC_ERR_FILE_READ,"Read past end of file");
if (err < 0) SETERRQ1(PETSC_ERR_FILE_READ,"Error reading from file, errno %d",errno);
m -= err;
pp += err;
}
#if !defined(PETSC_WORDS_BIGENDIAN)
ierr = PetscByteSwap(ptmp,type,n);CHKERRQ(ierr);
#endif
PetscFunctionReturn(0);
}
/*@
PetscBinaryWrite - Writes to a binary file.
Not Collective
Input Parameters:
+ fd - the file
. p - the buffer
. n - the number of items to write
. type - the type of items to read (PETSC_INT, PETSC_DOUBLE or PETSC_SCALAR)
- istemp - PETSC_FALSE if buffer data should be preserved, PETSC_TRUE otherwise.
Level: advanced
Notes:
PetscBinaryWrite() uses byte swapping to work on all machines; the files
are written using big-endian ordering to the file. On small-endian machines the numbers
are converted to the big-endian format when they are written to disk.
When PETSc is ./configure with --with-64bit-indices the integers are written to the
file as 64 bit integers, this means they can only be read back in when the option --with-64bit-indices
is used.
If running with __float128 precision the output is in __float128 unless one uses the -binary_write_double option
The Buffer p should be read-write buffer, and not static data.
This way, byte-swapping is done in-place, and then the buffer is
written to the file.
This routine restores the original contents of the buffer, after
it is written to the file. This is done by byte-swapping in-place
the second time. If the flag istemp is set to PETSC_TRUE, the second
byte-swapping operation is not done, thus saving some computation,
but the buffer is left corrupted.
Because byte-swapping may be done on the values in data it cannot be declared const
Concepts: files^writing binary
Concepts: binary files^writing
.seealso: PetscBinaryRead(), PetscBinaryOpen(), PetscBinaryClose(), PetscViewerBinaryGetDescriptor(), PetscBinarySynchronizedWrite(),
PetscBinarySynchronizedRead(), PetscBinarySynchronizedSeek()
@*/
PetscErrorCode PetscBinaryWrite(int fd,void *p,PetscInt n,PetscDataType type,PetscBool istemp)
{
char *pp = (char*)p;
int err,wsize;
size_t m = (size_t)n,maxblock=65536;
PetscErrorCode ierr;
void *ptmp = p;
char *fname = NULL;
#if defined(PETSC_USE_REAL___FLOAT128)
PetscBool writedouble = PETSC_FALSE;
double *ppp;
PetscReal *pv;
PetscInt i;
#endif
PetscDataType wtype = type;
PetscFunctionBegin;
if (n < 0) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Trying to write a negative amount of data %D",n);
if (!n) PetscFunctionReturn(0);
if (type == PETSC_FUNCTION) {
#if defined(PETSC_SERIALIZE_FUNCTIONS)
const char *fnametmp;
#endif
m = 64;
fname = (char*)malloc(m*sizeof(char));
if (!fname) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_MEM,"Cannot allocate space for function name");
#if defined(PETSC_SERIALIZE_FUNCTIONS)
if (n > 1) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Can only binary view a single function at a time");
ierr = PetscFPTFind(*(void**)p,&fnametmp);CHKERRQ(ierr);
ierr = PetscStrncpy(fname,fnametmp,m);CHKERRQ(ierr);
#else
ierr = PetscStrncpy(fname,"",m);CHKERRQ(ierr);
#endif
wtype = PETSC_CHAR;
pp = (char*)fname;
ptmp = (void*)fname;
}
#if defined(PETSC_USE_REAL___FLOAT128)
ierr = PetscOptionsGetBool(NULL,NULL,"-binary_write_double",&writedouble,NULL);CHKERRQ(ierr);
/* If using __float128 precision we still write in doubles to file */
if ((type == PETSC_SCALAR || type == PETSC_REAL) && writedouble) {
wtype = PETSC_DOUBLE;
ierr = PetscMalloc1(n,&ppp);CHKERRQ(ierr);
pv = (PetscReal*)pp;
for (i=0; i<n; i++) {
ppp[i] = (double) pv[i];
}
pp = (char*)ppp;
ptmp = (char*)ppp;
}
#endif
if (wtype == PETSC_INT) m *= sizeof(PetscInt);
else if (wtype == PETSC_SCALAR) m *= sizeof(PetscScalar);
else if (wtype == PETSC_REAL) m *= sizeof(PetscReal);
else if (wtype == PETSC_DOUBLE) m *= sizeof(double);
else if (wtype == PETSC_FLOAT) m *= sizeof(float);
else if (wtype == PETSC_SHORT) m *= sizeof(short);
else if (wtype == PETSC_LONG) m *= sizeof(long);
else if (wtype == PETSC_CHAR) m *= sizeof(char);
else if (wtype == PETSC_ENUM) m *= sizeof(PetscEnum);
else if (wtype == PETSC_BOOL) m *= sizeof(PetscBool);
else if (wtype == PETSC_INT64) m *= sizeof(PetscInt64);
else if (wtype == PETSC_BIT_LOGICAL) m = PetscBTLength(m)*sizeof(char);
else SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Unknown type");
if (!PetscBinaryBigEndian()) {ierr = PetscByteSwap(ptmp,wtype,n);CHKERRQ(ierr);}
while (m) {
wsize = (m < maxblock) ? m : maxblock;
err = write(fd,pp,wsize);
if (err < 0 && errno == EINTR) continue;
if (err != wsize) SETERRQ3(PETSC_COMM_SELF,PETSC_ERR_FILE_WRITE,"Error writing to file total size %d err %d wsize %d",(int)n,(int)err,(int)wsize);
m -= wsize;
pp += wsize;
}
if (!istemp) {
if (!PetscBinaryBigEndian()) {ierr = PetscByteSwap(ptmp,wtype,n);CHKERRQ(ierr);}
}
if (type == PETSC_FUNCTION) {
free(fname);
}
#if defined(PETSC_USE_REAL___FLOAT128)
if ((type == PETSC_SCALAR || type == PETSC_REAL) && writedouble) {
ierr = PetscFree(ppp);CHKERRQ(ierr);
}
#endif
PetscFunctionReturn(0);
}
/*@C
PetscBinaryRead - Reads from a binary file.
Not Collective
Input Parameters:
+ fd - the file descriptor
. num - the maximum number of items to read
- type - the type of items to read (PETSC_INT, PETSC_REAL, PETSC_SCALAR, etc.)
Output Parameters:
+ data - the buffer
- count - the number of items read, optional
Level: developer
Notes:
If count is not provided and the number of items read is less than
the maximum number of items to read, then this routine errors.
PetscBinaryRead() uses byte swapping to work on all machines; the files
are written to file ALWAYS using big-endian ordering. On small-endian machines the numbers
are converted to the small-endian format when they are read in from the file.
When PETSc is ./configure with --with-64bit-indices the integers are written to the
file as 64 bit integers, this means they can only be read back in when the option --with-64bit-indices
is used.
Concepts: files^reading binary
Concepts: binary files^reading
.seealso: PetscBinaryWrite(), PetscBinaryOpen(), PetscBinaryClose(), PetscViewerBinaryGetDescriptor(), PetscBinarySynchronizedWrite(),
PetscBinarySynchronizedRead(), PetscBinarySynchronizedSeek()
@*/
PetscErrorCode PetscBinaryRead(int fd,void *data,PetscInt num,PetscInt *count,PetscDataType type)
{
size_t typesize, m = (size_t) num, n = 0, maxblock = 65536;
char *p = (char*)data;
#if defined(PETSC_USE_REAL___FLOAT128)
PetscBool readdouble = PETSC_FALSE;
double *pdouble;
#endif
void *ptmp = data;
char *fname = NULL;
PetscErrorCode ierr;
PetscFunctionBegin;
if (count) *count = 0;
if (num < 0) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Trying to read a negative amount of data %D",num);
if (!num) PetscFunctionReturn(0);
if (type == PETSC_FUNCTION) {
m = 64;
type = PETSC_CHAR;
fname = (char*)malloc(m*sizeof(char));
p = (char*)fname;
ptmp = (void*)fname;
if (!fname) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_MEM,"Cannot allocate space for function name");
}
if (type == PETSC_BIT_LOGICAL) m = PetscBTLength(m);
ierr = PetscDataTypeGetSize(type,&typesize);CHKERRQ(ierr);
#if defined(PETSC_USE_REAL___FLOAT128)
ierr = PetscOptionsGetBool(NULL,NULL,"-binary_read_double",&readdouble,NULL);CHKERRQ(ierr);
/* If using __float128 precision we still read in doubles from file */
if ((type == PETSC_REAL || type == PETSC_COMPLEX) && readdouble) {
PetscInt cnt = num * ((type == PETSC_REAL) ? 1 : 2);
ierr = PetscMalloc1(cnt,&pdouble);CHKERRQ(ierr);
p = (char*)pdouble;
typesize /= 2;
}
#endif
m *= typesize;
while (m) {
size_t len = (m < maxblock) ? m : maxblock;
int ret = (int)read(fd,p,len);
if (ret < 0 && errno == EINTR) continue;
if (!ret && len > 0) break; /* Proxy for EOF */
if (ret < 0) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_FILE_READ,"Error reading from file, errno %d",errno);
m -= ret;
p += ret;
n += ret;
}
if (m && !count) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_FILE_READ,"Read past end of file");
num = (PetscInt)(n/typesize); /* Should we require `n % typesize == 0` ? */
if (count) *count = num; /* TODO: This is most likely wrong for PETSC_BIT_LOGICAL */
#if defined(PETSC_USE_REAL___FLOAT128)
if ((type == PETSC_REAL || type == PETSC_COMPLEX) && readdouble) {
PetscInt i, cnt = num * ((type == PETSC_REAL) ? 1 : 2);
PetscReal *preal = (PetscReal*)data;
if (!PetscBinaryBigEndian()) {ierr = PetscByteSwapDouble(pdouble,cnt);CHKERRQ(ierr);}
for (i=0; i<cnt; i++) preal[i] = pdouble[i];
ierr = PetscFree(pdouble);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
#endif
if (!PetscBinaryBigEndian()) {ierr = PetscByteSwap(ptmp,type,num);CHKERRQ(ierr);}
if (type == PETSC_FUNCTION) {
#if defined(PETSC_SERIALIZE_FUNCTIONS)
ierr = PetscDLSym(NULL,fname,(void**)data);CHKERRQ(ierr);
#else
*(void**)data = NULL;
#endif
free(fname);
}
PetscFunctionReturn(0);
}
/*@
PetscBinaryWrite - Writes to a binary file.
Not Collective
Input Parameters:
+ fd - the file
. p - the buffer
. n - the number of items to write
. type - the type of items to read (PETSC_INT, PETSC_DOUBLE or PETSC_SCALAR)
- istemp - PETSC_FALSE if buffer data should be preserved, PETSC_TRUE otherwise.
Level: advanced
Notes:
PetscBinaryWrite() uses byte swapping to work on all machines; the files
are written using big-endian ordering to the file. On small-endian machines the numbers
are converted to the big-endian format when they are written to disk.
When PETSc is ./configure with --with-64bit-indices the integers are written to the
file as 64 bit integers, this means they can only be read back in when the option --with-64bit-indices
is used.
The Buffer p should be read-write buffer, and not static data.
This way, byte-swapping is done in-place, and then the buffer is
written to the file.
This routine restores the original contents of the buffer, after
it is written to the file. This is done by byte-swapping in-place
the second time. If the flag istemp is set to PETSC_TRUE, the second
byte-swapping operation is not done, thus saving some computation,
but the buffer is left corrupted.
Because byte-swapping may be done on the values in data it cannot be declared const
Concepts: files^writing binary
Concepts: binary files^writing
.seealso: PetscBinaryRead(), PetscBinaryOpen(), PetscBinaryClose(), PetscViewerBinaryGetDescriptor(), PetscBinarySynchronizedWrite(),
PetscBinarySynchronizedRead(), PetscBinarySynchronizedSeek()
@*/
PetscErrorCode PetscBinaryWrite(int fd,void *p,PetscInt n,PetscDataType type,PetscBool istemp)
{
char *pp = (char*)p;
int err,wsize;
size_t m = (size_t)n,maxblock=65536;
PetscErrorCode ierr;
#if !defined(PETSC_WORDS_BIGENDIAN)
void *ptmp = p;
#endif
char *fname = NULL;
PetscFunctionBegin;
if (n < 0) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Trying to write a negative amount of data %D",n);
if (!n) PetscFunctionReturn(0);
if (type == PETSC_FUNCTION) {
#if defined(PETSC_SERIALIZE_FUNCTIONS)
const char *fnametmp;
#endif
m = 64;
fname = (char*)malloc(m*sizeof(char));
if (!fname) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_MEM,"Cannot allocate space for function name");
#if defined(PETSC_SERIALIZE_FUNCTIONS)
if (n > 1) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Can only binary view a single function at a time");
ierr = PetscFPTFind(*(void**)p,&fnametmp);CHKERRQ(ierr);
ierr = PetscStrncpy(fname,fnametmp,m);CHKERRQ(ierr);
#else
ierr = PetscStrncpy(fname,"",m);CHKERRQ(ierr);
#endif
type = PETSC_CHAR;
pp = (char*)fname;
#if !defined(PETSC_WORDS_BIGENDIAN)
ptmp = (void*)fname;
#endif
}
if (type == PETSC_INT) m *= sizeof(PetscInt);
else if (type == PETSC_SCALAR) m *= sizeof(PetscScalar);
else if (type == PETSC_DOUBLE) m *= sizeof(double);
else if (type == PETSC_FLOAT) m *= sizeof(float);
else if (type == PETSC_SHORT) m *= sizeof(short);
else if (type == PETSC_CHAR) m *= sizeof(char);
else if (type == PETSC_ENUM) m *= sizeof(PetscEnum);
else if (type == PETSC_BOOL) m *= sizeof(PetscBool);
else if (type == PETSC_BIT_LOGICAL) m = PetscBTLength(m)*sizeof(char);
else SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Unknown type");
#if !defined(PETSC_WORDS_BIGENDIAN)
ierr = PetscByteSwap(ptmp,type,n);CHKERRQ(ierr);
#endif
while (m) {
wsize = (m < maxblock) ? m : maxblock;
err = write(fd,pp,wsize);
if (err < 0 && errno == EINTR) continue;
if (err != wsize) SETERRQ3(PETSC_COMM_SELF,PETSC_ERR_FILE_WRITE,"Error writing to file total size %d err %d wsize %d",(int)n,(int)err,(int)wsize);
m -= wsize;
pp += wsize;
}
#if !defined(PETSC_WORDS_BIGENDIAN)
if (!istemp) {
ierr = PetscByteSwap(ptmp,type,n);CHKERRQ(ierr);
}
#endif
if (type == PETSC_FUNCTION) {
free(fname);
}
PetscFunctionReturn(0);
}
/*@
PetscBinaryRead - Reads from a binary file.
Not Collective
Input Parameters:
+ fd - the file
. n - the number of items to read
- type - the type of items to read (PETSC_INT, PETSC_DOUBLE or PETSC_SCALAR)
Output Parameters:
. p - the buffer
Level: developer
Notes:
PetscBinaryRead() uses byte swapping to work on all machines; the files
are written to file ALWAYS using big-endian ordering. On small-endian machines the numbers
are converted to the small-endian format when they are read in from the file.
When PETSc is ./configure with --with-64bit-indices the integers are written to the
file as 64 bit integers, this means they can only be read back in when the option --with-64bit-indices
is used.
Concepts: files^reading binary
Concepts: binary files^reading
.seealso: PetscBinaryWrite(), PetscBinaryOpen(), PetscBinaryClose(), PetscViewerBinaryGetDescriptor(), PetscBinarySynchronizedWrite(),
PetscBinarySynchronizedRead(), PetscBinarySynchronizedSeek()
@*/
PetscErrorCode PetscBinaryRead(int fd,void *p,PetscInt n,PetscDataType type)
{
int wsize,err;
size_t m = (size_t) n,maxblock = 65536;
char *pp = (char*)p;
#if defined(PETSC_USE_REAL___FLOAT128)
PetscBool readdouble = PETSC_FALSE;
double *ppp;
#endif
#if !defined(PETSC_WORDS_BIGENDIAN) || defined(PETSC_USE_REAL___FLOAT128)
PetscErrorCode ierr;
#endif
#if !defined(PETSC_WORDS_BIGENDIAN)
void *ptmp = p;
#endif
char *fname = NULL;
PetscFunctionBegin;
if (n < 0) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Trying to write a negative amount of data %D",n);
if (!n) PetscFunctionReturn(0);
if (type == PETSC_FUNCTION) {
m = 64;
type = PETSC_CHAR;
fname = (char*) malloc(m*sizeof(char));
if (!fname) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_MEM,"Cannot allocate space for function name");
pp = (char*)fname;
#if !defined(PETSC_WORDS_BIGENDIAN)
ptmp = (void*)fname;
#endif
}
if (type == PETSC_INT) m *= sizeof(PetscInt);
else if (type == PETSC_SCALAR) m *= sizeof(PetscScalar);
else if (type == PETSC_DOUBLE) m *= sizeof(double);
else if (type == PETSC_FLOAT) m *= sizeof(float);
else if (type == PETSC_SHORT) m *= sizeof(short);
else if (type == PETSC_CHAR) m *= sizeof(char);
else if (type == PETSC_ENUM) m *= sizeof(PetscEnum);
else if (type == PETSC_BOOL) m *= sizeof(PetscBool);
else if (type == PETSC_BIT_LOGICAL) m = PetscBTLength(m)*sizeof(char);
else SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Unknown type");
#if defined(PETSC_USE_REAL___FLOAT128)
ierr = PetscOptionsGetBool(NULL,"-binary_read_double",&readdouble,NULL);CHKERRQ(ierr);
/* If using __float128 precision we still read in doubles from file */
if (type == PETSC_SCALAR && readdouble) {
m = m/2;
ierr = PetscMalloc1(n,&ppp);CHKERRQ(ierr);
pp = (char*)ppp;
}
#endif
while (m) {
wsize = (m < maxblock) ? m : maxblock;
err = read(fd,pp,wsize);
if (err < 0 && errno == EINTR) continue;
if (!err && wsize > 0) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_FILE_READ,"Read past end of file");
if (err < 0) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_FILE_READ,"Error reading from file, errno %d",errno);
m -= err;
pp += err;
}
#if defined(PETSC_USE_REAL___FLOAT128)
if (type == PETSC_SCALAR && readdouble) {
PetscScalar *pv = (PetscScalar*) p;
PetscInt i;
#if !defined(PETSC_WORDS_BIGENDIAN)
ierr = PetscByteSwapDouble(ppp,n);CHKERRQ(ierr);
#endif
for (i=0; i<n; i++) pv[i] = ppp[i];
ierr = PetscFree(ppp);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
#endif
#if !defined(PETSC_WORDS_BIGENDIAN)
ierr = PetscByteSwap(ptmp,type,n);CHKERRQ(ierr);
#endif
if (type == PETSC_FUNCTION) {
#if defined(PETSC_SERIALIZE_FUNCTIONS)
ierr = PetscDLSym(NULL,fname,(void**)p);CHKERRQ(ierr);
#else
*(void**)p = NULL;
#endif
free(fname);
}
PetscFunctionReturn(0);
}
/*@
DMPlexCreateGmsh - Create a DMPlex mesh from a Gmsh file viewer
Collective on comm
Input Parameters:
+ comm - The MPI communicator
. viewer - The Viewer associated with a Gmsh file
- interpolate - Create faces and edges in the mesh
Output Parameter:
. dm - The DM object representing the mesh
Note: http://www.geuz.org/gmsh/doc/texinfo/#MSH-ASCII-file-format
and http://www.geuz.org/gmsh/doc/texinfo/#MSH-binary-file-format
Level: beginner
.keywords: mesh,Gmsh
.seealso: DMPLEX, DMCreate()
@*/
PetscErrorCode DMPlexCreateGmsh(MPI_Comm comm, PetscViewer viewer, PetscBool interpolate, DM *dm)
{
PetscViewerType vtype;
GmshElement *gmsh_elem;
PetscSection coordSection;
Vec coordinates;
PetscScalar *coords, *coordsIn = NULL;
PetscInt dim = 0, coordSize, c, v, d, r, cell;
int i, numVertices = 0, numCells = 0, trueNumCells = 0, numRegions = 0, snum;
PetscMPIInt num_proc, rank;
char line[PETSC_MAX_PATH_LEN];
PetscBool match, binary, bswap = PETSC_FALSE;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = MPI_Comm_rank(comm, &rank);CHKERRQ(ierr);
ierr = MPI_Comm_size(comm, &num_proc);CHKERRQ(ierr);
ierr = DMCreate(comm, dm);CHKERRQ(ierr);
ierr = DMSetType(*dm, DMPLEX);CHKERRQ(ierr);
ierr = PetscLogEventBegin(DMPLEX_CreateGmsh,*dm,0,0,0);CHKERRQ(ierr);
ierr = PetscViewerGetType(viewer, &vtype);CHKERRQ(ierr);
ierr = PetscStrcmp(vtype, PETSCVIEWERBINARY, &binary);CHKERRQ(ierr);
if (!rank || binary) {
PetscBool match;
int fileType, dataSize;
float version;
/* Read header */
ierr = PetscViewerRead(viewer, line, 1, NULL, PETSC_STRING);CHKERRQ(ierr);
ierr = PetscStrncmp(line, "$MeshFormat", PETSC_MAX_PATH_LEN, &match);CHKERRQ(ierr);
if (!match) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "File is not a valid Gmsh file");
ierr = PetscViewerRead(viewer, line, 3, NULL, PETSC_STRING);CHKERRQ(ierr);
snum = sscanf(line, "%f %d %d", &version, &fileType, &dataSize);
if (snum != 3) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Unable to parse Gmsh file header: %s", line);
if (version < 2.0) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Gmsh file must be at least version 2.0");
if (dataSize != sizeof(double)) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Data size %d is not valid for a Gmsh file", dataSize);
if (binary) {
int checkInt;
ierr = PetscViewerRead(viewer, &checkInt, 1, NULL, PETSC_ENUM);CHKERRQ(ierr);
if (checkInt != 1) {
ierr = PetscByteSwap(&checkInt, PETSC_ENUM, 1);CHKERRQ(ierr);
if (checkInt == 1) bswap = PETSC_TRUE;
else SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "File type %d is not a valid Gmsh binary file", fileType);
}
} else if (fileType) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "File type %d is not a valid Gmsh ASCII file", fileType);
ierr = PetscViewerRead(viewer, line, 1, NULL, PETSC_STRING);CHKERRQ(ierr);
ierr = PetscStrncmp(line, "$EndMeshFormat", PETSC_MAX_PATH_LEN, &match);CHKERRQ(ierr);
if (!match) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "File is not a valid Gmsh file");
/* OPTIONAL Read physical names */
ierr = PetscViewerRead(viewer, line, 1, NULL, PETSC_STRING);CHKERRQ(ierr);
ierr = PetscStrncmp(line, "$PhysicalNames", PETSC_MAX_PATH_LEN, &match);CHKERRQ(ierr);
if (match) {
ierr = PetscViewerRead(viewer, line, 1, NULL, PETSC_STRING);CHKERRQ(ierr);
snum = sscanf(line, "%d", &numRegions);
if (snum != 1) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "File is not a valid Gmsh file");
for (r = 0; r < numRegions; ++r) {
PetscInt rdim, tag;
ierr = PetscViewerRead(viewer, &rdim, 1, NULL, PETSC_ENUM);CHKERRQ(ierr);
ierr = PetscViewerRead(viewer, &tag, 1, NULL, PETSC_ENUM);CHKERRQ(ierr);
ierr = PetscViewerRead(viewer, line, 1, NULL, PETSC_STRING);CHKERRQ(ierr);
}
ierr = PetscViewerRead(viewer, line, 1, NULL, PETSC_STRING);CHKERRQ(ierr);
ierr = PetscStrncmp(line, "$EndPhysicalNames", PETSC_MAX_PATH_LEN, &match);CHKERRQ(ierr);
if (!match) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "File is not a valid Gmsh file");
/* Initial read for vertex section */
ierr = PetscViewerRead(viewer, line, 1, NULL, PETSC_STRING);CHKERRQ(ierr);
}
/* Read vertices */
ierr = PetscStrncmp(line, "$Nodes", PETSC_MAX_PATH_LEN, &match);CHKERRQ(ierr);
if (!match) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "File is not a valid Gmsh file");
ierr = PetscViewerRead(viewer, line, 1, NULL, PETSC_STRING);CHKERRQ(ierr);
snum = sscanf(line, "%d", &numVertices);
if (snum != 1) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "File is not a valid Gmsh file");
ierr = PetscMalloc1(numVertices*3, &coordsIn);CHKERRQ(ierr);
if (binary) {
size_t doubleSize, intSize;
PetscInt elementSize;
char *buffer;
PetscScalar *baseptr;
ierr = PetscDataTypeGetSize(PETSC_ENUM, &intSize);CHKERRQ(ierr);
ierr = PetscDataTypeGetSize(PETSC_DOUBLE, &doubleSize);CHKERRQ(ierr);
elementSize = (intSize + 3*doubleSize);
ierr = PetscMalloc1(elementSize*numVertices, &buffer);CHKERRQ(ierr);
ierr = PetscViewerRead(viewer, buffer, elementSize*numVertices, NULL, PETSC_CHAR);CHKERRQ(ierr);
if (bswap) ierr = PetscByteSwap(buffer, PETSC_CHAR, elementSize*numVertices);CHKERRQ(ierr);
for (v = 0; v < numVertices; ++v) {
baseptr = ((PetscScalar*)(buffer+v*elementSize+intSize));
coordsIn[v*3+0] = baseptr[0];
coordsIn[v*3+1] = baseptr[1];
coordsIn[v*3+2] = baseptr[2];
}
ierr = PetscFree(buffer);CHKERRQ(ierr);
} else {
for (v = 0; v < numVertices; ++v) {
ierr = PetscViewerRead(viewer, &i, 1, NULL, PETSC_ENUM);CHKERRQ(ierr);
ierr = PetscViewerRead(viewer, &(coordsIn[v*3]), 3, NULL, PETSC_DOUBLE);CHKERRQ(ierr);
if (i != (int)v+1) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Invalid node number %d should be %d", i, v+1);
}
}
ierr = PetscViewerRead(viewer, line, 1, NULL, PETSC_STRING);CHKERRQ(ierr);;
ierr = PetscStrncmp(line, "$EndNodes", PETSC_MAX_PATH_LEN, &match);CHKERRQ(ierr);
if (!match) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "File is not a valid Gmsh file");
/* Read cells */
ierr = PetscViewerRead(viewer, line, 1, NULL, PETSC_STRING);CHKERRQ(ierr);;
ierr = PetscStrncmp(line, "$Elements", PETSC_MAX_PATH_LEN, &match);CHKERRQ(ierr);
if (!match) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "File is not a valid Gmsh file");
ierr = PetscViewerRead(viewer, line, 1, NULL, PETSC_STRING);CHKERRQ(ierr);;
snum = sscanf(line, "%d", &numCells);
if (snum != 1) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "File is not a valid Gmsh file");
}
if (!rank || binary) {
/* Gmsh elements can be of any dimension/co-dimension, so we need to traverse the
file contents multiple times to figure out the true number of cells and facets
in the given mesh. To make this more efficient we read the file contents only
once and store them in memory, while determining the true number of cells. */
ierr = DMPlexCreateGmsh_ReadElement(viewer, numCells, binary, bswap, &gmsh_elem);CHKERRQ(ierr);
for (trueNumCells=0, c = 0; c < numCells; ++c) {
if (gmsh_elem[c].dim > dim) {dim = gmsh_elem[c].dim; trueNumCells = 0;}
if (gmsh_elem[c].dim == dim) trueNumCells++;
}
ierr = PetscViewerRead(viewer, line, 1, NULL, PETSC_STRING);CHKERRQ(ierr);;
ierr = PetscStrncmp(line, "$EndElements", PETSC_MAX_PATH_LEN, &match);CHKERRQ(ierr);
if (!match) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "File is not a valid Gmsh file");
}
/* For binary we read on all ranks, but only build the plex on rank 0 */
if (binary && rank) {trueNumCells = 0; numVertices = 0;};
/* Allocate the cell-vertex mesh */
ierr = DMPlexSetChart(*dm, 0, trueNumCells+numVertices);CHKERRQ(ierr);
if (!rank) {
for (cell = 0, c = 0; c < numCells; ++c) {
if (gmsh_elem[c].dim == dim) {
ierr = DMPlexSetConeSize(*dm, cell, gmsh_elem[c].numNodes);CHKERRQ(ierr);
cell++;
}
}
}
ierr = DMSetUp(*dm);CHKERRQ(ierr);
/* Add cell-vertex connections */
if (!rank) {
PetscInt pcone[8], corner;
for (cell = 0, c = 0; c < numCells; ++c) {
if (gmsh_elem[c].dim == dim) {
for (corner = 0; corner < gmsh_elem[c].numNodes; ++corner) {
pcone[corner] = gmsh_elem[c].nodes[corner] + trueNumCells-1;
}
if (dim == 3) {
/* Tetrahedra are inverted */
if (gmsh_elem[c].numNodes == 4) {
PetscInt tmp = pcone[0];
pcone[0] = pcone[1];
pcone[1] = tmp;
}
/* Hexahedra are inverted */
if (gmsh_elem[c].numNodes == 8) {
PetscInt tmp = pcone[1];
pcone[1] = pcone[3];
pcone[3] = tmp;
}
}
ierr = DMPlexSetCone(*dm, cell, pcone);CHKERRQ(ierr);
cell++;
}
}
}
ierr = MPI_Bcast(&dim, 1, MPIU_INT, 0, comm);CHKERRQ(ierr);
ierr = DMSetDimension(*dm, dim);CHKERRQ(ierr);
ierr = DMPlexSymmetrize(*dm);CHKERRQ(ierr);
ierr = DMPlexStratify(*dm);CHKERRQ(ierr);
if (interpolate) {
DM idm = NULL;
ierr = DMPlexInterpolate(*dm, &idm);CHKERRQ(ierr);
ierr = DMDestroy(dm);CHKERRQ(ierr);
*dm = idm;
}
if (!rank) {
/* Apply boundary IDs by finding the relevant facets with vertex joins */
PetscInt pcone[8], corner, vStart, vEnd;
ierr = DMPlexGetDepthStratum(*dm, 0, &vStart, &vEnd);CHKERRQ(ierr);
for (c = 0; c < numCells; ++c) {
if (gmsh_elem[c].dim == dim-1) {
PetscInt joinSize;
const PetscInt *join;
for (corner = 0; corner < gmsh_elem[c].numNodes; ++corner) {
pcone[corner] = gmsh_elem[c].nodes[corner] + vStart - 1;
}
ierr = DMPlexGetFullJoin(*dm, gmsh_elem[c].numNodes, (const PetscInt *) pcone, &joinSize, &join);CHKERRQ(ierr);
if (joinSize != 1) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Could not determine Plex facet for element %d", gmsh_elem[c].id);
ierr = DMSetLabelValue(*dm, "Face Sets", join[0], gmsh_elem[c].tags[0]);CHKERRQ(ierr);
ierr = DMPlexRestoreJoin(*dm, gmsh_elem[c].numNodes, (const PetscInt *) pcone, &joinSize, &join);CHKERRQ(ierr);
}
}
/* Create cell sets */
for (cell = 0, c = 0; c < numCells; ++c) {
if (gmsh_elem[c].dim == dim) {
if (gmsh_elem[c].numTags > 0) {
ierr = DMSetLabelValue(*dm, "Cell Sets", cell, gmsh_elem[c].tags[0]);CHKERRQ(ierr);
cell++;
}
}
}
}
/* Read coordinates */
ierr = DMGetCoordinateSection(*dm, &coordSection);CHKERRQ(ierr);
ierr = PetscSectionSetNumFields(coordSection, 1);CHKERRQ(ierr);
ierr = PetscSectionSetFieldComponents(coordSection, 0, dim);CHKERRQ(ierr);
ierr = PetscSectionSetChart(coordSection, trueNumCells, trueNumCells + numVertices);CHKERRQ(ierr);
for (v = trueNumCells; v < trueNumCells+numVertices; ++v) {
ierr = PetscSectionSetDof(coordSection, v, dim);CHKERRQ(ierr);
ierr = PetscSectionSetFieldDof(coordSection, v, 0, dim);CHKERRQ(ierr);
}
ierr = PetscSectionSetUp(coordSection);CHKERRQ(ierr);
ierr = PetscSectionGetStorageSize(coordSection, &coordSize);CHKERRQ(ierr);
ierr = VecCreate(PETSC_COMM_SELF, &coordinates);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) coordinates, "coordinates");CHKERRQ(ierr);
ierr = VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);CHKERRQ(ierr);
ierr = VecSetBlockSize(coordinates, dim);CHKERRQ(ierr);
ierr = VecSetType(coordinates, VECSTANDARD);CHKERRQ(ierr);
ierr = VecGetArray(coordinates, &coords);CHKERRQ(ierr);
if (!rank) {
for (v = 0; v < numVertices; ++v) {
for (d = 0; d < dim; ++d) {
coords[v*dim+d] = coordsIn[v*3+d];
}
}
}
ierr = VecRestoreArray(coordinates, &coords);CHKERRQ(ierr);
ierr = PetscFree(coordsIn);CHKERRQ(ierr);
ierr = DMSetCoordinatesLocal(*dm, coordinates);CHKERRQ(ierr);
ierr = VecDestroy(&coordinates);CHKERRQ(ierr);
/* Clean up intermediate storage */
if (!rank || binary) ierr = PetscFree(gmsh_elem);CHKERRQ(ierr);
ierr = PetscLogEventEnd(DMPLEX_CreateGmsh,*dm,0,0,0);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode DMPlexCreateGmsh_ReadElement(PetscViewer viewer, PetscInt numCells, PetscBool binary, PetscBool byteSwap, GmshElement **gmsh_elems)
{
PetscInt c, p;
GmshElement *elements;
int i, cellType, dim, numNodes, numElem, numTags;
int ibuf[16];
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscMalloc1(numCells, &elements);CHKERRQ(ierr);
for (c = 0; c < numCells;) {
ierr = PetscViewerRead(viewer, &ibuf, 3, NULL, PETSC_ENUM);CHKERRQ(ierr);
if (byteSwap) ierr = PetscByteSwap(&ibuf, PETSC_ENUM, 3);CHKERRQ(ierr);
if (binary) {
cellType = ibuf[0];
numElem = ibuf[1];
numTags = ibuf[2];
} else {
elements[c].id = ibuf[0];
cellType = ibuf[1];
numTags = ibuf[2];
numElem = 1;
}
switch (cellType) {
case 1: /* 2-node line */
dim = 1;
numNodes = 2;
break;
case 2: /* 3-node triangle */
dim = 2;
numNodes = 3;
break;
case 3: /* 4-node quadrangle */
dim = 2;
numNodes = 4;
break;
case 4: /* 4-node tetrahedron */
dim = 3;
numNodes = 4;
break;
case 5: /* 8-node hexahedron */
dim = 3;
numNodes = 8;
break;
case 15: /* 1-node vertex */
dim = 0;
numNodes = 1;
break;
default:
SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Unsupported Gmsh element type %d", cellType);
}
if (binary) {
const PetscInt nint = numNodes + numTags + 1;
for (i = 0; i < numElem; ++i, ++c) {
/* Loop over inner binary element block */
elements[c].dim = dim;
elements[c].numNodes = numNodes;
elements[c].numTags = numTags;
ierr = PetscViewerRead(viewer, &ibuf, nint, NULL, PETSC_ENUM);CHKERRQ(ierr);
if (byteSwap) ierr = PetscByteSwap( &ibuf, PETSC_ENUM, nint);CHKERRQ(ierr);
elements[c].id = ibuf[0];
for (p = 0; p < numTags; p++) elements[c].tags[p] = ibuf[1 + p];
for (p = 0; p < numNodes; p++) elements[c].nodes[p] = ibuf[1 + numTags + p];
}
} else {
elements[c].dim = dim;
elements[c].numNodes = numNodes;
elements[c].numTags = numTags;
ierr = PetscViewerRead(viewer, elements[c].tags, elements[c].numTags, NULL, PETSC_ENUM);CHKERRQ(ierr);
ierr = PetscViewerRead(viewer, elements[c].nodes, elements[c].numNodes, NULL, PETSC_ENUM);CHKERRQ(ierr);
c++;
}
}
*gmsh_elems = elements;
PetscFunctionReturn(0);
}