Grid *ReadUserGrid()
{
Grid *user_grid;
SubgridArray *user_all_subgrids;
SubgridArray *user_subgrids;
int num_user_subgrids;
int i;
num_user_subgrids = GetIntDefault("UserGrid.NumSubgrids", 1);
/* read user_subgrids */
user_all_subgrids = NewSubgridArray();
user_subgrids = NewSubgridArray();
for(i = 0; i < num_user_subgrids; i++)
{
AppendSubgrid(ReadUserSubgrid(), user_all_subgrids);
AppendSubgrid(SubgridArraySubgrid(user_all_subgrids, i), user_subgrids);
}
/* create user_grid */
user_grid = NewGrid(user_subgrids, user_all_subgrids);
return user_grid;
}
void LoadParflowB(
char *filename,
SubgridArray *all_subgrids,
Background *background,
Databox *databox)
{
char output_name[MAXPATHLEN];
FILE *file;
FILE *dist_file;
Subgrid *subgrid;
int process, num_procs;
int p;
double *ptr;
int NX = DataboxNx(databox);
int NY = DataboxNy(databox);
int NZ = DataboxNz(databox);
int ix, iy, iz;
int nx, ny, nz;
int k, j, s_i;
long file_pos=0;
/*--------------------------------------------------------------------
* Determine num_procs, and clear output files
*--------------------------------------------------------------------*/
num_procs = -1;
ForSubgridI(s_i, all_subgrids)
{
subgrid = SubgridArraySubgrid(all_subgrids, s_i);
process = SubgridProcess(subgrid);
#ifdef AMPS_SPLIT_FILE
sprintf(output_name, "%s.%05d", filename, process);
remove(output_name);
#endif
if (process > num_procs)
num_procs = process;
}
SubgridArray *GetGridSubgrids(
SubgridArray *all_subgrids)
{
SubgridArray *subgrids;
Subgrid *s;
int i, my_proc;
my_proc = amps_Rank(amps_CommWorld);
subgrids = NewSubgridArray();
ForSubgridI(i, all_subgrids)
{
s = SubgridArraySubgrid(all_subgrids, i);
if (SubgridProcess(s) == my_proc)
AppendSubgrid(s, subgrids);
}
void ICPhaseSatur(
Vector *ic_phase_satur,
int phase,
ProblemData *problem_data)
{
PFModule *this_module = ThisPFModule;
PublicXtra *public_xtra = (PublicXtra *)PFModulePublicXtra(this_module);
Grid *grid = VectorGrid(ic_phase_satur);
Type0 *dummy0;
SubgridArray *subgrids = GridSubgrids(grid);
Subgrid *subgrid;
Subvector *ps_sub;
double *data;
int ix, iy, iz;
int nx, ny, nz;
int r;
double field_sum;
int is, i, j, k, ips;
/*-----------------------------------------------------------------------
* Initial saturation conditions for this phase
*-----------------------------------------------------------------------*/
InitVector(ic_phase_satur, 0.0);
switch((public_xtra -> type[phase]))
{
case 0:
{
int num_regions;
int *region_indices;
double *values;
GrGeomSolid *gr_solid;
double value;
int ir;
dummy0 = (Type0 *)(public_xtra -> data[phase]);
num_regions = (dummy0 -> num_regions);
region_indices = (dummy0 -> region_indices);
values = (dummy0 -> values);
for (ir = 0; ir < num_regions; ir++)
{
gr_solid = ProblemDataGrSolid(problem_data, region_indices[ir]);
value = values[ir];
ForSubgridI(is, subgrids)
{
subgrid = SubgridArraySubgrid(subgrids, is);
ps_sub = VectorSubvector(ic_phase_satur, is);
ix = SubgridIX(subgrid);
iy = SubgridIY(subgrid);
iz = SubgridIZ(subgrid);
nx = SubgridNX(subgrid);
ny = SubgridNY(subgrid);
nz = SubgridNZ(subgrid);
/* RDF: assume resolution is the same in all 3 directions */
r = SubgridRX(subgrid);
data = SubvectorData(ps_sub);
GrGeomInLoop(i, j, k, gr_solid, r, ix, iy, iz, nx, ny, nz,
{
ips = SubvectorEltIndex(ps_sub, i, j, k);
data[ips] = value;
});
}
}
break;
}
void ComputeDomain(
SubgridArray *all_subgrids,
Databox *top,
Databox *bottom,
int P,
int Q,
int R)
{
int num_procs = P * Q * R;
int p;
// For each subgrid find the min/max k values
// in the active region (using top/bottom).
// Reset the subgrid to reflect this vertical extent.
for(p = 0; p < num_procs; p++)
{
int s_i;
ForSubgridI(s_i, all_subgrids)
{
Subgrid* subgrid = SubgridArraySubgrid(all_subgrids, s_i);
int process = SubgridProcess(subgrid);
if(process == p) {
int i;
int j;
int ix = SubgridIX(subgrid);
int iy = SubgridIY(subgrid);
int iz = SubgridIZ(subgrid);
int nx = SubgridNX(subgrid);
int ny = SubgridNY(subgrid);
int nz = SubgridNZ(subgrid);
int patch_top = iz;
int patch_bottom = iz + nz;
for (j = iy; j < iy+ ny; ++j)
{
for (i = ix; i < ix + nx; ++i)
{
int k_top = *(DataboxCoeff(top, i, j, 0));
if ( k_top >= 0 ) {
patch_top = max(patch_top, k_top);
}
int k_bottom = *(DataboxCoeff(bottom, i, j, 0));
if ( k_bottom >= 0 ) {
patch_bottom = min(patch_bottom, k_bottom);
}
}
}
// adjust grid to include 2 pad cells
patch_top = min(patch_top+2, iz + nz - 1);
patch_bottom = max(patch_bottom-2, iz);
// adjust for ghost cells, need to have patches
// that extend in height to the neighbor patches.
//
// There is a more efficient way to compute all this but
// since these are 2d arrays it should be reasonably quick.
// Not a single loop since we don't need to pad these values.
ix = max(0, ix -1);
nx = min(DataboxNx(top) - ix, nx + 2 - ix);
iy = max(0, iy -1);
ny = min(DataboxNy(top) - iy, ny + 2 - iy);
for (j = iy; j < iy+ ny; ++j)
{
for (i = ix; i < ix + nx; ++i)
{
int k_top = *(DataboxCoeff(top, i, j, 0));
if ( k_top >= 0 ) {
patch_top = max(patch_top, k_top);
}
int k_bottom = *(DataboxCoeff(bottom, i, j, 0));
if ( k_bottom >= 0 ) {
patch_bottom = min(patch_bottom, k_bottom);
}
}
}
SubgridIZ(subgrid) = patch_bottom;
SubgridNZ(subgrid) = (patch_top - SubgridIZ(subgrid)) + 1;
}
}
}
void XSlope(
ProblemData *problem_data,
Vector * x_slope,
Vector * dummy)
{
PFModule *this_module = ThisPFModule;
PublicXtra *public_xtra = (PublicXtra*)PFModulePublicXtra(this_module);
InstanceXtra *instance_xtra = (InstanceXtra*)PFModuleInstanceXtra(this_module);
Grid *grid3d = instance_xtra->grid3d;
GrGeomSolid *gr_solid, *gr_domain;
Type0 *dummy0;
Type1 *dummy1;
Type2 *dummy2;
Type3 *dummy3;
VectorUpdateCommHandle *handle;
SubgridArray *subgrids = GridSubgrids(grid3d);
Subgrid *subgrid;
Subvector *ps_sub;
Subvector *sx_values_sub;
double *data;
double *psdat, *sx_values_dat;
//double slopex[60][32][392];
int ix, iy, iz;
int nx, ny, nz;
int r;
int is, i, j, k, ips, ipicv;
double time = 0.0;
(void)dummy;
/*-----------------------------------------------------------------------
* Put in any user defined sources for this phase
*-----------------------------------------------------------------------*/
InitVectorAll(x_slope, 0.0);
switch ((public_xtra->type))
{
case 0:
{
int num_regions;
int *region_indices;
double *values;
double x, y, z;
double value;
int ir;
dummy0 = (Type0*)(public_xtra->data);
num_regions = (dummy0->num_regions);
region_indices = (dummy0->region_indices);
values = (dummy0->values);
for (ir = 0; ir < num_regions; ir++)
{
gr_solid = ProblemDataGrSolid(problem_data, region_indices[ir]);
value = values[ir];
ForSubgridI(is, subgrids)
{
subgrid = SubgridArraySubgrid(subgrids, is);
ps_sub = VectorSubvector(x_slope, is);
ix = SubgridIX(subgrid);
iy = SubgridIY(subgrid);
iz = SubgridIZ(subgrid);
nx = SubgridNX(subgrid);
ny = SubgridNY(subgrid);
nz = SubgridNZ(subgrid);
/* RDF: assume resolution is the same in all 3 directions */
r = SubgridRX(subgrid);
/*
* TODO
* SGS this does not match the loop in nl_function_eval. That
* loop is going over more than the inner geom locations. Is that
* important? Originally the x_slope array was not being allocated
* by ctalloc, just alloc and unitialized memory reads were being
* caused. Switched that to be ctalloc to init to 0 to "hack" a
* fix but is this really a sign of deeper indexing problems?
*/
/* @RMM: todo. the looping to set slopes only goes over interior nodes
* not ALL nodes (including ghost) as in nl fn eval and now the overland eval
* routines. THis is fine in the KW approximation which only needs interior values
* but for diffusive wave and for the terrain following grid (which uses the surface
* topo slopes as subsurface slopes) this can cuase bddy problems. */
data = SubvectorData(ps_sub);
GrGeomInLoop(i, j, k, gr_solid, r, ix, iy, iz, nx, ny, nz,
{
ips = SubvectorEltIndex(ps_sub, i, j, 0);
x = RealSpaceX(i, SubgridRX(subgrid));
//data[ips] = sin(x)/8.0 + (1/8)*pow(x,-(7/8)) +sin(x/5.0)/(5.0*8.0);
data[ips] = value;
});
}
}
break;
} /* End case 0 */
void LBInitializeBC(
Lattice * lattice,
Problem * problem,
ProblemData *problem_data)
{
/*------------------------------------------------------------*
* Local variables
*------------------------------------------------------------*/
/* Lattice variables */
Grid *grid = (lattice->grid);
Vector *pressure = (lattice->pressure);
Vector *perm = (lattice->perm);
CharVector *cellType = (lattice->cellType);
double time = (lattice->t);
/* Structures */
BCPressureData *bc_pressure_data = ProblemDataBCPressureData(problem_data);
TimeCycleData *time_cycle_data;
SubgridArray *subgrids = GridSubgrids(grid);
GrGeomSolid *gr_domain;
/* Patch variables */
double ***values;
double *patch_values = NULL;
int *fdir;
/* Grid parameters */
Subgrid *subgrid;
int nx, ny, nz;
int ix, iy, iz;
int nx_v, ny_v, nz_v;
/* Indices and counters */
int num_patches;
int num_phases;
int ipatch, is, i, j, k, ival;
int cycle_number, interval_number;
int r;
/* Physical variables and coefficients */
Subvector *sub_p;
double *pp;
Subvector *sub_perm;
double *permp;
Subcharvector *sub_cellType;
char *cellTypep;
double rho_g;
/* Communications */
VectorUpdateCommHandle *handle;
/*--------------------------
* Initializations
*--------------------------*/
rho_g = ProblemGravity(problem) * RHO;
num_patches = BCPressureDataNumPatches(bc_pressure_data);
gr_domain = ProblemDataGrDomain(problem_data);
num_phases = BCPressureDataNumPhases(bc_pressure_data);
if (num_patches > 0)
{
time_cycle_data = BCPressureDataTimeCycleData(bc_pressure_data);
values = ctalloc(double **, num_patches);
for (ipatch = 0; ipatch < num_patches; ipatch++)
{
values[ipatch] = ctalloc(double *, SubgridArraySize(subgrids));
cycle_number = BCPressureDataCycleNumber(bc_pressure_data, ipatch);
interval_number = TimeCycleDataComputeIntervalNumber(problem, time,
time_cycle_data, cycle_number);
switch (BCPressureDataType(bc_pressure_data, ipatch))
{
case 0:
{
BCPressureType0 *bc_pressure_type0;
GeomSolid *ref_solid;
double z, dz2;
double **elevations;
int ref_patch, iel;
bc_pressure_type0 = (BCPressureType0*)BCPressureDataIntervalValue(
bc_pressure_data, ipatch, interval_number);
ref_solid = ProblemDataSolid(problem_data,
BCPressureType0RefSolid(bc_pressure_type0));
ref_patch = BCPressureType0RefPatch(bc_pressure_type0);
/* Calculate elevations at (x,y) points on reference patch. */
elevations = CalcElevations(ref_solid, ref_patch, subgrids, problem_data);
ForSubgridI(is, subgrids)
{
/* subgrid = GridSubgrid(grid, is); */
subgrid = SubgridArraySubgrid(subgrids, is);
sub_p = VectorSubvector(pressure, is);
sub_perm = VectorSubvector(perm, is);
sub_cellType = CharVectorSubcharvector(cellType, is);
nx = SubgridNX(subgrid);
ny = SubgridNY(subgrid);
nz = SubgridNZ(subgrid);
ix = SubgridIX(subgrid);
iy = SubgridIY(subgrid);
iz = SubgridIZ(subgrid);
/* RDF: assume resolution is the same in all 3 directions */
r = SubgridRX(subgrid);
pp = SubvectorData(sub_p);
permp = SubvectorData(sub_perm);
cellTypep = SubcharvectorData(sub_cellType);
nx_v = SubvectorNX(sub_p);
ny_v = SubvectorNY(sub_p);
nz_v = SubvectorNZ(sub_p);
values[ipatch][is] = patch_values;
dz2 = RealSpaceDZ(0) / 2.0;
GrGeomPatchLoop(i, j, k, fdir, gr_domain, ipatch,
r, ix, iy, iz, nx, ny, nz,
{
ival = SubvectorEltIndex(sub_p, i, j, k);
iel = (i - ix) + (j - iy) * nx;
z = RealSpaceZ(k, 0) + fdir[2] * dz2;
pp[ival] = BCPressureType0Value(bc_pressure_type0)
- rho_g * (z - elevations[is][iel]);
cellTypep[ival] = 0;
});
tfree(elevations[is]);
} /* End subgrid loop */
tfree(elevations);
break;
}
case 1:
{
BCPressureType1 *bc_pressure_type1;
int num_points;
double x, y, z, dx2, dy2, dz2;
double unitx, unity, line_min, line_length, xy, slope;
int ip;
bc_pressure_type1 = (BCPressureType1*)BCPressureDataIntervalValue(bc_pressure_data, ipatch, interval_number);
ForSubgridI(is, subgrids)
{
/* subgrid = GridSubgrid(grid, is); */
subgrid = SubgridArraySubgrid(subgrids, is);
sub_p = VectorSubvector(pressure, is);
sub_perm = VectorSubvector(perm, is);
sub_cellType = CharVectorSubcharvector(cellType, is);
nx = SubgridNX(subgrid);
ny = SubgridNY(subgrid);
nz = SubgridNZ(subgrid);
ix = SubgridIX(subgrid);
iy = SubgridIY(subgrid);
iz = SubgridIZ(subgrid);
/* RDF: assume resolution is the same in all 3 directions */
r = SubgridRX(subgrid);
pp = SubvectorData(sub_p);
permp = SubvectorData(sub_perm);
cellTypep = SubcharvectorData(sub_cellType);
nx_v = SubvectorNX(sub_p);
ny_v = SubvectorNY(sub_p);
nz_v = SubvectorNZ(sub_p);
values[ipatch][is] = patch_values;
dx2 = RealSpaceDX(0) / 2.0;
dy2 = RealSpaceDY(0) / 2.0;
dz2 = RealSpaceDZ(0) / 2.0;
/* compute unit direction vector for piecewise linear line */
unitx = BCPressureType1XUpper(bc_pressure_type1) - BCPressureType1XLower(bc_pressure_type1);
unity = BCPressureType1YUpper(bc_pressure_type1) - BCPressureType1YLower(bc_pressure_type1);
line_length = sqrt(unitx * unitx + unity * unity);
unitx /= line_length;
unity /= line_length;
line_min = BCPressureType1XLower(bc_pressure_type1) * unitx
+ BCPressureType1YLower(bc_pressure_type1) * unity;
GrGeomPatchLoop(i, j, k, fdir, gr_domain, ipatch,
r, ix, iy, iz, nx, ny, nz,
{
ival = SubvectorEltIndex(sub_p, i, j, k);
x = RealSpaceX(i, 0) + fdir[0] * dx2;
y = RealSpaceY(j, 0) + fdir[1] * dy2;
z = RealSpaceZ(k, 0) + fdir[2] * dz2;
/* project center of BC face onto piecewise line */
xy = (x * unitx + y * unity - line_min) / line_length;
/* find two neighboring points */
ip = 1;
/* Kludge; this needs to be fixed. */
num_points = 2;
for (; ip < (num_points - 1); ip++)
{
if (xy < BCPressureType1Point(bc_pressure_type1, ip))
break;
}
/* compute the slope */
slope = ((BCPressureType1Value(bc_pressure_type1, ip) - BCPressureType1Value(bc_pressure_type1, (ip - 1)))
/ (BCPressureType1Point(bc_pressure_type1, ip) - BCPressureType1Point(bc_pressure_type1, (ip - 1))));
pp[ival] = BCPressureType1Value(bc_pressure_type1, ip - 1)
+ slope * (xy - BCPressureType1Point(
bc_pressure_type1, ip - 1))
- rho_g * z;
cellTypep[ival] = 0;
});
} /* End subgrid loop */
void BCPhaseSaturation(
Vector * saturation,
int phase,
GrGeomSolid *gr_domain)
{
PFModule *this_module = ThisPFModule;
PublicXtra *public_xtra = (PublicXtra*)PFModulePublicXtra(this_module);
Type0 *dummy0;
Type1 *dummy1;
Type2 *dummy2;
int num_patches = (public_xtra->num_patches);
int *patch_indexes = (public_xtra->patch_indexes);
int *input_types = (public_xtra->input_types);
int *bc_types = (public_xtra->bc_types);
Grid *grid = VectorGrid(saturation);
SubgridArray *subgrids = GridSubgrids(grid);
Subgrid *subgrid;
Subvector *sat_sub;
double *satp;
BCStruct *bc_struct;
int patch_index;
int nx_v, ny_v, nz_v;
int sx_v, sy_v, sz_v;
int *fdir;
int indx, ipatch, is, i, j, k, ival, iv, sv;
/*-----------------------------------------------------------------------
* Get an offset into the PublicXtra data
*-----------------------------------------------------------------------*/
indx = (phase * num_patches);
/*-----------------------------------------------------------------------
* Set up bc_struct with NULL values component
*-----------------------------------------------------------------------*/
bc_struct = NewBCStruct(subgrids, gr_domain,
num_patches, patch_indexes, bc_types, NULL);
/*-----------------------------------------------------------------------
* Implement BC's
*-----------------------------------------------------------------------*/
for (ipatch = 0; ipatch < num_patches; ipatch++)
{
patch_index = patch_indexes[ipatch];
ForSubgridI(is, subgrids)
{
subgrid = SubgridArraySubgrid(subgrids, is);
sat_sub = VectorSubvector(saturation, is);
nx_v = SubvectorNX(sat_sub);
ny_v = SubvectorNY(sat_sub);
nz_v = SubvectorNZ(sat_sub);
sx_v = 1;
sy_v = nx_v;
sz_v = ny_v * nx_v;
satp = SubvectorData(sat_sub);
switch (input_types[indx + ipatch])
{
case 0:
{
double constant;
dummy0 = (Type0*)(public_xtra->data[indx + ipatch]);
constant = (dummy0->constant);
BCStructPatchLoop(i, j, k, fdir, ival, bc_struct, ipatch, is,
{
sv = 0;
if (fdir[0])
sv = fdir[0] * sx_v;
else if (fdir[1])
sv = fdir[1] * sy_v;
else if (fdir[2])
sv = fdir[2] * sz_v;
iv = SubvectorEltIndex(sat_sub, i, j, k);
satp[iv ] = constant;
satp[iv + sv] = constant;
satp[iv + 2 * sv] = constant;
});
break;
}
case 1:
{
double height;
double lower;
double upper;
double z, dz2;
dummy1 = (Type1*)(public_xtra->data[indx + ipatch]);
height = (dummy1->height);
lower = (dummy1->lower);
upper = (dummy1->upper);
dz2 = SubgridDZ(subgrid) / 2.0;
BCStructPatchLoop(i, j, k, fdir, ival, bc_struct, ipatch, is,
{
sv = 0;
if (fdir[0])
sv = fdir[0] * sx_v;
else if (fdir[1])
sv = fdir[1] * sy_v;
else if (fdir[2])
sv = fdir[2] * sz_v;
iv = SubvectorEltIndex(sat_sub, i, j, k);
z = RealSpaceZ(k, SubgridRZ(subgrid)) + fdir[2] * dz2;
if (z <= height)
{
satp[iv ] = lower;
satp[iv + sv] = lower;
satp[iv + 2 * sv] = lower;
}
else
{
satp[iv ] = upper;
satp[iv + sv] = upper;
satp[iv + 2 * sv] = upper;
}
});
break;
}
case 2:
{
int ip, num_points;
double *point;
double *height;
double lower;
double upper;
double x, y, z, dx2, dy2, dz2;
double unitx, unity, line_min, line_length, xy, slope;
double interp_height;
dummy2 = (Type2*)(public_xtra->data[indx + ipatch]);
num_points = (dummy2->num_points);
point = (dummy2->point);
height = (dummy2->height);
lower = (dummy2->lower);
upper = (dummy2->upper);
dx2 = SubgridDX(subgrid) / 2.0;
dy2 = SubgridDY(subgrid) / 2.0;
dz2 = SubgridDZ(subgrid) / 2.0;
/* compute unit direction vector for piecewise linear line */
unitx = (dummy2->xupper) - (dummy2->xlower);
unity = (dummy2->yupper) - (dummy2->ylower);
line_length = sqrt(unitx * unitx + unity * unity);
unitx /= line_length;
unity /= line_length;
line_min = (dummy2->xlower) * unitx + (dummy2->ylower) * unity;
BCStructPatchLoop(i, j, k, fdir, ival, bc_struct, ipatch, is,
{
sv = 0;
if (fdir[0])
sv = fdir[0] * sx_v;
else if (fdir[1])
sv = fdir[1] * sy_v;
else if (fdir[2])
sv = fdir[2] * sz_v;
iv = SubvectorEltIndex(sat_sub, i, j, k);
x = RealSpaceX(i, SubgridRX(subgrid)) + fdir[0] * dx2;
y = RealSpaceY(j, SubgridRY(subgrid)) + fdir[1] * dy2;
z = RealSpaceZ(k, SubgridRZ(subgrid)) + fdir[2] * dz2;
/* project center of BC face onto piecewise linear line */
xy = x * unitx + y * unity;
xy = (xy - line_min) / line_length;
/* find two neighboring points */
ip = 1;
for (; ip < (num_points - 1); ip++)
{
if (xy < point[ip])
break;
}
/* compute the slope */
slope = ((height[ip] - height[ip - 1]) /
(point[ip] - point[ip - 1]));
interp_height = height[ip - 1] + slope * (xy - point[ip - 1]);
if (z <= interp_height)
{
satp[iv ] = lower;
satp[iv + sv] = lower;
satp[iv + 2 * sv] = lower;
}
else
{
satp[iv ] = upper;
satp[iv + sv] = upper;
satp[iv + 2 * sv] = upper;
}
});
break;
}
void ComputeTop(Problem * problem, /* General problem information */
ProblemData *problem_data /* Contains geometry information for the problem */
)
{
GrGeomSolid *gr_solid = ProblemDataGrDomain(problem_data);
Vector *top = ProblemDataIndexOfDomainTop(problem_data);
Vector *perm_x = ProblemDataPermeabilityX(problem_data);
Grid *grid2d = VectorGrid(top);
SubgridArray *grid2d_subgrids = GridSubgrids(grid2d);
/* use perm grid as top is 2D and want to loop over Z */
Grid *grid3d = VectorGrid(perm_x);
SubgridArray *grid3d_subgrids = GridSubgrids(grid3d);
double *top_data;
int index;
VectorUpdateCommHandle *handle;
(void)problem;
InitVectorAll(top, -1);
// PFVConstInit(-1, top);
int is;
ForSubgridI(is, grid3d_subgrids)
{
Subgrid *grid2d_subgrid = SubgridArraySubgrid(grid2d_subgrids, is);
Subgrid *grid3d_subgrid = SubgridArraySubgrid(grid3d_subgrids, is);
Subvector *top_subvector = VectorSubvector(top, is);
int grid3d_ix = SubgridIX(grid3d_subgrid);
int grid3d_iy = SubgridIY(grid3d_subgrid);
int grid3d_iz = SubgridIZ(grid3d_subgrid);
int grid2d_iz = SubgridIZ(grid2d_subgrid);
int grid3d_nx = SubgridNX(grid3d_subgrid);
int grid3d_ny = SubgridNY(grid3d_subgrid);
int grid3d_nz = SubgridNZ(grid3d_subgrid);
int grid3d_r = SubgridRX(grid3d_subgrid);
top_data = SubvectorData(top_subvector);
int i, j, k;
GrGeomInLoop(i, j, k,
gr_solid, grid3d_r,
grid3d_ix, grid3d_iy, grid3d_iz,
grid3d_nx, grid3d_ny, grid3d_nz,
{
index = SubvectorEltIndex(top_subvector, i, j, grid2d_iz);
if (top_data[index] < k)
{
top_data[index] = k;
}
});
void PermeabilityFace(
Vector *zperm,
Vector *permeability)
{
PFModule *this_module = ThisPFModule;
InstanceXtra *instance_xtra = (InstanceXtra *)PFModuleInstanceXtra(this_module);
PublicXtra *public_xtra = (PublicXtra *)PFModulePublicXtra(this_module);
Grid *z_grid = (instance_xtra -> z_grid);
VectorUpdateCommHandle *handle;
SubgridArray *subgrids;
Subgrid *subgrid;
Subvector *subvector_pc, *subvector_pf;
int ix, iy, iz;
int nx, ny, nz;
double dx, dy, dz;
int nx_pc, ny_pc, nz_pc;
int nx_pf, ny_pf, nz_pf;
int pci, pfi;
int sg, i, j, k;
int flopest;
double *pf, *pc_l, *pc_u;
/*-----------------------------------------------------------------------
* Begin timing
*-----------------------------------------------------------------------*/
BeginTiming(public_xtra -> time_index);
/*-----------------------------------------------------------------------
* exchange boundary data for cell permeability values
*-----------------------------------------------------------------------*/
handle = InitVectorUpdate(permeability, VectorUpdateAll);
FinalizeVectorUpdate(handle);
/*-----------------------------------------------------------------------
* compute the z-face permeabilities for each subgrid
*-----------------------------------------------------------------------*/
subgrids = GridSubgrids(z_grid);
ForSubgridI(sg, subgrids)
{
subgrid = SubgridArraySubgrid(subgrids, sg);
subvector_pc = VectorSubvector(permeability, sg);
subvector_pf = VectorSubvector(zperm, sg);
ix = SubgridIX(subgrid);
iy = SubgridIY(subgrid);
iz = SubgridIZ(subgrid);
nx = SubgridNX(subgrid);
ny = SubgridNY(subgrid);
nz = SubgridNZ(subgrid);
dx = SubgridDX(subgrid);
dy = SubgridDY(subgrid);
dz = SubgridDZ(subgrid);
nx_pc = SubvectorNX(subvector_pc);
ny_pc = SubvectorNY(subvector_pc);
nz_pc = SubvectorNZ(subvector_pc);
nx_pf = SubvectorNX(subvector_pf);
ny_pf = SubvectorNY(subvector_pf);
nz_pf = SubvectorNZ(subvector_pf);
flopest = nx_pf * ny_pf * nz_pf;
pc_l = SubvectorElt(subvector_pc, ix ,iy ,iz-1);
pc_u = SubvectorElt(subvector_pc, ix ,iy ,iz );
pf = SubvectorElt(subvector_pf, ix ,iy ,iz);
pci = 0; pfi = 0;
BoxLoopI2(i,j,k,
ix,iy,iz,nx,ny,nz,
pci,nx_pc,ny_pc,nz_pc,1,1,1,
pfi,nx_pf,ny_pf,nz_pf,1,1,1,
{
pf[pfi] = Mean( pc_l[pci], pc_u[pci] );
});
void PFMG(
Vector *soln,
Vector *rhs,
double tol,
int zero)
{
(void)zero;
#ifdef HAVE_HYPRE
PFModule *this_module = ThisPFModule;
InstanceXtra *instance_xtra = (InstanceXtra*)PFModuleInstanceXtra(this_module);
PublicXtra *public_xtra = (PublicXtra*)PFModulePublicXtra(this_module);
HYPRE_StructMatrix hypre_mat = instance_xtra->hypre_mat;
HYPRE_StructVector hypre_b = instance_xtra->hypre_b;
HYPRE_StructVector hypre_x = instance_xtra->hypre_x;
HYPRE_StructSolver hypre_pfmg_data = instance_xtra->hypre_pfmg_data;
Grid *grid = VectorGrid(rhs);
Subgrid *subgrid;
int sg;
Subvector *rhs_sub;
Subvector *soln_sub;
double *rhs_ptr;
double *soln_ptr;
double value;
int index[3];
int ix, iy, iz;
int nx, ny, nz;
int nx_v, ny_v, nz_v;
int i, j, k;
int iv;
int num_iterations;
double rel_norm;
/* Copy rhs to hypre_b vector. */
BeginTiming(public_xtra->time_index_copy_hypre);
ForSubgridI(sg, GridSubgrids(grid))
{
subgrid = SubgridArraySubgrid(GridSubgrids(grid), sg);
rhs_sub = VectorSubvector(rhs, sg);
rhs_ptr = SubvectorData(rhs_sub);
ix = SubgridIX(subgrid);
iy = SubgridIY(subgrid);
iz = SubgridIZ(subgrid);
nx = SubgridNX(subgrid);
ny = SubgridNY(subgrid);
nz = SubgridNZ(subgrid);
nx_v = SubvectorNX(rhs_sub);
ny_v = SubvectorNY(rhs_sub);
nz_v = SubvectorNZ(rhs_sub);
iv = SubvectorEltIndex(rhs_sub, ix, iy, iz);
BoxLoopI1(i, j, k, ix, iy, iz, nx, ny, nz,
iv, nx_v, ny_v, nz_v, 1, 1, 1,
{
index[0] = i;
index[1] = j;
index[2] = k;
HYPRE_StructVectorSetValues(hypre_b, index, rhs_ptr[iv]);
});
GrGeomExtentArray *GrGeomCreateExtentArray(
SubgridArray *subgrids,
int xl_ghost,
int xu_ghost,
int yl_ghost,
int yu_ghost,
int zl_ghost,
int zu_ghost)
{
Background *bg = GlobalsBackground;
GrGeomExtentArray *extent_array;
GrGeomExtents *extents;
int size;
Subgrid *subgrid;
int ref;
int bg_ix, bg_iy, bg_iz;
int bg_nx, bg_ny, bg_nz;
int is;
size = SubgridArraySize(subgrids);
extents = ctalloc(GrGeomExtents, size);
ForSubgridI(is, subgrids)
{
subgrid = SubgridArraySubgrid(subgrids, is);
/* compute background grid extents on MaxRefLevel index space */
ref = (int)pow(2.0, GlobalsMaxRefLevel);
bg_ix = BackgroundIX(bg) * ref;
bg_iy = BackgroundIY(bg) * ref;
bg_iz = BackgroundIZ(bg) * ref;
bg_nx = BackgroundNX(bg) * ref;
bg_ny = BackgroundNY(bg) * ref;
bg_nz = BackgroundNZ(bg) * ref;
ref = (int)Pow2(GlobalsMaxRefLevel);
/*------------------------------------------
* set the lower extent values
*------------------------------------------*/
if (xl_ghost > -1)
{
xl_ghost = pfmax(xl_ghost, 1);
GrGeomExtentsIXLower(extents[is]) =
(SubgridIX(subgrid) - xl_ghost) * ref;
}
else
{
GrGeomExtentsIXLower(extents[is]) = bg_ix;
}
if (yl_ghost > -1)
{
yl_ghost = pfmax(yl_ghost, 1);
GrGeomExtentsIYLower(extents[is]) =
(SubgridIY(subgrid) - yl_ghost) * ref;
}
else
{
GrGeomExtentsIYLower(extents[is]) = bg_iy;
}
if (zl_ghost > -1)
{
zl_ghost = pfmax(zl_ghost, 1);
GrGeomExtentsIZLower(extents[is]) =
(SubgridIZ(subgrid) - zl_ghost) * ref;
}
else
{
GrGeomExtentsIZLower(extents[is]) = bg_iz;
}
/*------------------------------------------
* set the upper extent values
*------------------------------------------*/
if (xu_ghost > -1)
{
xu_ghost = pfmax(xu_ghost, 1);
GrGeomExtentsIXUpper(extents[is]) =
(SubgridIX(subgrid) + SubgridNX(subgrid) + xu_ghost) * ref - 1;
}
else
{
GrGeomExtentsIXUpper(extents[is]) = bg_ix + bg_nx - 1;
}
if (yu_ghost > -1)
{
yu_ghost = pfmax(yu_ghost, 1);
GrGeomExtentsIYUpper(extents[is]) =
(SubgridIY(subgrid) + SubgridNY(subgrid) + yu_ghost) * ref - 1;
}
else
{
GrGeomExtentsIYUpper(extents[is]) = bg_iy + bg_ny - 1;
}
if (zu_ghost > -1)
{
zu_ghost = pfmax(zu_ghost, 1);
GrGeomExtentsIZUpper(extents[is]) =
(SubgridIZ(subgrid) + SubgridNZ(subgrid) + zu_ghost) * ref - 1;
}
else
{
GrGeomExtentsIZUpper(extents[is]) = bg_iz + bg_nz - 1;
}
/*------------------------------------------
* convert to "octree coordinates"
*------------------------------------------*/
/* Moved into the loop by SGS 7/8/98, was lying outside the is
* loop which was an error (accessing invalid array elements)
*/
GrGeomExtentsIXLower(extents[is]) -= bg_ix;
GrGeomExtentsIYLower(extents[is]) -= bg_iy;
GrGeomExtentsIZLower(extents[is]) -= bg_iz;
GrGeomExtentsIXUpper(extents[is]) -= bg_ix;
GrGeomExtentsIYUpper(extents[is]) -= bg_iy;
GrGeomExtentsIZUpper(extents[is]) -= bg_iz;
}