/*
Caculate the source term of the equations, which includes all
terms except convetion term, diffusion term, and timedependent term.
*/
PetscErrorCode CaculateLocalSourceTerm(DM dm, Vec locX, Vec F, User user)
{
PetscErrorCode ierr;
DM dmGrad = user->dmGrad;
const PetscScalar *x;
PetscScalar *f;
PetscInt cStart, cell;
const PetscScalar *cellgeom;
const CellGeom *cg;
Vec locGrad, Grad;
const PetscScalar *grad;
DM dmCell;
PetscFunctionBeginUser;
ierr = VecGetDM(user->cellgeom,&dmCell);CHKERRQ(ierr);
ierr = VecGetArrayRead(locX,&x);CHKERRQ(ierr);
ierr = VecGetArray(F,&f);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 0, &cStart, NULL);CHKERRQ(ierr);
ierr = VecGetArrayRead(user->cellgeom,&cellgeom);CHKERRQ(ierr);
ierr = DMGetGlobalVector(dmGrad,&Grad);CHKERRQ(ierr);
ierr = DMGetLocalVector(dmGrad,&locGrad);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(dmGrad,Grad,INSERT_VALUES,locGrad);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(dmGrad,Grad,INSERT_VALUES,locGrad);CHKERRQ(ierr);
ierr = DMRestoreGlobalVector(dmGrad,&Grad);CHKERRQ(ierr);
ierr = VecGetArrayRead(locGrad,&grad);CHKERRQ(ierr);
for (cell = cStart; cell < user->cEndInterior; cell++) {
PetscScalar *fref;
const PetscScalar *xref;
PetscScalar *cgrad;
ierr = DMPlexPointLocalRead(dmCell,cell,cellgeom,&cg);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dm,cell,x,&xref);CHKERRQ(ierr); /*For the unkown variables*/
ierr = DMPlexPointGlobalRef(dm,cell,f,&fref);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmGrad,cell,grad,&cgrad);CHKERRQ(ierr);
// if (!fref){ PetscPrintf(PETSC_COMM_WORLD,"%d, %d\n", cell, user->cEndInterior);}
if (fref){
fref[0] += SourceRho(user, cgrad, xref, cg->centroid);/*the continuity equation*/
fref[1] += SourceU(user, cgrad, xref, cg->centroid); /*Momentum U*/
fref[2] += SourceV(user, cgrad, xref, cg->centroid); /*Momentum V*/
fref[3] += SourceW(user, cgrad, xref, cg->centroid); /*Momentum W*/
fref[4] += SourceE(user, cgrad, xref, cg->centroid);/*Energy*/
}
}
ierr = VecRestoreArrayRead(locX,&x);CHKERRQ(ierr);
ierr = VecRestoreArray(F,&f);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(user->cellgeom,&cellgeom);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(locGrad,&grad);CHKERRQ(ierr);
ierr = DMRestoreLocalVector(dmGrad,&locGrad);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*
Compute the gradient of the variables at the center of the cell
by the least-square reconstruction method based on the function
BuildLeastSquares.
*/
PetscErrorCode ConstructCellCentriodGradient(DM dm,DM dmFace,DM dmCell,PetscReal time,Vec locX,Vec F,User user)
{
DM dmGrad = user->dmGrad;
Model mod = user->model;
Physics phys = mod->physics;
const PetscInt dof = phys->dof;
PetscErrorCode ierr;
const PetscScalar *facegeom, *cellgeom, *x;
PetscInt fStart, fEnd, face, cStart;
Vec Grad;
PetscFunctionBeginUser;
ierr = DMGetGlobalVector(dmGrad,&Grad);CHKERRQ(ierr);
ierr = VecZeroEntries(Grad);CHKERRQ(ierr);
ierr = VecGetArrayRead(user->facegeom,&facegeom);CHKERRQ(ierr);
ierr = VecGetArrayRead(user->cellgeom,&cellgeom);CHKERRQ(ierr);
ierr = VecGetArrayRead(locX,&x);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 1, &fStart, &fEnd);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 0, &cStart, NULL);CHKERRQ(ierr);
{
PetscScalar *grad;
ierr = VecGetArray(Grad,&grad);CHKERRQ(ierr);
/* Reconstruct gradients */
for (face=fStart; face<fEnd; face++) {
const PetscInt *cells;
const PetscScalar *cx[2];
const FaceGeom *fg;
PetscScalar *cgrad[2];
PetscInt i,j;
PetscBool ghost;
ierr = IsExteriorGhostFace(dm,face,&ghost);CHKERRQ(ierr);
if (ghost) continue;
ierr = DMPlexGetSupport(dm,face,&cells);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmFace,face,facegeom,&fg);CHKERRQ(ierr);
for (i=0; i<2; i++) {
ierr = DMPlexPointLocalRead(dm,cells[i],x,&cx[i]);CHKERRQ(ierr);
ierr = DMPlexPointGlobalRef(dmGrad,cells[i],grad,&cgrad[i]);CHKERRQ(ierr);
}
for (i=0; i<dof; i++) {
PetscScalar delta = cx[1][i] - cx[0][i];
for (j=0; j<DIM; j++) {
if (cgrad[0]) cgrad[0][i*DIM+j] += fg->grad[0][j] * delta;
if (cgrad[1]) cgrad[1][i*DIM+j] -= fg->grad[1][j] * delta;
}
}
}
ierr = VecRestoreArray(Grad,&grad);CHKERRQ(ierr);
}
ierr = DMRestoreGlobalVector(dmGrad,&Grad);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(user->facegeom,&facegeom);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(user->cellgeom,&cellgeom);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(locX,&x);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode BuildGradientReconstruction(DM dm, PetscFV fvm, DM dmFace, PetscScalar *fgeom, DM dmCell, PetscScalar *cgeom)
{
DMLabel ghostLabel;
PetscScalar *dx, *grad, **gref;
PetscInt dim, cStart, cEnd, c, cEndInterior, maxNumFaces;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = DMPlexGetDimension(dm, &dim);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);CHKERRQ(ierr);
ierr = DMPlexGetHybridBounds(dm, &cEndInterior, NULL, NULL, NULL);CHKERRQ(ierr);
ierr = DMPlexGetMaxSizes(dm, &maxNumFaces, NULL);CHKERRQ(ierr);
ierr = PetscFVLeastSquaresSetMaxFaces(fvm, maxNumFaces);CHKERRQ(ierr);
ierr = DMPlexGetLabel(dm, "ghost", &ghostLabel);CHKERRQ(ierr);
ierr = PetscMalloc3(maxNumFaces*dim, &dx, maxNumFaces*dim, &grad, maxNumFaces, &gref);CHKERRQ(ierr);
for (c = cStart; c < cEndInterior; c++) {
const PetscInt *faces;
PetscInt numFaces, usedFaces, f, d;
const CellGeom *cg;
PetscBool boundary;
PetscInt ghost;
ierr = DMPlexPointLocalRead(dmCell, c, cgeom, &cg);CHKERRQ(ierr);
ierr = DMPlexGetConeSize(dm, c, &numFaces);CHKERRQ(ierr);
ierr = DMPlexGetCone(dm, c, &faces);CHKERRQ(ierr);
if (numFaces < dim) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_INCOMP,"Cell %D has only %D faces, not enough for gradient reconstruction", c, numFaces);
for (f = 0, usedFaces = 0; f < numFaces; ++f) {
const CellGeom *cg1;
FaceGeom *fg;
const PetscInt *fcells;
PetscInt ncell, side;
ierr = DMLabelGetValue(ghostLabel, faces[f], &ghost);CHKERRQ(ierr);
ierr = DMPlexIsBoundaryPoint(dm, faces[f], &boundary);CHKERRQ(ierr);
if ((ghost >= 0) || boundary) continue;
ierr = DMPlexGetSupport(dm, faces[f], &fcells);CHKERRQ(ierr);
side = (c != fcells[0]); /* c is on left=0 or right=1 of face */
ncell = fcells[!side]; /* the neighbor */
ierr = DMPlexPointLocalRef(dmFace, faces[f], fgeom, &fg);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmCell, ncell, cgeom, &cg1);CHKERRQ(ierr);
for (d = 0; d < dim; ++d) dx[usedFaces*dim+d] = cg1->centroid[d] - cg->centroid[d];
gref[usedFaces++] = fg->grad[side]; /* Gradient reconstruction term will go here */
}
if (!usedFaces) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_USER, "Mesh contains isolated cell (no neighbors). Is it intentional?");
ierr = PetscFVComputeGradient(fvm, usedFaces, dx, grad);CHKERRQ(ierr);
for (f = 0, usedFaces = 0; f < numFaces; ++f) {
ierr = DMLabelGetValue(ghostLabel, faces[f], &ghost);CHKERRQ(ierr);
ierr = DMPlexIsBoundaryPoint(dm, faces[f], &boundary);CHKERRQ(ierr);
if ((ghost >= 0) || boundary) continue;
for (d = 0; d < dim; ++d) gref[usedFaces][d] = grad[usedFaces*dim+d];
++usedFaces;
}
}
ierr = PetscFree3(dx, grad, gref);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode SetInitialCondition(DM dm, Vec X, User user)
{
DM dmCell;
const PetscScalar *cellgeom;
PetscScalar *x;
PetscInt cStart, cEnd, cEndInterior = user->cEndInterior, c;
PetscErrorCode ierr;
PetscFunctionBeginUser;
ierr = VecGetDM(user->cellgeom, &dmCell);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);CHKERRQ(ierr);
ierr = VecGetArrayRead(user->cellgeom, &cellgeom);CHKERRQ(ierr);
ierr = VecGetArray(X, &x);CHKERRQ(ierr);
for (c = cStart; c < cEndInterior; ++c) {
const CellGeom *cg;
PetscScalar *xc;
ierr = DMPlexPointLocalRead(dmCell,c,cellgeom,&cg);CHKERRQ(ierr);
ierr = DMPlexPointGlobalRef(dm,c,x,&xc);CHKERRQ(ierr);
if (xc) {
ierr = InitialCondition(0.0, cg->centroid, xc, user);CHKERRQ(ierr);
}
}
ierr = VecRestoreArrayRead(user->cellgeom, &cellgeom);CHKERRQ(ierr);
ierr = VecRestoreArray(X, &x);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode CheckPoint(DM dm, Vec u, PetscInt point, AppCtx *user)
{
PetscSection s;
const PetscScalar *array, *a;
PetscInt dof, d;
PetscErrorCode ierr;
PetscFunctionBeginUser;
ierr = DMGetDefaultSection(dm, &s);CHKERRQ(ierr);
ierr = VecGetArrayRead(u, &array);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dm, point, array, &a);CHKERRQ(ierr);
ierr = PetscSectionGetDof(s, point, &dof);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF, "Point %D: ", point);CHKERRQ(ierr);
for (d = 0; d < dof; ++d) {
if (d > 0) {ierr = PetscPrintf(PETSC_COMM_SELF, ", ");CHKERRQ(ierr);}
ierr = PetscPrintf(PETSC_COMM_SELF, "%2.0f", a[d]);CHKERRQ(ierr);
}
ierr = PetscPrintf(PETSC_COMM_SELF, "\n");CHKERRQ(ierr);
ierr = VecRestoreArrayRead(u, &array);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode SetInitialCondition(DM dm, Vec X, User user)
{
DM dmCell;
const PetscScalar *cellgeom;
PetscScalar *x;
PetscInt cStart, cEnd, cEndInterior = user->cEndInterior, c;
PetscErrorCode ierr;
PetscFunctionBeginUser;
ierr = VecGetDM(user->cellgeom, &dmCell);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);CHKERRQ(ierr);
ierr = VecGetArrayRead(user->cellgeom, &cellgeom);CHKERRQ(ierr);
ierr = VecGetArray(X, &x);CHKERRQ(ierr);
for (c = cStart; c < cEndInterior; ++c) {
const CellGeom *cg;
PetscScalar *xc;
ierr = DMPlexPointLocalRead(dmCell,c,cellgeom,&cg);CHKERRQ(ierr);
ierr = DMPlexPointGlobalRef(dm,c,x,&xc);CHKERRQ(ierr);
if (xc) {
ierr = InitialCondition(0.0, cg->centroid, xc, user);CHKERRQ(ierr);
}
}
ierr = VecRestoreArrayRead(user->cellgeom, &cellgeom);CHKERRQ(ierr);
ierr = VecRestoreArray(X, &x);CHKERRQ(ierr);
{ //Apply the Boundary condition for the intial condition
Vec XLocal;
ierr = DMGetLocalVector(user->dm, &XLocal);CHKERRQ(ierr);
ierr = VecSet(XLocal, 0);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(user->dm, X, INSERT_VALUES, XLocal);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(user->dm, X, INSERT_VALUES, XLocal);CHKERRQ(ierr);
ierr = ApplyBC(user->dm, user->current_time, XLocal, user);CHKERRQ(ierr);
ierr = DMLocalToGlobalBegin(user->dm, XLocal, INSERT_VALUES, X);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(user->dm, XLocal, INSERT_VALUES, X);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
PetscErrorCode ApplyBC(DM dm, PetscReal time, Vec locX, User user)
{
const char *name = "Face Sets"; /*Set up in the function DMPlexCreateExodus. is the side set*/
DM dmFace;
IS idIS;
const PetscInt *ids;
PetscScalar *x;
const PetscScalar *facegeom;
PetscInt numFS, fs;
PetscErrorCode ierr;
PetscMPIInt rank;
PetscFunctionBeginUser;
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr);
ierr = VecGetDM(user->facegeom,&dmFace);CHKERRQ(ierr);
ierr = DMPlexGetLabelIdIS(dm, name, &idIS);CHKERRQ(ierr);
// ISView(idIS, PETSC_VIEWER_STDOUT_SELF);
if (!idIS) PetscFunctionReturn(0);
ierr = ISGetLocalSize(idIS, &numFS);CHKERRQ(ierr);
ierr = ISGetIndices(idIS, &ids);CHKERRQ(ierr);
ierr = VecGetArrayRead(user->facegeom, &facegeom);CHKERRQ(ierr);
ierr = VecGetArray(locX, &x);CHKERRQ(ierr);
for (fs = 0; fs < numFS; ++fs) {
IS faceIS;
const PetscInt *faces;
PetscInt numFaces, f;
ierr = DMPlexGetStratumIS(dm, name, ids[fs], &faceIS);CHKERRQ(ierr);
ierr = ISGetLocalSize(faceIS, &numFaces);CHKERRQ(ierr);
ierr = ISGetIndices(faceIS, &faces);CHKERRQ(ierr);
for (f = 0; f < numFaces; ++f) {
// PetscPrintf(PETSC_COMM_SELF, "rank[%d]: ids[%d] = %d, faceIS[%d] = %d, numFaces = %d\n", rank, fs, ids[fs], f, faces[f], numFaces);
const PetscInt face = faces[f], *cells;
const PetscScalar *xI; /*Inner point*/
PetscScalar *xG; /*Ghost point*/
const FaceGeom *fg;
ierr = DMPlexPointLocalRead(dmFace, face, facegeom, &fg);CHKERRQ(ierr);
ierr = DMPlexGetSupport(dm, face, &cells);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dm, cells[0], x, &xI);CHKERRQ(ierr);
ierr = DMPlexPointLocalRef(dm, cells[1], x, &xG);CHKERRQ(ierr);
if (ids[fs]==1){
//PetscPrintf(PETSC_COMM_SELF, "Set Inlfow Boundary Condition! \n");
ierr = BoundaryInflow(time, fg->centroid, fg->normal, xI, xG, user);CHKERRQ(ierr);
// DM dmCell;
// const PetscScalar *cellgeom;
// const CellGeom *cgL, *cgR;
// ierr = VecGetDM(user->cellgeom,&dmCell);CHKERRQ(ierr);
// ierr = VecGetArrayRead(user->cellgeom, &cellgeom);CHKERRQ(ierr);
// ierr = DMPlexPointLocalRead(dmCell, cells[0], cellgeom, &cgL);CHKERRQ(ierr);
// ierr = DMPlexPointLocalRead(dmCell, cells[1], cellgeom, &cgR);CHKERRQ(ierr);
// ierr = PetscPrintf(PETSC_COMM_WORLD,"cells[0] = (%f, %f, %f), cells[1] = (%f, %f, %f)\n",cgL->centroid[0], cgL->centroid[1], cgL->centroid[2],cgR->centroid[0], cgR->centroid[1], cgR->centroid[2]);CHKERRQ(ierr);
}else if (ids[fs]==2){
//PetscPrintf(PETSC_COMM_SELF, "Set Outlfow Boundary Condition! \n");
ierr = BoundaryOutflow(time, fg->centroid, fg->normal, xI, xG, user);CHKERRQ(ierr);
}else if (ids[fs]==3){
//PetscPrintf(PETSC_COMM_SELF, "Set Wall Boundary Condition! \n");
ierr = BoundaryWallflow(time, fg->centroid, fg->normal, xI, xG, user);CHKERRQ(ierr);
}else {
SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"Wrong type of boundary condition setup!!! \n The set up of the boundary should be: 1 for the inflow, 2 for the outflow, and 3 for the wallflow");
}
}
// PetscPrintf(PETSC_COMM_SELF, " \n");
ierr = ISRestoreIndices(faceIS, &faces);CHKERRQ(ierr);
ierr = ISDestroy(&faceIS);CHKERRQ(ierr);
}
ierr = VecRestoreArray(locX, &x);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(user->facegeom,&facegeom);CHKERRQ(ierr);
ierr = ISRestoreIndices(idIS, &ids);CHKERRQ(ierr);
ierr = ISDestroy(&idIS);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/**
Compute the gadient of the cell center gradient obtained by the least-square method
*/
PetscErrorCode GradientGradientJacobian(DM dm, Vec locX, PetscScalar elemMat[], void *ctx)
{
User user = (User) ctx;
Physics phys = user->model->physics;
PetscInt dof = phys->dof;
const PetscScalar *facegeom, *cellgeom,*x;
PetscErrorCode ierr;
DM dmFace, dmCell;
DM dmGrad = user->dmGrad;
PetscInt fStart, fEnd, face, cStart;
Vec Grad;
/*here the localGradLimiter refers to the gradient that has been multiplied by the limiter function.
The locGradLimiter is used to construct the uL and uR, and the locGrad is used to caculate the diffusion term*/
Vec TempVec; /*a temperal vec for the vector restore*/
PetscFunctionBeginUser;
ierr = VecGetDM(user->facegeom,&dmFace);CHKERRQ(ierr);
ierr = VecGetDM(user->cellgeom,&dmCell);CHKERRQ(ierr);
ierr = DMGetGlobalVector(dmGrad,&Grad);CHKERRQ(ierr);
ierr = VecZeroEntries(Grad);CHKERRQ(ierr);
ierr = VecDuplicate(Grad, &TempVec);CHKERRQ(ierr);
ierr = VecCopy(Grad, TempVec);CHKERRQ(ierr);
ierr = VecGetArrayRead(user->facegeom,&facegeom);CHKERRQ(ierr);
ierr = VecGetArrayRead(user->cellgeom,&cellgeom);CHKERRQ(ierr);
ierr = VecGetArrayRead(locX,&x);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 1, &fStart, &fEnd);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 0, &cStart, NULL);CHKERRQ(ierr);
{
PetscScalar *grad;
ierr = VecGetArray(TempVec,&grad);CHKERRQ(ierr);
/* Reconstruct gradients */
for (face=fStart; face<fEnd; face++) {
const PetscInt *cells;
const PetscScalar *cx[2];
const FaceGeom *fg;
PetscScalar *cgrad[2];
PetscInt i,j;
PetscBool ghost;
ierr = IsExteriorGhostFace(dm,face,&ghost);CHKERRQ(ierr);
if (ghost) continue;
ierr = DMPlexGetSupport(dm,face,&cells);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmFace,face,facegeom,&fg);CHKERRQ(ierr);
for (i=0; i<2; i++) {
ierr = DMPlexPointLocalRead(dm,cells[i],x,&cx[i]);CHKERRQ(ierr);
ierr = DMPlexPointGlobalRef(dmGrad,cells[i],grad,&cgrad[i]);CHKERRQ(ierr);
}
for (i=0; i<dof; i++) {
PetscScalar delta = cx[1][i] - cx[0][i];
for (j=0; j<DIM; j++) {
if (cgrad[0]) cgrad[0][i*DIM+j] += fg->grad[0][j] * delta;
if (cgrad[1]) cgrad[1][i*DIM+j] -= fg->grad[1][j] * delta;
}
}
for (i=0; i<phys->dof; i++) {
for (j=0; j<phys->dof; j++) {
if(cells[0]<user->cEndInterior) elemMat[cells[0]*dof*dof + i*dof + j] -= cells[0]*1.0;
if(cells[1]<user->cEndInterior) elemMat[cells[1]*dof*dof + i*dof + j] += cells[1]*1.2;
}
}
}
ierr = VecRestoreArray(TempVec,&grad);CHKERRQ(ierr);
}
ierr = DMRestoreGlobalVector(dmGrad,&Grad);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(user->facegeom,&facegeom);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(user->cellgeom,&cellgeom);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(locX,&x);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode ComputeJacobian_LS(DM dm, Vec locX, PetscInt cell, PetscScalar CellValues[], void *ctx)
{
User user = (User) ctx;
Physics phys = user->model->physics;
PetscInt dof = phys->dof;
const PetscScalar *facegeom, *cellgeom,*x;
PetscErrorCode ierr;
DM dmFace, dmCell;
DM dmGrad = user->dmGrad;
PetscInt fStart, fEnd, face, cStart;
Vec locGrad, locGradLimiter, Grad;
/*here the localGradLimiter refers to the gradient that has been multiplied by the limiter function.
The locGradLimiter is used to construct the uL and uR, and the locGrad is used to caculate the diffusion term*/
Vec TempVec; /*a temperal vec for the vector restore*/
PetscFunctionBeginUser;
ierr = VecGetDM(user->facegeom,&dmFace);CHKERRQ(ierr);
ierr = VecGetDM(user->cellgeom,&dmCell);CHKERRQ(ierr);
ierr = DMGetGlobalVector(dmGrad,&Grad);CHKERRQ(ierr);
ierr = VecDuplicate(Grad, &TempVec);CHKERRQ(ierr);
ierr = VecCopy(Grad, TempVec);CHKERRQ(ierr);
/*Backup the original vector and use it to restore the value of dmGrad,
because I do not want to change the values of the cell gradient*/
ierr = VecGetArrayRead(user->facegeom,&facegeom);CHKERRQ(ierr);
ierr = VecGetArrayRead(user->cellgeom,&cellgeom);CHKERRQ(ierr);
ierr = VecGetArrayRead(locX,&x);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 1, &fStart, &fEnd);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 0, &cStart, NULL);CHKERRQ(ierr);
{
PetscScalar *grad;
ierr = VecGetArray(Grad,&grad);CHKERRQ(ierr);
/* Limit interior gradients. Using cell-based loop because it generalizes better to vector limiters. */
const PetscInt *faces;
PetscInt numFaces,f;
PetscReal *cellPhi; /* Scalar limiter applied to each component separately */
const PetscScalar *cx;
const CellGeom *cg;
PetscScalar *cgrad;
PetscInt i;
ierr = PetscMalloc(phys->dof*sizeof(PetscScalar),&cellPhi);CHKERRQ(ierr);
ierr = DMPlexGetConeSize(dm,cell,&numFaces);CHKERRQ(ierr);
ierr = DMPlexGetCone(dm,cell,&faces);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dm,cell,x,&cx);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmCell,cell,cellgeom,&cg);CHKERRQ(ierr);
ierr = DMPlexPointGlobalRef(dmGrad,cell,grad,&cgrad);CHKERRQ(ierr);
/* Limiter will be minimum value over all neighbors */
for (i=0; i<dof; i++) {
cellPhi[i] = PETSC_MAX_REAL;
}
for (f=0; f<numFaces; f++) {
const PetscScalar *ncx;
const CellGeom *ncg;
const PetscInt *fcells;
PetscInt face = faces[f],ncell;
PetscScalar v[DIM];
PetscBool ghost;
ierr = IsExteriorGhostFace(dm,face,&ghost);CHKERRQ(ierr);
if (ghost) continue;
ierr = DMPlexGetSupport(dm,face,&fcells);CHKERRQ(ierr);
ncell = cell == fcells[0] ? fcells[1] : fcells[0]; /*The expression (x ? y : z) has the value of y if x is nonzero, z otherwise */
ierr = DMPlexPointLocalRead(dm,ncell,x,&ncx);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmCell,ncell,cellgeom,&ncg);CHKERRQ(ierr);
Waxpy2(-1, cg->centroid, ncg->centroid, v);
for (i=0; i<dof; i++) {
/* We use the symmetric slope limited form of Berger, Aftosmis, and Murman 2005 */
PetscScalar phi,flim = 0.5 * (ncx[i] - cx[i]) / Dot2(&cgrad[i*DIM],v);
phi = (*user->LimitGrad)(flim);
cellPhi[i] = PetscMin(cellPhi[i],phi);
}
}
/* Apply limiter to gradient */
for (i=0; i<dof; i++) Scale2(cellPhi[i],&cgrad[i*DIM],&cgrad[i*DIM]);
ierr = PetscFree(cellPhi);CHKERRQ(ierr);
ierr = VecRestoreArray(Grad,&grad);CHKERRQ(ierr);
}
ierr = DMGetLocalVector(dmGrad,&locGradLimiter);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(dmGrad,Grad,INSERT_VALUES,locGradLimiter);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(dmGrad,Grad,INSERT_VALUES,locGradLimiter);CHKERRQ(ierr);
ierr = VecCopy(TempVec, Grad);CHKERRQ(ierr);/*Restore the vector*/
ierr = DMGetLocalVector(dmGrad,&locGrad);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(dmGrad,Grad,INSERT_VALUES,locGrad);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(dmGrad,Grad,INSERT_VALUES,locGrad);CHKERRQ(ierr);
ierr = DMRestoreGlobalVector(dmGrad,&Grad);CHKERRQ(ierr);
ierr = VecDestroy(&TempVec);CHKERRQ(ierr);
{
const PetscScalar *grad, *gradlimiter;
ierr = VecGetArrayRead(locGrad,&grad);CHKERRQ(ierr);
ierr = VecGetArrayRead(locGradLimiter,&gradlimiter);CHKERRQ(ierr);
for (face=fStart; face<fEnd; face++) {
const PetscInt *cells;
PetscInt ghost,i,j;
PetscScalar *fluxcon, *fluxdiff, *fx[2];
const FaceGeom *fg;
const CellGeom *cg[2];
const PetscScalar *cx[2],*cgrad[2], *cgradlimiter[2];
PetscScalar *uL, *uR;
PetscReal FaceArea;
ierr = PetscMalloc(phys->dof * phys->dof * sizeof(PetscScalar), &fluxcon);CHKERRQ(ierr); /*For the convection terms*/
ierr = PetscMalloc(phys->dof * phys->dof * sizeof(PetscScalar), &fluxdiff);CHKERRQ(ierr); /*For the diffusion terms*/
ierr = PetscMalloc(phys->dof * sizeof(PetscScalar), &uL);CHKERRQ(ierr);
ierr = PetscMalloc(phys->dof * sizeof(PetscScalar), &uR);CHKERRQ(ierr);
fx[0] = uL; fx[1] = uR;
ierr = DMPlexGetLabelValue(dm, "ghost", face, &ghost);CHKERRQ(ierr);
if (ghost >= 0) continue;
ierr = DMPlexGetSupport(dm, face, &cells);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmFace,face,facegeom,&fg);CHKERRQ(ierr);
for (i=0; i<2; i++) {
PetscScalar dx[DIM];
ierr = DMPlexPointLocalRead(dmCell,cells[i],cellgeom,&cg[i]);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dm,cells[i],x,&cx[i]);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmGrad,cells[i],gradlimiter,&cgradlimiter[i]);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmGrad,cells[i],grad,&cgrad[i]);CHKERRQ(ierr);
Waxpy2(-1,cg[i]->centroid,fg->centroid,dx);
for (j=0; j<dof; j++) {
fx[i][j] = cx[i][j] + Dot2(cgradlimiter[i],dx);
}
/*fx[0] and fx[1] are the value of the variables on the left and right
side of the face, respectively, that is u_L and u_R.*/
}
ierr = RiemannSolver_Rusanov_Jacobian(user, cgrad[0], cgrad[1], fg->centroid, cg[0]->centroid, cg[1]->centroid, fg->normal,
fx[0], fx[1], fluxcon, fluxdiff);CHKERRQ(ierr);
ierr = DMPlexComputeCellGeometryFVM(dm, face, &FaceArea, NULL, NULL);CHKERRQ(ierr);
/*Compute the face area*/
for (i=0; i<phys->dof; i++) {
for (j=0; j<phys->dof; j++) {
if(cells[0]<user->cEndInterior) CellValues[cells[0]*dof*dof + i*dof + j] -= cells[0]*1.0;
if(cells[1]<user->cEndInterior) CellValues[cells[1]*dof*dof + i*dof + j] += cells[1]*1.2;
}
}
// ierr = PetscPrintf(PETSC_COMM_WORLD,"\n");CHKERRQ(ierr);
ierr = PetscFree(fluxcon);CHKERRQ(ierr);
ierr = PetscFree(fluxdiff);CHKERRQ(ierr);
ierr = PetscFree(uL);CHKERRQ(ierr);
ierr = PetscFree(uR);CHKERRQ(ierr);
}
ierr = VecRestoreArrayRead(locGrad,&grad);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(locGradLimiter,&gradlimiter);CHKERRQ(ierr);
}
ierr = VecRestoreArrayRead(user->facegeom,&facegeom);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(user->cellgeom,&cellgeom);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(locX,&x);CHKERRQ(ierr);
ierr = DMRestoreLocalVector(dmGrad,&locGradLimiter);CHKERRQ(ierr);
ierr = DMRestoreLocalVector(dmGrad,&locGrad);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/**
Caculate the flux using the Monotonic Upstream-Centered Scheme for Conservation Laws (van Leer, 1979)
*/
PetscErrorCode CaculateLocalFunction_LS(DM dm,DM dmFace,DM dmCell,PetscReal time,Vec locX,Vec F,User user)
{
DM dmGrad = user->dmGrad;
Model mod = user->model;
Physics phys = mod->physics;
const PetscInt dof = phys->dof;
PetscErrorCode ierr;
const PetscScalar *facegeom, *cellgeom, *x;
PetscScalar *f;
PetscInt fStart, fEnd, face, cStart, cell;
Vec locGrad, locGradLimiter, Grad;
/*
Here the localGradLimiter refers to the gradient that
has been multiplied by the limiter function.
The locGradLimiter is used to construct the uL and uR,
and the locGrad is used to caculate the diffusion term
*/
Vec TempVec; /*a temperal vec for the vector restore*/
PetscFunctionBeginUser;
ierr = DMGetGlobalVector(dmGrad,&Grad);CHKERRQ(ierr);
ierr = VecDuplicate(Grad, &TempVec);CHKERRQ(ierr);
ierr = VecCopy(Grad, TempVec);CHKERRQ(ierr);
/*
Backup the original vector and use it to restore the value of dmGrad,
because I do not want to change the values of the cell gradient.
*/
ierr = VecGetArrayRead(user->facegeom,&facegeom);CHKERRQ(ierr);
ierr = VecGetArrayRead(user->cellgeom,&cellgeom);CHKERRQ(ierr);
ierr = VecGetArrayRead(locX,&x);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 1, &fStart, &fEnd);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 0, &cStart, NULL);CHKERRQ(ierr);
{
PetscScalar *grad;
ierr = VecGetArray(Grad,&grad);CHKERRQ(ierr);
const PetscInt *faces;
PetscInt numFaces,f;
PetscReal *cellPhi; // Scalar limiter applied to each component separately
const PetscScalar *cx;
const CellGeom *cg;
PetscScalar *cgrad;
PetscInt i;
ierr = PetscMalloc(phys->dof*sizeof(PetscScalar),&cellPhi);CHKERRQ(ierr);
// Limit interior gradients. Using cell-based loop because it generalizes better to vector limiters.
for (cell=cStart; cell<user->cEndInterior; cell++) {
ierr = DMPlexGetConeSize(dm,cell,&numFaces);CHKERRQ(ierr);
ierr = DMPlexGetCone(dm,cell,&faces);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dm,cell,x,&cx);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmCell,cell,cellgeom,&cg);CHKERRQ(ierr);
ierr = DMPlexPointGlobalRef(dmGrad,cell,grad,&cgrad);CHKERRQ(ierr);
if (!cgrad) continue; // ghost cell, we don't compute
// Limiter will be minimum value over all neighbors
for (i=0; i<dof; i++) cellPhi[i] = PETSC_MAX_REAL;
for (f=0; f<numFaces; f++) {
const PetscScalar *ncx;
const CellGeom *ncg;
const PetscInt *fcells;
PetscInt face = faces[f],ncell;
PetscScalar v[DIM];
PetscBool ghost;
ierr = IsExteriorGhostFace(dm,face,&ghost);CHKERRQ(ierr);
if (ghost) continue;
ierr = DMPlexGetSupport(dm,face,&fcells);CHKERRQ(ierr);
ncell = cell == fcells[0] ? fcells[1] : fcells[0];
// The expression (x ? y : z) has the value of y if x is nonzero, z otherwise
ierr = DMPlexPointLocalRead(dm,ncell,x,&ncx);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmCell,ncell,cellgeom,&ncg);CHKERRQ(ierr);
Waxpy2(-1, cg->centroid, ncg->centroid, v);
for (i=0; i<dof; i++) {
// We use the symmetric slope limited form of Berger, Aftosmis, and Murman 2005
PetscScalar phi,flim = 0.5 * (ncx[i] - cx[i]) / Dot2(&cgrad[i*DIM],v);
phi = (*user->Limit)(flim);
cellPhi[i] = PetscMin(cellPhi[i],phi);
}
}
// Apply limiter to gradient
for (i=0; i<dof; i++) Scale2(cellPhi[i],&cgrad[i*DIM],&cgrad[i*DIM]);
}
ierr = PetscFree(cellPhi);CHKERRQ(ierr);
ierr = VecRestoreArray(Grad,&grad);CHKERRQ(ierr);
}
ierr = DMGetLocalVector(dmGrad,&locGradLimiter);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(dmGrad,Grad,INSERT_VALUES,locGradLimiter);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(dmGrad,Grad,INSERT_VALUES,locGradLimiter);CHKERRQ(ierr);
ierr = VecCopy(TempVec, Grad);CHKERRQ(ierr);//Restore the vector
ierr = DMGetLocalVector(dmGrad,&locGrad);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(dmGrad,Grad,INSERT_VALUES,locGrad);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(dmGrad,Grad,INSERT_VALUES,locGrad);CHKERRQ(ierr);
ierr = DMRestoreGlobalVector(dmGrad,&Grad);CHKERRQ(ierr);
ierr = VecDestroy(&TempVec);CHKERRQ(ierr);
{
const PetscScalar *grad, *gradlimiter;
const PetscInt *cells;
PetscInt ghost,i,j;
PetscScalar *fluxcon, *fluxdiff, *fx[2],*cf[2];
const FaceGeom *fg;
const CellGeom *cg[2];
const PetscScalar *cx[2],*cgrad[2], *cgradlimiter[2];
PetscScalar *uL, *uR;
PetscReal FaceArea;
ierr = VecGetArrayRead(locGrad,&grad);CHKERRQ(ierr);
ierr = VecGetArrayRead(locGradLimiter,&gradlimiter);CHKERRQ(ierr);
ierr = VecGetArray(F,&f);CHKERRQ(ierr);
ierr = PetscMalloc(phys->dof * sizeof(PetscScalar), &fluxcon);CHKERRQ(ierr); // For the convection terms
ierr = PetscMalloc(phys->dof * sizeof(PetscScalar), &fluxdiff);CHKERRQ(ierr); // For the diffusion terms
ierr = PetscMalloc(phys->dof * sizeof(PetscScalar), &uL);CHKERRQ(ierr);
ierr = PetscMalloc(phys->dof * sizeof(PetscScalar), &uR);CHKERRQ(ierr);// Please do not put the Malloc function into a for loop!!!!
for (face=fStart; face<fEnd; face++) {
fx[0] = uL; fx[1] = uR;
ierr = DMPlexGetLabelValue(dm, "ghost", face, &ghost);CHKERRQ(ierr);
if (ghost >= 0) continue;
ierr = DMPlexGetSupport(dm, face, &cells);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmFace,face,facegeom,&fg);CHKERRQ(ierr);
for (i=0; i<2; i++) {
PetscScalar dx[DIM];
ierr = DMPlexPointLocalRead(dmCell,cells[i],cellgeom,&cg[i]);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dm,cells[i],x,&cx[i]);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmGrad,cells[i],gradlimiter,&cgradlimiter[i]);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmGrad,cells[i],grad,&cgrad[i]);CHKERRQ(ierr);
ierr = DMPlexPointGlobalRef(dm,cells[i],f,&cf[i]);CHKERRQ(ierr);
Waxpy2(-1,cg[i]->centroid,fg->centroid,dx);
for (j=0; j<dof; j++) {
fx[i][j] = cx[i][j] + Dot2(cgradlimiter[i],dx);
}
// fx[0] and fx[1] are the value of the variables on the left and right
// side of the face, respectively, that is u_L and u_R.
}
ierr = RiemannSolver_Rusanov(user, cgrad[0], cgrad[1], fg->centroid, cg[0]->centroid, cg[1]->centroid, fg->normal, fx[0], fx[1], fluxcon, fluxdiff);CHKERRQ(ierr);
ierr = DMPlexComputeCellGeometryFVM(dm, face, &FaceArea, NULL, NULL);CHKERRQ(ierr);
// Compute the face area
for (i=0; i<phys->dof; i++) {
if (cf[0]) cf[0][i] -= FaceArea*(fluxcon[i] + fluxdiff[i])/cg[0]->volume;
if (cf[1]) cf[1][i] += FaceArea*(fluxcon[i] + fluxdiff[i])/cg[1]->volume;
// The flux on the interface, for the cell[0], it is an outcome flux and for the cell[1], it is
// an income flux.
}
// ierr = PetscPrintf(PETSC_COMM_WORLD,"\n");CHKERRQ(ierr);
}
ierr = VecRestoreArrayRead(locGrad,&grad);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(locGradLimiter,&gradlimiter);CHKERRQ(ierr);
ierr = VecRestoreArray(F,&f);CHKERRQ(ierr);
ierr = PetscFree(fluxcon);CHKERRQ(ierr);
ierr = PetscFree(fluxdiff);CHKERRQ(ierr);
ierr = PetscFree(uL);CHKERRQ(ierr);
ierr = PetscFree(uR);CHKERRQ(ierr);
// VecView(F,PETSC_VIEWER_STDOUT_WORLD);
}
ierr = VecRestoreArrayRead(user->facegeom,&facegeom);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(user->cellgeom,&cellgeom);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(locX,&x);CHKERRQ(ierr);
ierr = DMRestoreLocalVector(dmGrad,&locGradLimiter);CHKERRQ(ierr);
ierr = DMRestoreLocalVector(dmGrad,&locGrad);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*
Use the first order upwind scheme to compute the flux
*/
PetscErrorCode CaculateLocalFunction_Upwind(DM dm,DM dmFace,DM dmCell,PetscReal time,Vec locX,Vec F,User user)
{
Physics phys = user->model->physics;
DM dmGrad = user->dmGrad;
PetscErrorCode ierr;
const PetscScalar *facegeom, *cellgeom, *x;
PetscScalar *f;
PetscInt fStart, fEnd, face;
Vec locGrad, Grad;
PetscFunctionBeginUser;
ierr = VecGetArrayRead(user->facegeom, &facegeom);CHKERRQ(ierr);
ierr = VecGetArrayRead(user->cellgeom, &cellgeom);CHKERRQ(ierr);
ierr = VecGetArrayRead(locX, &x);CHKERRQ(ierr);
ierr = VecGetArray(F, &f);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 1, &fStart, &fEnd);CHKERRQ(ierr);
ierr = DMGetGlobalVector(dmGrad, &Grad);CHKERRQ(ierr);
ierr = DMGetLocalVector(dmGrad, &locGrad);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(dmGrad, Grad, INSERT_VALUES, locGrad);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(dmGrad, Grad, INSERT_VALUES, locGrad);CHKERRQ(ierr);
ierr = DMRestoreGlobalVector(dmGrad, &Grad);CHKERRQ(ierr);
const PetscScalar *grad;
ierr = VecGetArrayRead(locGrad, &grad);CHKERRQ(ierr);
{
const PetscInt *cells;
PetscInt i,ghost;
PetscScalar *fluxcon, *fluxdiff, *fL,*fR;
const FaceGeom *fg;
const CellGeom *cgL,*cgR;
const PetscScalar *xL,*xR;
const PetscScalar *cgrad[2];
PetscReal FaceArea;
ierr = PetscMalloc(phys->dof * sizeof(PetscScalar), &fluxcon);CHKERRQ(ierr); /*For the convection terms*/
ierr = PetscMalloc(phys->dof * sizeof(PetscScalar), &fluxdiff);CHKERRQ(ierr); /*For the diffusion terms*/
for (face = fStart; face < fEnd; ++face) {
ierr = DMPlexGetLabelValue(dm, "ghost", face, &ghost);CHKERRQ(ierr);
if (ghost >= 0) continue;
ierr = DMPlexGetSupport(dm, face, &cells);CHKERRQ(ierr);/*The support of a face is the cells (two cells)*/
ierr = DMPlexPointLocalRead(dmFace, face, facegeom, &fg);CHKERRQ(ierr);/*Read the data from "facegeom" for the point "face"*/
ierr = DMPlexPointLocalRead(dmCell, cells[0], cellgeom, &cgL);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmCell, cells[1], cellgeom, &cgR);CHKERRQ(ierr);
/*
PetscPrintf(PETSC_COMM_SELF, "face[%d]:(%f, %f, %f), cgL:(%f, %f, %f), cgR:(%f, %f, %f), fnorm:(%f, %f, %f)\n",
face, fg->centroid[0], fg->centroid[1], fg->centroid[2],
cgL->centroid[0], cgL->centroid[1], cgL->centroid[2], cgR->centroid[0], cgR->centroid[1], cgR->centroid[2],
fg->normal[0], fg->normal[1], fg->normal[2]);
*/
ierr = DMPlexPointLocalRead(dm, cells[0], x, &xL);CHKERRQ(ierr); /*For the unkown variables*/
ierr = DMPlexPointLocalRead(dm, cells[1], x, &xR);CHKERRQ(ierr);
ierr = DMPlexPointGlobalRef(dm, cells[0], f, &fL);CHKERRQ(ierr); /*For the functions*/
ierr = DMPlexPointGlobalRef(dm, cells[1], f, &fR);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmGrad, cells[0], grad, &cgrad[0]);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmGrad, cells[1], grad, &cgrad[1]);CHKERRQ(ierr);
ierr = RiemannSolver_Rusanov(user, cgrad[0], cgrad[1], fg->centroid, cgL->centroid, cgR->centroid, fg->normal, xL, xR, fluxcon, fluxdiff);CHKERRQ(ierr);
/*Caculate the flux*/
ierr = DMPlexComputeCellGeometryFVM(dm, face, &FaceArea, NULL, NULL);CHKERRQ(ierr);
//PetscPrintf(PETSC_COMM_SELF, "FaceArea=%f, Volume=%f\n",FaceArea,cgL->volume);
/*Compute the face area*/
// FaceArea = 0.0;
for (i=0; i<phys->dof; i++) {
/*
PetscPrintf(PETSC_COMM_SELF, "face[%d]:(%f, %f, %f), GradL[%d] = (%f, %f, %f), GradR[%d] = (%f, %f, %f), fluxcon[%d] = %f\n",
face, fg->centroid[0], fg->centroid[1], fg->centroid[2],
i, cgrad[0][DIM*i], cgrad[0][DIM*i + 1], cgrad[0][DIM*i + 2],
i, cgrad[1][DIM*i], cgrad[1][DIM*i + 1], cgrad[1][DIM*i + 2], i, fluxcon[i]);
*/
if (fL) {
fL[i] -= FaceArea*(fluxcon[i] + fluxdiff[i])/cgL->volume;
// if (fL) PetscPrintf(PETSC_COMM_SELF, "x=%g, y=%g, z=%g,fluxcon[i]=%g, FaceArea=%g, volume=%g, fLc=%g, fL=%g\n",fg->centroid[0], fg->centroid[1], fg->centroid[2],fluxcon[i],FaceArea,cgL->volume,FaceArea*(fluxcon[i] + fluxdiff[i])/cgL->volume,fL[i]);
}
if (fR) fR[i] += FaceArea*(fluxcon[i] + fluxdiff[i])/cgR->volume;
}
}
ierr = PetscFree(fluxcon);CHKERRQ(ierr);
ierr = PetscFree(fluxdiff);CHKERRQ(ierr);
}
// VecView(F,PETSC_VIEWER_STDOUT_WORLD);
ierr = VecRestoreArrayRead(locGrad,&grad);CHKERRQ(ierr);
ierr = DMRestoreLocalVector(dmGrad,&locGrad);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(user->facegeom,&facegeom);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(user->cellgeom,&cellgeom);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(locX,&x);CHKERRQ(ierr);
ierr = VecRestoreArray(F,&f);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode DMPlexTSSetupGeometry(DM dm, PetscFV fvm, DMTS_Plex *dmplexts)
{
DM dmFace, dmCell;
DMLabel ghostLabel;
PetscSection sectionFace, sectionCell;
PetscSection coordSection;
Vec coordinates;
PetscReal minradius;
PetscScalar *fgeom, *cgeom;
PetscInt dim, cStart, cEnd, cEndInterior, c, fStart, fEnd, f;
PetscErrorCode ierr;
PetscFunctionBegin;
if (dmplexts->setupGeom) PetscFunctionReturn(0);
ierr = DMPlexGetDimension(dm, &dim);CHKERRQ(ierr);
ierr = DMGetCoordinateSection(dm, &coordSection);CHKERRQ(ierr);
ierr = DMGetCoordinatesLocal(dm, &coordinates);CHKERRQ(ierr);
/* Make cell centroids and volumes */
ierr = DMClone(dm, &dmCell);CHKERRQ(ierr);
ierr = DMSetCoordinateSection(dmCell, coordSection);CHKERRQ(ierr);
ierr = DMSetCoordinatesLocal(dmCell, coordinates);CHKERRQ(ierr);
ierr = PetscSectionCreate(PetscObjectComm((PetscObject) dm), §ionCell);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);CHKERRQ(ierr);
ierr = DMPlexGetHybridBounds(dm, &cEndInterior, NULL, NULL, NULL);CHKERRQ(ierr);
ierr = PetscSectionSetChart(sectionCell, cStart, cEnd);CHKERRQ(ierr);
for (c = cStart; c < cEnd; ++c) {ierr = PetscSectionSetDof(sectionCell, c, sizeof(CellGeom)/sizeof(PetscScalar));CHKERRQ(ierr);}
ierr = PetscSectionSetUp(sectionCell);CHKERRQ(ierr);
ierr = DMSetDefaultSection(dmCell, sectionCell);CHKERRQ(ierr);
ierr = PetscSectionDestroy(§ionCell);CHKERRQ(ierr);
ierr = DMCreateLocalVector(dmCell, &dmplexts->cellgeom);CHKERRQ(ierr);
ierr = VecGetArray(dmplexts->cellgeom, &cgeom);CHKERRQ(ierr);
for (c = cStart; c < cEndInterior; ++c) {
CellGeom *cg;
ierr = DMPlexPointLocalRef(dmCell, c, cgeom, &cg);CHKERRQ(ierr);
ierr = PetscMemzero(cg, sizeof(*cg));CHKERRQ(ierr);
ierr = DMPlexComputeCellGeometryFVM(dmCell, c, &cg->volume, cg->centroid, NULL);CHKERRQ(ierr);
}
/* Compute face normals and minimum cell radius */
ierr = DMClone(dm, &dmFace);CHKERRQ(ierr);
ierr = PetscSectionCreate(PetscObjectComm((PetscObject) dm), §ionFace);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 1, &fStart, &fEnd);CHKERRQ(ierr);
ierr = PetscSectionSetChart(sectionFace, fStart, fEnd);CHKERRQ(ierr);
for (f = fStart; f < fEnd; ++f) {ierr = PetscSectionSetDof(sectionFace, f, sizeof(FaceGeom)/sizeof(PetscScalar));CHKERRQ(ierr);}
ierr = PetscSectionSetUp(sectionFace);CHKERRQ(ierr);
ierr = DMSetDefaultSection(dmFace, sectionFace);CHKERRQ(ierr);
ierr = PetscSectionDestroy(§ionFace);CHKERRQ(ierr);
ierr = DMCreateLocalVector(dmFace, &dmplexts->facegeom);CHKERRQ(ierr);
ierr = VecGetArray(dmplexts->facegeom, &fgeom);CHKERRQ(ierr);
ierr = DMPlexGetLabel(dm, "ghost", &ghostLabel);CHKERRQ(ierr);
minradius = PETSC_MAX_REAL;
for (f = fStart; f < fEnd; ++f) {
FaceGeom *fg;
PetscReal area;
PetscInt ghost, d;
ierr = DMLabelGetValue(ghostLabel, f, &ghost);CHKERRQ(ierr);
if (ghost >= 0) continue;
ierr = DMPlexPointLocalRef(dmFace, f, fgeom, &fg);CHKERRQ(ierr);
ierr = DMPlexComputeCellGeometryFVM(dm, f, &area, fg->centroid, fg->normal);CHKERRQ(ierr);
for (d = 0; d < dim; ++d) fg->normal[d] *= area;
/* Flip face orientation if necessary to match ordering in support, and Update minimum radius */
{
CellGeom *cL, *cR;
const PetscInt *cells;
PetscReal *lcentroid, *rcentroid;
PetscReal v[3];
ierr = DMPlexGetSupport(dm, f, &cells);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmCell, cells[0], cgeom, &cL);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmCell, cells[1], cgeom, &cR);CHKERRQ(ierr);
lcentroid = cells[0] >= cEndInterior ? fg->centroid : cL->centroid;
rcentroid = cells[1] >= cEndInterior ? fg->centroid : cR->centroid;
WaxpyD(dim, -1, lcentroid, rcentroid, v);
if (DotRealD(dim, fg->normal, v) < 0) {
for (d = 0; d < dim; ++d) fg->normal[d] = -fg->normal[d];
}
if (DotRealD(dim, fg->normal, v) <= 0) {
if (dim == 2) SETERRQ5(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Direction for face %d could not be fixed, normal (%g,%g) v (%g,%g)", f, (double) fg->normal[0], (double) fg->normal[1], (double) v[0], (double) v[1]);
if (dim == 3) SETERRQ7(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Direction for face %d could not be fixed, normal (%g,%g,%g) v (%g,%g,%g)", f, (double) fg->normal[0], (double) fg->normal[1], (double) fg->normal[2], (double) v[0], (double) v[1], (double) v[2]);
SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Direction for face %d could not be fixed", f);
}
if (cells[0] < cEndInterior) {
WaxpyD(dim, -1, fg->centroid, cL->centroid, v);
minradius = PetscMin(minradius, NormD(dim, v));
}
if (cells[1] < cEndInterior) {
WaxpyD(dim, -1, fg->centroid, cR->centroid, v);
minradius = PetscMin(minradius, NormD(dim, v));
}
}
}
ierr = MPI_Allreduce(&minradius, &dmplexts->minradius, 1, MPIU_REAL, MPI_MIN, PetscObjectComm((PetscObject)dm));CHKERRQ(ierr);
/* Compute centroids of ghost cells */
for (c = cEndInterior; c < cEnd; ++c) {
FaceGeom *fg;
const PetscInt *cone, *support;
PetscInt coneSize, supportSize, s;
ierr = DMPlexGetConeSize(dmCell, c, &coneSize);CHKERRQ(ierr);
if (coneSize != 1) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Ghost cell %d has cone size %d != 1", c, coneSize);
ierr = DMPlexGetCone(dmCell, c, &cone);CHKERRQ(ierr);
ierr = DMPlexGetSupportSize(dmCell, cone[0], &supportSize);CHKERRQ(ierr);
if (supportSize != 2) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Face %d has support size %d != 1", cone[0], supportSize);
ierr = DMPlexGetSupport(dmCell, cone[0], &support);CHKERRQ(ierr);
ierr = DMPlexPointLocalRef(dmFace, cone[0], fgeom, &fg);CHKERRQ(ierr);
for (s = 0; s < 2; ++s) {
/* Reflect ghost centroid across plane of face */
if (support[s] == c) {
const CellGeom *ci;
CellGeom *cg;
PetscReal c2f[3], a;
ierr = DMPlexPointLocalRead(dmCell, support[(s+1)%2], cgeom, &ci);CHKERRQ(ierr);
WaxpyD(dim, -1, ci->centroid, fg->centroid, c2f); /* cell to face centroid */
a = DotRealD(dim, c2f, fg->normal)/DotRealD(dim, fg->normal, fg->normal);
ierr = DMPlexPointLocalRef(dmCell, support[s], cgeom, &cg);CHKERRQ(ierr);
WaxpyD(dim, 2*a, fg->normal, ci->centroid, cg->centroid);
cg->volume = ci->volume;
}
}
}
ierr = VecRestoreArray(dmplexts->facegeom, &fgeom);CHKERRQ(ierr);
ierr = VecRestoreArray(dmplexts->cellgeom, &cgeom);CHKERRQ(ierr);
ierr = DMDestroy(&dmCell);CHKERRQ(ierr);
ierr = DMDestroy(&dmFace);CHKERRQ(ierr);
dmplexts->setupGeom = PETSC_TRUE;
PetscFunctionReturn(0);
}
static PetscErrorCode TSComputeRHSFunction_DMPlex(TS ts, PetscReal time, Vec X, Vec F, void *ctx)
{
DM dm;
DMTS_Plex *dmplexts = (DMTS_Plex *) ctx;
void (*riemann)(const PetscReal[], const PetscReal[], const PetscScalar[], const PetscScalar[], PetscScalar[], void *) = dmplexts->riemann;
PetscFV fvm;
PetscLimiter lim;
Vec faceGeometry = dmplexts->facegeom;
Vec cellGeometry = dmplexts->cellgeom;
Vec Grad = NULL, locGrad, locX;
DM dmFace, dmCell;
DMLabel ghostLabel;
PetscCellGeometry fgeom, cgeom;
const PetscScalar *facegeom, *cellgeom, *x, *lgrad;
PetscScalar *grad, *f, *uL, *uR, *fluxL, *fluxR;
PetscReal *centroid, *normal, *vol, *cellPhi;
PetscBool computeGradients;
PetscInt Nf, dim, pdim, fStart, fEnd, numFaces = 0, face, iface, cell, cStart, cEnd, cEndInterior;
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(ts,TS_CLASSID,1);
PetscValidHeaderSpecific(X,VEC_CLASSID,3);
PetscValidHeaderSpecific(F,VEC_CLASSID,5);
ierr = TSGetDM(ts, &dm);CHKERRQ(ierr);
ierr = DMGetLocalVector(dm, &locX);CHKERRQ(ierr);
ierr = VecZeroEntries(locX);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(dm, X, INSERT_VALUES, locX);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(dm, X, INSERT_VALUES, locX);CHKERRQ(ierr);
ierr = VecZeroEntries(F);CHKERRQ(ierr);
ierr = DMPlexGetDimension(dm, &dim);CHKERRQ(ierr);
ierr = DMGetNumFields(dm, &Nf);CHKERRQ(ierr);
ierr = DMGetField(dm, 0, (PetscObject *) &fvm);CHKERRQ(ierr);
ierr = PetscFVGetLimiter(fvm, &lim);CHKERRQ(ierr);
ierr = PetscFVGetNumComponents(fvm, &pdim);CHKERRQ(ierr);
ierr = PetscFVGetComputeGradients(fvm, &computeGradients);CHKERRQ(ierr);
if (computeGradients) {
ierr = DMGetGlobalVector(dmplexts->dmGrad, &Grad);CHKERRQ(ierr);
ierr = VecZeroEntries(Grad);CHKERRQ(ierr);
ierr = VecGetArray(Grad, &grad);CHKERRQ(ierr);
}
ierr = DMPlexGetLabel(dm, "ghost", &ghostLabel);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 1, &fStart, &fEnd);CHKERRQ(ierr);
ierr = VecGetDM(faceGeometry, &dmFace);CHKERRQ(ierr);
ierr = VecGetDM(cellGeometry, &dmCell);CHKERRQ(ierr);
ierr = VecGetArrayRead(faceGeometry, &facegeom);CHKERRQ(ierr);
ierr = VecGetArrayRead(cellGeometry, &cellgeom);CHKERRQ(ierr);
ierr = VecGetArrayRead(locX, &x);CHKERRQ(ierr);
/* Count faces and reconstruct gradients */
for (face = fStart; face < fEnd; ++face) {
const PetscInt *cells;
const FaceGeom *fg;
const PetscScalar *cx[2];
PetscScalar *cgrad[2];
PetscBool boundary;
PetscInt ghost, c, pd, d;
ierr = DMLabelGetValue(ghostLabel, face, &ghost);CHKERRQ(ierr);
if (ghost >= 0) continue;
++numFaces;
if (!computeGradients) continue;
ierr = DMPlexIsBoundaryPoint(dm, face, &boundary);CHKERRQ(ierr);
if (boundary) continue;
ierr = DMPlexGetSupport(dm, face, &cells);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmFace, face, facegeom, &fg);CHKERRQ(ierr);
for (c = 0; c < 2; ++c) {
ierr = DMPlexPointLocalRead(dm, cells[c], x, &cx[c]);CHKERRQ(ierr);
ierr = DMPlexPointGlobalRef(dmplexts->dmGrad, cells[c], grad, &cgrad[c]);CHKERRQ(ierr);
}
for (pd = 0; pd < pdim; ++pd) {
PetscScalar delta = cx[1][pd] - cx[0][pd];
for (d = 0; d < dim; ++d) {
if (cgrad[0]) cgrad[0][pd*dim+d] += fg->grad[0][d] * delta;
if (cgrad[1]) cgrad[1][pd*dim+d] -= fg->grad[1][d] * delta;
}
}
}
/* Limit interior gradients (using cell-based loop because it generalizes better to vector limiters) */
ierr = DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);CHKERRQ(ierr);
ierr = DMPlexGetHybridBounds(dm, &cEndInterior, NULL, NULL, NULL);CHKERRQ(ierr);
ierr = DMGetWorkArray(dm, pdim, PETSC_REAL, &cellPhi);CHKERRQ(ierr);
for (cell = computeGradients && lim ? cStart : cEnd; cell < cEndInterior; ++cell) {
const PetscInt *faces;
const PetscScalar *cx;
const CellGeom *cg;
PetscScalar *cgrad;
PetscInt coneSize, f, pd, d;
ierr = DMPlexGetConeSize(dm, cell, &coneSize);CHKERRQ(ierr);
ierr = DMPlexGetCone(dm, cell, &faces);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dm, cell, x, &cx);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmCell, cell, cellgeom, &cg);CHKERRQ(ierr);
ierr = DMPlexPointGlobalRef(dmplexts->dmGrad, cell, grad, &cgrad);CHKERRQ(ierr);
if (!cgrad) continue; /* Unowned overlap cell, we do not compute */
/* Limiter will be minimum value over all neighbors */
for (d = 0; d < pdim; ++d) cellPhi[d] = PETSC_MAX_REAL;
for (f = 0; f < coneSize; ++f) {
const PetscScalar *ncx;
const CellGeom *ncg;
const PetscInt *fcells;
PetscInt face = faces[f], ncell, ghost;
PetscReal v[3];
PetscBool boundary;
ierr = DMLabelGetValue(ghostLabel, face, &ghost);CHKERRQ(ierr);
ierr = DMPlexIsBoundaryPoint(dm, face, &boundary);CHKERRQ(ierr);
if ((ghost >= 0) || boundary) continue;
ierr = DMPlexGetSupport(dm, face, &fcells);CHKERRQ(ierr);
ncell = cell == fcells[0] ? fcells[1] : fcells[0];
ierr = DMPlexPointLocalRead(dm, ncell, x, &ncx);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmCell, ncell, cellgeom, &ncg);CHKERRQ(ierr);
WaxpyD(dim, -1, cg->centroid, ncg->centroid, v);
for (d = 0; d < pdim; ++d) {
/* We use the symmetric slope limited form of Berger, Aftosmis, and Murman 2005 */
PetscReal phi, flim = 0.5 * PetscRealPart(ncx[d] - cx[d]) / DotD(dim, &cgrad[d*dim], v);
ierr = PetscLimiterLimit(lim, flim, &phi);CHKERRQ(ierr);
cellPhi[d] = PetscMin(cellPhi[d], phi);
}
}
/* Apply limiter to gradient */
for (pd = 0; pd < pdim; ++pd)
/* Scalar limiter applied to each component separately */
for (d = 0; d < dim; ++d) cgrad[pd*dim+d] *= cellPhi[pd];
}
ierr = DMRestoreWorkArray(dm, pdim, PETSC_REAL, &cellPhi);CHKERRQ(ierr);
ierr = DMPlexInsertBoundaryValuesFVM_Static(dm, fvm, time, locX, Grad, dmplexts);CHKERRQ(ierr);
if (computeGradients) {
ierr = VecRestoreArray(Grad, &grad);CHKERRQ(ierr);
ierr = DMGetLocalVector(dmplexts->dmGrad, &locGrad);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(dmplexts->dmGrad, Grad, INSERT_VALUES, locGrad);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(dmplexts->dmGrad, Grad, INSERT_VALUES, locGrad);CHKERRQ(ierr);
ierr = DMRestoreGlobalVector(dmplexts->dmGrad, &Grad);CHKERRQ(ierr);
ierr = VecGetArrayRead(locGrad, &lgrad);CHKERRQ(ierr);
}
ierr = PetscMalloc7(numFaces*dim,¢roid,numFaces*dim,&normal,numFaces*2,&vol,numFaces*pdim,&uL,numFaces*pdim,&uR,numFaces*pdim,&fluxL,numFaces*pdim,&fluxR);CHKERRQ(ierr);
/* Read out values */
for (face = fStart, iface = 0; face < fEnd; ++face) {
const PetscInt *cells;
const FaceGeom *fg;
const CellGeom *cgL, *cgR;
const PetscScalar *xL, *xR, *gL, *gR;
PetscInt ghost, d;
ierr = DMLabelGetValue(ghostLabel, face, &ghost);CHKERRQ(ierr);
if (ghost >= 0) continue;
ierr = DMPlexPointLocalRead(dmFace, face, facegeom, &fg);CHKERRQ(ierr);
ierr = DMPlexGetSupport(dm, face, &cells);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmCell, cells[0], cellgeom, &cgL);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmCell, cells[1], cellgeom, &cgR);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dm, cells[0], x, &xL);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dm, cells[1], x, &xR);CHKERRQ(ierr);
if (computeGradients) {
PetscReal dxL[3], dxR[3];
ierr = DMPlexPointLocalRead(dmplexts->dmGrad, cells[0], lgrad, &gL);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmplexts->dmGrad, cells[1], lgrad, &gR);CHKERRQ(ierr);
WaxpyD(dim, -1, cgL->centroid, fg->centroid, dxL);
WaxpyD(dim, -1, cgR->centroid, fg->centroid, dxR);
for (d = 0; d < pdim; ++d) {
uL[iface*pdim+d] = xL[d] + DotD(dim, &gL[d*dim], dxL);
uR[iface*pdim+d] = xR[d] + DotD(dim, &gR[d*dim], dxR);
}
} else {
for (d = 0; d < pdim; ++d) {
uL[iface*pdim+d] = xL[d];
uR[iface*pdim+d] = xR[d];
}
}
for (d = 0; d < dim; ++d) {
centroid[iface*dim+d] = fg->centroid[d];
normal[iface*dim+d] = fg->normal[d];
}
vol[iface*2+0] = cgL->volume;
vol[iface*2+1] = cgR->volume;
++iface;
}
if (computeGradients) {
ierr = VecRestoreArrayRead(locGrad,&lgrad);CHKERRQ(ierr);
ierr = DMRestoreLocalVector(dmplexts->dmGrad, &locGrad);CHKERRQ(ierr);
}
ierr = VecRestoreArrayRead(locX, &x);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(faceGeometry, &facegeom);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(cellGeometry, &cellgeom);CHKERRQ(ierr);
fgeom.v0 = centroid;
fgeom.n = normal;
cgeom.vol = vol;
/* Riemann solve */
ierr = PetscFVIntegrateRHSFunction(fvm, numFaces, Nf, &fvm, 0, fgeom, cgeom, uL, uR, riemann, fluxL, fluxR, dmplexts->rhsfunctionlocalctx);CHKERRQ(ierr);
/* Insert fluxes */
ierr = VecGetArray(F, &f);CHKERRQ(ierr);
for (face = fStart, iface = 0; face < fEnd; ++face) {
const PetscInt *cells;
PetscScalar *fL, *fR;
PetscInt ghost, d;
ierr = DMLabelGetValue(ghostLabel, face, &ghost);CHKERRQ(ierr);
if (ghost >= 0) continue;
ierr = DMPlexGetSupport(dm, face, &cells);CHKERRQ(ierr);
ierr = DMPlexPointGlobalRef(dm, cells[0], f, &fL);CHKERRQ(ierr);
ierr = DMPlexPointGlobalRef(dm, cells[1], f, &fR);CHKERRQ(ierr);
for (d = 0; d < pdim; ++d) {
if (fL) fL[d] -= fluxL[iface*pdim+d];
if (fR) fR[d] += fluxR[iface*pdim+d];
}
++iface;
}
ierr = VecRestoreArray(F, &f);CHKERRQ(ierr);
ierr = PetscFree7(centroid,normal,vol,uL,uR,fluxL,fluxR);CHKERRQ(ierr);
ierr = DMRestoreLocalVector(dm, &locX);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
static PetscErrorCode DMPlexInsertBoundaryValuesFVM_Static(DM dm, PetscFV fvm, PetscReal time, Vec locX, Vec Grad, DMTS_Plex *dmplexts)
{
Vec faceGeometry = dmplexts->facegeom;
Vec cellGeometry = dmplexts->cellgeom;
DM dmFace, dmCell;
const PetscScalar *facegeom, *cellgeom, *grad;
PetscScalar *x, *fx;
PetscInt numBd, b, dim, pdim, fStart, fEnd;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = DMPlexGetDimension(dm, &dim);CHKERRQ(ierr);
ierr = PetscFVGetNumComponents(fvm, &pdim);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 1, &fStart, &fEnd);CHKERRQ(ierr);
ierr = DMPlexGetNumBoundary(dm, &numBd);CHKERRQ(ierr);
if (Grad) {
ierr = VecGetDM(cellGeometry, &dmCell);CHKERRQ(ierr);
ierr = VecGetArrayRead(cellGeometry, &cellgeom);CHKERRQ(ierr);
ierr = DMGetWorkArray(dm, pdim, PETSC_SCALAR, &fx);CHKERRQ(ierr);
ierr = VecGetArrayRead(Grad, &grad);CHKERRQ(ierr);
}
ierr = VecGetDM(faceGeometry, &dmFace);CHKERRQ(ierr);
ierr = VecGetArrayRead(faceGeometry, &facegeom);CHKERRQ(ierr);
ierr = VecGetArray(locX, &x);CHKERRQ(ierr);
for (b = 0; b < numBd; ++b) {
PetscErrorCode (*func)(PetscReal,const PetscReal*,const PetscReal*,const PetscScalar*,PetscScalar*,void*);
DMLabel label;
const char *labelname;
const PetscInt *ids;
PetscInt numids, i;
void *ctx;
ierr = DMPlexGetBoundary(dm, b, NULL, NULL, &labelname, NULL, (void (**)()) &func, &numids, &ids, &ctx);CHKERRQ(ierr);
ierr = DMPlexGetLabel(dm, labelname, &label);CHKERRQ(ierr);
for (i = 0; i < numids; ++i) {
IS faceIS;
const PetscInt *faces;
PetscInt numFaces, f;
ierr = DMLabelGetStratumIS(label, ids[i], &faceIS);CHKERRQ(ierr);
if (!faceIS) continue; /* No points with that id on this process */
ierr = ISGetLocalSize(faceIS, &numFaces);CHKERRQ(ierr);
ierr = ISGetIndices(faceIS, &faces);CHKERRQ(ierr);
for (f = 0; f < numFaces; ++f) {
const PetscInt face = faces[f], *cells;
const FaceGeom *fg;
if ((face < fStart) || (face >= fEnd)) continue; /* Refinement adds non-faces to labels */
ierr = DMPlexPointLocalRead(dmFace, face, facegeom, &fg);CHKERRQ(ierr);
ierr = DMPlexGetSupport(dm, face, &cells);CHKERRQ(ierr);
if (Grad) {
const CellGeom *cg;
const PetscScalar *cx, *cgrad;
PetscScalar *xG;
PetscReal dx[3];
PetscInt d;
ierr = DMPlexPointLocalRead(dmCell, cells[0], cellgeom, &cg);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dm, cells[0], x, &cx);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmplexts->dmGrad, cells[0], grad, &cgrad);CHKERRQ(ierr);
ierr = DMPlexPointLocalRef(dm, cells[1], x, &xG);CHKERRQ(ierr);
WaxpyD(dim, -1, cg->centroid, fg->centroid, dx);
for (d = 0; d < pdim; ++d) fx[d] = cx[d] + DotD(dim, &cgrad[d*dim], dx);
ierr = (*func)(time, fg->centroid, fg->normal, fx, xG, ctx);CHKERRQ(ierr);
} else {
const PetscScalar *xI;
PetscScalar *xG;
ierr = DMPlexPointLocalRead(dm, cells[0], x, &xI);CHKERRQ(ierr);
ierr = DMPlexPointLocalRef(dm, cells[1], x, &xG);CHKERRQ(ierr);
ierr = (*func)(time, fg->centroid, fg->normal, xI, xG, ctx);CHKERRQ(ierr);
}
}
ierr = ISRestoreIndices(faceIS, &faces);CHKERRQ(ierr);
ierr = ISDestroy(&faceIS);CHKERRQ(ierr);
}
}
ierr = VecRestoreArrayRead(faceGeometry, &facegeom);CHKERRQ(ierr);
ierr = VecRestoreArray(locX, &x);CHKERRQ(ierr);
if (Grad) {
ierr = DMRestoreWorkArray(dm, pdim, PETSC_SCALAR, &fx);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(Grad, &grad);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
/*
Write all fields that have been provided to the viewer
Multi-block XML format with binary appended data.
*/
PetscErrorCode DMPlexVTKWriteAll_VTU(DM dm,PetscViewer viewer)
{
MPI_Comm comm;
PetscViewer_VTK *vtk = (PetscViewer_VTK*)viewer->data;
PetscViewerVTKObjectLink link;
FILE *fp;
PetscMPIInt rank,size,tag;
PetscErrorCode ierr;
PetscInt dim,cellHeight,cStart,cEnd,vStart,vEnd,cMax,numLabelCells,hasLabel,c,v,r,i;
PieceInfo piece,*gpiece = NULL;
void *buffer = NULL;
PetscFunctionBegin;
ierr = PetscObjectGetComm((PetscObject)dm,&comm);CHKERRQ(ierr);
#if defined(PETSC_USE_COMPLEX)
SETERRQ(PetscObjectComm((PetscObject)dm),PETSC_ERR_SUP,"Complex values not supported");
#endif
ierr = MPI_Comm_size(comm,&size);CHKERRQ(ierr);
ierr = MPI_Comm_rank(comm,&rank);CHKERRQ(ierr);
tag = ((PetscObject)viewer)->tag;
ierr = PetscFOpen(comm,vtk->filename,"wb",&fp);CHKERRQ(ierr);
ierr = PetscFPrintf(comm,fp,"<?xml version=\"1.0\"?>\n");CHKERRQ(ierr);
#if defined(PETSC_WORDS_BIGENDIAN)
ierr = PetscFPrintf(comm,fp,"<VTKFile type=\"UnstructuredGrid\" version=\"0.1\" byte_order=\"BigEndian\">\n");CHKERRQ(ierr);
#else
ierr = PetscFPrintf(comm,fp,"<VTKFile type=\"UnstructuredGrid\" version=\"0.1\" byte_order=\"LittleEndian\">\n");CHKERRQ(ierr);
#endif
ierr = PetscFPrintf(comm,fp," <UnstructuredGrid>\n");CHKERRQ(ierr);
ierr = DMPlexGetDimension(dm, &dim);CHKERRQ(ierr);
ierr = DMPlexGetVTKCellHeight(dm, &cellHeight);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, cellHeight, &cStart, &cEnd);CHKERRQ(ierr);
ierr = DMPlexGetDepthStratum(dm, 0, &vStart, &vEnd);CHKERRQ(ierr);
ierr = DMPlexGetHybridBounds(dm, &cMax, NULL, NULL, NULL);CHKERRQ(ierr);
if (cMax >= 0) cEnd = PetscMin(cEnd, cMax);
ierr = DMPlexGetStratumSize(dm, "vtk", 1, &numLabelCells);CHKERRQ(ierr);
hasLabel = numLabelCells > 0 ? PETSC_TRUE : PETSC_FALSE;
piece.nvertices = vEnd - vStart;
piece.ncells = 0;
piece.nconn = 0;
for (c = cStart; c < cEnd; ++c) {
PetscInt *closure = NULL;
PetscInt closureSize;
if (hasLabel) {
PetscInt value;
ierr = DMPlexGetLabelValue(dm, "vtk", c, &value);CHKERRQ(ierr);
if (value != 1) continue;
}
ierr = DMPlexGetTransitiveClosure(dm, c, PETSC_TRUE, &closureSize, &closure);CHKERRQ(ierr);
for (v = 0; v < closureSize*2; v += 2) {
if ((closure[v] >= vStart) && (closure[v] < vEnd)) piece.nconn++;
}
ierr = DMPlexRestoreTransitiveClosure(dm, c, PETSC_TRUE, &closureSize, &closure);CHKERRQ(ierr);
piece.ncells++;
}
if (!rank) {ierr = PetscMalloc(size*sizeof(piece),&gpiece);CHKERRQ(ierr);}
ierr = MPI_Gather((PetscInt*)&piece,sizeof(piece)/sizeof(PetscInt),MPIU_INT,(PetscInt*)gpiece,sizeof(piece)/sizeof(PetscInt),MPIU_INT,0,comm);CHKERRQ(ierr);
/*
* Write file header
*/
if (!rank) {
PetscInt boffset = 0;
for (r=0; r<size; r++) {
ierr = PetscFPrintf(PETSC_COMM_SELF,fp," <Piece NumberOfPoints=\"%D\" NumberOfCells=\"%D\">\n",gpiece[r].nvertices,gpiece[r].ncells);CHKERRQ(ierr);
/* Coordinate positions */
ierr = PetscFPrintf(PETSC_COMM_SELF,fp," <Points>\n");CHKERRQ(ierr);
ierr = PetscFPrintf(PETSC_COMM_SELF,fp," <DataArray type=\"%s\" Name=\"Position\" NumberOfComponents=\"3\" format=\"appended\" offset=\"%D\" />\n",precision,boffset);CHKERRQ(ierr);
boffset += gpiece[r].nvertices*3*sizeof(PetscScalar) + sizeof(int);
ierr = PetscFPrintf(PETSC_COMM_SELF,fp," </Points>\n");CHKERRQ(ierr);
/* Cell connectivity */
ierr = PetscFPrintf(PETSC_COMM_SELF,fp," <Cells>\n");CHKERRQ(ierr);
ierr = PetscFPrintf(PETSC_COMM_SELF,fp," <DataArray type=\"Int32\" Name=\"connectivity\" NumberOfComponents=\"1\" format=\"appended\" offset=\"%D\" />\n",boffset);CHKERRQ(ierr);
boffset += gpiece[r].nconn*sizeof(PetscInt) + sizeof(int);
ierr = PetscFPrintf(PETSC_COMM_SELF,fp," <DataArray type=\"Int32\" Name=\"offsets\" NumberOfComponents=\"1\" format=\"appended\" offset=\"%D\" />\n",boffset);CHKERRQ(ierr);
boffset += gpiece[r].ncells*sizeof(PetscInt) + sizeof(int);
ierr = PetscFPrintf(PETSC_COMM_SELF,fp," <DataArray type=\"UInt8\" Name=\"types\" NumberOfComponents=\"1\" format=\"appended\" offset=\"%D\" />\n",boffset);CHKERRQ(ierr);
boffset += gpiece[r].ncells*sizeof(unsigned char) + sizeof(int);
ierr = PetscFPrintf(PETSC_COMM_SELF,fp," </Cells>\n");CHKERRQ(ierr);
/*
* Cell Data headers
*/
ierr = PetscFPrintf(PETSC_COMM_SELF,fp," <CellData>\n");CHKERRQ(ierr);
ierr = PetscFPrintf(PETSC_COMM_SELF,fp," <DataArray type=\"Int32\" Name=\"Rank\" NumberOfComponents=\"1\" format=\"appended\" offset=\"%D\" />\n",boffset);CHKERRQ(ierr);
boffset += gpiece[r].ncells*sizeof(int) + sizeof(int);
/* all the vectors */
for (link=vtk->link; link; link=link->next) {
Vec X = (Vec)link->vec;
PetscInt bs,nfields,field;
const char *vecname = "";
if ((link->ft != PETSC_VTK_CELL_FIELD) && (link->ft != PETSC_VTK_CELL_VECTOR_FIELD)) continue;
if (((PetscObject)X)->name || link != vtk->link) { /* If the object is already named, use it. If it is past the first link, name it to disambiguate. */
ierr = PetscObjectGetName((PetscObject)X,&vecname);CHKERRQ(ierr);
}
ierr = PetscSectionGetDof(dm->defaultSection,cStart,&bs);CHKERRQ(ierr);
ierr = PetscSectionGetNumFields(dm->defaultSection,&nfields);CHKERRQ(ierr);
for (field=0,i=0; field<(nfields?nfields:1); field++) {
PetscInt fbs,j;
const char *fieldname = NULL;
char buf[256];
if (nfields) { /* We have user-defined fields/components */
ierr = PetscSectionGetFieldDof(dm->defaultSection,cStart,field,&fbs);CHKERRQ(ierr);
ierr = PetscSectionGetFieldName(dm->defaultSection,field,&fieldname);CHKERRQ(ierr);
} else fbs = bs; /* Say we have one field with 'bs' components */
if (!fieldname) {
ierr = PetscSNPrintf(buf,sizeof(buf),"CellField%D",field);CHKERRQ(ierr);
fieldname = buf;
}
for (j=0; j<fbs; j++) {
ierr = PetscFPrintf(comm,fp," <DataArray type=\"%s\" Name=\"%s%s.%D\" NumberOfComponents=\"1\" format=\"appended\" offset=\"%D\" />\n",precision,vecname,fieldname,j,boffset);CHKERRQ(ierr);
boffset += gpiece[r].ncells*sizeof(PetscScalar) + sizeof(int);
i++;
}
}
if (i != bs) SETERRQ2(comm,PETSC_ERR_PLIB,"Total number of field components %D != block size %D",i,bs);
}
ierr = PetscFPrintf(PETSC_COMM_SELF,fp," </CellData>\n");CHKERRQ(ierr);
/*
* Point Data headers
*/
ierr = PetscFPrintf(PETSC_COMM_SELF,fp," <PointData>\n");CHKERRQ(ierr);
for (link=vtk->link; link; link=link->next) {
Vec X = (Vec)link->vec;
PetscInt bs,nfields,field;
const char *vecname = "";
if ((link->ft != PETSC_VTK_POINT_FIELD) && (link->ft != PETSC_VTK_POINT_VECTOR_FIELD)) continue;
if (((PetscObject)X)->name || link != vtk->link) { /* If the object is already named, use it. If it is past the first link, name it to disambiguate. */
ierr = PetscObjectGetName((PetscObject)X,&vecname);CHKERRQ(ierr);
}
ierr = PetscSectionGetDof(dm->defaultSection,vStart,&bs);CHKERRQ(ierr);
ierr = PetscSectionGetNumFields(dm->defaultSection,&nfields);CHKERRQ(ierr);
for (field=0,i=0; field<(nfields?nfields:1); field++) {
PetscInt fbs,j;
const char *fieldname = NULL;
char buf[256];
if (nfields) { /* We have user-defined fields/components */
ierr = PetscSectionGetFieldDof(dm->defaultSection,vStart,field,&fbs);CHKERRQ(ierr);
ierr = PetscSectionGetFieldName(dm->defaultSection,field,&fieldname);CHKERRQ(ierr);
} else fbs = bs; /* Say we have one field with 'bs' components */
if (!fieldname) {
ierr = PetscSNPrintf(buf,sizeof(buf),"PointField%D",field);CHKERRQ(ierr);
fieldname = buf;
}
for (j=0; j<fbs; j++) {
ierr = PetscFPrintf(comm,fp," <DataArray type=\"%s\" Name=\"%s%s.%D\" NumberOfComponents=\"1\" format=\"appended\" offset=\"%D\" />\n",precision,vecname,fieldname,j,boffset);CHKERRQ(ierr);
boffset += gpiece[r].nvertices*sizeof(PetscScalar) + sizeof(int);
}
}
}
ierr = PetscFPrintf(PETSC_COMM_SELF,fp," </PointData>\n");CHKERRQ(ierr);
ierr = PetscFPrintf(PETSC_COMM_SELF,fp," </Piece>\n");CHKERRQ(ierr);
}
}
ierr = PetscFPrintf(comm,fp," </UnstructuredGrid>\n");CHKERRQ(ierr);
ierr = PetscFPrintf(comm,fp," <AppendedData encoding=\"raw\">\n");CHKERRQ(ierr);
ierr = PetscFPrintf(comm,fp,"_");CHKERRQ(ierr);
if (!rank) {
PetscInt maxsize = 0;
for (r=0; r<size; r++) {
maxsize = PetscMax(maxsize, (PetscInt) (gpiece[r].nvertices*3*sizeof(PetscScalar)));
maxsize = PetscMax(maxsize, (PetscInt) (gpiece[r].ncells*sizeof(PetscScalar)));
maxsize = PetscMax(maxsize, (PetscInt) (gpiece[r].nconn*sizeof(PetscVTKInt)));
}
ierr = PetscMalloc(maxsize,&buffer);CHKERRQ(ierr);
}
for (r=0; r<size; r++) {
if (r == rank) {
PetscInt nsend;
{ /* Position */
const PetscScalar *x;
PetscScalar *y = NULL;
Vec coords;
nsend = piece.nvertices*3;
ierr = DMGetCoordinatesLocal(dm,&coords);CHKERRQ(ierr);
ierr = VecGetArrayRead(coords,&x);CHKERRQ(ierr);
if (dim != 3) {
ierr = PetscMalloc(piece.nvertices*3*sizeof(PetscScalar),&y);CHKERRQ(ierr);
for (i=0; i<piece.nvertices; i++) {
y[i*3+0] = x[i*dim+0];
y[i*3+1] = (dim > 1) ? x[i*dim+1] : 0;
y[i*3+2] = 0;
}
}
ierr = TransferWrite(viewer,fp,r,0,y ? y : x,buffer,nsend,PETSC_SCALAR,tag);CHKERRQ(ierr);
ierr = PetscFree(y);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(coords,&x);CHKERRQ(ierr);
}
{ /* Connectivity, offsets, types */
PetscVTKInt *connectivity = NULL,*offsets;
PetscVTKType *types;
ierr = DMPlexGetVTKConnectivity(dm,&piece,&connectivity,&offsets,&types);CHKERRQ(ierr);
ierr = TransferWrite(viewer,fp,r,0,connectivity,buffer,piece.nconn,PETSC_INT32,tag);CHKERRQ(ierr);
ierr = TransferWrite(viewer,fp,r,0,offsets,buffer,piece.ncells,PETSC_INT32,tag);CHKERRQ(ierr);
ierr = TransferWrite(viewer,fp,r,0,types,buffer,piece.ncells,PETSC_UINT8,tag);CHKERRQ(ierr);
ierr = PetscFree3(connectivity,offsets,types);CHKERRQ(ierr);
}
{ /* Owners (cell data) */
PetscVTKInt *owners;
ierr = PetscMalloc(piece.ncells*sizeof(PetscVTKInt),&owners);CHKERRQ(ierr);
for (i=0; i<piece.ncells; i++) owners[i] = rank;
ierr = TransferWrite(viewer,fp,r,0,owners,buffer,piece.ncells,PETSC_INT32,tag);CHKERRQ(ierr);
ierr = PetscFree(owners);CHKERRQ(ierr);
}
/* Cell data */
for (link=vtk->link; link; link=link->next) {
Vec X = (Vec)link->vec;
const PetscScalar *x;
PetscScalar *y;
PetscInt bs;
if ((link->ft != PETSC_VTK_CELL_FIELD) && (link->ft != PETSC_VTK_CELL_VECTOR_FIELD)) continue;
ierr = PetscSectionGetDof(dm->defaultSection,cStart,&bs);CHKERRQ(ierr);
ierr = VecGetArrayRead(X,&x);CHKERRQ(ierr);
ierr = PetscMalloc(piece.ncells*sizeof(PetscScalar),&y);CHKERRQ(ierr);
for (i=0; i<bs; i++) {
PetscInt cnt;
for (c=cStart,cnt=0; c<cEnd; c++) {
const PetscScalar *xpoint;
if (hasLabel) { /* Ignore some cells */
PetscInt value;
ierr = DMPlexGetLabelValue(dm, "vtk", c, &value);CHKERRQ(ierr);
if (value != 1) continue;
}
ierr = DMPlexPointLocalRead(dm,c,x,&xpoint);CHKERRQ(ierr);
y[cnt++] = xpoint[i];
}
if (cnt != piece.ncells) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Count does not match");
ierr = TransferWrite(viewer,fp,r,0,y,buffer,piece.ncells,PETSC_SCALAR,tag);CHKERRQ(ierr);
}
ierr = PetscFree(y);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(X,&x);CHKERRQ(ierr);
}
for (link=vtk->link; link; link=link->next) {
Vec X = (Vec)link->vec;
const PetscScalar *x;
PetscScalar *y;
PetscInt bs;
if ((link->ft != PETSC_VTK_POINT_FIELD) && (link->ft != PETSC_VTK_POINT_VECTOR_FIELD)) continue;
ierr = PetscSectionGetDof(dm->defaultSection,vStart,&bs);CHKERRQ(ierr);
ierr = VecGetArrayRead(X,&x);CHKERRQ(ierr);
ierr = PetscMalloc(piece.nvertices*sizeof(PetscScalar),&y);CHKERRQ(ierr);
for (i=0; i<bs; i++) {
PetscInt cnt;
for (v=vStart,cnt=0; v<vEnd; v++) {
const PetscScalar *xpoint;
ierr = DMPlexPointLocalRead(dm,v,x,&xpoint);CHKERRQ(ierr);
y[cnt++] = xpoint[i];
}
if (cnt != piece.nvertices) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Count does not match");
ierr = TransferWrite(viewer,fp,r,0,y,buffer,piece.nvertices,PETSC_SCALAR,tag);CHKERRQ(ierr);
}
ierr = PetscFree(y);CHKERRQ(ierr);
ierr = VecRestoreArrayRead(X,&x);CHKERRQ(ierr);
}
} else if (!rank) {
ierr = TransferWrite(viewer,fp,r,0,NULL,buffer,gpiece[r].nvertices*3,PETSC_SCALAR,tag);CHKERRQ(ierr); /* positions */
ierr = TransferWrite(viewer,fp,r,0,NULL,buffer,gpiece[r].nconn,PETSC_INT32,tag);CHKERRQ(ierr); /* connectivity */
ierr = TransferWrite(viewer,fp,r,0,NULL,buffer,gpiece[r].ncells,PETSC_INT32,tag);CHKERRQ(ierr); /* offsets */
ierr = TransferWrite(viewer,fp,r,0,NULL,buffer,gpiece[r].ncells,PETSC_UINT8,tag);CHKERRQ(ierr); /* types */
ierr = TransferWrite(viewer,fp,r,0,NULL,buffer,gpiece[r].ncells,PETSC_INT32,tag);CHKERRQ(ierr); /* owner rank (cells) */
/* all cell data */
for (link=vtk->link; link; link=link->next) {
PetscInt bs;
if ((link->ft != PETSC_VTK_CELL_FIELD) && (link->ft != PETSC_VTK_CELL_VECTOR_FIELD)) continue;
ierr = PetscSectionGetDof(dm->defaultSection,cStart,&bs);CHKERRQ(ierr);
for (i=0; i<bs; i++) {
ierr = TransferWrite(viewer,fp,r,0,NULL,buffer,gpiece[r].ncells,PETSC_SCALAR,tag);CHKERRQ(ierr);
}
}
/* all point data */
for (link=vtk->link; link; link=link->next) {
PetscInt bs;
if ((link->ft != PETSC_VTK_POINT_FIELD) && (link->ft != PETSC_VTK_POINT_VECTOR_FIELD)) continue;
ierr = PetscSectionGetDof(dm->defaultSection,vStart,&bs);CHKERRQ(ierr);
for (i=0; i<bs; i++) {
ierr = TransferWrite(viewer,fp,r,0,NULL,buffer,gpiece[r].nvertices,PETSC_SCALAR,tag);CHKERRQ(ierr);
}
}
}
}
ierr = PetscFree(gpiece);CHKERRQ(ierr);
ierr = PetscFree(buffer);CHKERRQ(ierr);
ierr = PetscFPrintf(comm,fp,"\n </AppendedData>\n");CHKERRQ(ierr);
ierr = PetscFPrintf(comm,fp,"</VTKFile>\n");CHKERRQ(ierr);
PetscFunctionReturn(0);
}
int main(int argc, char *argv[])
{
PetscErrorCode ierr;
DM dm;
PetscBool interpolate = PETSC_TRUE;
PetscInt dim;
PetscInt pStart, pEnd;
PetscInt vStart, vEnd;
PetscInt eStart, eEnd;
PetscInt cStart, cEnd;
PetscSection s;
ierr = PetscInitialize(&argc, &argv, (char*)0, help); CHKERRQ(ierr);
ierr = DMPlexCreateGmshFromFile(MPI_COMM_WORLD, argv[1], interpolate, &dm); CHKERRQ(ierr);
ierr = DMGetDimension(dm, &dim); CHKERRQ(ierr);
printf("dim = %d\n", dim);
ierr = DMPlexGetChart(dm, &pStart, &pEnd); CHKERRQ(ierr);
printf("chart: pstart, pend = %d %d\n", pStart, pEnd);
// vertices
ierr = DMPlexGetDepthStratum(dm, 0, &vStart, &vEnd); CHKERRQ(ierr);
printf("Depth 0: vstart, vend, len = %d %d %d\n", vStart, vEnd, vEnd-vStart);
// edges
ierr = DMPlexGetDepthStratum(dm, 1, &eStart, &eEnd); CHKERRQ(ierr);
printf("Depth 1: estart, eend, len = %d %d %d\n", eStart, eEnd, eEnd-eStart);
// cells
ierr = DMPlexGetDepthStratum(dm, 2, &cStart, &cEnd); CHKERRQ(ierr);
printf("Depth 2: cstart, cend, len = %d %d %d\n", cStart, cEnd, cEnd-cStart);
// cells adjacent to face
{
FILE * fid = fopen("face_nbr.txt","w");
for(PetscInt e=eStart; e<eEnd; ++e)
{
PetscInt nbr;
ierr = DMPlexGetSupportSize(dm, e, &nbr); CHKERRQ(ierr);
const PetscInt *nbcells;
ierr = DMPlexGetSupport(dm, e, &nbcells); CHKERRQ(ierr);
if(nbr == 1) // boundary face
fprintf(fid, "%d %d\n",e-eStart+1,nbcells[0]-cStart+1);
else if(nbr == 2) // interior face
fprintf(fid, "%d %d %d\n",e-eStart+1,nbcells[0]-cStart+1,nbcells[1]-cStart+1);
else
{
printf("nbr is not 1 or 2\n");
exit(0);
}
}
fclose(fid);
}
// point coordinates
{
Vec coordinates;
ierr = DMGetCoordinatesLocal(dm, &coordinates); CHKERRQ(ierr);
const PetscScalar *coords;
ierr = VecGetArrayRead(coordinates, &coords); CHKERRQ(ierr);
DM dmCoord;
ierr = DMGetCoordinateDM(dm, &dmCoord); CHKERRQ(ierr);
FILE * fid = fopen("vertices.txt","w");
for(PetscInt v=vStart; v<vEnd; ++v)
{
PetscScalar *vertex;
ierr = DMPlexPointLocalRead(dmCoord, v, coords, &vertex); CHKERRQ(ierr);
fprintf(fid, "%f %f\n", vertex[0], vertex[1]);
}
fclose(fid);
ierr = VecRestoreArrayRead(coordinates, &coords); CHKERRQ(ierr);
}
// compute cell and face geometry
{
Vec cellgeom, facegeom;
ierr = DMPlexComputeGeometryFVM(dm, &cellgeom, &facegeom); CHKERRQ(ierr);
// cell information
DM dmCell;
ierr = VecGetDM(cellgeom, &dmCell); CHKERRQ(ierr);
const PetscScalar *cgeom;
ierr = VecGetArrayRead(cellgeom, &cgeom); CHKERRQ(ierr);
FILE * fid = fopen("cells.txt","w");
for(PetscInt c=cStart; c<cEnd; ++c)
{
// cell properties like volume, centroid
PetscFVCellGeom *cg;
ierr = DMPlexPointLocalRead(dmCell, c, cgeom, &cg); CHKERRQ(ierr);
fprintf(fid, "%d %f %f %f\n", c-cStart+1, cg->volume,
cg->centroid[0], cg->centroid[1]);
}
fclose(fid);
ierr = VecRestoreArrayRead(cellgeom, &cgeom); CHKERRQ(ierr);
// face information
DM dmFace;
ierr = VecGetDM(facegeom, &dmFace); CHKERRQ(ierr);
const PetscScalar *fgeom;
ierr = VecGetArrayRead(facegeom, &fgeom); CHKERRQ(ierr);
fid = fopen("faces.txt","w");
for(PetscInt e=eStart; e<eEnd; ++e)
{
// face properties like area normal, centroid
PetscFVFaceGeom *fg;
ierr = DMPlexPointLocalRead(dmFace, e, fgeom, &fg); CHKERRQ(ierr);
fprintf(fid, "%d %f %f %f %f\n", e-eStart+1, fg->normal[0], fg->normal[1],
fg->centroid[0], fg->centroid[1]);
}
fclose(fid);
ierr = VecRestoreArrayRead(facegeom, &fgeom); CHKERRQ(ierr);
}
// create section with one variable in each cell
ierr = PetscSectionCreate(PetscObjectComm((PetscObject)dm), &s); CHKERRQ(ierr);
ierr = PetscSectionSetChart(s, pStart, pEnd); CHKERRQ(ierr);
for(PetscInt c=cStart; c<cEnd; ++c)
{
ierr = PetscSectionSetDof(s, c, 1); CHKERRQ(ierr);
}
ierr = PetscSectionSetUp(s); CHKERRQ(ierr);
// create vector to store solution
Vec lv, gv;
ierr = DMSetDefaultSection(dm, s); CHKERRQ(ierr);
ierr = DMGetLocalVector(dm, &lv); CHKERRQ(ierr);
ierr = DMGetGlobalVector(dm, &gv); CHKERRQ(ierr);
}