PetscErrorCode ProcessOptions(MPI_Comm comm, AppCtx *options)
{
PetscErrorCode ierr;
PetscFunctionBegin;
options->debug = 0;
options->dim = 2;
options->interpolate = PETSC_FALSE;
options->refinementLimit = 0.0;
ierr = MPI_Comm_size(comm, &options->numProcs);CHKERRQ(ierr);
ierr = MPI_Comm_rank(comm, &options->rank);CHKERRQ(ierr);
ierr = PetscOptionsBegin(comm, "", "Mesh Distribution Options", "DMMESH");CHKERRQ(ierr);
ierr = PetscOptionsInt("-debug", "The debugging level", "ex1.c", options->debug, &options->debug, PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsInt("-dim", "The topological mesh dimension", "ex1.c", options->dim, &options->dim, PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-interpolate", "Generate intermediate mesh elements", "ex1.c", options->interpolate, &options->interpolate, PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-refinement_limit", "The largest allowable cell volume", "ex1.c", options->refinementLimit, &options->refinementLimit, PETSC_NULL);CHKERRQ(ierr);
ierr = PetscStrcpy(options->filename, "");CHKERRQ(ierr);
ierr = PetscOptionsString("-filename", "The input filename", "ex1.c", options->filename, options->filename, 2048, PETSC_NULL);CHKERRQ(ierr);
ierr = PetscStrcpy(options->partitioner, "chaco");CHKERRQ(ierr);
ierr = PetscOptionsString("-partitioner", "The graph partitioner", "ex1.c", options->partitioner, options->partitioner, 2048, PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsEnd();
ierr = PetscLogEventRegister("CreateMesh", DM_CLASSID, &options->createMeshEvent);CHKERRQ(ierr);
PetscFunctionReturn(0);
};
EXTERN_C_END
#undef __FUNCT__
#define __FUNCT__ "MatPartitioningSetFromOptions_Party"
PetscErrorCode MatPartitioningSetFromOptions_Party(MatPartitioning part)
{
PetscErrorCode ierr;
PetscBool flag;
char value[256];
PetscReal r;
MatPartitioning_Party *party = (MatPartitioning_Party*)part->data;
PetscFunctionBegin;
ierr = PetscOptionsHead("Set Party partitioning options");CHKERRQ(ierr);
ierr = PetscOptionsString("-mat_partitioning_party_global","Global method","MatPartitioningPartySetGlobal",party->global,value,256,&flag);CHKERRQ(ierr);
if (flag) { ierr = MatPartitioningPartySetGlobal(part,value);CHKERRQ(ierr); }
ierr = PetscOptionsString("-mat_partitioning_party_local","Local method","MatPartitioningPartySetLocal",party->local,value,256,&flag);CHKERRQ(ierr);
if (flag) { ierr = MatPartitioningPartySetLocal(part,value);CHKERRQ(ierr); }
ierr = PetscOptionsReal("-mat_partitioning_party_coarse","Coarse level","MatPartitioningPartySetCoarseLevel",0.0,&r,&flag);CHKERRQ(ierr);
if (flag) { ierr = MatPartitioningPartySetCoarseLevel(part,r);CHKERRQ(ierr); }
ierr = PetscOptionsBool("-mat_partitioning_party_match_optimization","Matching optimization on/off","MatPartitioningPartySetMatchOptimization",party->redo,&party->redo,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-mat_partitioning_party_bipart","Bipartitioning on/off","MatPartitioningPartySetBipart",party->recursive,&party->recursive,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-mat_partitioning_party_verbose","Show library output","",party->verbose,&party->verbose,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode ProcessOptions(MPI_Comm comm, AppCtx *options)
{
PetscErrorCode ierr;
PetscFunctionBeginUser;
options->dim = 2;
options->cellSimplex = PETSC_TRUE;
options->filename[0] = '\0';
options->testPartition = PETSC_TRUE;
options->testNum = 0;
ierr = PetscOptionsBegin(comm, "", "Meshing Problem Options", "DMPLEX");
CHKERRQ(ierr);
ierr = PetscOptionsInt("-dim", "The topological mesh dimension", "ex13.c", options->dim, &options->dim, NULL);
CHKERRQ(ierr);
ierr = PetscOptionsBool("-cell_simplex", "Use simplices if true, otherwise hexes", "ex13.c", options->cellSimplex, &options->cellSimplex, NULL);
CHKERRQ(ierr);
ierr = PetscOptionsString("-filename", "The mesh file", "ex13.c", options->filename, options->filename, PETSC_MAX_PATH_LEN, NULL);
CHKERRQ(ierr);
ierr = PetscOptionsBool("-test_partition", "Use a fixed partition for testing", "ex13.c", options->testPartition, &options->testPartition, NULL);
CHKERRQ(ierr);
ierr = PetscOptionsInt("-test_num", "The test partition number", "ex13.c", options->testNum, &options->testNum, NULL);
CHKERRQ(ierr);
ierr = PetscOptionsEnd();
PetscFunctionReturn(0);
};
static PetscErrorCode ProcessOptions(MPI_Comm comm, AppCtx *options)
{
PetscInt dim;
PetscErrorCode ierr;
PetscFunctionBegin;
options->test = 0;
options->dim = 3;
options->simplex = PETSC_TRUE;
options->interpolate = PETSC_FALSE;
options->filename[0] = '\0';
ierr = PetscOptionsBegin(comm, "", "Zero-sized DMPlexGetCellFields Test Options", "DMPLEX");CHKERRQ(ierr);
ierr = PetscOptionsInt("-test", "Test to run", FILENAME, options->test, &options->test, NULL);CHKERRQ(ierr);
ierr = PetscOptionsInt("-dim", "The topological mesh dimension", FILENAME, options->dim, &options->dim, NULL);CHKERRQ(ierr);
if (options->dim > 3) SETERRQ1(comm, PETSC_ERR_ARG_OUTOFRANGE, "dimension set to %d, must be <= 3", options->dim);
ierr = PetscOptionsBool("-simplex", "Use simplices if true, otherwise hexes", FILENAME, options->simplex, &options->simplex, NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-interpolate", "Interpolate the mesh", FILENAME, options->interpolate, &options->interpolate, NULL);CHKERRQ(ierr);
ierr = PetscOptionsString("-filename", "The mesh file", FILENAME, options->filename, options->filename, PETSC_MAX_PATH_LEN, NULL);CHKERRQ(ierr);
options->faces[0] = 1; options->faces[1] = 1; options->faces[2] = 1;
dim = options->dim;
ierr = PetscOptionsIntArray("-faces", "Number of faces per dimension", FILENAME, options->faces, &dim, NULL);CHKERRQ(ierr);
if (dim) options->dim = dim;
ierr = PetscOptionsEnd();
PetscFunctionReturn(0);
}
PetscErrorCode DMSetFromOptions_AKKT(DM dm) {
PetscErrorCode ierr;
DM_AKKT* kkt = (DM_AKKT*)(dm->data);
PetscFunctionBegin;
ierr = PetscOptionsBool("-dm_akkt_duplicate_mat",
"Duplicate underlying Mat in DMCreateMatrix",
"DMAKKTSetDupulicateMat",
kkt->duplicate_mat,
&kkt->duplicate_mat,
PETSC_NULL);
CHKERRQ(ierr);
ierr = PetscOptionsBool("-dm_akkt_detect_saddle_point",
"Identify dual variables by zero diagonal entries",
"DMAKKTSetDetectSaddlePoint",
kkt->detect_saddle_point,
&kkt->detect_saddle_point,
PETSC_NULL);
CHKERRQ(ierr);
ierr = PetscOptionsString("-dm_akkt_decomposition_name",
"Name of primal-dual decomposition to request from DM",
"DMAKKTSetFieldDecompositionName",
kkt->dname,
kkt->dname,
DMAKKT_DECOMPOSITION_NAME_LEN,
PETSC_NULL);
CHKERRQ(ierr);
dm->setupcalled = PETSC_FALSE;
PetscFunctionReturn(0);
}
PetscErrorCode ProcessOptions(MPI_Comm comm, AppCtx *options)
{
PetscErrorCode ierr;
PetscFunctionBegin;
options->debug = 0;
options->dim = 2;
options->interpolate = PETSC_FALSE;
options->refinementUniform = PETSC_FALSE;
options->refinementLimit = 0.0;
options->cellSimplex = PETSC_TRUE;
options->filename[0] = '\0';
ierr = PetscOptionsBegin(comm, "", "Meshing Problem Options", "DMPLEX");CHKERRQ(ierr);
ierr = PetscOptionsInt("-debug", "The debugging level", "ex1.c", options->debug, &options->debug, NULL);CHKERRQ(ierr);
ierr = PetscOptionsInt("-dim", "The topological mesh dimension", "ex1.c", options->dim, &options->dim, NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-interpolate", "Generate intermediate mesh elements", "ex1.c", options->interpolate, &options->interpolate, NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-refinement_uniform", "Uniformly refine the mesh", "ex1.c", options->refinementUniform, &options->refinementUniform, NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-refinement_limit", "The largest allowable cell volume", "ex1.c", options->refinementLimit, &options->refinementLimit, NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-cell_simplex", "Use simplices if true, otherwise hexes", "ex1.c", options->cellSimplex, &options->cellSimplex, NULL);CHKERRQ(ierr);
ierr = PetscOptionsString("-filename", "The mesh file", "ex7.c", options->filename, options->filename, PETSC_MAX_PATH_LEN, NULL);CHKERRQ(ierr);
ierr = PetscOptionsEnd();
ierr = PetscLogEventRegister("CreateMesh", DM_CLASSID, &options->createMeshEvent);CHKERRQ(ierr);
PetscFunctionReturn(0);
};
int main(int argc, char **argv)
{
DM dm;
char typeString[256] = {'\0'};
PetscViewer viewer = NULL;
PetscBool flg;
PetscErrorCode ierr;
ierr = PetscInitialize(&argc, &argv, NULL,help);if (ierr) return ierr;
ierr = DMCreate(PETSC_COMM_WORLD, &dm);CHKERRQ(ierr);
ierr = PetscStrncpy(typeString,DMFOREST,256);CHKERRQ(ierr);
ierr = PetscOptionsBegin(PETSC_COMM_WORLD,NULL,"DM Forest example options",NULL);CHKERRQ(ierr);
ierr = PetscOptionsString("-dm_type","The type of the dm",NULL,DMFOREST,typeString,sizeof(typeString),NULL);CHKERRQ(ierr);
ierr = PetscOptionsEnd();CHKERRQ(ierr);
ierr = DMSetType(dm,(DMType) typeString);CHKERRQ(ierr);
ierr = DMSetFromOptions(dm);CHKERRQ(ierr);
ierr = DMSetUp(dm);CHKERRQ(ierr);
ierr = PetscOptionsGetViewer(PETSC_COMM_WORLD,NULL,"-dm_view",&viewer,NULL,&flg);CHKERRQ(ierr);
if (flg) {
ierr = DMView(dm,viewer);CHKERRQ(ierr);
}
ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr);
ierr = DMDestroy(&dm);CHKERRQ(ierr);
ierr = PetscFinalize();
return ierr;
}
PetscErrorCode PetscViewerSetFromOptions_Socket(PetscViewer v)
{
PetscErrorCode ierr;
PetscInt def = -1;
char sdef[256];
PetscTruth tflg;
PetscFunctionBegin;
/*
These options are not processed here, they are processed in PetscViewerSocketSetConnection(), they
are listed here for the GUI to display
*/
ierr = PetscOptionsHead("Socket PetscViewer Options");CHKERRQ(ierr);
ierr = PetscOptionsGetenv(((PetscObject)v)->comm,"PETSC_VIEWER_SOCKET_PORT",sdef,16,&tflg);CHKERRQ(ierr);
if (tflg) {
ierr = PetscOptionsAtoi(sdef,&def);CHKERRQ(ierr);
} else {
def = PETSCSOCKETDEFAULTPORT;
}
ierr = PetscOptionsInt("-viewer_socket_port","Port number to use for socket","PetscViewerSocketSetConnection",def,0,0);CHKERRQ(ierr);
ierr = PetscOptionsString("-viewer_socket_machine","Machine to use for socket","PetscViewerSocketSetConnection",sdef,0,0,0);CHKERRQ(ierr);
ierr = PetscOptionsGetenv(((PetscObject)v)->comm,"PETSC_VIEWER_SOCKET_MACHINE",sdef,256,&tflg);CHKERRQ(ierr);
if (!tflg) {
ierr = PetscGetHostName(sdef,256);CHKERRQ(ierr);
}
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
MatFDColoringSetFromOptions - Sets coloring finite difference parameters from
the options database.
Collective on MatFDColoring
The Jacobian, F'(u), is estimated with the differencing approximation
.vb
F'(u)_{:,i} = [F(u+h*dx_{i}) - F(u)]/h where
h = error_rel*u[i] if abs(u[i]) > umin
= +/- error_rel*umin otherwise, with +/- determined by the sign of u[i]
dx_{i} = (0, ... 1, .... 0)
.ve
Input Parameter:
. coloring - the coloring context
Options Database Keys:
+ -mat_fd_coloring_err <err> - Sets <err> (square root of relative error in the function)
. -mat_fd_coloring_umin <umin> - Sets umin, the minimum allowable u-value magnitude
. -mat_fd_type - "wp" or "ds" (see MATMFFD_WP or MATMFFD_DS)
. -mat_fd_coloring_view - Activates basic viewing
. -mat_fd_coloring_view ::ascii_info - Activates viewing info
- -mat_fd_coloring_view draw - Activates drawing
Level: intermediate
.keywords: Mat, finite differences, parameters
.seealso: MatFDColoringCreate(), MatFDColoringView(), MatFDColoringSetParameters()
@*/
PetscErrorCode MatFDColoringSetFromOptions(MatFDColoring matfd)
{
PetscErrorCode ierr;
PetscBool flg;
char value[3];
PetscFunctionBegin;
PetscValidHeaderSpecific(matfd,MAT_FDCOLORING_CLASSID,1);
ierr = PetscObjectOptionsBegin((PetscObject)matfd);CHKERRQ(ierr);
ierr = PetscOptionsReal("-mat_fd_coloring_err","Square root of relative error in function","MatFDColoringSetParameters",matfd->error_rel,&matfd->error_rel,0);CHKERRQ(ierr);
ierr = PetscOptionsReal("-mat_fd_coloring_umin","Minimum allowable u magnitude","MatFDColoringSetParameters",matfd->umin,&matfd->umin,0);CHKERRQ(ierr);
ierr = PetscOptionsString("-mat_fd_type","Algorithm to compute h, wp or ds","MatFDColoringCreate",matfd->htype,value,3,&flg);CHKERRQ(ierr);
if (flg) {
if (value[0] == 'w' && value[1] == 'p') matfd->htype = "wp";
else if (value[0] == 'd' && value[1] == 's') matfd->htype = "ds";
else SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Unknown finite differencing type %s",value);
}
ierr = PetscOptionsInt("-mat_fd_coloring_brows","Number of block rows","MatFDColoringSetBlockSize",matfd->brows,&matfd->brows,NULL);CHKERRQ(ierr);
ierr = PetscOptionsInt("-mat_fd_coloring_bcols","Number of block columns","MatFDColoringSetBlockSize",matfd->bcols,&matfd->bcols,&flg);CHKERRQ(ierr);
if (flg && matfd->bcols > matfd->ncolors) {
/* input bcols cannot be > matfd->ncolors, thus set it as ncolors */
matfd->bcols = matfd->ncolors;
}
/* process any options handlers added with PetscObjectAddOptionsHandler() */
ierr = PetscObjectProcessOptionsHandlers((PetscObject)matfd);CHKERRQ(ierr);
PetscOptionsEnd();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode ProcessOptions(MPI_Comm comm, AppCtx *options)
{
const char *names[8] = {"none", "ghosted", "mirror", "periodic", "twist", "DMBoundaryType", "DM_BOUNDARY_", NULL};
PetscInt n;
PetscErrorCode ierr;
PetscFunctionBegin;
options->dim = 2;
options->cellSimplex = PETSC_TRUE;
options->faces[0] = 1;
options->faces[1] = 1;
options->faces[2] = 1;
options->periodicity[0] = DM_BOUNDARY_NONE;
options->periodicity[1] = DM_BOUNDARY_NONE;
options->periodicity[2] = DM_BOUNDARY_NONE;
options->filename[0] = '\0';
ierr = PetscOptionsBegin(comm, "", "Meshing Interpolation Test Options", "DMPLEX");CHKERRQ(ierr);
ierr = PetscOptionsInt("-dim", "The topological mesh dimension", "ex32.c", options->dim, &options->dim, NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-cell_simplex", "Use simplices if true, otherwise hexes", "ex32.c", options->cellSimplex, &options->cellSimplex, NULL);CHKERRQ(ierr);
n = 3;
ierr = PetscOptionsIntArray("-faces", "Faces per direction", "ex32.c", options->faces, &n, NULL);CHKERRQ(ierr);
n = 3;
ierr = PetscOptionsEnumArray("-periodicity", "Periodicity per direction", "ex32.c", names, (PetscEnum *) options->periodicity, &n, &options->isPeriodic);CHKERRQ(ierr);
ierr = PetscOptionsString("-filename", "The mesh file", "ex32.c", options->filename, options->filename, PETSC_MAX_PATH_LEN, NULL);CHKERRQ(ierr);
ierr = PetscOptionsEnd();
PetscFunctionReturn(0);
}
dErr dUnitsSetFromOptions(dUnits un)
{
dErr err;
dFunctionBegin;
dValidHeader(un,dUNITS_CLASSID,1);
err = PetscOptionsBegin(((PetscObject)un)->comm,((PetscObject)un)->prefix,"Units manager","dUnits");dCHK(err);
for (dUnitsBaseType btype = 0; btype < dUNITS_MAX; btype++) {
char opt[256],help[256],uspec[256];
dReal commonpersi = 1.0,scale = 1.0;
dBool flg;
err = PetscSNPrintf(opt,sizeof opt,"-units_%s",dUnitsBaseTypes[btype]);dCHK(err);
err = PetscSNPrintf(uspec,sizeof uspec,"%s:%s:%f:%f",dUnitsBaseNamesSI[btype],dUnitsBaseNamesShortSI[btype],commonpersi,scale);
err = PetscSNPrintf(help,sizeof help,"Common name:short name:one common unit of %s expressed in %s:common units per non-dimensionalized",dUnitsBaseTypes[btype],dUnitsBaseNamesSI[btype]);dCHK(err);
err = PetscOptionsString(opt,help,"dUnitsSetBase",uspec,uspec,sizeof uspec,&flg);dCHK(err);
if (flg) {
char *longname,*shortname,*buf1,*buf2;
longname = uspec;
if (!(shortname = strchr(longname,':'))) dERROR(((dObject)un)->comm,PETSC_ERR_USER,"The field specification '%s' is ':' delimited",opt);
*shortname++ = 0;
if (!(buf1 = strchr(shortname,':'))) dERROR(((dObject)un)->comm,PETSC_ERR_USER,"The field specification for '%s' needs four arguments, but only two given",longname);
*buf1++ = 0;
if (!(buf2 = strchr(buf1,':'))) dERROR(((dObject)un)->comm,PETSC_ERR_USER,"The field specification for '%s' needs four arguments, but only three given",longname);
*buf2++ = 0;
if (sscanf(buf1,"%lf",&commonpersi) != 1) dERROR(((dObject)un)->comm,PETSC_ERR_USER,"Size of common unit '%s' could not be parsed from '%s'",longname,buf1);
if (sscanf(buf2,"%lf",&scale) != 1) dERROR(((dObject)un)->comm,PETSC_ERR_USER,"Scale for common unit '%s' could not be parsed from '%s'",longname,buf2);
err = dUnitsSetBase(un,btype,longname,shortname,commonpersi,scale,NULL);dCHK(err);
}
}
err = PetscOptionsEnd();dCHK(err);
dFunctionReturn(0);
}
PetscErrorCode ProcessOptions(MPI_Comm comm, AppCtx *options)
{
PetscErrorCode ierr;
PetscFunctionBegin;
options->debug = 0;
options->dim = 2;
options->interpolate = PETSC_FALSE;
options->refinementLimit = 0.0;
options->cellSimplex = PETSC_TRUE;
options->filename[0] = '\0';
options->testPartition = PETSC_FALSE;
options->overlap = PETSC_FALSE;
options->testShape = PETSC_FALSE;
ierr = PetscOptionsBegin(comm, "", "Meshing Problem Options", "DMPLEX");CHKERRQ(ierr);
ierr = PetscOptionsInt("-debug", "The debugging level", "ex1.c", options->debug, &options->debug, NULL);CHKERRQ(ierr);
ierr = PetscOptionsInt("-dim", "The topological mesh dimension", "ex1.c", options->dim, &options->dim, NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-interpolate", "Generate intermediate mesh elements", "ex1.c", options->interpolate, &options->interpolate, NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-refinement_limit", "The largest allowable cell volume", "ex1.c", options->refinementLimit, &options->refinementLimit, NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-cell_simplex", "Use simplices if true, otherwise hexes", "ex1.c", options->cellSimplex, &options->cellSimplex, NULL);CHKERRQ(ierr);
ierr = PetscOptionsString("-filename", "The mesh file", "ex1.c", options->filename, options->filename, PETSC_MAX_PATH_LEN, NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-test_partition", "Use a fixed partition for testing", "ex1.c", options->testPartition, &options->testPartition, NULL);CHKERRQ(ierr);
ierr = PetscOptionsInt("-overlap", "The cell overlap for partitioning", "ex1.c", options->overlap, &options->overlap, NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-test_shape", "Report cell shape qualities (Jacobian condition numbers)", "ex1.c", options->testShape, &options->testShape, NULL);CHKERRQ(ierr);
ierr = PetscOptionsEnd();
ierr = PetscLogEventRegister("CreateMesh", DM_CLASSID, &options->createMeshEvent);CHKERRQ(ierr);
PetscFunctionReturn(0);
};
PetscErrorCode ProcessOptions(MPI_Comm comm, AppCtx *options)
{
const char *bcTypes[2] = {"neumann", "dirichlet"};
const char *runTypes[2] = {"full", "test"};
PetscInt bc, run;
PetscErrorCode ierr;
PetscFunctionBeginUser;
options->debug = 0;
options->runType = RUN_FULL;
options->dim = 2;
options->interpolate = PETSC_FALSE;
options->refinementLimit = 0.0;
options->bcType = DIRICHLET;
options->numBatches = 1;
options->numBlocks = 1;
options->jacobianMF = PETSC_FALSE;
options->showInitial = PETSC_FALSE;
options->showSolution = PETSC_TRUE;
options->fem.f0Funcs = (void (**)(const PetscScalar[], const PetscScalar[], const PetscScalar[], const PetscScalar[], const PetscReal[], PetscScalar[])) &options->f0Funcs;
options->fem.f1Funcs = (void (**)(const PetscScalar[], const PetscScalar[], const PetscScalar[], const PetscScalar[], const PetscReal[], PetscScalar[])) &options->f1Funcs;
options->fem.g0Funcs = (void (**)(const PetscScalar[], const PetscScalar[], const PetscScalar[], const PetscScalar[], const PetscReal[], PetscScalar[])) &options->g0Funcs;
options->fem.g1Funcs = (void (**)(const PetscScalar[], const PetscScalar[], const PetscScalar[], const PetscScalar[], const PetscReal[], PetscScalar[])) &options->g1Funcs;
options->fem.g2Funcs = (void (**)(const PetscScalar[], const PetscScalar[], const PetscScalar[], const PetscScalar[], const PetscReal[], PetscScalar[])) &options->g2Funcs;
options->fem.g3Funcs = (void (**)(const PetscScalar[], const PetscScalar[], const PetscScalar[], const PetscScalar[], const PetscReal[], PetscScalar[])) &options->g3Funcs;
ierr = MPI_Comm_size(comm, &options->numProcs);CHKERRQ(ierr);
ierr = MPI_Comm_rank(comm, &options->rank);CHKERRQ(ierr);
ierr = PetscOptionsBegin(comm, "", "Stokes Problem Options", "DMPLEX");CHKERRQ(ierr);
ierr = PetscOptionsInt("-debug", "The debugging level", "ex62.c", options->debug, &options->debug, NULL);CHKERRQ(ierr);
run = options->runType;
ierr = PetscOptionsEList("-run_type", "The run type", "ex62.c", runTypes, 2, runTypes[options->runType], &run, NULL);CHKERRQ(ierr);
options->runType = (RunType) run;
ierr = PetscOptionsInt("-dim", "The topological mesh dimension", "ex62.c", options->dim, &options->dim, NULL);CHKERRQ(ierr);
spatialDim = options->dim;
ierr = PetscOptionsBool("-interpolate", "Generate intermediate mesh elements", "ex62.c", options->interpolate, &options->interpolate, NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-refinement_limit", "The largest allowable cell volume", "ex62.c", options->refinementLimit, &options->refinementLimit, NULL);CHKERRQ(ierr);
ierr = PetscStrcpy(options->partitioner, "chaco");CHKERRQ(ierr);
ierr = PetscOptionsString("-partitioner", "The graph partitioner", "pflotran.cxx", options->partitioner, options->partitioner, 2048, NULL);CHKERRQ(ierr);
bc = options->bcType;
ierr = PetscOptionsEList("-bc_type","Type of boundary condition","ex62.c",bcTypes,2,bcTypes[options->bcType],&bc,NULL);CHKERRQ(ierr);
options->bcType = (BCType) bc;
ierr = PetscOptionsInt("-gpu_batches", "The number of cell batches per kernel", "ex62.c", options->numBatches, &options->numBatches, NULL);CHKERRQ(ierr);
ierr = PetscOptionsInt("-gpu_blocks", "The number of concurrent blocks per kernel", "ex62.c", options->numBlocks, &options->numBlocks, NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-jacobian_mf", "Calculate the action of the Jacobian on the fly", "ex62.c", options->jacobianMF, &options->jacobianMF, NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-show_initial", "Output the initial guess for verification", "ex62.c", options->showInitial, &options->showInitial, NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-show_solution", "Output the solution for verification", "ex62.c", options->showSolution, &options->showSolution, NULL);CHKERRQ(ierr);
ierr = PetscOptionsEnd();
ierr = PetscLogEventRegister("CreateMesh", DM_CLASSID, &options->createMeshEvent);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode PCSetFromOptions_Factor(PC pc)
{
PC_Factor *factor = (PC_Factor*)pc->data;
PetscErrorCode ierr;
PetscBool flg = PETSC_FALSE,set;
char tname[256], solvertype[64];
PetscFunctionList ordlist;
PetscEnum etmp;
PetscFunctionBegin;
if (!MatOrderingRegisterAllCalled) {ierr = MatOrderingRegisterAll();CHKERRQ(ierr);}
ierr = PetscOptionsBool("-pc_factor_in_place","Form factored matrix in the same memory as the matrix","PCFactorSetUseInPlace",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {
ierr = PCFactorSetUseInPlace(pc);CHKERRQ(ierr);
}
ierr = PetscOptionsReal("-pc_factor_fill","Expected non-zeros in factored matrix","PCFactorSetFill",((PC_Factor*)factor)->info.fill,&((PC_Factor*)factor)->info.fill,0);CHKERRQ(ierr);
ierr = PetscOptionsEnum("-pc_factor_shift_type","Type of shift to add to diagonal","PCFactorSetShiftType",
MatFactorShiftTypes,(PetscEnum)(int)((PC_Factor*)factor)->info.shifttype,&etmp,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PCFactorSetShiftType(pc,(MatFactorShiftType)etmp);CHKERRQ(ierr);
}
ierr = PetscOptionsReal("-pc_factor_shift_amount","Shift added to diagonal","PCFactorSetShiftAmount",((PC_Factor*)factor)->info.shiftamount,&((PC_Factor*)factor)->info.shiftamount,0);CHKERRQ(ierr);
ierr = PetscOptionsReal("-pc_factor_zeropivot","Pivot is considered zero if less than","PCFactorSetZeroPivot",((PC_Factor*)factor)->info.zeropivot,&((PC_Factor*)factor)->info.zeropivot,0);CHKERRQ(ierr);
ierr = PetscOptionsReal("-pc_factor_column_pivot","Column pivot tolerance (used only for some factorization)","PCFactorSetColumnPivot",((PC_Factor*)factor)->info.dtcol,&((PC_Factor*)factor)->info.dtcol,&flg);CHKERRQ(ierr);
flg = ((PC_Factor*)factor)->info.pivotinblocks ? PETSC_TRUE : PETSC_FALSE;
ierr = PetscOptionsBool("-pc_factor_pivot_in_blocks","Pivot inside matrix dense blocks for BAIJ and SBAIJ","PCFactorSetPivotInBlocks",flg,&flg,&set);CHKERRQ(ierr);
if (set) {
ierr = PCFactorSetPivotInBlocks(pc,flg);CHKERRQ(ierr);
}
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-pc_factor_reuse_fill","Use fill from previous factorization","PCFactorSetReuseFill",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {
ierr = PCFactorSetReuseFill(pc,PETSC_TRUE);CHKERRQ(ierr);
}
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-pc_factor_reuse_ordering","Reuse ordering from previous factorization","PCFactorSetReuseOrdering",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {
ierr = PCFactorSetReuseOrdering(pc,PETSC_TRUE);CHKERRQ(ierr);
}
ierr = MatGetOrderingList(&ordlist);CHKERRQ(ierr);
ierr = PetscOptionsList("-pc_factor_mat_ordering_type","Reordering to reduce nonzeros in factored matrix","PCFactorSetMatOrderingType",ordlist,((PC_Factor*)factor)->ordering,tname,256,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PCFactorSetMatOrderingType(pc,tname);CHKERRQ(ierr);
}
/* maybe should have MatGetSolverTypes(Mat,&list) like the ordering list */
ierr = PetscOptionsString("-pc_factor_mat_solver_package","Specific direct solver to use","MatGetFactor",((PC_Factor*)factor)->solvertype,solvertype,64,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PCFactorSetMatSolverPackage(pc,solvertype);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
/*@
PetscBagSetFromOptions - Allows setting options from a bag
Collective on PetscBag
Input Parameter:
. bag - the bag of values
Level: beginner
.seealso: PetscBag, PetscBagSetName(), PetscBagDestroy(), PetscBagLoad(), PetscBagGetData()
PetscBagRegisterReal(), PetscBagRegisterInt(), PetscBagRegisterBool(), PetscBagRegisterScalar()
PetscBagSetFromOptions(), PetscBagCreate(), PetscBagGetName(), PetscBagView(), PetscBagRegisterEnum()
@*/
PetscErrorCode PetscBagSetFromOptions(PetscBag bag)
{
PetscErrorCode ierr;
PetscBagItem nitem = bag->bagitems;
char name[PETSC_BAG_NAME_LENGTH+1],helpname[PETSC_BAG_NAME_LENGTH+PETSC_BAG_HELP_LENGTH+3];
PetscInt n;
PetscFunctionBegin;
ierr = PetscStrcpy(helpname,bag->bagname);CHKERRQ(ierr);
ierr = PetscStrcat(helpname," ");CHKERRQ(ierr);
ierr = PetscStrcat(helpname,bag->baghelp);CHKERRQ(ierr);
ierr = PetscOptionsBegin(bag->bagcomm,bag->bagprefix,helpname,0);CHKERRQ(ierr);
while (nitem) {
name[0] = '-';
name[1] = 0;
ierr = PetscStrcat(name,nitem->name);CHKERRQ(ierr);
if (nitem->dtype == PETSC_CHAR) { /* special handling for fortran required? [due to space padding vs null termination] */
char *value = (char*)(((char*)bag) + nitem->offset);
ierr = PetscOptionsString(name,nitem->help,"",value,value,nitem->msize,NULL);CHKERRQ(ierr);
} else if (nitem->dtype == PETSC_REAL) {
PetscReal *value = (PetscReal*)(((char*)bag) + nitem->offset);
if (nitem->msize == 1) {
ierr = PetscOptionsReal(name,nitem->help,"",*value,value,NULL);CHKERRQ(ierr);
} else {
n = nitem->msize;
ierr = PetscOptionsRealArray(name,nitem->help,"",value,&n,NULL);CHKERRQ(ierr);
}
} else if (nitem->dtype == PETSC_SCALAR) {
PetscScalar *value = (PetscScalar*)(((char*)bag) + nitem->offset);
ierr = PetscOptionsScalar(name,nitem->help,"",*value,value,NULL);CHKERRQ(ierr);
} else if (nitem->dtype == PETSC_INT) {
PetscInt *value = (PetscInt*)(((char*)bag) + nitem->offset);
if (nitem->msize == 1) {
ierr = PetscOptionsInt(name,nitem->help,"",*value,value,NULL);CHKERRQ(ierr);
} else {
n = nitem->msize;
ierr = PetscOptionsIntArray(name,nitem->help,"",value,&n,NULL);CHKERRQ(ierr);
}
} else if (nitem->dtype == PETSC_ENUM) {
PetscEnum *value = (PetscEnum*)(((char*)bag) + nitem->offset);
PetscInt i = 0;
while (nitem->list[i++]) ;
ierr = PetscOptionsEnum(name,nitem->help,nitem->list[i-3],(const char*const*)nitem->list,*value,value,NULL);CHKERRQ(ierr);
} else if (nitem->dtype == PETSC_BOOL) {
PetscBool *value = (PetscBool*)(((char*)bag) + nitem->offset);
if (nitem->msize == 1) {
ierr = PetscOptionsBool(name,nitem->help,"",*value,value,NULL);CHKERRQ(ierr);
} else {
n = nitem->msize;
ierr = PetscOptionsBoolArray(name,nitem->help,"",value,&n,NULL);CHKERRQ(ierr);
}
}
nitem = nitem->next;
}
PetscOptionsEnd();
PetscFunctionReturn(0);
}
int main(int argc, char **argv)
{
PetscErrorCode ierr; /* Error code */
char ptype[256] = "hull1972a1"; /* Problem specification */
PetscInt n_refine = 1; /* Number of refinement levels for convergence analysis */
PetscReal refine_fac = 2.0; /* Refinement factor for dt */
PetscReal dt_initial = 0.01; /* Initial default value of dt */
PetscReal dt;
PetscReal tfinal = 20.0; /* Final time for the time-integration */
PetscInt maxiter = 100000; /* Maximum number of time-integration iterations */
PetscReal *error; /* Array to store the errors for convergence analysis */
PetscMPIInt size; /* No of processors */
PetscBool flag; /* Flag denoting availability of exact solution */
PetscInt r;
/* Initialize program */
PetscInitialize(&argc,&argv,(char*)0,help);
/* Check if running with only 1 proc */
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
if (size>1) SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"Only for sequential runs");
ierr = PetscOptionsString("-problem","Problem specification","<hull1972a1>",
ptype,ptype,sizeof(ptype),NULL);CHKERRQ(ierr);
ierr = PetscOptionsInt("-refinement_levels","Number of refinement levels for convergence analysis",
"<1>",n_refine,&n_refine,NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-refinement_factor","Refinement factor for dt","<2.0>",
refine_fac,&refine_fac,NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-dt","Time step size (for convergence analysis, initial time step)",
"<0.01>",dt_initial,&dt_initial,NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-final_time","Final time for the time-integration","<20.0>",
tfinal,&tfinal,NULL);CHKERRQ(ierr);
ierr = PetscMalloc1(n_refine,&error);CHKERRQ(ierr);
for (r = 0,dt = dt_initial; r < n_refine; r++) {
error[r] = 0;
if (r > 0) dt /= refine_fac;
ierr = PetscPrintf(PETSC_COMM_WORLD,"Solving ODE \"%s\" with dt %f, final time %f and system size %D.\n",ptype,(double)dt,(double)tfinal,GetSize(&ptype[0]));
ierr = SolveODE(&ptype[0],dt,tfinal,maxiter,&error[r],&flag);
if (flag) {
/* If exact solution available for the specified ODE */
if (r > 0) {
PetscReal conv_rate = (PetscLogReal(error[r]) - PetscLogReal(error[r-1])) / (-PetscLogReal(refine_fac));
ierr = PetscPrintf(PETSC_COMM_WORLD,"Error = %E,\tConvergence rate = %f\n.",(double)error[r],(double)conv_rate);CHKERRQ(ierr);
} else {
ierr = PetscPrintf(PETSC_COMM_WORLD,"Error = %E.\n",error[r]);CHKERRQ(ierr);
}
}
}
ierr = PetscFree(error);CHKERRQ(ierr);
/* Exit */
PetscFinalize();
return(0);
}
PetscErrorCode MatPartitioningSetFromOptions_Party(MatPartitioning part)
{
PetscErrorCode ierr;
PetscTruth flag, b;
char value[15];
PetscReal r;
PetscFunctionBegin;
ierr = PetscOptionsHead("Set Party partitioning options");CHKERRQ(ierr);
ierr = PetscOptionsString("-mat_partitioning_party_global",
"Global method to use", "MatPartitioningPartySetGlobal", "gcf,gbf",
value, 15, &flag);CHKERRQ(ierr);
if (flag)
ierr = MatPartitioningPartySetGlobal(part, value);CHKERRQ(ierr);
ierr = PetscOptionsString("-mat_partitioning_party_local",
"Local method to use", "MatPartitioningPartySetLocal", "kl", value, 15,
&flag);CHKERRQ(ierr);
if (flag)
ierr = MatPartitioningPartySetLocal(part, value);CHKERRQ(ierr);
ierr = PetscOptionsReal("-mat_partitioning_party_coarse_level",
"Coarse level", "MatPartitioningPartySetCoarseLevel", 0, &r,
&flag);CHKERRQ(ierr);
if (flag)
ierr = MatPartitioningPartySetCoarseLevel(part, r);CHKERRQ(ierr);
ierr = PetscOptionsTruth("-mat_partitioning_party_match_optimization",
"Matching optimization on/off (boolean)",
"MatPartitioningPartySetMatchOptimization", PETSC_TRUE, &b, &flag);CHKERRQ(ierr);
if (flag)
ierr = MatPartitioningPartySetMatchOptimization(part, b);CHKERRQ(ierr);
ierr = PetscOptionsTruth("-mat_partitioning_party_bipart",
"Bipartitioning option on/off (boolean)",
"MatPartitioningPartySetBipart", PETSC_TRUE, &b, &flag);CHKERRQ(ierr);
if (flag)
ierr = MatPartitioningPartySetBipart(part, b);CHKERRQ(ierr);
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@C
PetscDrawSetFromOptions - Sets the graphics type from the options database.
Defaults to a PETSc X windows graphics.
Collective on PetscDraw
Input Parameter:
. draw - the graphics context
Options Database Keys:
+ -nox - do not use X graphics (ignore graphics calls, but run program correctly)
- -nox_warning - when X windows support is not installed this prevents the warning message
from being printed
Level: intermediate
Notes:
Must be called after PetscDrawCreate() before the PetscDrawtor is used.
Concepts: drawing^setting options
Concepts: graphics^setting options
.seealso: PetscDrawCreate(), PetscDrawSetType()
@*/
PetscErrorCode PetscDrawSetFromOptions(PetscDraw draw)
{
PetscErrorCode ierr;
PetscBool flg,nox;
char vtype[256];
const char *def;
PetscBool save;
#if !defined(PETSC_USE_WINDOWS_GRAPHICS) && !defined(PETSC_HAVE_X)
PetscBool warn;
#endif
char filename[PETSC_MAX_PATH_LEN];
PetscBool movie = PETSC_FALSE;
PetscFunctionBegin;
PetscValidHeaderSpecific(draw,PETSC_DRAW_CLASSID,1);
if (!PetscDrawList) {
ierr = PetscDrawRegisterAll(PETSC_NULL);CHKERRQ(ierr);
}
if (((PetscObject)draw)->type_name) {
def = ((PetscObject)draw)->type_name;
} else {
ierr = PetscOptionsHasName(PETSC_NULL,"-nox",&nox);CHKERRQ(ierr);
def = PETSC_DRAW_NULL;
#if defined(PETSC_USE_WINDOWS_GRAPHICS) && !defined(PETSC_HAVE_X)
if (!nox) def = PETSC_DRAW_WIN32;
#elif defined(PETSC_HAVE_X)
if (!nox) def = PETSC_DRAW_X;
#else
ierr = PetscOptionsHasName(PETSC_NULL,"-nox_warning",&warn);CHKERRQ(ierr);
if (!nox && !warn) {
(*PetscErrorPrintf)("PETSc installed without X windows on this machine\nproceeding without graphics\n");
}
#endif
}
ierr = PetscObjectOptionsBegin((PetscObject)draw);CHKERRQ(ierr);
ierr = PetscOptionsList("-draw_type","Type of graphical output","PetscDrawSetType",PetscDrawList,def,vtype,256,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PetscDrawSetType(draw,vtype);CHKERRQ(ierr);
} else if (!((PetscObject)draw)->type_name) {
ierr = PetscDrawSetType(draw,def);CHKERRQ(ierr);
}
ierr = PetscOptionsName("-nox","Run without graphics","None",&nox);CHKERRQ(ierr);
ierr = PetscOptionsBool("-draw_save_movie","Make a movie from the images saved","PetscDrawSetSave",movie,&movie,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsString("-draw_save","Save graphics to file","PetscDrawSetSave",filename,filename,PETSC_MAX_PATH_LEN,&save);CHKERRQ(ierr);
if (save) {
ierr = PetscDrawSetSave(draw,filename,movie);CHKERRQ(ierr);
}
/* process any options handlers added with PetscObjectAddOptionsHandler() */
ierr = PetscObjectProcessOptionsHandlers((PetscObject)draw);CHKERRQ(ierr);
ierr = PetscOptionsEnd();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode MatPartitioningSetFromOptions_Hierarchical(PetscOptions *PetscOptionsObject,MatPartitioning part)
{
MatPartitioning_Hierarchical *hpart = (MatPartitioning_Hierarchical*)part->data;
PetscErrorCode ierr;
char value[1024];
PetscBool flag = PETSC_FALSE;
PetscFunctionBegin;
ierr = PetscOptionsHead(PetscOptionsObject,"Set hierarchical partitioning options");CHKERRQ(ierr);
ierr = PetscOptionsString("-mat_partitioning_hierarchical_coarseparttype","coarse part type",PETSC_NULL,PETSC_NULL,value,1024,&flag);CHKERRQ(ierr);
if(flag){
ierr = PetscCalloc1(1024,&hpart->coarseparttype);CHKERRQ(ierr);
ierr = PetscStrcpy(hpart->coarseparttype,value);CHKERRQ(ierr);
}
ierr = PetscOptionsString("-mat_partitioning_hierarchical_fineparttype","fine part type",PETSC_NULL,PETSC_NULL,value,1024,&flag);CHKERRQ(ierr);
if(flag){
ierr = PetscCalloc1(1024,&hpart->fineparttype);CHKERRQ(ierr);
ierr = PetscStrcpy(hpart->fineparttype,value);CHKERRQ(ierr);
}
ierr = PetscOptionsInt("-mat_partitioning_hierarchical_Ncoarseparts","number of coarse parts",PETSC_NULL,0,&hpart->Ncoarseparts,&flag);CHKERRQ(ierr);
ierr = PetscOptionsInt("-mat_partitioning_hierarchical_Nfineparts","number of fine parts",PETSC_NULL,1,&hpart->Nfineparts,&flag);CHKERRQ(ierr);
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode PFSetFromOptions_Matlab(PF pf)
{
PetscErrorCode ierr;
PetscTruth flag;
char value[256];
PF_Matlab *matlab = (PF_Matlab*)pf->data;
PetscFunctionBegin;
ierr = PetscOptionsHead("Matlab function options");CHKERRQ(ierr);
ierr = PetscOptionsString("-pf_matlab","Matlab function","None","",value,256,&flag);CHKERRQ(ierr);
if (flag) {
ierr = PetscStrallocpy((char*)value,&matlab->string);CHKERRQ(ierr);
}
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode PFSetFromOptions_String(PF pf)
{
PetscErrorCode ierr;
PetscTruth flag;
char value[PETSC_MAX_PATH_LEN];
PetscErrorCode (*f)(void*,PetscInt,PetscScalar*,PetscScalar*) = 0;
PetscFunctionBegin;
ierr = PetscOptionsHead("String function options");CHKERRQ(ierr);
ierr = PetscOptionsString("-pf_string","Enter the function","PFStringCreateFunction","",value,PETSC_MAX_PATH_LEN,&flag);CHKERRQ(ierr);
if (flag) {
ierr = PFStringCreateFunction(pf,value,(void**)&f);CHKERRQ(ierr);
pf->ops->apply = f;
}
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode KSPSetFromOptions_LSQR(KSP ksp)
{
PetscErrorCode ierr;
KSP_LSQR *lsqr = (KSP_LSQR*)ksp->data;
char monfilename[PETSC_MAX_PATH_LEN];
PetscViewer monviewer;
PetscBool flg;
PetscFunctionBegin;
ierr = PetscOptionsHead("KSP LSQR Options");CHKERRQ(ierr);
ierr = PetscOptionsName("-ksp_lsqr_set_standard_error","Set Standard Error Estimates of Solution","KSPLSQRSetStandardErrorVec",&lsqr->se_flg);CHKERRQ(ierr);
ierr = PetscOptionsString("-ksp_lsqr_monitor","Monitor residual norm and norm of residual of normal equations","KSPMonitorSet","stdout",monfilename,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PetscViewerASCIIOpen(PetscObjectComm((PetscObject)ksp),monfilename,&monviewer);CHKERRQ(ierr);
ierr = KSPMonitorSet(ksp,KSPLSQRMonitorDefault,monviewer,(PetscErrorCode (*)(void**))PetscViewerDestroy);CHKERRQ(ierr);
}
ierr = PetscOptionsTail();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode ProcessOptions(MPI_Comm comm, AppCtx *options)
{
PetscErrorCode ierr;
PetscFunctionBegin;
options->debug = 0;
options->dim = 2;
options->testNum = 0;
options->uninterpolate = PETSC_FALSE;
options->filename[0] = '\0';
ierr = PetscOptionsBegin(comm, "", "Meshing Problem Options", "DMPLEX");CHKERRQ(ierr);
ierr = PetscOptionsInt("-debug", "The debugging level", "ex14.c", options->debug, &options->debug, NULL);CHKERRQ(ierr);
ierr = PetscOptionsInt("-dim", "The topological mesh dimension", "ex14.c", options->dim, &options->dim, NULL);CHKERRQ(ierr);
ierr = PetscOptionsInt("-test_num", "The particular mesh to test", "ex14.c", options->testNum, &options->testNum, NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-uninterpolate", "Uninterpolate the mesh at the end", "ex14.c", options->uninterpolate, &options->uninterpolate, NULL);CHKERRQ(ierr);
ierr = PetscOptionsString("-f", "Filename to read", "ex14.c", options->filename, options->filename, sizeof(options->filename), NULL);CHKERRQ(ierr);
ierr = PetscOptionsEnd();
PetscFunctionReturn(0);
};
PetscErrorCode ProcessOptions(MPI_Comm comm, AppCtx *options)
{
PetscErrorCode ierr;
PetscFunctionBegin;
options->debug = 0;
options->testNum = 0;
options->dim = 2;
options->cellSimplex = PETSC_TRUE;
options->useGenerator = PETSC_FALSE;
options->filename[0] = '\0';
ierr = PetscOptionsBegin(comm, "", "Meshing Interpolation Test Options", "DMPLEX");CHKERRQ(ierr);
ierr = PetscOptionsInt("-debug", "The debugging level", "ex7.c", options->debug, &options->debug, NULL);CHKERRQ(ierr);
ierr = PetscOptionsInt("-testnum", "The mesh to create", "ex7.c", options->testNum, &options->testNum, NULL);CHKERRQ(ierr);
ierr = PetscOptionsInt("-dim", "The topological mesh dimension", "ex7.c", options->dim, &options->dim, NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-cell_simplex", "Use simplices if true, otherwise hexes", "ex7.c", options->cellSimplex, &options->cellSimplex, NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-use_generator", "Use a mesh generator to build the mesh", "ex7.c", options->useGenerator, &options->useGenerator, NULL);CHKERRQ(ierr);
ierr = PetscOptionsString("-filename", "The mesh file", "ex7.c", options->filename, options->filename, PETSC_MAX_PATH_LEN, NULL);CHKERRQ(ierr);
ierr = PetscOptionsEnd();
PetscFunctionReturn(0);
};
static PetscErrorCode ProcessOptions(MPI_Comm comm, AppCtx *options)
{
const char *pointTypes[3] = {"centroid", "grid", "grid_replicated"};
PetscInt pt;
PetscErrorCode ierr;
PetscFunctionBegin;
options->dim = 3;
options->cellSimplex = PETSC_TRUE;
options->filename[0] = '\0';
options->pointType = CENTROID;
ierr = PetscOptionsBegin(comm, "", "Interpolation Options", "DMPLEX");CHKERRQ(ierr);
ierr = PetscOptionsInt("-dim", "The topological mesh dimension", "ex2.c", options->dim, &options->dim, NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-cell_simplex", "Use simplices if true, otherwise hexes", "ex2.c", options->cellSimplex, &options->cellSimplex, NULL);CHKERRQ(ierr);
ierr = PetscOptionsString("-filename", "The mesh file", "ex2.c", options->filename, options->filename, PETSC_MAX_PATH_LEN, NULL);CHKERRQ(ierr);
pt = options->pointType;
ierr = PetscOptionsEList("-point_type", "The point type", "ex2.c", pointTypes, 3, pointTypes[options->pointType], &pt, NULL);CHKERRQ(ierr);
options->pointType = (PointType) pt;
ierr = PetscOptionsEnd();
PetscFunctionReturn(0);
}
PetscErrorCode SNESSetFromOptions_FAS(PetscOptions *PetscOptionsObject,SNES snes)
{
SNES_FAS *fas = (SNES_FAS*) snes->data;
PetscInt levels = 1;
PetscBool flg = PETSC_FALSE, upflg = PETSC_FALSE, downflg = PETSC_FALSE, monflg = PETSC_FALSE, galerkinflg = PETSC_FALSE,continuationflg = PETSC_FALSE;
PetscErrorCode ierr;
char monfilename[PETSC_MAX_PATH_LEN];
SNESFASType fastype;
const char *optionsprefix;
SNESLineSearch linesearch;
PetscInt m, n_up, n_down;
SNES next;
PetscBool isFine;
PetscFunctionBegin;
ierr = SNESFASCycleIsFine(snes, &isFine);CHKERRQ(ierr);
ierr = PetscOptionsHead(PetscOptionsObject,"SNESFAS Options-----------------------------------");CHKERRQ(ierr);
/* number of levels -- only process most options on the finest level */
if (isFine) {
ierr = PetscOptionsInt("-snes_fas_levels", "Number of Levels", "SNESFASSetLevels", levels, &levels, &flg);CHKERRQ(ierr);
if (!flg && snes->dm) {
ierr = DMGetRefineLevel(snes->dm,&levels);CHKERRQ(ierr);
levels++;
fas->usedmfornumberoflevels = PETSC_TRUE;
}
ierr = SNESFASSetLevels(snes, levels, NULL);CHKERRQ(ierr);
fastype = fas->fastype;
ierr = PetscOptionsEnum("-snes_fas_type","FAS correction type","SNESFASSetType",SNESFASTypes,(PetscEnum)fastype,(PetscEnum*)&fastype,&flg);CHKERRQ(ierr);
if (flg) {
ierr = SNESFASSetType(snes, fastype);CHKERRQ(ierr);
}
ierr = SNESGetOptionsPrefix(snes, &optionsprefix);CHKERRQ(ierr);
ierr = PetscOptionsInt("-snes_fas_cycles","Number of cycles","SNESFASSetCycles",fas->n_cycles,&m,&flg);CHKERRQ(ierr);
if (flg) {
ierr = SNESFASSetCycles(snes, m);CHKERRQ(ierr);
}
ierr = PetscOptionsBool("-snes_fas_continuation","Corrected grid-sequence continuation","SNESFASSetContinuation",fas->continuation,&continuationflg,&flg);CHKERRQ(ierr);
if (flg) {
ierr = SNESFASSetContinuation(snes,continuationflg);CHKERRQ(ierr);
}
ierr = PetscOptionsBool("-snes_fas_galerkin", "Form coarse problems with Galerkin","SNESFASSetGalerkin",fas->galerkin,&galerkinflg,&flg);CHKERRQ(ierr);
if (flg) {
ierr = SNESFASSetGalerkin(snes, galerkinflg);CHKERRQ(ierr);
}
if (fas->fastype == SNES_FAS_FULL) {
ierr = PetscOptionsBool("-snes_fas_full_downsweep","Smooth on the initial upsweep for full FAS cycles","SNESFASFullSetDownSweep",fas->full_downsweep,&fas->full_downsweep,&flg);CHKERRQ(ierr);
if (flg) {SNESFASFullSetDownSweep(snes,fas->full_downsweep);CHKERRQ(ierr);}
}
ierr = PetscOptionsInt("-snes_fas_smoothup","Number of post-smoothing steps","SNESFASSetNumberSmoothUp",fas->max_up_it,&n_up,&upflg);CHKERRQ(ierr);
ierr = PetscOptionsInt("-snes_fas_smoothdown","Number of pre-smoothing steps","SNESFASSetNumberSmoothDown",fas->max_down_it,&n_down,&downflg);CHKERRQ(ierr);
ierr = PetscOptionsString("-snes_fas_monitor","Monitor FAS progress","SNESFASSetMonitor","stdout",monfilename,PETSC_MAX_PATH_LEN,&monflg);CHKERRQ(ierr);
if (monflg) ierr = SNESFASSetMonitor(snes, PETSC_TRUE);CHKERRQ(ierr);
flg = PETSC_FALSE;
monflg = PETSC_TRUE;
ierr = PetscOptionsBool("-snes_fas_log","Log times for each FAS level","SNESFASSetLog",monflg,&monflg,&flg);CHKERRQ(ierr);
if (flg) {ierr = SNESFASSetLog(snes,monflg);CHKERRQ(ierr);}
}
ierr = PetscOptionsTail();CHKERRQ(ierr);
/* setup from the determined types if there is no pointwise procedure or smoother defined */
if (upflg) {
ierr = SNESFASSetNumberSmoothUp(snes,n_up);CHKERRQ(ierr);
}
if (downflg) {
ierr = SNESFASSetNumberSmoothDown(snes,n_down);CHKERRQ(ierr);
}
/* set up the default line search for coarse grid corrections */
if (fas->fastype == SNES_FAS_ADDITIVE) {
if (!snes->linesearch) {
ierr = SNESGetLineSearch(snes, &linesearch);CHKERRQ(ierr);
ierr = SNESLineSearchSetType(linesearch, SNESLINESEARCHL2);CHKERRQ(ierr);
}
}
ierr = SNESFASCycleGetCorrection(snes, &next);CHKERRQ(ierr);
/* recursive option setting for the smoothers */
if (next) {ierr = SNESSetFromOptions(next);CHKERRQ(ierr);}
PetscFunctionReturn(0);
}
int main(int argc, char **argv)
{
MPI_Comm comm;
PetscMPIInt rank;
PetscErrorCode ierr;
User user;
PetscLogDouble v1, v2;
PetscInt nplot = 0;
char filename1[2048], fileName[2048];
PetscBool set = PETSC_FALSE;
PetscInt steps_output;
ierr = PetscInitialize(&argc, &argv, (char*) 0, help);CHKERRQ(ierr);
comm = PETSC_COMM_WORLD;
ierr = MPI_Comm_rank(comm, &rank);CHKERRQ(ierr);
ierr = PetscNew(&user);CHKERRQ(ierr);
ierr = PetscNew(&user->algebra);CHKERRQ(ierr);
ierr = PetscNew(&user->model);CHKERRQ(ierr);
ierr = PetscNew(&user->model->physics);CHKERRQ(ierr);
Algebra algebra = user->algebra;
ierr = LoadOptions(comm, user);CHKERRQ(ierr);
ierr = PetscTime(&v1);CHKERRQ(ierr);
ierr = CreateMesh(comm, user);CHKERRQ(ierr);
ierr = PetscTime(&v2);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,
"Read and Distribute mesh takes %f sec \n", v2 - v1);CHKERRQ(ierr);
ierr = SetUpLocalSpace(user);CHKERRQ(ierr); //Set up the dofs of each element
ierr = ConstructGeometryFVM(&user->facegeom, &user->cellgeom, user);CHKERRQ(ierr);
ierr = LimiterSetup(user);CHKERRQ(ierr);
if(user->output_solution){
// the output file options
ierr = PetscOptionsBegin(PETSC_COMM_WORLD,0,"Options for output solution",0);CHKERRQ(ierr);
ierr = PetscOptionsString("-solutionfile", "solution file", "AeroSim.c", filename1,filename1, 2048, &set);CHKERRQ(ierr);
if(!set){SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_NULL,"please use option -solutionfile to specify solution file name \n");}
ierr = PetscOptionsInt("-steps_output", "the number of time steps between two outputs", "", steps_output, &steps_output, &set);CHKERRQ(ierr);
if(!set){ steps_output = 1;}
ierr = PetscOptionsEnd();CHKERRQ(ierr);
}
if (user->TimeIntegralMethod == EXPLICITMETHOD) {
if(user->myownexplicitmethod){
ierr = PetscPrintf(PETSC_COMM_WORLD,"Using the fully explicit method based on my own routing\n");CHKERRQ(ierr);
user->current_time = user->initial_time;
user->current_step = 1;
ierr = DMCreateGlobalVector(user->dm, &algebra->solution);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) algebra->solution, "solution");CHKERRQ(ierr);
ierr = SetInitialCondition(user->dm, algebra->solution, user);CHKERRQ(ierr);
ierr = VecDuplicate(algebra->solution, &algebra->fn);CHKERRQ(ierr);
ierr = VecDuplicate(algebra->solution, &algebra->oldsolution);CHKERRQ(ierr);
if(user->Explicit_RK2){
ierr = PetscPrintf(PETSC_COMM_WORLD,"Use the second order Runge Kutta method \n");CHKERRQ(ierr);
}else{
ierr = PetscPrintf(PETSC_COMM_WORLD,"Use the first order forward Euler method \n");CHKERRQ(ierr);
}
nplot = 0; //the plot step
while(user->current_time < (user->final_time - 0.05 * user->dt)){
user->current_time = user->current_time + user->dt;
ierr = FormTimeStepFunction(user, algebra, algebra->solution, algebra->fn);CHKERRQ(ierr);
PetscReal fnnorm;
ierr = VecNorm(algebra->fn,NORM_INFINITY,&fnnorm);CHKERRQ(ierr);
if(0){
PetscViewer viewer;
ierr = OutputVTK(user->dm, "function.vtk", &viewer);CHKERRQ(ierr);
ierr = VecView(algebra->fn, viewer);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Step %D at time %g with founction norm = %g \n",
user->current_step, user->current_time, fnnorm);CHKERRQ(ierr);
//break;
}
if(user->Explicit_RK2){
ierr = VecCopy(algebra->solution, algebra->oldsolution);CHKERRQ(ierr);//U^n
ierr = VecAXPY(algebra->solution, user->dt, algebra->fn);CHKERRQ(ierr);//U^{(1)}
ierr = FormTimeStepFunction(user, algebra, algebra->solution, algebra->fn);CHKERRQ(ierr);//f(U^{(1)})
ierr = VecAXPY(algebra->solution, 1.0, algebra->oldsolution);CHKERRQ(ierr);//U^n + U^{(1)}
ierr = VecAXPY(algebra->solution, user->dt, algebra->fn);CHKERRQ(ierr);// + dt*f(U^{(1)})
ierr = VecScale(algebra->solution, 0.5);CHKERRQ(ierr);
}else{
ierr = VecCopy(algebra->solution, algebra->oldsolution);CHKERRQ(ierr);
ierr = VecAXPY(algebra->solution, user->dt, algebra->fn);CHKERRQ(ierr);
}
{// Monitor the solution and function norms
PetscReal norm;
PetscLogDouble space =0;
PetscInt size;
ierr = VecNorm(algebra->solution,NORM_INFINITY,&norm);CHKERRQ(ierr);
ierr = VecGetSize(algebra->solution, &size);CHKERRQ(ierr);
norm = norm/size;
if (norm>1.e5) {
SETERRQ2(PETSC_COMM_WORLD, PETSC_ERR_LIB,
"The norm of the solution is: %f (current time: %f). The explicit method is going to DIVERGE!!!", norm, user->current_time);
}
if (user->current_step%10==0) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"Step %D at time %g with solution norm = %g and founction norm = %g \n",
user->current_step, user->current_time, norm, fnnorm);CHKERRQ(ierr);
}
ierr = PetscMallocGetCurrentUsage(&space);CHKERRQ(ierr);
// if (user->current_step%10==0) {
// ierr = PetscPrintf(PETSC_COMM_WORLD,"Current space PetscMalloc()ed %g M\n",
// space/(1024*1024));CHKERRQ(ierr);
// }
}
{ // Monitor the difference of two steps' solution
PetscReal norm;
ierr = VecAXPY(algebra->oldsolution, -1, algebra->solution);CHKERRQ(ierr);
ierr = VecNorm(algebra->oldsolution,NORM_INFINITY,&norm);CHKERRQ(ierr);
if (user->current_step%10==0) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"Step %D at time %g with ||u_k-u_{k-1}|| = %g \n",
user->current_step, user->current_time, norm);CHKERRQ(ierr);
}
if((norm<1.e-6)||(user->current_step > user->max_time_its)) break;
}
// output the solution
if (user->output_solution && (user->current_step%steps_output==0)){
PetscViewer viewer;
// update file name for the current time step
ierr = PetscSNPrintf(fileName, sizeof(fileName),"%s_%d.vtk",filename1, nplot);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Outputing solution %s (current time %f)\n", fileName, user->current_time);CHKERRQ(ierr);
ierr = OutputVTK(user->dm, fileName, &viewer);CHKERRQ(ierr);
ierr = VecView(algebra->solution, viewer);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr);
nplot++;
}
user->current_step++;
}
ierr = VecDestroy(&algebra->fn);CHKERRQ(ierr);
}else{
PetscReal ftime;
TS ts;
TSConvergedReason reason;
PetscInt nsteps;
ierr = PetscPrintf(PETSC_COMM_WORLD,"Using the fully explicit method based on the PETSC TS routing\n");CHKERRQ(ierr);
ierr = DMCreateGlobalVector(user->dm, &algebra->solution);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) algebra->solution, "solution");CHKERRQ(ierr);
ierr = SetInitialCondition(user->dm, algebra->solution, user);CHKERRQ(ierr);
ierr = TSCreate(comm, &ts);CHKERRQ(ierr);
ierr = TSSetType(ts, TSEULER);CHKERRQ(ierr);
ierr = TSSetDM(ts, user->dm);CHKERRQ(ierr);
ierr = TSMonitorSet(ts,TSMonitorFunctionError,&user,NULL);CHKERRQ(ierr);
ierr = TSSetRHSFunction(ts, NULL, MyRHSFunction, user);CHKERRQ(ierr);
ierr = TSSetDuration(ts, 1000, user->final_time);CHKERRQ(ierr);
ierr = TSSetInitialTimeStep(ts, user->initial_time, user->dt);CHKERRQ(ierr);
ierr = TSSetFromOptions(ts);CHKERRQ(ierr);
ierr = TSSolve(ts, algebra->solution);CHKERRQ(ierr);
ierr = TSGetSolveTime(ts, &ftime);CHKERRQ(ierr);
ierr = TSGetTimeStepNumber(ts, &nsteps);CHKERRQ(ierr);
ierr = TSGetConvergedReason(ts, &reason);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"%s at time %g after %D steps\n",TSConvergedReasons[reason],ftime,nsteps);CHKERRQ(ierr);
ierr = TSDestroy(&ts);CHKERRQ(ierr);
}
if(user->benchmark_couette) {
ierr = DMCreateGlobalVector(user->dm, &algebra->exactsolution);CHKERRQ(ierr);
ierr = ComputeExactSolution(user->dm, user->final_time, algebra->exactsolution, user);CHKERRQ(ierr);
}
if (user->output_solution){
PetscViewer viewer;
ierr = OutputVTK(user->dm, "solution.vtk", &viewer);CHKERRQ(ierr);
ierr = VecView(algebra->solution, viewer);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr);
}
if(user->benchmark_couette) {
PetscViewer viewer;
PetscReal norm;
ierr = OutputVTK(user->dm, "exact_solution.vtk", &viewer);CHKERRQ(ierr);
ierr = VecView(algebra->exactsolution, viewer);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr);
ierr = VecAXPY(algebra->exactsolution, -1, algebra->solution);CHKERRQ(ierr);
ierr = VecNorm(algebra->exactsolution,NORM_INFINITY,&norm);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Final time at %f, Error: ||u_k-u|| = %g \n", user->final_time, norm);CHKERRQ(ierr);
ierr = OutputVTK(user->dm, "Error.vtk", &viewer);CHKERRQ(ierr);
ierr = VecView(algebra->exactsolution, viewer);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr);
}
ierr = VecDestroy(&algebra->solution);CHKERRQ(ierr);
ierr = VecDestroy(&algebra->oldsolution);CHKERRQ(ierr);
ierr = DMDestroy(&user->dm);CHKERRQ(ierr);
} else if (user->TimeIntegralMethod == IMPLICITMETHOD) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"Using the fully implicit method\n");CHKERRQ(ierr);
ierr = SNESCreate(comm,&user->snes);CHKERRQ(ierr);
ierr = SNESSetDM(user->snes,user->dm);CHKERRQ(ierr);
ierr = DMCreateGlobalVector(user->dm, &algebra->solution);CHKERRQ(ierr);
ierr = VecDuplicate(algebra->solution, &algebra->oldsolution);CHKERRQ(ierr);
ierr = VecDuplicate(algebra->solution, &algebra->f);CHKERRQ(ierr);
ierr = VecDuplicate(algebra->solution, &algebra->fn);CHKERRQ(ierr);
ierr = VecDuplicate(algebra->solution, &algebra->oldfn);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) algebra->solution, "solution");CHKERRQ(ierr);
ierr = SetInitialCondition(user->dm, algebra->solution, user);CHKERRQ(ierr);
ierr = DMSetMatType(user->dm, MATAIJ);CHKERRQ(ierr);
// ierr = DMCreateMatrix(user->dm, &algebra->A);CHKERRQ(ierr);
ierr = DMCreateMatrix(user->dm, &algebra->J);CHKERRQ(ierr);
if (user->JdiffP) {
/*Set up the preconditioner matrix*/
ierr = DMCreateMatrix(user->dm, &algebra->P);CHKERRQ(ierr);
}else{
algebra->P = algebra->J;
}
ierr = MatSetOption(algebra->J, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE);CHKERRQ(ierr);
/*set nonlinear function */
ierr = SNESSetFunction(user->snes, algebra->f, FormFunction, (void*)user);CHKERRQ(ierr);
/* compute Jacobian */
ierr = SNESSetJacobian(user->snes, algebra->J, algebra->P, FormJacobian, (void*)user);CHKERRQ(ierr);
ierr = SNESSetFromOptions(user->snes);CHKERRQ(ierr);
/* do the solve */
if (user->timestep == TIMESTEP_STEADY_STATE) {
ierr = SolveSteadyState(user);CHKERRQ(ierr);
} else {
ierr = SolveTimeDependent(user);CHKERRQ(ierr);
}
if (user->output_solution){
PetscViewer viewer;
ierr = OutputVTK(user->dm, "solution.vtk", &viewer);CHKERRQ(ierr);
ierr = VecView(algebra->solution, viewer);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr);
}
if(user->benchmark_couette) {
PetscViewer viewer;
PetscReal norm;
ierr = OutputVTK(user->dm, "exact_solution.vtk", &viewer);CHKERRQ(ierr);
ierr = VecView(algebra->exactsolution, viewer);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr);
ierr = VecAXPY(algebra->exactsolution, -1, algebra->solution);CHKERRQ(ierr);
ierr = VecNorm(algebra->exactsolution,NORM_INFINITY,&norm);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Error: ||u_k-u|| = %g \n", norm);CHKERRQ(ierr);
ierr = OutputVTK(user->dm, "Error.vtk", &viewer);CHKERRQ(ierr);
ierr = VecView(algebra->exactsolution, viewer);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr);
}
ierr = VecDestroy(&algebra->solution);CHKERRQ(ierr);
ierr = VecDestroy(&algebra->f);CHKERRQ(ierr);
ierr = VecDestroy(&algebra->oldsolution);CHKERRQ(ierr);
ierr = VecDestroy(&algebra->fn);CHKERRQ(ierr);
ierr = VecDestroy(&algebra->oldfn);CHKERRQ(ierr);
ierr = SNESDestroy(&user->snes);CHKERRQ(ierr);
ierr = DMDestroy(&user->dm);CHKERRQ(ierr);
} else {
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_USER,"WRONG option for the time integral method. Using the option '-time_integral_method 0 or 1'");
}
ierr = VecDestroy(&user->cellgeom);CHKERRQ(ierr);
ierr = VecDestroy(&user->facegeom);CHKERRQ(ierr);
ierr = DMDestroy(&user->dmGrad);CHKERRQ(ierr);
ierr = PetscFunctionListDestroy(&LimitList);CHKERRQ(ierr);
ierr = PetscFree(user->model->physics);CHKERRQ(ierr);
ierr = PetscFree(user->algebra);CHKERRQ(ierr);
ierr = PetscFree(user->model);CHKERRQ(ierr);
ierr = PetscFree(user);CHKERRQ(ierr);
{
PetscLogDouble space =0;
ierr = PetscMallocGetCurrentUsage(&space);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Unfreed space at the End %g M\n", space/(1024*1024));CHKERRQ(ierr);
}
ierr = PetscFinalize();
return(0);
}
PetscErrorCode LoadOptions(MPI_Comm comm, User user)
{
PetscErrorCode ierr;
PetscFunctionBeginUser;
Model model = user->model;
//Algebra algebra = user->algebra;
Physics phy = model->physics;
ierr = PetscOptionsBegin(comm,NULL,"Physics Model Options","");CHKERRQ(ierr);
{
user->includeenergy = PETSC_FALSE;
ierr = PetscOptionsBool("-includeenergy","Including the Energy fields","",user->includeenergy,&user->includeenergy,NULL);CHKERRQ(ierr);
if (user->includeenergy){
phy->field_desc = PhysicsFields_Full;
}else{
phy->field_desc = PhysicsFields_Partial;
}
user->KDof = 3.0;
user->adiabatic = 1.67;
//user->R = 8.3144621;
user->R = 287.0;
user->viscosity = 0.1;
user->k = 0.026;
user->inflow_u = 0.0;
user->inflow_v = 0.0;
user->inflow_w = 0.0;
ierr = PetscOptionsReal("-kinematic_dof","Kinematic Degrees of freedom, for the monoatomic gas, kinematic_dof = 3 and for a diatomic gas, kinematic_dof = 5","",user->KDof,&user->KDof,NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-adiabatic","Heat capacity ratio or called adiabatic","", user->adiabatic, &user->adiabatic, NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-R","The gas constant which is 8.3144621 J K^{-1} mol^{-1} for the state equation","", user->R, &user->R, NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-viscosity","The viscosity of the flow","", user->viscosity, &user->viscosity, NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-k","the thermal conductivity coefficient","", user->k, &user->k, NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-inflow_u","the inflow velocity in x direction","", user->inflow_u, &user->inflow_u, NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-inflow_v","the inflow velocity in y direction","", user->inflow_v, &user->inflow_v, NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-inflow_w","the inflow velocity in z direction","", user->inflow_w, &user->inflow_w, NULL);CHKERRQ(ierr);
}
ierr = PetscOptionsEnd();CHKERRQ(ierr);
ierr = PetscOptionsBegin(comm,NULL,"Unstructured Finite Volume Mesh Options","");CHKERRQ(ierr);
{
//user->filename = "sevenside.exo";
ierr = PetscOptionsString("-f","Exodus.II filename to read","",user->filename,user->filename,sizeof(user->filename),NULL);CHKERRQ(ierr);
user->show_partition = PETSC_FALSE;
ierr = PetscOptionsBool("-show_partition","Write cell geometry (for debugging)","",user->show_partition,&user->show_partition,NULL);CHKERRQ(ierr);
user->overlap = 1;
ierr = PetscOptionsInt("-overlap","Number of cells to overlap partitions","",user->overlap,&user->overlap,NULL);CHKERRQ(ierr);
}
ierr = PetscOptionsEnd();CHKERRQ(ierr);
ierr = PetscOptionsBegin(comm,NULL,"Unstructured Finite Volume Method Options","");CHKERRQ(ierr);
{
user->reconstruct = PETSC_FALSE;
ierr = PetscOptionsBool("-reconstruct","Reconstruct gradients for a second order method (grows stencil)","",user->reconstruct,&user->reconstruct,NULL);CHKERRQ(ierr);
user->TimeIntegralMethod = 0;
ierr = PetscOptionsInt("-time_integral_method","Method for the time integral, 0 for the explicit method and 1 for the implicit method","",user->TimeIntegralMethod,&user->TimeIntegralMethod,NULL);CHKERRQ(ierr);
user->timestep = 0;
ierr = PetscOptionsInt("-timestep","Scheme for the implicit time integral: backward Euler, BDF2, ...","",user->timestep,&user->timestep,NULL);CHKERRQ(ierr);
user->myownexplicitmethod = PETSC_FALSE;
ierr = PetscOptionsBool("-myownexplicitmethod","Using my own explicit metod","",user->myownexplicitmethod,&user->myownexplicitmethod,NULL);CHKERRQ(ierr);
user->PressureFlux = PETSC_FALSE;
ierr = PetscOptionsBool("-PressureFlux","Transfer the pressure term to the flux style","",user->PressureFlux,&user->PressureFlux,NULL);CHKERRQ(ierr);
user->output_solution = PETSC_FALSE;
ierr = PetscOptionsBool("-output_solution","output the solution to a file","",user->output_solution,&user->output_solution,NULL);CHKERRQ(ierr);
user->JdiffP = PETSC_FALSE;
ierr = PetscOptionsBool("-JdiffP","The preconditioner matrix is different from the Jacobian matrix","",user->JdiffP,&user->JdiffP,NULL);CHKERRQ(ierr);
user->dt = 0.001;
ierr = PetscOptionsReal("-dt","The time step size","",user->dt,&user->dt,NULL);CHKERRQ(ierr);
user->initial_time = 0.0;
ierr = PetscOptionsReal("-initial_time","The initial time","", user->initial_time, &user->initial_time, NULL);CHKERRQ(ierr);
user->final_time = 1.0;
ierr = PetscOptionsReal("-final_time","The final time","",user->final_time,&user->final_time,NULL);CHKERRQ(ierr);
user->second_order = PETSC_FALSE;
ierr = PetscOptionsBool("-second_order","Use the second order scheme by using the reconstruction","",user->second_order,&user->second_order,NULL);CHKERRQ(ierr);
user->fd_jacobian = PETSC_FALSE;
ierr = PetscOptionsBool("-fd_jacobian","Use the PETSc default finite difference method to construct the Jacobian matrix","",user->fd_jacobian,&user->fd_jacobian,NULL);CHKERRQ(ierr);
user->fd_jacobian_color = PETSC_FALSE;
ierr = PetscOptionsBool("-fd_jacobian_color","Use the PETSc default finite difference method to construct the Jacobian matrix","",user->fd_jacobian_color,&user->fd_jacobian_color,NULL);CHKERRQ(ierr);
}
ierr = PetscOptionsEnd();CHKERRQ(ierr);
ierr = PetscOptionsBegin(comm,NULL,"Other Options","");CHKERRQ(ierr);
{
user->benchmark_couette = PETSC_FALSE;
ierr = PetscOptionsBool("-benchmark_couette","For the Couette benchmark problem test","",user->benchmark_couette,&user->benchmark_couette,NULL);CHKERRQ(ierr);
user->max_time_its = 0;
ierr = PetscOptionsInt("-max_time_its","The maximum time steps","",user->max_time_its,&user->max_time_its,NULL);CHKERRQ(ierr);
user->Explicit_RK2 = PETSC_FALSE;
ierr = PetscOptionsBool("-Explicit_RK2","Use the second order Runge Kutta method","",user->Explicit_RK2,&user->Explicit_RK2,NULL);CHKERRQ(ierr);
user->T0 = 0.0;
ierr = PetscOptionsReal("-T0","For the couette test case","", user->T0, &user->T0, NULL);CHKERRQ(ierr);
user->T1 = 0.0;
ierr = PetscOptionsReal("-T1","For the couette test case","", user->T1, &user->T1, NULL);CHKERRQ(ierr);
user->Euler = PETSC_FALSE;
ierr = PetscOptionsBool("-Euler","Use the Euler equation","",user->Euler,&user->Euler, NULL);CHKERRQ(ierr);
}
ierr = PetscOptionsEnd();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
int main(int argc,char **argv)
{
PetscErrorCode ierr;
DM da; /* structured grid topology object */
TS ts; /* time-stepping object (contains snes) */
SNES snes; /* Newton solver object */
Vec X,residual; /* solution, residual */
Mat J; /* Jacobian matrix */
PetscInt Mx,My,fsteps,steps;
ISColoring iscoloring;
PetscReal tstart,tend,ftime,secperday=3600.0*24.0,Y0;
PetscBool fdflg = PETSC_FALSE, mfileflg = PETSC_FALSE, optflg = PETSC_FALSE;
char mfile[PETSC_MAX_PATH_LEN] = "out.m";
MatFDColoring matfdcoloring;
PorousCtx user; /* user-defined work context */
PetscInitialize(&argc,&argv,(char *)0,help);
ierr = DMDACreate2d(PETSC_COMM_WORLD,
DMDA_BOUNDARY_NONE, DMDA_BOUNDARY_NONE, // correct for zero Dirichlet
DMDA_STENCIL_STAR, // nonlinear diffusion but diffusivity
// depends on soln W not grad W
-21,-21, // default to 20x20 grid but override with
// -da_grid_x, -da_grid_y (or -da_refine)
PETSC_DECIDE,PETSC_DECIDE, // num of procs in each dim
2, // dof = 2: node = (W,Y)
// or node = (P,dPsqr)
// or node = (ddxE,ddyN)
1, // s = 1 (stencil extends out one cell)
PETSC_NULL,PETSC_NULL, // no specify proc decomposition
&da);CHKERRQ(ierr);
ierr = DMSetApplicationContext(da,&user);CHKERRQ(ierr);
/* get Vecs and Mats for this grid */
ierr = DMCreateGlobalVector(da,&X);CHKERRQ(ierr);
ierr = VecDuplicate(X,&residual);CHKERRQ(ierr);
ierr = VecDuplicate(X,&user.geom);CHKERRQ(ierr);
ierr = DMGetMatrix(da,MATAIJ,&J);CHKERRQ(ierr);
/* set up contexts */
tstart = 10.0 * secperday; /* 10 days in seconds */
tend = 30.0 * secperday;
steps = 20;
Y0 = 1.0; /* initial value of Y, for computing initial
value of P; note Ymin = 0.1 is different */
user.da = da;
ierr = DefaultContext(&user);CHKERRQ(ierr);
ierr = PetscOptionsBegin(PETSC_COMM_WORLD,
"","options to (W,P)-space better hydrology model alt","");CHKERRQ(ierr);
{
ierr = PetscOptionsReal("-alt_sigma","nonlinear power","",
user.sigma,&user.sigma,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-alt_Ymin",
"min capacity thickness (esp. in pressure computation)","",
user.Ymin,&user.Ymin,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-alt_Wmin",
"min water amount (esp. in pressure computation)","",
user.Wmin,&user.Wmin,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-alt_Y0",
"constant initial capacity thickness","",
Y0,&Y0,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-alt_Cmelt",
"additional coefficient for amount of melt","",
user.Cmelt,&user.Cmelt,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-alt_Creep",
"creep closure coefficient","",
user.Creep,&user.Creep,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-alt_L","half-width of square region in meters","",
user.L,&user.L,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-alt_tstart_days","start time in days","",
tstart/secperday,&tstart,&optflg);CHKERRQ(ierr);
if (optflg) { tstart *= secperday; }
ierr = PetscOptionsReal("-alt_tend_days","end time in days","",
tend/secperday,&tend,&optflg);CHKERRQ(ierr);
if (optflg) { tend *= secperday; }
ierr = PetscOptionsInt("-alt_steps","number of timesteps to take","",
steps,&steps,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-alt_converge_check",
"run silent and check for convergence",
"",user.run_silent,&user.run_silent,PETSC_NULL);
CHKERRQ(ierr);
ierr = PetscOptionsString("-mfile",
"name of Matlab file to write results","",
mfile,mfile,PETSC_MAX_PATH_LEN,&mfileflg);
CHKERRQ(ierr);
}
ierr = PetscOptionsEnd();CHKERRQ(ierr);
/* fix remaining parameters */
ierr = DerivedConstants(&user);CHKERRQ(ierr);
ierr = VecStrideSet(user.geom,0,user.H0);CHKERRQ(ierr); /* H(x,y) = H0 */
ierr = VecStrideSet(user.geom,1,0.0);CHKERRQ(ierr); /* b(x,y) = 0 */
ierr = DMDASetUniformCoordinates(da, // square domain
-user.L, user.L, -user.L, user.L, 0.0, 1.0);CHKERRQ(ierr);
ierr = DMDAGetInfo(da,PETSC_IGNORE,&Mx,&My,
PETSC_IGNORE,PETSC_IGNORE,PETSC_IGNORE,
PETSC_IGNORE,PETSC_IGNORE,PETSC_IGNORE,PETSC_IGNORE,
PETSC_IGNORE,PETSC_IGNORE,PETSC_IGNORE);CHKERRQ(ierr);
user.dx = 2.0 * user.L / (Mx-1);
user.dy = 2.0 * user.L / (My-1);
/* setup TS = timestepping object */
ierr = TSCreate(PETSC_COMM_WORLD,&ts);CHKERRQ(ierr);
ierr = TSSetType(ts,TSCN);CHKERRQ(ierr);
ierr = TSSetRHSFunction(ts,residual,RHSFunction,&user);CHKERRQ(ierr);
/* use coloring to compute rhs Jacobian efficiently */
ierr = PetscOptionsGetBool(PETSC_NULL,"-fd",&fdflg,PETSC_NULL);CHKERRQ(ierr);
if (fdflg){
ierr = DMGetColoring(da,IS_COLORING_GLOBAL,MATAIJ,&iscoloring);CHKERRQ(ierr);
ierr = MatFDColoringCreate(J,iscoloring,&matfdcoloring);CHKERRQ(ierr);
ierr = MatFDColoringSetFromOptions(matfdcoloring);CHKERRQ(ierr);
ierr = ISColoringDestroy(&iscoloring);CHKERRQ(ierr);
ierr = MatFDColoringSetFunction(matfdcoloring,
(PetscErrorCode (*)(void))RHSFunction,&user);CHKERRQ(ierr);
ierr = TSSetRHSJacobian(ts,J,J,TSDefaultComputeJacobianColor,
matfdcoloring);CHKERRQ(ierr);
} else { /* default case */
ierr = TSSetRHSJacobian(ts,J,J,RHSJacobian,&user);CHKERRQ(ierr);
}
/* set initial state: W = barenblatt, P = pi (W/Y0)^sigma */
ierr = InitialState(da,&user,tstart,Y0,X);CHKERRQ(ierr);
/* set up times for time-stepping */
ierr = TSSetInitialTimeStep(ts,tstart,
(tend - tstart) / (PetscReal)steps);CHKERRQ(ierr);
ierr = TSSetDuration(ts,steps,tend);CHKERRQ(ierr);
ierr = TSSetExactFinalTime(ts,PETSC_TRUE);CHKERRQ(ierr);
ierr = TSMonitorSet(ts,MyTSMonitor,&user,PETSC_NULL);CHKERRQ(ierr);
/* Set SNESVI type and supply upper and lower bounds. */
ierr = TSGetSNES(ts,&snes);CHKERRQ(ierr);
ierr = SNESVISetComputeVariableBounds(snes,FormPositivityBounds);
CHKERRQ(ierr);
/* ask user to finalize settings */
ierr = TSSetFromOptions(ts);CHKERRQ(ierr);
/* report on setup */
if (!user.run_silent) {
ierr = PetscPrintf(PETSC_COMM_WORLD,
"setup done: square side length = %.3f km\n"
" grid Mx,My = %d,%d\n"
" spacing dx,dy = %.3f,%.3f m\n"
" times tstart:dt:tend = %.3f:%.3f:%.3f days\n",
2.0 * user.L / 1000.0, Mx, My, user.dx, user.dy,
tstart / secperday, (tend-tstart)/(steps*secperday), tend / secperday);
CHKERRQ(ierr);
}
if (mfileflg) {
if (!user.run_silent) {
ierr = PetscPrintf(PETSC_COMM_WORLD,
"writing initial W,P and geometry H,b to Matlab file %s ...\n",
mfile);CHKERRQ(ierr);
}
ierr = print2vecmatlab(da,X,"W_init","P_init",mfile,PETSC_FALSE);CHKERRQ(ierr);
ierr = print2vecmatlab(da,user.geom,"H","b",mfile,PETSC_TRUE);CHKERRQ(ierr);
}
/* run time-stepping with implicit steps */
ierr = TSSolve(ts,X,&ftime);CHKERRQ(ierr);
/* make a report on run and final state */
ierr = TSGetTimeStepNumber(ts,&fsteps);CHKERRQ(ierr);
if ((!user.run_silent) && (ftime != tend)) {
ierr = PetscPrintf(PETSC_COMM_WORLD,
"***WARNING3***: reported final time wrong: ftime(=%.12e) != tend(=%.12e) (days)\n",
ftime / secperday, tend / secperday);CHKERRQ(ierr); }
if ((!user.run_silent) && (fsteps != steps)) {
ierr = PetscPrintf(PETSC_COMM_WORLD,
"***WARNING4***: reported number of steps wrong: fsteps(=%D) != steps(=%D)\n",
fsteps, steps);CHKERRQ(ierr); }
if (mfileflg) {
if (!user.run_silent) {
ierr = PetscPrintf(PETSC_COMM_WORLD,
"writing final fields to %s ...\n",mfile);CHKERRQ(ierr);
}
ierr = print2vecmatlab(da,X,"W_final","P_final",mfile,PETSC_TRUE);CHKERRQ(ierr);
ierr = printfigurematlab(da,2,"W_init","W_final",mfile,PETSC_TRUE);CHKERRQ(ierr);
ierr = printfigurematlab(da,3,"P_init","P_final",mfile,PETSC_TRUE);CHKERRQ(ierr);
}
if (user.run_silent) {
ierr = PetscPrintf(PETSC_COMM_WORLD, "%6d %6d %9.3f %.12e\n",
Mx, My, (tend-tstart)/secperday, user.maxrnorm);CHKERRQ(ierr);
}
/* Free work space. */
ierr = MatDestroy(&J);CHKERRQ(ierr);
if (fdflg) { ierr = MatFDColoringDestroy(&matfdcoloring);CHKERRQ(ierr); }
ierr = VecDestroy(&X);CHKERRQ(ierr);
ierr = VecDestroy(&user.geom);CHKERRQ(ierr);
ierr = VecDestroy(&residual);CHKERRQ(ierr);
ierr = TSDestroy(&ts);CHKERRQ(ierr);
ierr = DMDestroy(&da);CHKERRQ(ierr);
ierr = PetscFinalize();CHKERRQ(ierr);
PetscFunctionReturn((PetscInt)(user.not_converged_warning));
}
/*@
MFNSetFromOptions - Sets MFN options from the options database.
This routine must be called before MFNSetUp() if the user is to be
allowed to set the solver type.
Collective on MFN
Input Parameters:
. mfn - the matrix function context
Notes:
To see all options, run your program with the -help option.
Level: beginner
@*/
PetscErrorCode MFNSetFromOptions(MFN mfn)
{
PetscErrorCode ierr;
char type[256],monfilename[PETSC_MAX_PATH_LEN];
PetscBool flg,flg1,flg2;
PetscReal r;
PetscInt i;
PetscViewer monviewer;
PetscFunctionBegin;
PetscValidHeaderSpecific(mfn,MFN_CLASSID,1);
if (!MFNRegisterAllCalled) { ierr = MFNRegisterAll();CHKERRQ(ierr); }
ierr = PetscObjectOptionsBegin((PetscObject)mfn);CHKERRQ(ierr);
ierr = PetscOptionsFList("-mfn_type","Matrix Function method","MFNSetType",MFNList,(char*)(((PetscObject)mfn)->type_name?((PetscObject)mfn)->type_name:MFNKRYLOV),type,256,&flg);CHKERRQ(ierr);
if (flg) {
ierr = MFNSetType(mfn,type);CHKERRQ(ierr);
}
/*
Set the type if it was never set.
*/
if (!((PetscObject)mfn)->type_name) {
ierr = MFNSetType(mfn,MFNKRYLOV);CHKERRQ(ierr);
}
ierr = PetscOptionsBoolGroupBegin("-mfn_exp","matrix exponential","MFNSetFunction",&flg);CHKERRQ(ierr);
if (flg) {
ierr = MFNSetFunction(mfn,SLEPC_FUNCTION_EXP);CHKERRQ(ierr);
}
ierr = PetscOptionsScalar("-mfn_scale","Scale factor","MFNSetScaleFactor",mfn->sfactor,&mfn->sfactor,NULL);CHKERRQ(ierr);
i = mfn->max_it;
ierr = PetscOptionsInt("-mfn_max_it","Maximum number of iterations","MFNSetTolerances",mfn->max_it,&i,&flg1);CHKERRQ(ierr);
r = mfn->tol;
ierr = PetscOptionsReal("-mfn_tol","Tolerance","MFNSetTolerances",mfn->tol==PETSC_DEFAULT?SLEPC_DEFAULT_TOL:mfn->tol,&r,&flg2);CHKERRQ(ierr);
if (flg1 || flg2) {
ierr = MFNSetTolerances(mfn,r,i);CHKERRQ(ierr);
}
ierr = PetscOptionsInt("-mfn_ncv","Number of basis vectors","MFNSetDimensions",mfn->ncv,&i,&flg);CHKERRQ(ierr);
if (flg) {
ierr = MFNSetDimensions(mfn,i);CHKERRQ(ierr);
}
ierr = PetscOptionsBool("-mfn_error_if_not_converged","Generate error if solver does not converge","MFNSetErrorIfNotConverged",mfn->errorifnotconverged,&mfn->errorifnotconverged,NULL);CHKERRQ(ierr);
/* -----------------------------------------------------------------------*/
/*
Cancels all monitors hardwired into code before call to MFNSetFromOptions()
*/
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-mfn_monitor_cancel","Remove any hardwired monitor routines","MFNMonitorCancel",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {
ierr = MFNMonitorCancel(mfn);CHKERRQ(ierr);
}
/*
Prints error estimate at each iteration
*/
ierr = PetscOptionsString("-mfn_monitor","Monitor error estimate","MFNMonitorSet","stdout",monfilename,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PetscViewerASCIIOpen(PetscObjectComm((PetscObject)mfn),monfilename,&monviewer);CHKERRQ(ierr);
ierr = MFNMonitorSet(mfn,MFNMonitorDefault,monviewer,(PetscErrorCode (*)(void**))PetscViewerDestroy);CHKERRQ(ierr);
}
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-mfn_monitor_lg","Monitor error estimate graphically","MFNMonitorSet",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {
ierr = MFNMonitorSet(mfn,MFNMonitorLG,NULL,NULL);CHKERRQ(ierr);
}
/* -----------------------------------------------------------------------*/
ierr = PetscOptionsName("-mfn_view","Print detailed information on solver used","MFNView",0);CHKERRQ(ierr);
if (mfn->ops->setfromoptions) {
ierr = (*mfn->ops->setfromoptions)(mfn);CHKERRQ(ierr);
}
ierr = PetscObjectProcessOptionsHandlers((PetscObject)mfn);CHKERRQ(ierr);
ierr = PetscOptionsEnd();CHKERRQ(ierr);
if (!mfn->V) { ierr = MFNGetBV(mfn,&mfn->V);CHKERRQ(ierr); }
ierr = BVSetFromOptions(mfn->V);CHKERRQ(ierr);
if (!mfn->ds) { ierr = MFNGetDS(mfn,&mfn->ds);CHKERRQ(ierr); }
ierr = DSSetFromOptions(mfn->ds);CHKERRQ(ierr);
ierr = PetscRandomSetFromOptions(mfn->rand);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
