int main(int argc, char **args) {
PetscErrorCode ierr;
ierr = DCellInit(); CHKERRQ(ierr);
PetscReal dx = 1;
iCoor size = {1625,1145,0};
// iCoor size = {253,341,0};
int fd;
Coor dh = {dx,dx,dx};
iCoor pos = {0,0,0};
Grid chip;
ierr = GridCreate(dh,pos,size,1,&chip); CHKERRQ(ierr);
ierr = PetscInfo(0,"Reading image file\n"); CHKERRQ(ierr);
ierr = PetscBinaryOpen("/scratch/n/BL Big",FILE_MODE_READ,&fd); CHKERRQ(ierr);
ierr = PetscBinaryRead(fd,chip->v1,size.x*size.y,PETSC_DOUBLE); CHKERRQ(ierr);
ierr = PetscBinaryClose(fd); CHKERRQ(ierr);
ierr = PetscInfo(0,"Writing image file\n"); CHKERRQ(ierr);
ierr = GridWrite(chip,0); CHKERRQ(ierr);
FluidField fluid;
ierr = FluidFieldCreate(PETSC_COMM_WORLD, &fluid); CHKERRQ(ierr);
ierr = FluidFieldSetDims(fluid,size); CHKERRQ(ierr);
ierr = FluidFieldSetDx(fluid,dx); CHKERRQ(ierr);
ierr = FluidFieldSetMask(fluid, chip); CHKERRQ(ierr);
ierr = FluidFieldSetup(fluid); CHKERRQ(ierr);
ierr = SetPressureBC(fluid); CHKERRQ(ierr);
ierr = KSPSolve(fluid->ksp,fluid->rhs,fluid->vel); CHKERRQ(ierr);
ierr = FluidFieldWrite( fluid,0); CHKERRQ(ierr);
ierr = FluidFieldDestroy(fluid); CHKERRQ(ierr);
ierr = GridDestroy(chip); CHKERRQ(ierr);
ierr = DCellFinalize(); CHKERRQ(ierr);
return 0;
}
/*@C
PetscBinarySynchronizedRead - Reads from a binary file.
Collective on MPI_Comm
Input Parameters:
+ comm - the MPI communicator
. 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:
Does a PetscBinaryRead() followed by an MPI_Bcast()
PetscBinarySynchronizedRead() uses byte swapping to work on all machines.
Integers are stored on the file as 32 long, regardless of whether
they are stored in the machine as 32 or 64, this means the same
binary file may be read on any machine.
Concepts: files^synchronized reading of binary files
Concepts: binary files^reading, synchronized
.seealso: PetscBinaryWrite(), PetscBinaryOpen(), PetscBinaryClose(), PetscBinaryRead(), PetscBinarySynchronizedWrite(),
PetscBinarySynchronizedSeek()
@*/
PetscErrorCode PetscBinarySynchronizedRead(MPI_Comm comm,int fd,void *p,PetscInt n,PetscDataType type)
{
PetscErrorCode ierr;
PetscMPIInt rank;
MPI_Datatype mtype;
char *fname = NULL;
void *ptmp = NULL;
PetscFunctionBegin;
if (type == PETSC_FUNCTION) {
n = 64;
type = PETSC_CHAR;
ptmp = p;
fname = (char*)malloc(n*sizeof(char));
if (!fname) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_MEM,"Cannot allocate space for function name");
p = (void*)fname;
}
ierr = MPI_Comm_rank(comm,&rank);CHKERRQ(ierr);
if (!rank) {
ierr = PetscBinaryRead(fd,p,n,type);CHKERRQ(ierr);
}
ierr = PetscDataTypeToMPIDataType(type,&mtype);CHKERRQ(ierr);
ierr = MPI_Bcast(p,n,mtype,0,comm);CHKERRQ(ierr);
if (type == PETSC_FUNCTION) {
#if defined(PETSC_SERIALIZE_FUNCTIONS)
ierr = PetscDLLibrarySym(PETSC_COMM_SELF,&PetscDLLibrariesLoaded,NULL,fname,(void**)ptmp);CHKERRQ(ierr);
#else
*(void**)ptmp = NULL;
#endif
free(fname);
}
PetscFunctionReturn(0);
}
PetscErrorCode readProfileSurfaceScalarDataRecord(char *fileName, PetscScalar *arr, PetscInt numValsPerProfile, PetscInt iRec)
{
/* Random access version of readProfileSurfaceScalarData */
/* This version takes 1 additional argument: */
/* iRec: the record to read (iRec=1 is the first record) */
PetscErrorCode ierr;
off_t off, offset;
PetscViewer fd;
PetscInt fp;
PetscInt iShift;
PetscMPIInt numProcessors, myId;
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&myId);CHKERRQ(ierr);
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&numProcessors);CHKERRQ(ierr);
/* Shift file pointer to start of data owned by local process */
iShift = (iRec-1)*numValsPerProfile*totalNumProfiles + numValsPerProfile*numPrevProfiles;
off = PETSC_BINARY_SCALAR_SIZE*iShift;
ierr = PetscViewerBinaryOpen(PETSC_COMM_SELF,fileName,FILE_MODE_READ,&fd);CHKERRQ(ierr);
ierr = PetscViewerBinaryGetDescriptor(fd,&fp);CHKERRQ(ierr);
ierr = PetscBinarySeek(fp,off,PETSC_BINARY_SEEK_SET,&offset);CHKERRQ(ierr);
ierr = PetscBinaryRead(fp,arr,numValsPerProfile*lNumProfiles,PETSC_SCALAR);CHKERRQ(ierr);
ierr = PetscViewerDestroy(fd);CHKERRQ(ierr);
return 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);
}
PetscErrorCode iniPeriodicTimer( const char pre[], PeriodicTimer *thetimer )
{
PetscErrorCode ierr;
PetscBool flg, flg1;
PetscInt it;
PetscViewer fd;
PetscInt fp;
char timeFile[PETSC_MAX_PATH_LEN];
/* read time data */
ierr = PetscOptionsGetReal(pre,"-cycle_period",&thetimer->cyclePeriod,&flg);CHKERRQ(ierr);
if (!flg) SETERRQ1(PETSC_COMM_WORLD,1,"Must indicate matrix cycling time with the -%scycle_period option",pre);
ierr = PetscOptionsGetReal(pre,"-cycle_step",&thetimer->cycleStep,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"WARNING!: Cycling step has been specified for periodic object %s\n",pre);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," This is a legacy option retained for backward compatibility and will be removed in future releases\n");CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," Use -%snum_per_period instead\n",pre);CHKERRQ(ierr);
thetimer->numPerPeriod=thetimer->cyclePeriod/thetimer->cycleStep;
/* array for holding extended time array */
PetscMalloc((thetimer->numPerPeriod+2)*sizeof(PetscScalar), &thetimer->tdp);
for (it=0; it<=thetimer->numPerPeriod+1; it++) {
thetimer->tdp[it]=(-thetimer->cycleStep/2.0) + it*thetimer->cycleStep;
}
} else {
ierr = PetscOptionsGetInt(pre,"-num_per_period",&thetimer->numPerPeriod,&flg1);CHKERRQ(ierr);
if (!flg1) SETERRQ1(PETSC_COMM_WORLD,1,"Must indicate number of fields per period with the -%snum_per_period option",pre);
/* array for holding extended time array */
PetscMalloc((thetimer->numPerPeriod+2)*sizeof(PetscScalar), &thetimer->tdp);
ierr = PetscOptionsGetString(pre,"-periodic_times_file",timeFile,PETSC_MAX_PATH_LEN-1,&flg1);CHKERRQ(ierr);
if (flg1) {
ierr = PetscViewerBinaryOpen(PETSC_COMM_SELF,timeFile,FILE_MODE_READ,&fd);CHKERRQ(ierr);
ierr = PetscViewerBinaryGetDescriptor(fd,&fp);CHKERRQ(ierr);
ierr = PetscBinaryRead(fp,&thetimer->tdp[1],thetimer->numPerPeriod,PETSC_SCALAR);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&fd);CHKERRQ(ierr);
thetimer->tdp[0]=thetimer->tdp[thetimer->numPerPeriod]-thetimer->cyclePeriod;
thetimer->tdp[thetimer->numPerPeriod+1]=thetimer->tdp[1]+thetimer->cyclePeriod;
} else {
ierr = PetscPrintf(PETSC_COMM_WORLD,"Assuming equally-spaced fields for periodic object %s\n",pre);CHKERRQ(ierr);
thetimer->cycleStep=thetimer->cyclePeriod/thetimer->numPerPeriod;
for (it=0; it<=thetimer->numPerPeriod+1; it++) {
thetimer->tdp[it]=(-thetimer->cycleStep/2.0) + it*thetimer->cycleStep;
}
}
}
ierr = PetscPrintf(PETSC_COMM_WORLD,"Periodic object %s specified at times:\n",pre);CHKERRQ(ierr);
for (it=0; it<=thetimer->numPerPeriod+1; it++) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"tdp=%10.5f\n", thetimer->tdp[it]);CHKERRQ(ierr);
}
return 0;
}
PetscErrorCode HeaderlessBinaryReadCheck(DM dm,const char name[])
{
PetscErrorCode ierr;
int fdes;
PetscScalar buffer[DMDA_I*DMDA_J*DMDA_K*3];
PetscInt len,d,i,j,k,M,N;
PetscMPIInt rank;
PetscBool dataverified = PETSC_TRUE;
PetscFunctionBeginUser;
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr);
ierr = DMDAGetInfo(dm,NULL,&M,&N,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);CHKERRQ(ierr);
len = DMDA_I*DMDA_J*DMDA_K*3;
if (!rank) {
ierr = PetscBinaryOpen(name,FILE_MODE_READ,&fdes);CHKERRQ(ierr);
ierr = PetscBinaryRead(fdes,buffer,len,PETSC_SCALAR);CHKERRQ(ierr);
ierr = PetscBinaryClose(fdes);CHKERRQ(ierr);
for (k=0; k<DMDA_K; k++) {
for (j=0; j<DMDA_J; j++) {
for (i=0; i<DMDA_I; i++) {
for (d=0; d<3; d++) {
PetscScalar v,test_value_s,test_value;
PetscInt index;
test_value_s = dmda_i_val[i]*((PetscScalar)i) + dmda_j_val[j]*((PetscScalar)(i+j*M)) + dmda_k_val[k]*((PetscScalar)(i + j*M + k*M*N));
test_value = 3.0 * test_value_s + (PetscScalar)d;
index = 3*(i + j*M + k*M*N) + d;
v = PetscAbsScalar(test_value-buffer[index]);
#if defined(PETSC_USE_COMPLEX)
if ((PetscRealPart(v) > 1.0e-10) || (PetscImaginaryPart(v) > 1.0e-10)) {
ierr = PetscPrintf(PETSC_COMM_SELF,"ERROR: Difference > 1.0e-10 occurred (delta = (%+1.12e,%+1.12e) [loc %D,%D,%D(%D)])\n",(double)PetscRealPart(test_value),(double)PetscImaginaryPart(test_value),i,j,k,d);CHKERRQ(ierr);
dataverified = PETSC_FALSE;
}
#else
if (PetscRealPart(v) > 1.0e-10) {
ierr = PetscPrintf(PETSC_COMM_SELF,"ERROR: Difference > 1.0e-10 occurred (delta = %+1.12e [loc %D,%D,%D(%D)])\n",(double)PetscRealPart(test_value),i,j,k,d);CHKERRQ(ierr);
dataverified = PETSC_FALSE;
}
#endif
}
}
}
}
if (dataverified) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Headerless read of data verified for: %s\n",name);CHKERRQ(ierr);
}
}
PetscFunctionReturn(0);
}
/*@C
PetscBinarySynchronizedRead - Reads from a binary file.
Collective on MPI_Comm
Input Parameters:
+ comm - the MPI communicator
. 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
Options Database Key:
. -binary_longints - indicates the file was generated on a Cray vector
machine (not the T3E/D) and the ints are stored as 64 bit
quantities, otherwise they are stored as 32 bit
Level: developer
Notes:
Does a PetscBinaryRead() followed by an MPI_Bcast()
PetscBinarySynchronizedRead() uses byte swapping to work on all machines.
Integers are stored on the file as 32 long, regardless of whether
they are stored in the machine as 32 or 64, this means the same
binary file may be read on any machine.
Concepts: files^synchronized reading of binary files
Concepts: binary files^reading, synchronized
.seealso: PetscBinaryWrite(), PetscBinaryOpen(), PetscBinaryClose(), PetscBinaryRead(), PetscBinarySynchronizedWrite(),
PetscBinarySynchronizedSeek()
@*/
PetscErrorCode PETSC_DLLEXPORT PetscBinarySynchronizedRead(MPI_Comm comm,int fd,void *p,PetscInt n,PetscDataType type)
{
PetscErrorCode ierr;
PetscMPIInt rank;
MPI_Datatype mtype;
PetscFunctionBegin;
ierr = MPI_Comm_rank(comm,&rank);CHKERRQ(ierr);
if (!rank) {
ierr = PetscBinaryRead(fd,p,n,type);CHKERRQ(ierr);
}
ierr = PetscDataTypeToMPIDataType(type,&mtype);CHKERRQ(ierr);
ierr = MPI_Bcast(p,n,mtype,0,comm);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
PetscHTTPRequest - Send a request to an HTTP server
Input Parameters:
+ type - either "POST" or "GET"
. url - URL of request host/path
. header - additional header information, may be NULL
. ctype - data type of body, for example application/json
. body - data to send to server
. sock - obtained with PetscOpenSocket()
- buffsize - size of buffer
Output Parameter:
. buff - everything returned from server
Level: advanced
.seealso: PetscHTTPSRequest(), PetscOpenSocket(), PetscHTTPSConnect(), PetscPullJSONValue()
@*/
PetscErrorCode PetscHTTPRequest(const char type[],const char url[],const char header[],const char ctype[],const char body[],int sock,char buff[],size_t buffsize)
{
char *request;
size_t request_len;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscHTTPBuildRequest(type,url,header,ctype,body,&request);CHKERRQ(ierr);
ierr = PetscStrlen(request,&request_len);CHKERRQ(ierr);
ierr = PetscBinaryWrite(sock,request,request_len,PETSC_CHAR,PETSC_FALSE);CHKERRQ(ierr);
ierr = PetscFree(request);CHKERRQ(ierr);
PetscBinaryRead(sock,buff,buffsize,PETSC_CHAR);
buff[buffsize-1] = 0;
ierr = PetscInfo1(NULL,"HTTP result follows: \n%s\n",buff);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode readProfileSurfaceScalarData(char *fileName, PetscScalar *arr, PetscInt numValsPerProfile)
{
PetscErrorCode ierr;
/* PetscScalar *tmpArr; */
/* PetscInt ip; */
/* size_t m1, m2; */
off_t off, offset;
PetscViewer fd;
PetscInt fp;
PetscInt iShift;
PetscMPIInt numProcessors, myId;
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&myId);CHKERRQ(ierr);
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&numProcessors);CHKERRQ(ierr);
/* m1 = numValsPerProfile*totalNumProfiles*sizeof(PetscScalar); */
/* m2 = numValsPerProfile*lNumProfiles*sizeof(PetscScalar); */
/*Read all data into temporary array */
/* ierr = PetscMalloc(m1,&tmpArr);CHKERRQ(ierr); */
/* ierr = PetscViewerBinaryOpen(PETSC_COMM_SELF,fileName,FILE_MODE_READ,&fd);CHKERRQ(ierr); */
/* ierr = PetscViewerBinaryGetDescriptor(fd,&fp);CHKERRQ(ierr); */
/* ierr = PetscBinaryRead(fp,tmpArr,numValsPerProfile*totalNumProfiles,PETSC_SCALAR);CHKERRQ(ierr); */
/* ierr = PetscViewerDestroy(fd);CHKERRQ(ierr); */
/* Shift file pointer to start of data owned by local process */
iShift = numValsPerProfile*numPrevProfiles;
/* printf("ipro=%d,iShift=%d\n",myId,iShift); */
off = PETSC_BINARY_SCALAR_SIZE*iShift;
ierr = PetscViewerBinaryOpen(PETSC_COMM_SELF,fileName,FILE_MODE_READ,&fd);CHKERRQ(ierr);
ierr = PetscViewerBinaryGetDescriptor(fd,&fp);CHKERRQ(ierr);
ierr = PetscBinarySeek(fp,off,PETSC_BINARY_SEEK_SET,&offset);CHKERRQ(ierr);
ierr = PetscBinaryRead(fp,arr,numValsPerProfile*lNumProfiles,PETSC_SCALAR);CHKERRQ(ierr);
ierr = PetscViewerDestroy(fd);CHKERRQ(ierr);
/* ierr = PetscMalloc(m2,&arr);CHKERRQ(ierr); */
/* for (ip=1; ip<=lNumProfiles; ip++) { */
/* arr[ip-1]=tmpArr[numPrevProfiles+ip-1]; */
/* } */
/* ierr = PetscFree(tmpArr);CHKERRQ(ierr); */
return 0;
}
PetscErrorCode readProfileSurfaceIntData(char *fileName, PetscInt *arr, PetscInt numValsPerProfile)
{
PetscErrorCode ierr;
/* PetscInt *tmpArr; */
/* PetscInt ip; */
/* size_t m1, m2; */
off_t off, offset;
PetscViewer fd;
PetscInt fp;
PetscInt iShift;
/* m1 = totalNumProfiles*sizeof(PetscInt); */
/* m2 = lNumProfiles*sizeof(PetscInt); */
/* ierr = PetscMalloc(m1,&tmpArr);CHKERRQ(ierr); */
/* ierr = PetscViewerBinaryOpen(PETSC_COMM_SELF,fileName,FILE_MODE_READ,&fd);CHKERRQ(ierr); */
/* ierr = PetscViewerBinaryGetDescriptor(fd,&fp);CHKERRQ(ierr); */
/* ierr = PetscBinaryRead(fp,tmpArr,totalNumProfiles,PETSC_INT);CHKERRQ(ierr); */
/* ierr = PetscViewerDestroy(fd);CHKERRQ(ierr); */
/* Shift file pointer to start of data owned by local process */
iShift = numValsPerProfile*numPrevProfiles;
off = PETSC_BINARY_INT_SIZE*iShift;
ierr = PetscViewerBinaryOpen(PETSC_COMM_SELF,fileName,FILE_MODE_READ,&fd);CHKERRQ(ierr);
ierr = PetscViewerBinaryGetDescriptor(fd,&fp);CHKERRQ(ierr);
ierr = PetscBinarySeek(fp,off,PETSC_BINARY_SEEK_SET,&offset);CHKERRQ(ierr);
ierr = PetscBinaryRead(fp,arr,numValsPerProfile*lNumProfiles,PETSC_INT);CHKERRQ(ierr);
ierr = PetscViewerDestroy(fd);CHKERRQ(ierr);
/* for (ip=0; ip<totalNumProfiles; ip++) { */
/* ierr = PetscPrintf(PETSC_COMM_WORLD,"ip=%d,kc=%d\n",ip,tmpArr[ip]);CHKERRQ(ierr); */
/* } */
/* ierr = PetscMalloc(m2,&arr);CHKERRQ(ierr); */
/* for (ip=1; ip<=lNumProfiles; ip++) { */
/* arr[ip-1]=tmpArr[numPrevProfiles+ip-1]; */
/* ierr = PetscPrintf(PETSC_COMM_WORLD,"ip=%d,kc=%d\n",ip,arr[ip-1]);CHKERRQ(ierr); */
/* } */
/* ierr = PetscFree(tmpArr);CHKERRQ(ierr); */
return 0;
}
/*@C
PetscBinarySynchronizedRead - Reads from a binary file.
Collective on MPI_Comm
Input Parameters:
+ comm - the MPI communicator
. 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:
Does a PetscBinaryRead() followed by an MPI_Bcast()
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.
PetscBinarySynchronizedRead() uses byte swapping to work on all machines.
Integers are stored on the file as 32 long, regardless of whether
they are stored in the machine as 32 or 64, this means the same
binary file may be read on any machine.
Concepts: files^synchronized reading of binary files
Concepts: binary files^reading, synchronized
.seealso: PetscBinaryWrite(), PetscBinaryOpen(), PetscBinaryClose(), PetscBinaryRead(), PetscBinarySynchronizedWrite(),
PetscBinarySynchronizedSeek()
@*/
PetscErrorCode PetscBinarySynchronizedRead(MPI_Comm comm,int fd,void *data,PetscInt num,PetscInt *count,PetscDataType type)
{
PetscErrorCode ierr;
PetscMPIInt rank;
MPI_Datatype mtype;
PetscInt ibuf[2] = {0, 0};
char *fname = NULL;
void *fptr = NULL;
PetscFunctionBegin;
if (type == PETSC_FUNCTION) {
num = 64;
type = PETSC_CHAR;
fname = (char*)malloc(num*sizeof(char));
fptr = data;
data = (void*)fname;
if (!fname) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_MEM,"Cannot allocate space for function name");
}
ierr = MPI_Comm_rank(comm,&rank);CHKERRQ(ierr);
if (!rank) {
ibuf[0] = PetscBinaryRead(fd,data,num,count?&ibuf[1]:NULL,type);
}
ierr = MPI_Bcast(ibuf,2,MPIU_INT,0,comm);CHKERRQ(ierr);
ierr = (PetscErrorCode)ibuf[0];CHKERRQ(ierr);
ierr = PetscDataTypeToMPIDataType(type,&mtype);CHKERRQ(ierr);
ierr = MPI_Bcast(data,count?ibuf[1]:num,mtype,0,comm);CHKERRQ(ierr);
if (count) *count = ibuf[1];
if (type == PETSC_FUNCTION) {
#if defined(PETSC_SERIALIZE_FUNCTIONS)
ierr = PetscDLLibrarySym(PETSC_COMM_SELF,&PetscDLLibrariesLoaded,NULL,fname,(void**)fptr);CHKERRQ(ierr);
#else
*(void**)fptr = NULL;
#endif
free(fname);
}
PetscFunctionReturn(0);
}
/*@C
PetscBinarySynchronizedRead - Reads from a binary file.
Collective on MPI_Comm
Input Parameters:
+ comm - the MPI communicator
. 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
Options Database Key:
. -binary_longints - indicates the file was generated on a Cray vector
machine (not the T3E/D) and the ints are stored as 64 bit
quantities, otherwise they are stored as 32 bit
Level: developer
Notes:
Does a PetscBinaryRead() followed by an MPI_Bcast()
PetscBinarySynchronizedRead() uses byte swapping to work on all machines.
Integers are stored on the file as 32 long, regardless of whether
they are stored in the machine as 32 or 64, this means the same
binary file may be read on any machine.
Concepts: files^synchronized reading of binary files
Concepts: binary files^reading, synchronized
.seealso: PetscBinaryWrite(), PetscBinaryOpen(), PetscBinaryClose(), PetscBinaryRead(), PetscBinarySynchronizedWrite(),
PetscBinarySynchronizedSeek()
@*/
PetscErrorCode PetscBinarySynchronizedRead(MPI_Comm comm,int fd,void *p,PetscInt n,PetscDataType type)
{
PetscErrorCode ierr;
PetscMPIInt rank;
MPI_Datatype mtype;
char *fname;
PetscBool functionload = PETSC_FALSE;
void *ptmp = NULL;
PetscFunctionBegin;
if (type == PETSC_FUNCTION) {
functionload = PETSC_TRUE;
n = 64;
type = PETSC_CHAR;
ptmp = p;
/* warning memory leak */
fname = (char*)malloc(64*sizeof(char));
p = (void*)fname;
}
ierr = MPI_Comm_rank(comm,&rank);CHKERRQ(ierr);
if (!rank) {
ierr = PetscBinaryRead(fd,p,n,type);CHKERRQ(ierr);
}
ierr = PetscDataTypeToMPIDataType(type,&mtype);CHKERRQ(ierr);
ierr = MPI_Bcast(p,n,mtype,0,comm);CHKERRQ(ierr);
if (functionload) {
#if defined(PETSC_SERIALIZE_FUNCTIONS)
ierr = PetscDLLibrarySym(PETSC_COMM_SELF,&PetscDLLibrariesLoaded,NULL,fname,(void**)ptmp);CHKERRQ(ierr);
#else
*(void**)ptmp = NULL;
#endif
}
PetscFunctionReturn(0);
}
int main(int argc,char **args)
{
PetscErrorCode ierr;
PetscMPIInt size;
int fd;
PetscInt i,m = 10,sz;
PetscScalar *avec,*array;
Vec vec;
PetscViewer view_out,view_in;
PetscInitialize(&argc,&args,(char *)0,help);
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
if (size != 1) SETERRQ(PETSC_COMM_SELF,1,"This is a uniprocessor example only!");
ierr = PetscOptionsGetInt(PETSC_NULL,"-m",&m,PETSC_NULL);CHKERRQ(ierr);
/* ---------------------------------------------------------------------- */
/* PART 1: Write some data to a file in binary format */
/* ---------------------------------------------------------------------- */
/* Allocate array and set values */
ierr = PetscMalloc(m*sizeof(PetscScalar),&array);CHKERRQ(ierr);
for (i=0; i<m; i++) {
array[i] = i*10.0;
}
/* Open viewer for binary output */
ierr = PetscViewerBinaryOpen(PETSC_COMM_SELF,"input.dat",FILE_MODE_WRITE,&view_out);CHKERRQ(ierr);
ierr = PetscViewerBinaryGetDescriptor(view_out,&fd);CHKERRQ(ierr);
/* Write binary output */
ierr = PetscBinaryWrite(fd,&m,1,PETSC_INT,PETSC_FALSE);CHKERRQ(ierr);
ierr = PetscBinaryWrite(fd,array,m,PETSC_SCALAR,PETSC_FALSE);CHKERRQ(ierr);
/* Destroy the output viewer and work array */
ierr = PetscViewerDestroy(&view_out);CHKERRQ(ierr);
ierr = PetscFree(array);CHKERRQ(ierr);
/* ---------------------------------------------------------------------- */
/* PART 2: Read data from file and form a vector */
/* ---------------------------------------------------------------------- */
/* Open input binary viewer */
ierr = PetscViewerBinaryOpen(PETSC_COMM_SELF,"input.dat",FILE_MODE_READ,&view_in);CHKERRQ(ierr);
ierr = PetscViewerBinaryGetDescriptor(view_in,&fd);CHKERRQ(ierr);
/* Create vector and get pointer to data space */
ierr = VecCreate(PETSC_COMM_SELF,&vec);CHKERRQ(ierr);
ierr = VecSetSizes(vec,PETSC_DECIDE,m);CHKERRQ(ierr);
ierr = VecSetFromOptions(vec);CHKERRQ(ierr);
ierr = VecGetArray(vec,&avec);CHKERRQ(ierr);
/* Read data into vector */
ierr = PetscBinaryRead(fd,&sz,1,PETSC_INT);CHKERRQ(ierr);
if (sz <=0) SETERRQ(PETSC_COMM_SELF,1,"Error: Must have array length > 0");
ierr = PetscPrintf(PETSC_COMM_SELF,"reading data in binary from input.dat, sz =%D ...\n",sz);CHKERRQ(ierr);
ierr = PetscBinaryRead(fd,avec,sz,PETSC_SCALAR);CHKERRQ(ierr);
/* View vector */
ierr = VecRestoreArray(vec,&avec);CHKERRQ(ierr);
ierr = VecView(vec,PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);
/* Free data structures */
ierr = VecDestroy(&vec);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&view_in);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
PetscErrorCode VecLoad_Binary(Vec vec, PetscViewer viewer)
{
PetscMPIInt size,rank,tag;
int fd;
PetscInt i,rows = 0,n,*range,N,bs;
PetscErrorCode ierr;
PetscBool flag;
PetscScalar *avec,*avecwork;
MPI_Comm comm;
MPI_Request request;
MPI_Status status;
#if defined(PETSC_HAVE_MPIIO)
PetscBool useMPIIO;
#endif
PetscFunctionBegin;
ierr = PetscObjectGetComm((PetscObject)viewer,&comm);CHKERRQ(ierr);
ierr = MPI_Comm_rank(comm,&rank);CHKERRQ(ierr);
ierr = MPI_Comm_size(comm,&size);CHKERRQ(ierr);
ierr = PetscViewerBinaryGetDescriptor(viewer,&fd);CHKERRQ(ierr);
ierr = PetscViewerBinaryReadVecHeader_Private(viewer,&rows);CHKERRQ(ierr);
/* Set Vec sizes,blocksize,and type if not already set. Block size first so that local sizes will be compatible. */
ierr = PetscOptionsGetInt(((PetscObject)vec)->prefix, "-vecload_block_size", &bs, &flag);CHKERRQ(ierr);
if (flag) {
ierr = VecSetBlockSize(vec, bs);CHKERRQ(ierr);
}
if (vec->map->n < 0 && vec->map->N < 0) {
ierr = VecSetSizes(vec,PETSC_DECIDE,rows);CHKERRQ(ierr);
}
/* If sizes and type already set,check if the vector global size is correct */
ierr = VecGetSize(vec, &N);CHKERRQ(ierr);
if (N != rows) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_FILE_UNEXPECTED, "Vector in file different length (%d) then input vector (%d)", rows, N);
#if defined(PETSC_HAVE_MPIIO)
ierr = PetscViewerBinaryGetMPIIO(viewer,&useMPIIO);CHKERRQ(ierr);
if (useMPIIO) {
ierr = VecLoad_Binary_MPIIO(vec, viewer);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
#endif
ierr = VecGetLocalSize(vec,&n);CHKERRQ(ierr);
ierr = PetscObjectGetNewTag((PetscObject)viewer,&tag);CHKERRQ(ierr);
ierr = VecGetArray(vec,&avec);CHKERRQ(ierr);
if (!rank) {
ierr = PetscBinaryRead(fd,avec,n,PETSC_SCALAR);CHKERRQ(ierr);
if (size > 1) {
/* read in other chuncks and send to other processors */
/* determine maximum chunck owned by other */
range = vec->map->range;
n = 1;
for (i=1; i<size; i++) n = PetscMax(n,range[i+1] - range[i]);
ierr = PetscMalloc(n*sizeof(PetscScalar),&avecwork);CHKERRQ(ierr);
for (i=1; i<size; i++) {
n = range[i+1] - range[i];
ierr = PetscBinaryRead(fd,avecwork,n,PETSC_SCALAR);CHKERRQ(ierr);
ierr = MPI_Isend(avecwork,n,MPIU_SCALAR,i,tag,comm,&request);CHKERRQ(ierr);
ierr = MPI_Wait(&request,&status);CHKERRQ(ierr);
}
ierr = PetscFree(avecwork);CHKERRQ(ierr);
}
} else {
ierr = MPI_Recv(avec,n,MPIU_SCALAR,0,tag,comm,&status);CHKERRQ(ierr);
}
ierr = VecRestoreArray(vec,&avec);CHKERRQ(ierr);
ierr = VecAssemblyBegin(vec);CHKERRQ(ierr);
ierr = VecAssemblyEnd(vec);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode iniProfileData(PetscInt myId)
{
PetscMPIInt numProcessors;
PetscErrorCode ierr;
PetscInt ipro, ip;
PetscViewer fd;
PetscInt fp;
PetscTruth flg;
PetscInt avgprofiles, totalprofiles;
PetscInt dum;
useProfiles = PETSC_FALSE;
ierr = PetscOptionsHasName(PETSC_NULL,"-use_profiles",&useProfiles);CHKERRQ(ierr);
if (useProfiles) {
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&numProcessors);CHKERRQ(ierr);
/* Read in number of profiles per processor */
ierr = PetscMalloc(numProcessors*sizeof(PetscInt),&gNumProfiles);CHKERRQ(ierr);
/* ierr = PetscViewerBinaryOpen(PETSC_COMM_SELF,"numprofiles.bin",FILE_MODE_READ,&fd);CHKERRQ(ierr); */
/* ierr = PetscViewerBinaryGetDescriptor(fd,&fp);CHKERRQ(ierr); */
/* ierr = PetscBinaryRead(fp,gNumProfiles,numProcessors,PETSC_INT);CHKERRQ(ierr); */
/* ierr = PetscViewerDestroy(fd);CHKERRQ(ierr); */
/* ierr = PetscPrintf(PETSC_COMM_WORLD,"Done reading numprofiles.bin\n");CHKERRQ(ierr); */
/* Compute total number of profiles */
/* totalNumProfiles=0; */
/* for (ipro=1; ipro<=numProcessors; ipro++) { */
/* totalNumProfiles = totalNumProfiles + gNumProfiles[ipro-1]; */
/* } */
/* ierr=PetscPrintf(PETSC_COMM_WORLD,"totalNumProfiles = %d\n",totalNumProfiles);CHKERRQ(ierr); */
ierr = PetscMalloc(totalNumProfiles*sizeof(PetscInt),&gStartIndices);CHKERRQ(ierr);
ierr = PetscViewerBinaryOpen(PETSC_COMM_SELF,"gStartIndices.bin",FILE_MODE_READ,&fd);CHKERRQ(ierr);
ierr = PetscViewerBinaryGetDescriptor(fd,&fp);CHKERRQ(ierr);
ierr = PetscBinaryRead(fp,&totalNumProfiles,1,PETSC_INT);CHKERRQ(ierr);
if (totalNumProfiles<=0) SETERRQ(1,"Invalid total number of profiles! Must be >0");
/* Read in starting and ending global indices of profiles. NOTE: these have a base 1 index. */
ierr = PetscMalloc(totalNumProfiles*sizeof(PetscInt),&gStartIndices);CHKERRQ(ierr);
ierr = PetscBinaryRead(fp,gStartIndices,totalNumProfiles,PETSC_INT);CHKERRQ(ierr);
ierr = PetscViewerDestroy(fd);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Done reading gStartIndices.bin\n");CHKERRQ(ierr);
ierr = PetscMalloc(totalNumProfiles*sizeof(PetscInt),&gEndIndices);CHKERRQ(ierr);
ierr = PetscViewerBinaryOpen(PETSC_COMM_SELF,"gEndIndices.bin",FILE_MODE_READ,&fd);CHKERRQ(ierr);
ierr = PetscViewerBinaryGetDescriptor(fd,&fp);CHKERRQ(ierr);
ierr = PetscBinaryRead(fp,&dum,1,PETSC_INT);CHKERRQ(ierr);
if (dum != totalNumProfiles) SETERRQ(1,"Total number of profiles don't match!");
ierr = PetscBinaryRead(fp,gEndIndices,totalNumProfiles,PETSC_INT);CHKERRQ(ierr);
ierr = PetscViewerDestroy(fd);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Done reading gEndIndices.bin\n");CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Total number of profiles specified: %d\n",totalNumProfiles);CHKERRQ(ierr);
avgprofiles = floor(totalNumProfiles/numProcessors);
totalprofiles = 0;
for (ipro=1; ipro<=numProcessors; ipro++) {
gNumProfiles[ipro-1] = avgprofiles;
totalprofiles = totalprofiles + avgprofiles;
}
gNumProfiles[0] = gNumProfiles[0] + (totalNumProfiles - totalprofiles);
for (ipro=1; ipro<=numProcessors; ipro++) {
ierr=PetscPrintf(PETSC_COMM_WORLD,"Number of profiles on processor %d = %d\n",ipro-1,gNumProfiles[ipro-1]);CHKERRQ(ierr);
}
/* for (ip=1; ip<=totalNumProfiles; ip++) { */
/* gStartIndices[ip-1]=gStartIndices[ip-1]-1; */
/* gEndIndices[ip-1]=gEndIndices[ip-1]-1; */
/* ierr=PetscPrintf(PETSC_COMM_WORLD,"gStartIndices=%d, gEndIndices=%d\n",gStartIndices[ip-1],gEndIndices[ip-1]);CHKERRQ(ierr); */
/* } */
/* Compute total number of profiles upto (but not including) current processor */
/* NOTE: myId starts at 1 */
numPrevProfiles=0;
for (ipro=1; ipro<=myId-1; ipro++) {
numPrevProfiles = numPrevProfiles + gNumProfiles[ipro-1];
}
/* ierr=PetscPrintf(PETSC_COMM_WORLD,"myId = %d\n",myId);CHKERRQ(ierr); */
/* ierr=PetscPrintf(PETSC_COMM_WORLD,"nn = %d\n",nn);CHKERRQ(ierr); */
/* for (ipro=1; ipro<=myId; ipro++) { */
/* ierr=PetscPrintf(PETSC_COMM_WORLD,"ID=%d, gNumProfiles=%d\n",ipro,gNumProfiles[ipro-1]);CHKERRQ(ierr); */
/* } */
/* Compute starting and ending LOCAL indices of profiles on current processor. NOTE: These have a base 0 index. */
lNumProfiles = gNumProfiles[myId-1];
/* ierr=PetscPrintf(PETSC_COMM_WORLD,"lNumProfiles = %d\n",lNumProfiles);CHKERRQ(ierr); */
ierr = PetscMalloc(lNumProfiles*sizeof(PetscInt),&lStartIndices);CHKERRQ(ierr);
ierr = PetscMalloc(lNumProfiles*sizeof(PetscInt),&lEndIndices);CHKERRQ(ierr);
ierr = PetscMalloc(lNumProfiles*sizeof(PetscInt),&lProfileLength);CHKERRQ(ierr);
lSize=0; /* local size of vectors */
for (ip=1; ip<=lNumProfiles; ip++) {
lStartIndices[ip-1]=gStartIndices[numPrevProfiles+ip-1]-gStartIndices[numPrevProfiles+1-1];
lEndIndices[ip-1]=gEndIndices[numPrevProfiles+ip-1]-gStartIndices[numPrevProfiles+1-1];
lProfileLength[ip-1]=lEndIndices[ip-1]-lStartIndices[ip-1]+1;
/* ierr=PetscPrintf(PETSC_COMM_WORLD,"lStartIndices=%d, lEndIndices=%d, lProfileLength=%d\n",lStartIndices[ip-1],lEndIndices[ip-1],lProfileLength[ip-1]);CHKERRQ(ierr); */
lSize=lSize+lProfileLength[ip-1];
}
} /* useProfiles */
return 0;
}
void PETSC_STDCALL petscbinaryread_(int *fd,void*p,PetscInt *n,PetscDataType *type, int *__ierr ){
*__ierr = PetscBinaryRead(*fd,p,*n,*type);
}