PetscErrorCode DMRefineHierarchy_DA(DM da,PetscInt nlevels,DM daf[])
{
PetscErrorCode ierr;
PetscInt i,n,*refx,*refy,*refz;
PetscFunctionBegin;
PetscValidHeaderSpecific(da,DM_CLASSID,1);
if (nlevels < 0) SETERRQ(((PetscObject)da)->comm,PETSC_ERR_ARG_OUTOFRANGE,"nlevels cannot be negative");
if (nlevels == 0) PetscFunctionReturn(0);
PetscValidPointer(daf,3);
/* Get refinement factors, defaults taken from the coarse DMDA */
ierr = PetscMalloc3(nlevels,PetscInt,&refx,nlevels,PetscInt,&refy,nlevels,PetscInt,&refz);CHKERRQ(ierr);
for (i=0; i<nlevels; i++) {
ierr = DMDAGetRefinementFactor(da,&refx[i],&refy[i],&refz[i]);CHKERRQ(ierr);
}
n = nlevels;
ierr = PetscOptionsGetIntArray(((PetscObject)da)->prefix,"-da_refine_hierarchy_x",refx,&n,PETSC_NULL);CHKERRQ(ierr);
n = nlevels;
ierr = PetscOptionsGetIntArray(((PetscObject)da)->prefix,"-da_refine_hierarchy_y",refy,&n,PETSC_NULL);CHKERRQ(ierr);
n = nlevels;
ierr = PetscOptionsGetIntArray(((PetscObject)da)->prefix,"-da_refine_hierarchy_z",refz,&n,PETSC_NULL);CHKERRQ(ierr);
ierr = DMDASetRefinementFactor(da,refx[0],refy[0],refz[0]);CHKERRQ(ierr);
ierr = DMRefine(da,((PetscObject)da)->comm,&daf[0]);CHKERRQ(ierr);
for (i=1; i<nlevels; i++) {
ierr = DMDASetRefinementFactor(daf[i-1],refx[i],refy[i],refz[i]);CHKERRQ(ierr);
ierr = DMRefine(daf[i-1],((PetscObject)da)->comm,&daf[i]);CHKERRQ(ierr);
}
ierr = PetscFree3(refx,refy,refz);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
PetscBagRegisterIntArray - add an integer value to the bag
Logically Collective on PetscBag
Input Parameter:
+ bag - the bag of values
. addr - location of integer in struct
. msize - number of entries in array
. name - name of the integer array
- help - longer string with more information about the value
Level: beginner
.seealso: PetscBag, PetscBagSetName(), PetscBagView(), PetscBagLoad(), PetscBagGetData()
PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagRegisterEnum()
@*/
PetscErrorCode PetscBagRegisterIntArray(PetscBag bag,void *addr,PetscInt msize, const char *name, const char *help)
{
PetscErrorCode ierr;
PetscBagItem item;
char nname[PETSC_BAG_NAME_LENGTH+1];
PetscBool printhelp;
PetscInt i,tmp = msize;
PetscFunctionBegin;
/* ierr = PetscMemzero(addr,msize*sizeof(PetscInt));CHKERRQ(ierr);*/
nname[0] = '-';
nname[1] = 0;
ierr = PetscStrncat(nname,name,PETSC_BAG_NAME_LENGTH-1);CHKERRQ(ierr);
ierr = PetscOptionsHasName(NULL,"-help",&printhelp);CHKERRQ(ierr);
if (printhelp) {
ierr = (*PetscHelpPrintf)(bag->bagcomm," -%s%s <",bag->bagprefix ? bag->bagprefix : "",name);CHKERRQ(ierr);
for (i=0; i<msize; i++) {
ierr = (*PetscHelpPrintf)(bag->bagcomm,"%D ",*((PetscInt*)addr)+i);CHKERRQ(ierr);
}
ierr = (*PetscHelpPrintf)(bag->bagcomm,">: %s \n",help);CHKERRQ(ierr);
}
ierr = PetscOptionsGetIntArray(bag->bagprefix,nname,(PetscInt*)addr,&tmp,NULL);CHKERRQ(ierr);
ierr = PetscNew(&item);CHKERRQ(ierr);
item->dtype = PETSC_INT;
item->offset = ((char*)addr) - ((char*)bag);
if (item->offset > bag->bagsize) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Registered item %s %s is not in bag memory space",name,help);
item->next = 0;
item->msize = msize;
ierr = PetscBagRegister_Private(bag,item,name,help);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/* Precondition: blocksize is set to a meaningful value */
static PetscErrorCode SNESMultiblockSetFieldsRuntime_Private(SNES snes)
{
SNES_Multiblock *mb = (SNES_Multiblock *) snes->data;
PetscInt *ifields;
PetscInt i, nfields;
PetscBool flg = PETSC_TRUE;
char optionname[128], name[8];
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscMalloc(mb->bs * sizeof(PetscInt), &ifields);CHKERRQ(ierr);
for (i = 0; ; ++i) {
ierr = PetscSNPrintf(name, sizeof(name), "%D", i);CHKERRQ(ierr);
ierr = PetscSNPrintf(optionname, sizeof(optionname), "-snes_multiblock_%D_fields", i);CHKERRQ(ierr);
nfields = mb->bs;
ierr = PetscOptionsGetIntArray(((PetscObject) snes)->prefix, optionname, ifields, &nfields, &flg);CHKERRQ(ierr);
if (!flg) break;
if (!nfields) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_USER, "Cannot list zero fields");
ierr = SNESMultiblockSetFields(snes, name, nfields, ifields);CHKERRQ(ierr);
}
if (i > 0) {
/* Makes command-line setting of blocks take precedence over setting them in code.
Otherwise subsequent calls to SNESMultiblockSetIS() or SNESMultiblockSetFields() would
create new blocks, which would probably not be what the user wanted. */
mb->defined = PETSC_TRUE;
}
ierr = PetscFree(ifields);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode VecStashCreate_Private(MPI_Comm comm,PetscInt bs,VecStash *stash)
{
PetscErrorCode ierr;
PetscInt max,*opt,nopt;
PetscBool flg;
PetscFunctionBegin;
/* Require 2 tags, get the second using PetscCommGetNewTag() */
stash->comm = comm;
ierr = PetscCommGetNewTag(stash->comm,&stash->tag1);CHKERRQ(ierr);
ierr = PetscCommGetNewTag(stash->comm,&stash->tag2);CHKERRQ(ierr);
ierr = MPI_Comm_size(stash->comm,&stash->size);CHKERRQ(ierr);
ierr = MPI_Comm_rank(stash->comm,&stash->rank);CHKERRQ(ierr);
nopt = stash->size;
ierr = PetscMalloc1(nopt,&opt);CHKERRQ(ierr);
ierr = PetscOptionsGetIntArray(NULL,"-vecstash_initial_size",opt,&nopt,&flg);CHKERRQ(ierr);
if (flg) {
if (nopt == 1) max = opt[0];
else if (nopt == stash->size) max = opt[stash->rank];
else if (stash->rank < nopt) max = opt[stash->rank];
else max = 0; /* use default */
stash->umax = max;
} else {
stash->umax = 0;
}
ierr = PetscFree(opt);CHKERRQ(ierr);
if (bs <= 0) bs = 1;
stash->bs = bs;
stash->nmax = 0;
stash->oldnmax = 0;
stash->n = 0;
stash->reallocs = -1;
stash->idx = 0;
stash->array = 0;
stash->send_waits = 0;
stash->recv_waits = 0;
stash->send_status = 0;
stash->nsends = 0;
stash->nrecvs = 0;
stash->svalues = 0;
stash->rvalues = 0;
stash->rmax = 0;
stash->nprocs = 0;
stash->nprocessed = 0;
stash->donotstash = PETSC_FALSE;
stash->ignorenegidx = PETSC_FALSE;
PetscFunctionReturn(0);
}
PETSC_EXTERN PetscErrorCode PetscDrawCreate_Image(PetscDraw draw)
{
PetscImage img;
int w = draw->w, h = draw->h;
PetscInt size[2], nsize = 2;
PetscBool set;
PetscErrorCode ierr;
PetscFunctionBegin;
draw->pause = 0;
draw->coor_xl = 0; draw->coor_xr = 1;
draw->coor_yl = 0; draw->coor_yr = 1;
draw->port_xl = 0; draw->port_xr = 1;
draw->port_yl = 0; draw->port_yr = 1;
size[0] = w; if (size[0] < 1) size[0] = 300;
size[1] = h; if (size[1] < 1) size[1] = size[0];
ierr = PetscOptionsGetIntArray(((PetscObject)draw)->options,((PetscObject)draw)->prefix,"-draw_size",size,&nsize,&set);CHKERRQ(ierr);
if (set && nsize == 1) size[1] = size[0];
if (size[0] < 1) size[0] = 300;
if (size[1] < 1) size[1] = size[0];
draw->w = w = size[0]; draw->x = 0;
draw->h = h = size[1]; draw->x = 0;
ierr = PetscNewLog(draw,&img);CHKERRQ(ierr);
ierr = PetscMemcpy(draw->ops,&DvOps,sizeof(DvOps));CHKERRQ(ierr);
draw->data = (void*)img;
img->w = w; img->h = h;
ierr = PetscCalloc1((size_t)(img->w*img->h),&img->buffer);CHKERRQ(ierr);
PetscImageSetClip(img,0,0,img->w,img->h);
{
int i,k,ncolors = 256-PETSC_DRAW_BASIC_COLORS;
unsigned char R[256-PETSC_DRAW_BASIC_COLORS];
unsigned char G[256-PETSC_DRAW_BASIC_COLORS];
unsigned char B[256-PETSC_DRAW_BASIC_COLORS];
ierr = PetscDrawUtilitySetCmap(NULL,ncolors,R,G,B);CHKERRQ(ierr);
for (k=0; k<PETSC_DRAW_BASIC_COLORS; k++) {
img->palette[k][0] = BasicColors[k][0];
img->palette[k][1] = BasicColors[k][1];
img->palette[k][2] = BasicColors[k][2];
}
for (i=0; i<ncolors; i++, k++) {
img->palette[k][0] = R[i];
img->palette[k][1] = G[i];
img->palette[k][2] = B[i];
}
}
if (!draw->savefilename) {ierr = PetscDrawSetSave(draw,draw->title);CHKERRQ(ierr);}
PetscFunctionReturn(0);
}
PetscErrorCode MatStashCreate_Private(MPI_Comm comm,PetscInt bs,MatStash *stash)
{
PetscErrorCode ierr;
PetscInt max,*opt,nopt,i;
PetscTruth flg;
PetscFunctionBegin;
/* Require 2 tags,get the second using PetscCommGetNewTag() */
stash->comm = comm;
ierr = PetscCommGetNewTag(stash->comm,&stash->tag1);CHKERRQ(ierr);
ierr = PetscCommGetNewTag(stash->comm,&stash->tag2);CHKERRQ(ierr);
ierr = MPI_Comm_size(stash->comm,&stash->size);CHKERRQ(ierr);
ierr = MPI_Comm_rank(stash->comm,&stash->rank);CHKERRQ(ierr);
ierr = PetscMalloc(2*stash->size*sizeof(PetscMPIInt),&stash->flg_v);CHKERRQ(ierr);
for (i=0; i<2*stash->size; i++) stash->flg_v[i] = -1;
nopt = stash->size;
ierr = PetscMalloc(nopt*sizeof(PetscInt),&opt);CHKERRQ(ierr);
ierr = PetscOptionsGetIntArray(PETSC_NULL,"-matstash_initial_size",opt,&nopt,&flg);CHKERRQ(ierr);
if (flg) {
if (nopt == 1) max = opt[0];
else if (nopt == stash->size) max = opt[stash->rank];
else if (stash->rank < nopt) max = opt[stash->rank];
else max = 0; /* Use default */
stash->umax = max;
} else {
stash->umax = 0;
}
ierr = PetscFree(opt);CHKERRQ(ierr);
if (bs <= 0) bs = 1;
stash->bs = bs;
stash->nmax = 0;
stash->oldnmax = 0;
stash->n = 0;
stash->reallocs = -1;
stash->space_head = 0;
stash->space = 0;
stash->send_waits = 0;
stash->recv_waits = 0;
stash->send_status = 0;
stash->nsends = 0;
stash->nrecvs = 0;
stash->svalues = 0;
stash->rvalues = 0;
stash->rindices = 0;
stash->nprocessed = 0;
PetscFunctionReturn(0);
}
PetscErrorCode FluidFieldCreate(MPI_Comm comm, FluidField *fluid)
{
FluidField f;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscNew(struct _FluidField, &f); CHKERRQ(ierr);
// Default values
f->comm = comm;
f->mu = 1e-3; // pN s / um^2
ierr = PetscOptionsGetReal(0,"-fluid_viscosity",&f->mu,0); CHKERRQ(ierr);
int nmax = 3;
f->lens.x = 7;
f->lens.y = 7;
f->lens.z = 0;
ierr = PetscOptionsGetRealArray(0,"-fluid_lens", &f->lens.x, &nmax, 0); CHKERRQ(ierr);
f->is3D = (nmax == 3);
PetscReal dx = 1;
ierr = PetscOptionsGetReal(0,"-fluid_dx",&dx,0); CHKERRQ(ierr);
f->dh.x = dx;
f->dh.y = dx;
f->dh.z = dx;
nmax = 3;
f->dims.x = f->lens.x / f->dh.x;
f->dims.y = f->lens.y / f->dh.y;
f->dims.z = f->lens.z / f->dh.z;
ierr = PetscOptionsGetIntArray(0,"-fluid_dims", &f->dims.x, &nmax, 0); CHKERRQ(ierr);
if( !f->is3D ) {
f->lens.z = 0;
f->dims.z = 0;
f->dh.z = 0;
}
// Create BC index set
ierr = ArrayCreate("dirichletBC",sizeof(MatStencil),&f->dirichletBC); CHKERRQ(ierr);
ierr = FluidFieldRegisterEvents(); CHKERRQ(ierr);
*fluid = f;
PetscFunctionReturn(0);
}
PetscErrorCode DMDASelectFields(DM da,PetscInt *outfields,PetscInt **fields)
{
PetscErrorCode ierr;
PetscInt step,ndisplayfields,*displayfields,k,j;
PetscBool flg;
PetscFunctionBegin;
ierr = DMDAGetInfo(da,0,0,0,0,0,0,0,&step,0,0,0,0,0);CHKERRQ(ierr);
ierr = PetscMalloc1(step,&displayfields);CHKERRQ(ierr);
for (k=0; k<step; k++) displayfields[k] = k;
ndisplayfields = step;
ierr = PetscOptionsGetIntArray(NULL,"-draw_fields",displayfields,&ndisplayfields,&flg);CHKERRQ(ierr);
if (!ndisplayfields) ndisplayfields = step;
if (!flg) {
char **fields;
const char *fieldname;
PetscInt nfields = step;
ierr = PetscMalloc1(step,&fields);CHKERRQ(ierr);
ierr = PetscOptionsGetStringArray(NULL,"-draw_fields_by_name",fields,&nfields,&flg);CHKERRQ(ierr);
if (flg) {
ndisplayfields = 0;
for (k=0; k<nfields;k++) {
for (j=0; j<step; j++) {
ierr = DMDAGetFieldName(da,j,&fieldname);CHKERRQ(ierr);
ierr = PetscStrcmp(fieldname,fields[k],&flg);CHKERRQ(ierr);
if (flg) {
goto found;
}
}
SETERRQ1(PetscObjectComm((PetscObject)da),PETSC_ERR_USER,"Unknown fieldname %s",fields[k]);
found: displayfields[ndisplayfields++] = j;
}
}
for (k=0; k<nfields; k++) {
ierr = PetscFree(fields[k]);CHKERRQ(ierr);
}
ierr = PetscFree(fields);CHKERRQ(ierr);
}
*fields = displayfields;
*outfields = ndisplayfields;
PetscFunctionReturn(0);
}
PetscErrorCode iniStepTimer( const char pre[], PetscInt Iter0, StepTimer *thetimer )
{
PetscErrorCode ierr;
PetscBool flg;
PetscInt it;
PetscInt tmparr[MAX_NUM_INTERVALS];
/* read time step data */
thetimer->startTimeStep = Iter0 + 1; /* by default we start at first time step */
ierr = PetscOptionsGetInt(pre,"-start_time_step",&thetimer->startTimeStep,&flg);CHKERRQ(ierr);
thetimer->maxNumIntervals=MAX_NUM_INTERVALS;
ierr = PetscOptionsGetIntArray(pre,"-time_steps",tmparr,&thetimer->maxNumIntervals,&flg);CHKERRQ(ierr);
if (!flg) SETERRQ1(PETSC_COMM_WORLD,1,"Must indicate number of step timer time steps with the -%stime_step flag",pre);
if (thetimer->maxNumIntervals==1) {
thetimer->fixedStep=PETSC_TRUE;
thetimer->currInterval=0; /* Not used but we set it anyway to be safe */
thetimer->numTimeSteps=tmparr[0];
ierr = PetscPrintf(PETSC_COMM_WORLD,"Fixed interval of %d specified for StepTimer object %s\n", thetimer->numTimeSteps, pre);CHKERRQ(ierr);
} else {
thetimer->fixedStep=PETSC_FALSE;
PetscMalloc(thetimer->maxNumIntervals*sizeof(PetscInt), &thetimer->timeIntervals);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Variable number of intervals specified for StepTimer object %s\n", pre);CHKERRQ(ierr);
for (it=0; it<thetimer->maxNumIntervals; it++) {
thetimer->timeIntervals[it] = tmparr[it];
ierr = PetscPrintf(PETSC_COMM_WORLD," Interval #%d=%d\n", it+1,thetimer->timeIntervals[it]);CHKERRQ(ierr);
}
thetimer->currInterval=0;
thetimer->numTimeSteps=thetimer->timeIntervals[thetimer->currInterval];
}
thetimer->count=0;
return 0;
}
PetscErrorCode PetscViewerMathematicaSetFromOptions(PetscViewer v)
{
PetscViewer_Mathematica *vmath = (PetscViewer_Mathematica*) v->data;
char linkname[256];
char modename[256];
char hostname[256];
char type[256];
PetscInt numPorts;
PetscInt *ports;
PetscInt numHosts;
int h;
char **hosts;
PetscMPIInt size, rank;
PetscBool opt;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = MPI_Comm_size(PetscObjectComm((PetscObject)v), &size);
CHKERRQ(ierr);
ierr = MPI_Comm_rank(PetscObjectComm((PetscObject)v), &rank);
CHKERRQ(ierr);
/* Get link name */
ierr = PetscOptionsGetString("viewer_", "-math_linkname", linkname, 256, &opt);
CHKERRQ(ierr);
if (opt) {
ierr = PetscViewerMathematicaSetLinkName(v, linkname);
CHKERRQ(ierr);
}
/* Get link port */
numPorts = size;
ierr = PetscMalloc1(size, &ports);
CHKERRQ(ierr);
ierr = PetscOptionsGetIntArray("viewer_", "-math_linkport", ports, &numPorts, &opt);
CHKERRQ(ierr);
if (opt) {
if (numPorts > rank) snprintf(linkname, 255, "%6d", ports[rank]);
else snprintf(linkname, 255, "%6d", ports[0]);
ierr = PetscViewerMathematicaSetLinkName(v, linkname);
CHKERRQ(ierr);
}
ierr = PetscFree(ports);
CHKERRQ(ierr);
/* Get link host */
numHosts = size;
ierr = PetscMalloc1(size, &hosts);
CHKERRQ(ierr);
ierr = PetscOptionsGetStringArray("viewer_", "-math_linkhost", hosts, &numHosts, &opt);
CHKERRQ(ierr);
if (opt) {
if (numHosts > rank) {
ierr = PetscStrncpy(hostname, hosts[rank], 255);
CHKERRQ(ierr);
} else {
ierr = PetscStrncpy(hostname, hosts[0], 255);
CHKERRQ(ierr);
}
ierr = PetscViewerMathematicaSetLinkHost(v, hostname);
CHKERRQ(ierr);
}
for (h = 0; h < numHosts; h++) {
ierr = PetscFree(hosts[h]);
CHKERRQ(ierr);
}
ierr = PetscFree(hosts);
CHKERRQ(ierr);
/* Get link mode */
ierr = PetscOptionsGetString("viewer_", "-math_linkmode", modename, 256, &opt);
CHKERRQ(ierr);
if (opt) {
LinkMode mode;
ierr = PetscViewerMathematicaParseLinkMode_Private(modename, &mode);
CHKERRQ(ierr);
ierr = PetscViewerMathematicaSetLinkMode(v, mode);
CHKERRQ(ierr);
}
/* Get graphics type */
ierr = PetscOptionsGetString("viewer_", "-math_graphics", type, 256, &opt);
CHKERRQ(ierr);
if (opt) {
PetscBool isMotif, isPS, isPSFile;
ierr = PetscStrcasecmp(type, "Motif", &isMotif);
CHKERRQ(ierr);
ierr = PetscStrcasecmp(type, "PS", &isPS);
CHKERRQ(ierr);
ierr = PetscStrcasecmp(type, "PSFile", &isPSFile);
CHKERRQ(ierr);
if (isMotif) vmath->graphicsType = GRAPHICS_MOTIF;
else if (isPS) vmath->graphicsType = GRAPHICS_PS_STDOUT;
else if (isPSFile) vmath->graphicsType = GRAPHICS_PS_FILE;
}
/* Get plot type */
ierr = PetscOptionsGetString("viewer_", "-math_type", type, 256, &opt);
CHKERRQ(ierr);
if (opt) {
PetscBool isTri, isVecTri, isVec, isSurface;
ierr = PetscStrcasecmp(type, "Triangulation", &isTri);
CHKERRQ(ierr);
ierr = PetscStrcasecmp(type, "VectorTriangulation", &isVecTri);
CHKERRQ(ierr);
ierr = PetscStrcasecmp(type, "Vector", &isVec);
CHKERRQ(ierr);
ierr = PetscStrcasecmp(type, "Surface", &isSurface);
CHKERRQ(ierr);
if (isTri) vmath->plotType = MATHEMATICA_TRIANGULATION_PLOT;
else if (isVecTri) vmath->plotType = MATHEMATICA_VECTOR_TRIANGULATION_PLOT;
else if (isVec) vmath->plotType = MATHEMATICA_VECTOR_PLOT;
else if (isSurface) vmath->plotType = MATHEMATICA_SURFACE_PLOT;
}
PetscFunctionReturn(0);
}
/*
MatStashCreate_Private - Creates a stash,currently used for all the parallel
matrix implementations. The stash is where elements of a matrix destined
to be stored on other processors are kept until matrix assembly is done.
This is a simple minded stash. Simply adds entries to end of stash.
Input Parameters:
comm - communicator, required for scatters.
bs - stash block size. used when stashing blocks of values
Output Parameters:
stash - the newly created stash
*/
PetscErrorCode MatStashCreate_Private(MPI_Comm comm,PetscInt bs,MatStash *stash)
{
PetscErrorCode ierr;
PetscInt max,*opt,nopt,i;
PetscBool flg;
PetscFunctionBegin;
/* Require 2 tags,get the second using PetscCommGetNewTag() */
stash->comm = comm;
ierr = PetscCommGetNewTag(stash->comm,&stash->tag1);CHKERRQ(ierr);
ierr = PetscCommGetNewTag(stash->comm,&stash->tag2);CHKERRQ(ierr);
ierr = MPI_Comm_size(stash->comm,&stash->size);CHKERRQ(ierr);
ierr = MPI_Comm_rank(stash->comm,&stash->rank);CHKERRQ(ierr);
ierr = PetscMalloc1(2*stash->size,&stash->flg_v);CHKERRQ(ierr);
for (i=0; i<2*stash->size; i++) stash->flg_v[i] = -1;
nopt = stash->size;
ierr = PetscMalloc1(nopt,&opt);CHKERRQ(ierr);
ierr = PetscOptionsGetIntArray(NULL,NULL,"-matstash_initial_size",opt,&nopt,&flg);CHKERRQ(ierr);
if (flg) {
if (nopt == 1) max = opt[0];
else if (nopt == stash->size) max = opt[stash->rank];
else if (stash->rank < nopt) max = opt[stash->rank];
else max = 0; /* Use default */
stash->umax = max;
} else {
stash->umax = 0;
}
ierr = PetscFree(opt);CHKERRQ(ierr);
if (bs <= 0) bs = 1;
stash->bs = bs;
stash->nmax = 0;
stash->oldnmax = 0;
stash->n = 0;
stash->reallocs = -1;
stash->space_head = 0;
stash->space = 0;
stash->send_waits = 0;
stash->recv_waits = 0;
stash->send_status = 0;
stash->nsends = 0;
stash->nrecvs = 0;
stash->svalues = 0;
stash->rvalues = 0;
stash->rindices = 0;
stash->nprocessed = 0;
stash->reproduce = PETSC_FALSE;
stash->blocktype = MPI_DATATYPE_NULL;
ierr = PetscOptionsGetBool(NULL,NULL,"-matstash_reproduce",&stash->reproduce,NULL);CHKERRQ(ierr);
#if !defined(PETSC_HAVE_MPIUNI)
ierr = PetscOptionsGetBool(NULL,NULL,"-matstash_legacy",&flg,NULL);CHKERRQ(ierr);
if (!flg) {
stash->ScatterBegin = MatStashScatterBegin_BTS;
stash->ScatterGetMesg = MatStashScatterGetMesg_BTS;
stash->ScatterEnd = MatStashScatterEnd_BTS;
stash->ScatterDestroy = MatStashScatterDestroy_BTS;
} else {
#endif
stash->ScatterBegin = MatStashScatterBegin_Ref;
stash->ScatterGetMesg = MatStashScatterGetMesg_Ref;
stash->ScatterEnd = MatStashScatterEnd_Ref;
stash->ScatterDestroy = NULL;
#if !defined(PETSC_HAVE_MPIUNI)
}
#endif
PetscFunctionReturn(0);
}
PetscErrorCode DMSetFromOptions_DA(DM da)
{
PetscErrorCode ierr;
DM_DA *dd = (DM_DA*)da->data;
PetscInt refine = 0,maxnlevels = 100,*refx,*refy,*refz,n,i;
PetscBool negativeMNP = PETSC_FALSE,bM = PETSC_FALSE,bN = PETSC_FALSE, bP = PETSC_FALSE;
PetscFunctionBegin;
PetscValidHeaderSpecific(da,DM_CLASSID,1);
if (dd->M < 0) {
dd->M = -dd->M;
bM = PETSC_TRUE;
negativeMNP = PETSC_TRUE;
}
if (dd->dim > 1 && dd->N < 0) {
dd->N = -dd->N;
bN = PETSC_TRUE;
negativeMNP = PETSC_TRUE;
}
if (dd->dim > 2 && dd->P < 0) {
dd->P = -dd->P;
bP = PETSC_TRUE;
negativeMNP = PETSC_TRUE;
}
ierr = PetscOptionsHead("DMDA Options");CHKERRQ(ierr);
if (bM) {ierr = PetscOptionsInt("-da_grid_x","Number of grid points in x direction","DMDASetSizes",dd->M,&dd->M,PETSC_NULL);CHKERRQ(ierr);}
if (bN) {ierr = PetscOptionsInt("-da_grid_y","Number of grid points in y direction","DMDASetSizes",dd->N,&dd->N,PETSC_NULL);CHKERRQ(ierr);}
if (bP) {ierr = PetscOptionsInt("-da_grid_z","Number of grid points in z direction","DMDASetSizes",dd->P,&dd->P,PETSC_NULL);CHKERRQ(ierr);}
/* Handle DMDA parallel distibution */
ierr = PetscOptionsInt("-da_processors_x","Number of processors in x direction","DMDASetNumProcs",dd->m,&dd->m,PETSC_NULL);CHKERRQ(ierr);
if (dd->dim > 1) {ierr = PetscOptionsInt("-da_processors_y","Number of processors in y direction","DMDASetNumProcs",dd->n,&dd->n,PETSC_NULL);CHKERRQ(ierr);}
if (dd->dim > 2) {ierr = PetscOptionsInt("-da_processors_z","Number of processors in z direction","DMDASetNumProcs",dd->p,&dd->p,PETSC_NULL);CHKERRQ(ierr);}
/* Handle DMDA refinement */
ierr = PetscOptionsInt("-da_refine_x","Refinement ratio in x direction","DMDASetRefinementFactor",dd->refine_x,&dd->refine_x,PETSC_NULL);CHKERRQ(ierr);
if (dd->dim > 1) {ierr = PetscOptionsInt("-da_refine_y","Refinement ratio in y direction","DMDASetRefinementFactor",dd->refine_y,&dd->refine_y,PETSC_NULL);CHKERRQ(ierr);}
if (dd->dim > 2) {ierr = PetscOptionsInt("-da_refine_z","Refinement ratio in z direction","DMDASetRefinementFactor",dd->refine_z,&dd->refine_z,PETSC_NULL);CHKERRQ(ierr);}
dd->coarsen_x = dd->refine_x; dd->coarsen_y = dd->refine_y; dd->coarsen_z = dd->refine_z;
/* Get refinement factors, defaults taken from the coarse DMDA */
ierr = PetscMalloc3(maxnlevels,PetscInt,&refx,maxnlevels,PetscInt,&refy,maxnlevels,PetscInt,&refz);CHKERRQ(ierr);
ierr = DMDAGetRefinementFactor(da,&refx[0],&refy[0],&refz[0]);CHKERRQ(ierr);
for (i=1; i<maxnlevels; i++) {
refx[i] = refx[0];
refy[i] = refy[0];
refz[i] = refz[0];
}
n = maxnlevels;
ierr = PetscOptionsGetIntArray(((PetscObject)da)->prefix,"-da_refine_hierarchy_x",refx,&n,PETSC_NULL);CHKERRQ(ierr);
if (da->levelup - da->leveldown >= 0) dd->refine_x = refx[da->levelup - da->leveldown];
if (da->levelup - da->leveldown >= 1) dd->coarsen_x = refx[da->levelup - da->leveldown - 1];
if (dd->dim > 1) {
n = maxnlevels;
ierr = PetscOptionsGetIntArray(((PetscObject)da)->prefix,"-da_refine_hierarchy_y",refy,&n,PETSC_NULL);CHKERRQ(ierr);
if (da->levelup - da->leveldown >= 0) dd->refine_y = refy[da->levelup - da->leveldown];
if (da->levelup - da->leveldown >= 1) dd->coarsen_y = refy[da->levelup - da->leveldown - 1];
}
if (dd->dim > 2) {
n = maxnlevels;
ierr = PetscOptionsGetIntArray(((PetscObject)da)->prefix,"-da_refine_hierarchy_z",refz,&n,PETSC_NULL);CHKERRQ(ierr);
if (da->levelup - da->leveldown >= 0) dd->refine_z = refz[da->levelup - da->leveldown];
if (da->levelup - da->leveldown >= 1) dd->coarsen_z = refz[da->levelup - da->leveldown - 1];
}
if (negativeMNP) {ierr = PetscOptionsInt("-da_refine","Uniformly refine DA one or more times","None",refine,&refine,PETSC_NULL);CHKERRQ(ierr);}
ierr = PetscOptionsTail();CHKERRQ(ierr);
while (refine--) {
if (dd->bx == DMDA_BOUNDARY_PERIODIC || dd->interptype == DMDA_Q0){
dd->M = dd->refine_x*dd->M;
} else {
dd->M = 1 + dd->refine_x*(dd->M - 1);
}
if (dd->by == DMDA_BOUNDARY_PERIODIC || dd->interptype == DMDA_Q0){
dd->N = dd->refine_y*dd->N;
} else {
dd->N = 1 + dd->refine_y*(dd->N - 1);
}
if (dd->bz == DMDA_BOUNDARY_PERIODIC || dd->interptype == DMDA_Q0){
dd->P = dd->refine_z*dd->P;
} else {
dd->P = 1 + dd->refine_z*(dd->P - 1);
}
da->levelup++;
if (da->levelup - da->leveldown >= 0) {
dd->refine_x = refx[da->levelup - da->leveldown];
dd->refine_y = refy[da->levelup - da->leveldown];
dd->refine_z = refz[da->levelup - da->leveldown];
}
if (da->levelup - da->leveldown >= 1) {
dd->coarsen_x = refx[da->levelup - da->leveldown - 1];
dd->coarsen_y = refy[da->levelup - da->leveldown - 1];
dd->coarsen_z = refz[da->levelup - da->leveldown - 1];
}
}
ierr = PetscFree3(refx,refy,refz);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode VecView_MPI_Draw_DA1d(Vec xin,PetscViewer v)
{
DM da;
PetscErrorCode ierr;
PetscMPIInt rank,size,tag1,tag2;
PetscInt i,n,N,step,istart,isize,j,nbounds;
MPI_Status status;
PetscReal coors[4],ymin,ymax,min,max,xmin,xmax,tmp,xgtmp;
const PetscScalar *array,*xg;
PetscDraw draw;
PetscBool isnull,showpoints = PETSC_FALSE;
MPI_Comm comm;
PetscDrawAxis axis;
Vec xcoor;
DMDABoundaryType bx;
const PetscReal *bounds;
PetscInt *displayfields;
PetscInt k,ndisplayfields;
PetscBool flg,hold;
PetscFunctionBegin;
ierr = PetscViewerDrawGetDraw(v,0,&draw);CHKERRQ(ierr);
ierr = PetscDrawIsNull(draw,&isnull);CHKERRQ(ierr); if (isnull) PetscFunctionReturn(0);
ierr = PetscViewerDrawGetBounds(v,&nbounds,&bounds);CHKERRQ(ierr);
ierr = PetscObjectQuery((PetscObject)xin,"DM",(PetscObject*)&da);CHKERRQ(ierr);
if (!da) SETERRQ(((PetscObject)xin)->comm,PETSC_ERR_ARG_WRONG,"Vector not generated from a DMDA");
ierr = PetscOptionsGetBool(PETSC_NULL,"-draw_vec_mark_points",&showpoints,PETSC_NULL);CHKERRQ(ierr);
ierr = DMDAGetInfo(da,0,&N,0,0,0,0,0,&step,0,&bx,0,0,0);CHKERRQ(ierr);
ierr = DMDAGetCorners(da,&istart,0,0,&isize,0,0);CHKERRQ(ierr);
ierr = VecGetArrayRead(xin,&array);CHKERRQ(ierr);
ierr = VecGetLocalSize(xin,&n);CHKERRQ(ierr);
n = n/step;
/* get coordinates of nodes */
ierr = DMDAGetCoordinates(da,&xcoor);CHKERRQ(ierr);
if (!xcoor) {
ierr = DMDASetUniformCoordinates(da,0.0,1.0,0.0,0.0,0.0,0.0);CHKERRQ(ierr);
ierr = DMDAGetCoordinates(da,&xcoor);CHKERRQ(ierr);
}
ierr = VecGetArrayRead(xcoor,&xg);CHKERRQ(ierr);
ierr = PetscObjectGetComm((PetscObject)xin,&comm);CHKERRQ(ierr);
ierr = MPI_Comm_size(comm,&size);CHKERRQ(ierr);
ierr = MPI_Comm_rank(comm,&rank);CHKERRQ(ierr);
/*
Determine the min and max x coordinate in plot
*/
if (!rank) {
xmin = PetscRealPart(xg[0]);
}
if (rank == size-1) {
xmax = PetscRealPart(xg[n-1]);
}
ierr = MPI_Bcast(&xmin,1,MPIU_REAL,0,comm);CHKERRQ(ierr);
ierr = MPI_Bcast(&xmax,1,MPIU_REAL,size-1,comm);CHKERRQ(ierr);
ierr = PetscMalloc(step*sizeof(PetscInt),&displayfields);CHKERRQ(ierr);
for (i=0; i<step; i++) displayfields[i] = i;
ndisplayfields = step;
ierr = PetscOptionsGetIntArray(PETSC_NULL,"-draw_fields",displayfields,&ndisplayfields,&flg);CHKERRQ(ierr);
if (!flg) ndisplayfields = step;
for (k=0; k<ndisplayfields; k++) {
j = displayfields[k];
ierr = PetscViewerDrawGetDraw(v,k,&draw);CHKERRQ(ierr);
ierr = PetscDrawCheckResizedWindow(draw);CHKERRQ(ierr);
/*
Determine the min and max y coordinate in plot
*/
min = 1.e20; max = -1.e20;
for (i=0; i<n; i++) {
if (PetscRealPart(array[j+i*step]) < min) min = PetscRealPart(array[j+i*step]);
if (PetscRealPart(array[j+i*step]) > max) max = PetscRealPart(array[j+i*step]);
}
if (min + 1.e-10 > max) {
min -= 1.e-5;
max += 1.e-5;
}
if (j < nbounds) {
min = PetscMin(min,bounds[2*j]);
max = PetscMax(max,bounds[2*j+1]);
}
ierr = MPI_Reduce(&min,&ymin,1,MPIU_REAL,MPIU_MIN,0,comm);CHKERRQ(ierr);
ierr = MPI_Reduce(&max,&ymax,1,MPIU_REAL,MPIU_MAX,0,comm);CHKERRQ(ierr);
ierr = PetscViewerDrawGetHold(v,&hold);CHKERRQ(ierr);
if (!hold) {
ierr = PetscDrawSynchronizedClear(draw);CHKERRQ(ierr);
}
ierr = PetscViewerDrawGetDrawAxis(v,k,&axis);CHKERRQ(ierr);
ierr = PetscLogObjectParent(draw,axis);CHKERRQ(ierr);
if (!rank) {
const char *title;
ierr = PetscDrawAxisSetLimits(axis,xmin,xmax,ymin,ymax);CHKERRQ(ierr);
ierr = PetscDrawAxisDraw(axis);CHKERRQ(ierr);
ierr = PetscDrawGetCoordinates(draw,coors,coors+1,coors+2,coors+3);CHKERRQ(ierr);
ierr = DMDAGetFieldName(da,j,&title);CHKERRQ(ierr);
if (title) {ierr = PetscDrawSetTitle(draw,title);CHKERRQ(ierr);}
}
ierr = MPI_Bcast(coors,4,MPIU_REAL,0,comm);CHKERRQ(ierr);
if (rank) {
ierr = PetscDrawSetCoordinates(draw,coors[0],coors[1],coors[2],coors[3]);CHKERRQ(ierr);
}
/* draw local part of vector */
ierr = PetscObjectGetNewTag((PetscObject)xin,&tag1);CHKERRQ(ierr);
ierr = PetscObjectGetNewTag((PetscObject)xin,&tag2);CHKERRQ(ierr);
if (rank < size-1) { /*send value to right */
ierr = MPI_Send((void*)&array[j+(n-1)*step],1,MPIU_REAL,rank+1,tag1,comm);CHKERRQ(ierr);
ierr = MPI_Send((void*)&xg[n-1],1,MPIU_REAL,rank+1,tag1,comm);CHKERRQ(ierr);
}
if (!rank && bx == DMDA_BOUNDARY_PERIODIC && size > 1) { /* first processor sends first value to last */
ierr = MPI_Send((void*)&array[j],1,MPIU_REAL,size-1,tag2,comm);CHKERRQ(ierr);
}
for (i=1; i<n; i++) {
ierr = PetscDrawLine(draw,PetscRealPart(xg[i-1]),PetscRealPart(array[j+step*(i-1)]),PetscRealPart(xg[i]),PetscRealPart(array[j+step*i]),PETSC_DRAW_RED);CHKERRQ(ierr);
if (showpoints) {
ierr = PetscDrawPoint(draw,PetscRealPart(xg[i-1]),PetscRealPart(array[j+step*(i-1)]),PETSC_DRAW_BLACK);CHKERRQ(ierr);
}
}
if (rank) { /* receive value from left */
ierr = MPI_Recv(&tmp,1,MPIU_REAL,rank-1,tag1,comm,&status);CHKERRQ(ierr);
ierr = MPI_Recv(&xgtmp,1,MPIU_REAL,rank-1,tag1,comm,&status);CHKERRQ(ierr);
ierr = PetscDrawLine(draw,xgtmp,tmp,PetscRealPart(xg[0]),PetscRealPart(array[j]),PETSC_DRAW_RED);CHKERRQ(ierr);
if (showpoints) {
ierr = PetscDrawPoint(draw,xgtmp,tmp,PETSC_DRAW_BLACK);CHKERRQ(ierr);
}
}
if (rank == size-1 && bx == DMDA_BOUNDARY_PERIODIC && size > 1) {
ierr = MPI_Recv(&tmp,1,MPIU_REAL,0,tag2,comm,&status);CHKERRQ(ierr);
ierr = PetscDrawLine(draw,PetscRealPart(xg[n-2]),PetscRealPart(array[j+step*(n-1)]),PetscRealPart(xg[n-1]),tmp,PETSC_DRAW_RED);CHKERRQ(ierr);
if (showpoints) {
ierr = PetscDrawPoint(draw,PetscRealPart(xg[n-2]),PetscRealPart(array[j+step*(n-1)]),PETSC_DRAW_BLACK);CHKERRQ(ierr);
}
}
ierr = PetscDrawSynchronizedFlush(draw);CHKERRQ(ierr);
ierr = PetscDrawPause(draw);CHKERRQ(ierr);
}
ierr = PetscFree(displayfields);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(xcoor,&xg);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(xin,&array);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode PetscOptionsCheckInitial_Private(void)
{
char string[64],mname[PETSC_MAX_PATH_LEN],*f;
MPI_Comm comm = PETSC_COMM_WORLD;
PetscBool flg1 = PETSC_FALSE,flg2 = PETSC_FALSE,flg3 = PETSC_FALSE,flag;
PetscErrorCode ierr;
PetscReal si;
PetscInt intensity;
int i;
PetscMPIInt rank;
char version[256];
#if !defined(PETSC_HAVE_THREADSAFETY)
PetscReal logthreshold;
#endif
#if defined(PETSC_USE_LOG)
PetscViewerFormat format;
PetscBool flg4 = PETSC_FALSE;
#endif
PetscFunctionBegin;
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr);
#if !defined(PETSC_HAVE_THREADSAFETY)
/*
Setup the memory management; support for tracing malloc() usage
*/
ierr = PetscOptionsHasName(NULL,"-malloc_log",&flg3);CHKERRQ(ierr);
logthreshold = 0.0;
ierr = PetscOptionsGetReal(NULL,"-malloc_log_threshold",&logthreshold,&flg1);CHKERRQ(ierr);
if (flg1) flg3 = PETSC_TRUE;
#if defined(PETSC_USE_DEBUG)
ierr = PetscOptionsGetBool(NULL,"-malloc",&flg1,&flg2);CHKERRQ(ierr);
if ((!flg2 || flg1) && !petscsetmallocvisited) {
if (flg2 || !(PETSC_RUNNING_ON_VALGRIND)) {
/* turn off default -malloc if valgrind is being used */
ierr = PetscSetUseTrMalloc_Private();CHKERRQ(ierr);
}
}
#else
ierr = PetscOptionsGetBool(NULL,"-malloc_dump",&flg1,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetBool(NULL,"-malloc",&flg2,NULL);CHKERRQ(ierr);
if (flg1 || flg2 || flg3) {ierr = PetscSetUseTrMalloc_Private();CHKERRQ(ierr);}
#endif
if (flg3) {
ierr = PetscMallocSetDumpLogThreshold((PetscLogDouble)logthreshold);CHKERRQ(ierr);
}
flg1 = PETSC_FALSE;
ierr = PetscOptionsGetBool(NULL,"-malloc_debug",&flg1,NULL);CHKERRQ(ierr);
if (flg1) {
ierr = PetscSetUseTrMalloc_Private();CHKERRQ(ierr);
ierr = PetscMallocDebug(PETSC_TRUE);CHKERRQ(ierr);
}
flg1 = PETSC_FALSE;
ierr = PetscOptionsGetBool(NULL,"-malloc_test",&flg1,NULL);CHKERRQ(ierr);
#if defined(PETSC_USE_DEBUG)
if (flg1 && !PETSC_RUNNING_ON_VALGRIND) {
ierr = PetscSetUseTrMalloc_Private();CHKERRQ(ierr);
ierr = PetscMallocSetDumpLog();CHKERRQ(ierr);
ierr = PetscMallocDebug(PETSC_TRUE);CHKERRQ(ierr);
}
#endif
flg1 = PETSC_FALSE;
ierr = PetscOptionsGetBool(NULL,"-malloc_info",&flg1,NULL);CHKERRQ(ierr);
if (!flg1) {
flg1 = PETSC_FALSE;
ierr = PetscOptionsGetBool(NULL,"-memory_view",&flg1,NULL);CHKERRQ(ierr);
}
if (flg1) {
ierr = PetscMemorySetGetMaximumUsage();CHKERRQ(ierr);
}
#endif
#if defined(PETSC_USE_LOG)
ierr = PetscOptionsHasName(NULL,"-objects_dump",&PetscObjectsLog);CHKERRQ(ierr);
#endif
/*
Set the display variable for graphics
*/
ierr = PetscSetDisplay();CHKERRQ(ierr);
/*
Print the PETSc version information
*/
ierr = PetscOptionsHasName(NULL,"-v",&flg1);CHKERRQ(ierr);
ierr = PetscOptionsHasName(NULL,"-version",&flg2);CHKERRQ(ierr);
ierr = PetscOptionsHasName(NULL,"-help",&flg3);CHKERRQ(ierr);
if (flg1 || flg2 || flg3) {
/*
Print "higher-level" package version message
*/
if (PetscExternalVersionFunction) {
ierr = (*PetscExternalVersionFunction)(comm);CHKERRQ(ierr);
}
ierr = PetscGetVersion(version,256);CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm,"--------------------------------------------\
------------------------------\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm,"%s\n",version);CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm,"%s",PETSC_AUTHOR_INFO);CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm,"See docs/changes/index.html for recent updates.\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm,"See docs/faq.html for problems.\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm,"See docs/manualpages/index.html for help. \n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm,"Libraries linked from %s\n",PETSC_LIB_DIR);CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm,"--------------------------------------------\
------------------------------\n");CHKERRQ(ierr);
}
/*
Print "higher-level" package help message
*/
if (flg3) {
if (PetscExternalHelpFunction) {
ierr = (*PetscExternalHelpFunction)(comm);CHKERRQ(ierr);
}
}
/*
Setup the error handling
*/
flg1 = PETSC_FALSE;
ierr = PetscOptionsGetBool(NULL,"-on_error_abort",&flg1,NULL);CHKERRQ(ierr);
if (flg1) {
ierr = MPI_Comm_set_errhandler(PETSC_COMM_WORLD,MPI_ERRORS_ARE_FATAL);CHKERRQ(ierr);
ierr = PetscPushErrorHandler(PetscAbortErrorHandler,0);CHKERRQ(ierr);
}
flg1 = PETSC_FALSE;
ierr = PetscOptionsGetBool(NULL,"-on_error_mpiabort",&flg1,NULL);CHKERRQ(ierr);
if (flg1) { ierr = PetscPushErrorHandler(PetscMPIAbortErrorHandler,0);CHKERRQ(ierr);}
flg1 = PETSC_FALSE;
ierr = PetscOptionsGetBool(NULL,"-mpi_return_on_error",&flg1,NULL);CHKERRQ(ierr);
if (flg1) {
ierr = MPI_Comm_set_errhandler(comm,MPI_ERRORS_RETURN);CHKERRQ(ierr);
}
flg1 = PETSC_FALSE;
ierr = PetscOptionsGetBool(NULL,"-no_signal_handler",&flg1,NULL);CHKERRQ(ierr);
if (!flg1) {ierr = PetscPushSignalHandler(PetscSignalHandlerDefault,(void*)0);CHKERRQ(ierr);}
flg1 = PETSC_FALSE;
ierr = PetscOptionsGetBool(NULL,"-fp_trap",&flg1,NULL);CHKERRQ(ierr);
if (flg1) {ierr = PetscSetFPTrap(PETSC_FP_TRAP_ON);CHKERRQ(ierr);}
ierr = PetscOptionsGetInt(NULL,"-check_pointer_intensity",&intensity,&flag);CHKERRQ(ierr);
if (flag) {ierr = PetscCheckPointerSetIntensity(intensity);CHKERRQ(ierr);}
/*
Setup debugger information
*/
ierr = PetscSetDefaultDebugger();CHKERRQ(ierr);
ierr = PetscOptionsGetString(NULL,"-on_error_attach_debugger",string,64,&flg1);CHKERRQ(ierr);
if (flg1) {
MPI_Errhandler err_handler;
ierr = PetscSetDebuggerFromString(string);CHKERRQ(ierr);
ierr = MPI_Comm_create_errhandler((MPI_Handler_function*)Petsc_MPI_DebuggerOnError,&err_handler);CHKERRQ(ierr);
ierr = MPI_Comm_set_errhandler(comm,err_handler);CHKERRQ(ierr);
ierr = PetscPushErrorHandler(PetscAttachDebuggerErrorHandler,0);CHKERRQ(ierr);
}
ierr = PetscOptionsGetString(NULL,"-debug_terminal",string,64,&flg1);CHKERRQ(ierr);
if (flg1) { ierr = PetscSetDebugTerminal(string);CHKERRQ(ierr); }
ierr = PetscOptionsGetString(NULL,"-start_in_debugger",string,64,&flg1);CHKERRQ(ierr);
ierr = PetscOptionsGetString(NULL,"-stop_for_debugger",string,64,&flg2);CHKERRQ(ierr);
if (flg1 || flg2) {
PetscMPIInt size;
PetscInt lsize,*nodes;
MPI_Errhandler err_handler;
/*
we have to make sure that all processors have opened
connections to all other processors, otherwise once the
debugger has stated it is likely to receive a SIGUSR1
and kill the program.
*/
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
if (size > 2) {
PetscMPIInt dummy = 0;
MPI_Status status;
for (i=0; i<size; i++) {
if (rank != i) {
ierr = MPI_Send(&dummy,1,MPI_INT,i,109,PETSC_COMM_WORLD);CHKERRQ(ierr);
}
}
for (i=0; i<size; i++) {
if (rank != i) {
ierr = MPI_Recv(&dummy,1,MPI_INT,i,109,PETSC_COMM_WORLD,&status);CHKERRQ(ierr);
}
}
}
/* check if this processor node should be in debugger */
ierr = PetscMalloc1(size,&nodes);CHKERRQ(ierr);
lsize = size;
ierr = PetscOptionsGetIntArray(NULL,"-debugger_nodes",nodes,&lsize,&flag);CHKERRQ(ierr);
if (flag) {
for (i=0; i<lsize; i++) {
if (nodes[i] == rank) { flag = PETSC_FALSE; break; }
}
}
if (!flag) {
ierr = PetscSetDebuggerFromString(string);CHKERRQ(ierr);
ierr = PetscPushErrorHandler(PetscAbortErrorHandler,0);CHKERRQ(ierr);
if (flg1) {
ierr = PetscAttachDebugger();CHKERRQ(ierr);
} else {
ierr = PetscStopForDebugger();CHKERRQ(ierr);
}
ierr = MPI_Comm_create_errhandler((MPI_Handler_function*)Petsc_MPI_AbortOnError,&err_handler);CHKERRQ(ierr);
ierr = MPI_Comm_set_errhandler(comm,err_handler);CHKERRQ(ierr);
}
ierr = PetscFree(nodes);CHKERRQ(ierr);
}
ierr = PetscOptionsGetString(NULL,"-on_error_emacs",emacsmachinename,128,&flg1);CHKERRQ(ierr);
if (flg1 && !rank) {ierr = PetscPushErrorHandler(PetscEmacsClientErrorHandler,emacsmachinename);CHKERRQ(ierr);}
/*
Setup profiling and logging
*/
#if defined(PETSC_USE_INFO)
{
char logname[PETSC_MAX_PATH_LEN]; logname[0] = 0;
ierr = PetscOptionsGetString(NULL,"-info",logname,250,&flg1);CHKERRQ(ierr);
if (flg1 && logname[0]) {
ierr = PetscInfoAllow(PETSC_TRUE,logname);CHKERRQ(ierr);
} else if (flg1) {
ierr = PetscInfoAllow(PETSC_TRUE,NULL);CHKERRQ(ierr);
}
}
#endif
#if defined(PETSC_USE_LOG)
mname[0] = 0;
ierr = PetscOptionsGetString(NULL,"-history",mname,PETSC_MAX_PATH_LEN,&flg1);CHKERRQ(ierr);
if (flg1) {
if (mname[0]) {
ierr = PetscOpenHistoryFile(mname,&petsc_history);CHKERRQ(ierr);
} else {
ierr = PetscOpenHistoryFile(NULL,&petsc_history);CHKERRQ(ierr);
}
}
#if defined(PETSC_HAVE_MPE)
flg1 = PETSC_FALSE;
ierr = PetscOptionsHasName(NULL,"-log_mpe",&flg1);CHKERRQ(ierr);
if (flg1) {ierr = PetscLogMPEBegin();CHKERRQ(ierr);}
#endif
flg1 = PETSC_FALSE;
flg3 = PETSC_FALSE;
ierr = PetscOptionsGetBool(NULL,"-log_all",&flg1,NULL);CHKERRQ(ierr);
ierr = PetscOptionsHasName(NULL,"-log_summary",&flg3);CHKERRQ(ierr);
if (flg1) { ierr = PetscLogAllBegin();CHKERRQ(ierr); }
else if (flg3) { ierr = PetscLogDefaultBegin();CHKERRQ(ierr);}
ierr = PetscOptionsGetString(NULL,"-log_trace",mname,250,&flg1);CHKERRQ(ierr);
if (flg1) {
char name[PETSC_MAX_PATH_LEN],fname[PETSC_MAX_PATH_LEN];
FILE *file;
if (mname[0]) {
sprintf(name,"%s.%d",mname,rank);
ierr = PetscFixFilename(name,fname);CHKERRQ(ierr);
file = fopen(fname,"w");
if (!file) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN,"Unable to open trace file: %s",fname);
} else file = PETSC_STDOUT;
ierr = PetscLogTraceBegin(file);CHKERRQ(ierr);
}
ierr = PetscOptionsGetViewer(PETSC_COMM_WORLD,NULL,"-log_view",NULL,&format,&flg4);CHKERRQ(ierr);
if (flg4) {
if (format == PETSC_VIEWER_ASCII_XML){
ierr = PetscLogNestedBegin();CHKERRQ(ierr);
} else {
ierr = PetscLogDefaultBegin();CHKERRQ(ierr);
}
}
#endif
ierr = PetscOptionsGetBool(NULL,"-saws_options",&PetscOptionsPublish,NULL);CHKERRQ(ierr);
#if defined(PETSC_HAVE_CUDA)
ierr = PetscOptionsHasName(NULL,"-cuda_show_devices",&flg1);CHKERRQ(ierr);
if (flg1) {
struct cudaDeviceProp prop;
int devCount;
int device;
cudaError_t err = cudaSuccess;
err = cudaGetDeviceCount(&devCount);
if (err != cudaSuccess) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SYS,"error in cudaGetDeviceCount %s",cudaGetErrorString(err));
for (device = 0; device < devCount; ++device) {
err = cudaGetDeviceProperties(&prop, device);
if (err != cudaSuccess) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SYS,"error in cudaGetDeviceProperties %s",cudaGetErrorString(err));
ierr = PetscPrintf(PETSC_COMM_WORLD, "CUDA device %d: %s\n", device, prop.name);CHKERRQ(ierr);
}
}
{
int size;
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
if (size>1) {
int devCount, device, rank;
cudaError_t err = cudaSuccess;
/* check to see if we force multiple ranks to hit the same GPU */
ierr = PetscOptionsGetInt(NULL,"-cuda_set_device", &device, &flg1);CHKERRQ(ierr);
if (flg1) {
err = cudaSetDevice(device);
if (err != cudaSuccess) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SYS,"error in cudaSetDevice %s",cudaGetErrorString(err));
} else {
/* we're not using the same GPU on multiple MPI threads. So try to allocated different GPUs to different processes */
/* First get the device count */
err = cudaGetDeviceCount(&devCount);
if (err != cudaSuccess) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SYS,"error in cudaGetDeviceCount %s",cudaGetErrorString(err));
/* next determine the rank and then set the device via a mod */
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr);
device = rank % devCount;
err = cudaSetDevice(device);
if (err != cudaSuccess) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SYS,"error in cudaSetDevice %s",cudaGetErrorString(err));
}
/* set the device flags so that it can map host memory ... do NOT throw exception on err!=cudaSuccess
multiple devices may try to set the flags on the same device. So long as one of them succeeds, things
are ok. */
err = cudaSetDeviceFlags(cudaDeviceMapHost);
if (err != cudaSuccess) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SYS,"error in cudaSetDeviceFlags %s",cudaGetErrorString(err));
} else {
int device;
cudaError_t err = cudaSuccess;
/* the code below works for serial GPU simulations */
ierr = PetscOptionsGetInt(NULL,"-cuda_set_device", &device, &flg1);CHKERRQ(ierr);
if (flg1) {
err = cudaSetDevice(device);
if (err != cudaSuccess) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SYS,"error in cudaSetDevice %s",cudaGetErrorString(err));
}
/* set the device flags so that it can map host memory ... here, we error check. */
err = cudaSetDeviceFlags(cudaDeviceMapHost);
if (err != cudaSuccess) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SYS,"error in cudaSetDeviceFlags %s",cudaGetErrorString(err));
}
}
#endif
/*
Print basic help message
*/
ierr = PetscOptionsHasName(NULL,"-help",&flg1);CHKERRQ(ierr);
if (flg1) {
ierr = (*PetscHelpPrintf)(comm,"Options for all PETSc programs:\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -help: prints help method for each option\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -on_error_abort: cause an abort when an error is detected. Useful \n ");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," only when run in the debugger\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -on_error_attach_debugger [gdb,dbx,xxgdb,ups,noxterm]\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," start the debugger in new xterm\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," unless noxterm is given\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -start_in_debugger [gdb,dbx,xxgdb,ups,noxterm]\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," start all processes in the debugger\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -on_error_emacs <machinename>\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," emacs jumps to error file\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -debugger_nodes [n1,n2,..] Nodes to start in debugger\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -debugger_pause [m] : delay (in seconds) to attach debugger\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -stop_for_debugger : prints message on how to attach debugger manually\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," waits the delay for you to attach\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -display display: Location where X window graphics and debuggers are displayed\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -no_signal_handler: do not trap error signals\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -mpi_return_on_error: MPI returns error code, rather than abort on internal error\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -fp_trap: stop on floating point exceptions\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," note on IBM RS6000 this slows run greatly\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -malloc_dump <optional filename>: dump list of unfreed memory at conclusion\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -malloc: use our error checking malloc\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -malloc no: don't use error checking malloc\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -malloc_info: prints total memory usage\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -malloc_log: keeps log of all memory allocations\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -malloc_debug: enables extended checking for memory corruption\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -options_table: dump list of options inputted\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -options_left: dump list of unused options\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -options_left no: don't dump list of unused options\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -tmp tmpdir: alternative /tmp directory\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -shared_tmp: tmp directory is shared by all processors\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -not_shared_tmp: each processor has separate tmp directory\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -memory_view: print memory usage at end of run\n");CHKERRQ(ierr);
#if defined(PETSC_USE_LOG)
ierr = (*PetscHelpPrintf)(comm," -get_total_flops: total flops over all processors\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -log[_summary _summary_python]: logging objects and events\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -log_trace [filename]: prints trace of all PETSc calls\n");CHKERRQ(ierr);
#if defined(PETSC_HAVE_MPE)
ierr = (*PetscHelpPrintf)(comm," -log_mpe: Also create logfile viewable through Jumpshot\n");CHKERRQ(ierr);
#endif
ierr = (*PetscHelpPrintf)(comm," -info <optional filename>: print informative messages about the calculations\n");CHKERRQ(ierr);
#endif
ierr = (*PetscHelpPrintf)(comm," -v: prints PETSc version number and release date\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -options_file <file>: reads options from file\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm," -petsc_sleep n: sleeps n seconds before running program\n");CHKERRQ(ierr);
ierr = (*PetscHelpPrintf)(comm,"-----------------------------------------------\n");CHKERRQ(ierr);
}
#if defined(PETSC_HAVE_POPEN)
{
char machine[128];
ierr = PetscOptionsGetString(NULL,"-popen_machine",machine,128,&flg1);CHKERRQ(ierr);
if (flg1) {
ierr = PetscPOpenSetMachine(machine);CHKERRQ(ierr);
}
}
#endif
ierr = PetscOptionsGetReal(NULL,"-petsc_sleep",&si,&flg1);CHKERRQ(ierr);
if (flg1) {
ierr = PetscSleep(si);CHKERRQ(ierr);
}
ierr = PetscOptionsGetString(NULL,"-info_exclude",mname,PETSC_MAX_PATH_LEN,&flg1);CHKERRQ(ierr);
if (flg1) {
ierr = PetscStrstr(mname,"null",&f);CHKERRQ(ierr);
if (f) {
ierr = PetscInfoDeactivateClass(0);CHKERRQ(ierr);
}
}
#if defined(PETSC_HAVE_CUSP) || defined(PETSC_HAVE_VIENNACL)
ierr = PetscOptionsHasName(NULL,"-log_summary",&flg3);CHKERRQ(ierr);
if (!flg3) {
ierr = PetscOptionsHasName(NULL,"-log_view",&flg3);CHKERRQ(ierr);
}
#endif
#if defined(PETSC_HAVE_CUSP)
ierr = PetscOptionsGetBool(NULL,"-cusp_synchronize",&flg3,NULL);CHKERRQ(ierr);
PetscCUSPSynchronize = flg3;
#elif defined(PETSC_HAVE_VIENNACL)
ierr = PetscOptionsGetBool(NULL,"-viennacl_synchronize",&flg3,NULL);CHKERRQ(ierr);
PetscViennaCLSynchronize = flg3;
#endif
PetscFunctionReturn(0);
}
PetscInt main(PetscInt argc,char **args)
{
typedef enum {RANDOM, CONSTANT, TANH, NUM_FUNCS} FuncType;
const char *funcNames[NUM_FUNCS] = {"random", "constant", "tanh"};
Mat A, AA;
PetscMPIInt size;
PetscInt N,i, stencil=1,dof=3;
PetscInt dim[3] = {10,10,10}, ndim = 3;
Vec coords,x,y,z,xx, yy, zz;
Vec xxsplit[DOF], yysplit[DOF], zzsplit[DOF];
PetscReal h[3];
PetscScalar s;
PetscRandom rdm;
PetscReal norm, enorm;
PetscInt func;
FuncType function = TANH;
DM da, da1, coordsda;
PetscBool view_x = PETSC_FALSE, view_y = PETSC_FALSE, view_z = PETSC_FALSE;
PetscErrorCode ierr;
ierr = PetscInitialize(&argc,&args,(char *)0,help);CHKERRQ(ierr);
#if !defined(PETSC_USE_COMPLEX)
SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP, "This example requires complex numbers");
#endif
ierr = MPI_Comm_size(PETSC_COMM_WORLD, &size);CHKERRQ(ierr);
if (size != 1) SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP, "This is a uniprocessor example only!");
ierr = PetscOptionsBegin(PETSC_COMM_WORLD, PETSC_NULL, "USFFT Options", "ex27");CHKERRQ(ierr);
ierr = PetscOptionsEList("-function", "Function type", "ex27", funcNames, NUM_FUNCS, funcNames[function], &func, PETSC_NULL);CHKERRQ(ierr);
function = (FuncType) func;
ierr = PetscOptionsEnd();CHKERRQ(ierr);
ierr = PetscOptionsGetBool(PETSC_NULL,"-view_x",&view_x,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetBool(PETSC_NULL,"-view_y",&view_y,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetBool(PETSC_NULL,"-view_z",&view_z,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetIntArray(PETSC_NULL,"-dim",dim,&ndim,PETSC_NULL);CHKERRQ(ierr);
// DMDA with the correct fiber dimension
ierr = DMDACreate3d(PETSC_COMM_SELF,DMDA_BOUNDARY_NONE,DMDA_BOUNDARY_NONE,DMDA_BOUNDARY_NONE,DMDA_STENCIL_STAR,
dim[0], dim[1], dim[2],
PETSC_DECIDE, PETSC_DECIDE, PETSC_DECIDE,
dof, stencil,
PETSC_NULL, PETSC_NULL, PETSC_NULL,
&da);
CHKERRQ(ierr);
// DMDA with fiber dimension 1 for split fields
ierr = DMDACreate3d(PETSC_COMM_SELF,DMDA_BOUNDARY_NONE,DMDA_BOUNDARY_NONE,DMDA_BOUNDARY_NONE,DMDA_STENCIL_STAR,
dim[0], dim[1], dim[2],
PETSC_DECIDE, PETSC_DECIDE, PETSC_DECIDE,
1, stencil,
PETSC_NULL, PETSC_NULL, PETSC_NULL,
&da1);
CHKERRQ(ierr);
// Coordinates
ierr = DMDAGetCoordinateDA(da, &coordsda);
ierr = DMGetGlobalVector(coordsda, &coords);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) coords, "Grid coordinates");CHKERRQ(ierr);
for(i = 0, N = 1; i < 3; i++) {
h[i] = 1.0/dim[i];
PetscScalar *a;
ierr = VecGetArray(coords, &a);CHKERRQ(ierr);
PetscInt j,k,n = 0;
for(i = 0; i < 3; ++i) {
for(j = 0; j < dim[i]; ++j){
for(k = 0; k < 3; ++k) {
a[n] = j*h[i]; // coordinate along the j-th point in the i-th dimension
++n;
}
}
}
ierr = VecRestoreArray(coords, &a);CHKERRQ(ierr);
}
ierr = DMDASetCoordinates(da, coords);CHKERRQ(ierr);
ierr = VecDestroy(&coords);CHKERRQ(ierr);
// Work vectors
ierr = DMGetGlobalVector(da, &x);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) x, "Real space vector");CHKERRQ(ierr);
ierr = DMGetGlobalVector(da, &xx);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) xx, "Real space vector");CHKERRQ(ierr);
ierr = DMGetGlobalVector(da, &y);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) y, "USFFT frequency space vector");CHKERRQ(ierr);
ierr = DMGetGlobalVector(da, &yy);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) yy, "FFTW frequency space vector");CHKERRQ(ierr);
ierr = DMGetGlobalVector(da, &z);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) z, "USFFT reconstructed vector");CHKERRQ(ierr);
ierr = DMGetGlobalVector(da, &zz);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) zz, "FFTW reconstructed vector");CHKERRQ(ierr);
// Split vectors for FFTW
for(int ii = 0; ii < 3; ++ii) {
ierr = DMGetGlobalVector(da1, &xxsplit[ii]);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) xxsplit[ii], "Real space split vector");CHKERRQ(ierr);
ierr = DMGetGlobalVector(da1, &yysplit[ii]);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) yysplit[ii], "FFTW frequency space split vector");CHKERRQ(ierr);
ierr = DMGetGlobalVector(da1, &zzsplit[ii]);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) zzsplit[ii], "FFTW reconstructed split vector");CHKERRQ(ierr);
}
ierr = PetscPrintf(PETSC_COMM_SELF, "%3-D: USFFT on vector of ");CHKERRQ(ierr);
for(i = 0, N = 1; i < 3; i++) {
ierr = PetscPrintf(PETSC_COMM_SELF, "dim[%d] = %d ",i,dim[i]);CHKERRQ(ierr);
N *= dim[i];
}
ierr = PetscPrintf(PETSC_COMM_SELF, "; total size %d \n",N);CHKERRQ(ierr);
if (function == RANDOM) {
ierr = PetscRandomCreate(PETSC_COMM_SELF, &rdm);CHKERRQ(ierr);
ierr = PetscRandomSetFromOptions(rdm);CHKERRQ(ierr);
ierr = VecSetRandom(x, rdm);CHKERRQ(ierr);
ierr = PetscRandomDestroy(&rdm);CHKERRQ(ierr);
}
else if (function == CONSTANT) {
ierr = VecSet(x, 1.0);CHKERRQ(ierr);
}
else if (function == TANH) {
PetscScalar *a;
ierr = VecGetArray(x, &a);CHKERRQ(ierr);
PetscInt j,k = 0;
for(i = 0; i < 3; ++i) {
for(j = 0; j < dim[i]; ++j) {
a[k] = tanh((j - dim[i]/2.0)*(10.0/dim[i]));
++k;
}
}
ierr = VecRestoreArray(x, &a);CHKERRQ(ierr);
}
if(view_x) {
ierr = VecView(x, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
ierr = VecCopy(x,xx);CHKERRQ(ierr);
// Split xx
ierr = VecStrideGatherAll(xx,xxsplit, INSERT_VALUES);CHKERRQ(ierr); //YES! 'Gather' means 'split' (or maybe 'scatter'?)!
ierr = VecNorm(x,NORM_2,&norm);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF, "|x|_2 = %g\n",norm);CHKERRQ(ierr);
/* create USFFT object */
ierr = MatCreateSeqUSFFT(da,da,&A);CHKERRQ(ierr);
/* create FFTW object */
ierr = MatCreateSeqFFTW(PETSC_COMM_SELF,3,dim,&AA);CHKERRQ(ierr);
/* apply USFFT and FFTW FORWARD "preemptively", so the fftw_plans can be reused on different vectors */
ierr = MatMult(A,x,z);CHKERRQ(ierr);
for(int ii = 0; ii < 3; ++ii) {
ierr = MatMult(AA,xxsplit[ii],zzsplit[ii]);CHKERRQ(ierr);
}
// Now apply USFFT and FFTW forward several (3) times
for (i=0; i<3; ++i){
ierr = MatMult(A,x,y);CHKERRQ(ierr);
for(int ii = 0; ii < 3; ++ii) {
ierr = MatMult(AA,xxsplit[ii],yysplit[ii]);CHKERRQ(ierr);
}
ierr = MatMultTranspose(A,y,z);CHKERRQ(ierr);
for(int ii = 0; ii < 3; ++ii) {
ierr = MatMult(AA,yysplit[ii],zzsplit[ii]);CHKERRQ(ierr);
}
}
// Unsplit yy
ierr = VecStrideScatterAll(yysplit, yy, INSERT_VALUES);CHKERRQ(ierr); //YES! 'Scatter' means 'collect' (or maybe 'gather'?)!
// Unsplit zz
ierr = VecStrideScatterAll(zzsplit, zz, INSERT_VALUES);CHKERRQ(ierr); //YES! 'Scatter' means 'collect' (or maybe 'gather'?)!
if(view_y) {
ierr = PetscPrintf(PETSC_COMM_WORLD, "y = \n");CHKERRQ(ierr);
ierr = VecView(y, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "yy = \n");CHKERRQ(ierr);
ierr = VecView(yy, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
if(view_z) {
ierr = PetscPrintf(PETSC_COMM_WORLD, "z = \n");CHKERRQ(ierr);
ierr = VecView(z, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "zz = \n");CHKERRQ(ierr);
ierr = VecView(zz, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
/* compare x and z. USFFT computes an unnormalized DFT, thus z = N*x */
s = 1.0/(PetscReal)N;
ierr = VecScale(z,s);CHKERRQ(ierr);
ierr = VecAXPY(x,-1.0,z);CHKERRQ(ierr);
ierr = VecNorm(x,NORM_1,&enorm);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF, "|x-z| = %g\n",enorm);CHKERRQ(ierr);
/* compare xx and zz. FFTW computes an unnormalized DFT, thus zz = N*x */
s = 1.0/(PetscReal)N;
ierr = VecScale(zz,s);CHKERRQ(ierr);
ierr = VecAXPY(xx,-1.0,zz);CHKERRQ(ierr);
ierr = VecNorm(xx,NORM_1,&enorm);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF, "|xx-zz| = %g\n",enorm);CHKERRQ(ierr);
/* compare y and yy: USFFT and FFTW results*/
ierr = VecNorm(y,NORM_2,&norm);CHKERRQ(ierr);
ierr = VecAXPY(y,-1.0,yy);CHKERRQ(ierr);
ierr = VecNorm(y,NORM_1,&enorm);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF, "|y|_2 = %g\n",norm);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF, "|y-yy| = %g\n",enorm);CHKERRQ(ierr);
/* compare z and zz: USFFT and FFTW results*/
ierr = VecNorm(z,NORM_2,&norm);CHKERRQ(ierr);
ierr = VecAXPY(z,-1.0,zz);CHKERRQ(ierr);
ierr = VecNorm(z,NORM_1,&enorm);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF, "|z|_2 = %g\n",norm);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF, "|z-zz| = %g\n",enorm);CHKERRQ(ierr);
/* free spaces */
ierr = DMRestoreGlobalVector(da,&x);CHKERRQ(ierr);
ierr = DMRestoreGlobalVector(da,&xx);CHKERRQ(ierr);
ierr = DMRestoreGlobalVector(da,&y);CHKERRQ(ierr);
ierr = DMRestoreGlobalVector(da,&yy);CHKERRQ(ierr);
ierr = DMRestoreGlobalVector(da,&z);CHKERRQ(ierr);
ierr = DMRestoreGlobalVector(da,&zz);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
int main(int argc, char **argv)
{
TS ts;
Vec x; /*solution vector*/
Mat A; /*Jacobian*/
PetscInt steps,maxsteps,mx,eimex_rowcol[2],two;
PetscErrorCode ierr;
PetscScalar *x_ptr;
PetscReal ftime,dt,norm;
Vec ref;
struct _User user; /* user-defined work context */
PetscViewer viewer;
ierr = PetscInitialize(&argc,&argv,NULL,help);CHKERRQ(ierr);
/* Initialize user application context */
ierr = PetscOptionsBegin(PETSC_COMM_WORLD,NULL,"van der Pol options","");
user.mu = 1e0;
ierr = PetscOptionsReal("-eps","Stiffness controller","",user.mu,&user.mu,NULL);CHKERRQ(ierr);
ierr = PetscOptionsEnd();CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Set runtime options
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
ierr = PetscOptionsGetBool(NULL,NULL,"-monitor",&monitor,NULL);CHKERRQ(ierr);
*/
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create necessary matrix and vectors, solve same ODE on every process
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr);
ierr = MatSetSizes(A,PETSC_DECIDE,PETSC_DECIDE,2,2);CHKERRQ(ierr);
ierr = MatSetFromOptions(A);CHKERRQ(ierr);
ierr = MatSetUp(A);CHKERRQ(ierr);
ierr = MatCreateVecs(A,&x,NULL);CHKERRQ(ierr);
ierr = MatCreateVecs(A,&ref,NULL);CHKERRQ(ierr);
ierr = VecGetArray(ref,&x_ptr);CHKERRQ(ierr);
/*
* [0,1], mu=10^-3
*/
/*
x_ptr[0] = -1.8881254106283;
x_ptr[1] = 0.7359074233370;*/
/*
* [0,0.5],mu=10^-3
*/
/*
x_ptr[0] = 1.596980778659137;
x_ptr[1] = -1.029103015879544;
*/
/*
* [0,0.5],mu=1
*/
x_ptr[0] = 1.619084329683235;
x_ptr[1] = -0.803530465176385;
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create timestepping solver context
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = TSCreate(PETSC_COMM_WORLD,&ts);CHKERRQ(ierr);
ierr = TSSetType(ts,TSEIMEX);CHKERRQ(ierr);
ierr = TSSetRHSFunction(ts,NULL,RHSFunction,&user);CHKERRQ(ierr);
ierr = TSSetIFunction(ts,NULL,IFunction,&user);CHKERRQ(ierr);
ierr = TSSetIJacobian(ts,A,A,IJacobian,&user);CHKERRQ(ierr);
ftime = 1.1;
dt = 0.00001;
maxsteps = 100000;
ierr = TSSetDuration(ts,maxsteps,ftime);CHKERRQ(ierr);
ierr = TSSetInitialTimeStep(ts,0.0,dt);CHKERRQ(ierr);
ierr = TSSetExactFinalTime(ts,TS_EXACTFINALTIME_STEPOVER);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Set initial conditions
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = VecGetArray(x,&x_ptr);CHKERRQ(ierr);
x_ptr[0] = 2.;
x_ptr[1] = -2./3. + 10./81.*(user.mu) - 292./2187.* (user.mu) * (user.mu)
-1814./19683.*(user.mu)*(user.mu)*(user.mu);
ierr = TSSetSolution(ts,x);CHKERRQ(ierr);
ierr = VecGetSize(x,&mx);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Set runtime options
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = TSSetFromOptions(ts);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Solve nonlinear system
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = TSSolve(ts,x);CHKERRQ(ierr);
ierr = TSGetTime(ts,&ftime);CHKERRQ(ierr);
ierr = TSGetTimeStepNumber(ts,&steps);CHKERRQ(ierr);
ierr = VecAXPY(x,-1.0,ref);CHKERRQ(ierr);
ierr = VecNorm(x,NORM_2,&norm);CHKERRQ(ierr);
ierr = TSGetTimeStep(ts,&dt);CHKERRQ(ierr);
eimex_rowcol[0] = 0; eimex_rowcol[1] = 0; two = 2;
ierr = PetscOptionsGetIntArray(NULL,NULL,"-ts_eimex_row_col",eimex_rowcol,&two,NULL);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"order %11s %18s %37s\n","dt","norm","final solution components 0 and 1");CHKERRQ(ierr);
ierr = VecGetArray(x,&x_ptr);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"(%D,%D) %10.8f %18.15f %18.15f %18.15f\n",eimex_rowcol[0],eimex_rowcol[1],(double)dt,(double)norm,(double)PetscRealPart(x_ptr[0]),(double)PetscRealPart(x_ptr[1]));CHKERRQ(ierr);
ierr = VecRestoreArray(x,&x_ptr);CHKERRQ(ierr);
/* Write line in convergence log */
ierr = PetscViewerCreate(PETSC_COMM_WORLD,&viewer);CHKERRQ(ierr);
ierr = PetscViewerSetType(viewer,PETSCVIEWERASCII);CHKERRQ(ierr);
ierr = PetscViewerFileSetMode(viewer,FILE_MODE_APPEND);CHKERRQ(ierr);
ierr = PetscViewerFileSetName(viewer,"eimex_nonstiff_vdp.txt");CHKERRQ(ierr);
ierr = PetscViewerASCIIPrintf(viewer,"%D %D %10.8f %18.15f\n",eimex_rowcol[0],eimex_rowcol[1],(double)dt,(double)norm);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Free work space.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = MatDestroy(&A);CHKERRQ(ierr);
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&ref);CHKERRQ(ierr);
ierr = TSDestroy(&ts);CHKERRQ(ierr);
ierr = PetscFinalize();
return ierr;
}