double InnerProd(
Vector *x,
Vector *y)
{
Grid *grid = VectorGrid(x);
Subgrid *subgrid;
Subvector *y_sub;
Subvector *x_sub;
double *yp, *xp;
double result = 0.0;
int ix, iy, iz;
int nx, ny, nz;
int nx_v, ny_v, nz_v;
int i_s, i, j, k, iv;
amps_Invoice result_invoice;
result_invoice = amps_NewInvoice("%d", &result);
ForSubgridI(i_s, GridSubgrids(grid))
{
subgrid = GridSubgrid(grid, i_s);
ix = SubgridIX(subgrid);
iy = SubgridIY(subgrid);
iz = SubgridIZ(subgrid);
nx = SubgridNX(subgrid);
ny = SubgridNY(subgrid);
nz = SubgridNZ(subgrid);
y_sub = VectorSubvector(y, i_s);
x_sub = VectorSubvector(x, i_s);
nx_v = SubvectorNX(y_sub);
ny_v = SubvectorNY(y_sub);
nz_v = SubvectorNZ(y_sub);
yp = SubvectorElt(y_sub, ix, iy, iz);
xp = SubvectorElt(x_sub, ix, iy, iz);
iv = 0;
BoxLoopI1(i, j, k, ix, iy, iz, nx, ny, nz,
iv, nx_v, ny_v, nz_v, 1, 1, 1,
{
result += yp[iv] * xp[iv];
});
void Axpy(
double alpha,
Vector *x,
Vector *y)
{
Grid *grid = VectorGrid(x);
Subgrid *subgrid;
Subvector *y_sub;
Subvector *x_sub;
double *yp, *xp;
int ix, iy, iz;
int nx, ny, nz;
int nx_v, ny_v, nz_v;
int i_s, i, j, k, iv;
ForSubgridI(i_s, GridSubgrids(grid))
{
subgrid = GridSubgrid(grid, i_s);
ix = SubgridIX(subgrid);
iy = SubgridIY(subgrid);
iz = SubgridIZ(subgrid);
nx = SubgridNX(subgrid);
ny = SubgridNY(subgrid);
nz = SubgridNZ(subgrid);
y_sub = VectorSubvector(y, i_s);
x_sub = VectorSubvector(x, i_s);
nx_v = SubvectorNX(y_sub);
ny_v = SubvectorNY(y_sub);
nz_v = SubvectorNZ(y_sub);
yp = SubvectorElt(y_sub, ix, iy, iz);
xp = SubvectorElt(x_sub, ix, iy, iz);
iv = 0;
BoxLoopI1(i, j, k, ix, iy, iz, nx, ny, nz,
iv, nx_v, ny_v, nz_v, 1, 1, 1,
{
yp[iv] += alpha * xp[iv];
});
void PrintSubvectorAll(
amps_File file,
Subvector *subvector)
{
int ix, iy, iz;
int nx, ny, nz;
int i, j, k;
ix = SubvectorIX(subvector);
iy = SubvectorIY(subvector);
iz = SubvectorIZ(subvector);
nx = SubvectorNX(subvector);
ny = SubvectorNY(subvector);
nz = SubvectorNZ(subvector);
amps_Fprintf(file, "\t\tPosition(%d,%d,%d), Size (%d,%d,%d)\n",
ix, iy, iz, nx, ny, nz);
for(k = iz; k < iz + nz; k++)
for(j = iy; j < iy + ny; j++)
for(i = ix; i < ix + nx; i++)
amps_Fprintf(file, "\t\t(%d,%d,%d): %f\n", i, j, k,
*SubvectorElt(subvector, i, j, k));
}
void ReadPFBinary_Subvector(
amps_File file,
Subvector *subvector,
Subgrid *subgrid)
{
int ix, iy, iz;
int nx, ny, nz;
int rx, ry, rz;
int nx_v = SubvectorNX(subvector);
int ny_v = SubvectorNY(subvector);
int i, j, k, ai;
double *data;
(void)subgrid;
amps_ReadInt(file, &ix, 1);
amps_ReadInt(file, &iy, 1);
amps_ReadInt(file, &iz, 1);
amps_ReadInt(file, &nx, 1);
amps_ReadInt(file, &ny, 1);
amps_ReadInt(file, &nz, 1);
amps_ReadInt(file, &rx, 1);
amps_ReadInt(file, &ry, 1);
amps_ReadInt(file, &rz, 1);
data = SubvectorElt(subvector, ix, iy, iz);
ai = 0;
BoxLoopI1(i, j, k,
ix, iy, iz, nx, ny, nz,
ai, nx_v, ny_v, nz_v, 1, 1, 1,
{
amps_ReadDouble(file, &data[ai], 1);
});
void PFVLinearSum(
/* LinearSum : z = a * x + b * y */
double a,
Vector *x,
double b,
Vector *y,
Vector *z)
{
double c;
Vector *v1, *v2;
int test;
Grid *grid = VectorGrid(x);
Subgrid *subgrid;
Subvector *x_sub;
Subvector *y_sub;
Subvector *z_sub;
double *yp, *xp, *zp;
int ix, iy, iz;
int nx, ny, nz;
int nx_x, ny_x, nz_x;
int nx_y, ny_y, nz_y;
int nx_z, ny_z, nz_z;
int sg, i, j, k, i_x, i_y, i_z;
if ((b == ONE) && (z == y)) /* BLAS usage: axpy y <- ax+y */
{
PFVAxpy(a, x, y);
return;
}
if ((a == ONE) && (z == x)) /* BLAS usage: axpy x <- by+x */
{
PFVAxpy(b, y, x);
return;
}
/* Case: a == b == 1.0 */
if ((a == ONE) && (b == ONE))
{
PFVSum(x, y, z);
return;
}
/* Cases: (1) a == 1.0, b = -1.0, (2) a == -1.0, b == 1.0 */
if ((test = ((a == ONE) && (b == -ONE))) || ((a == -ONE) && (b == ONE)))
{
v1 = test ? y : x;
v2 = test ? x : y;
PFVDiff(v2, v1, z);
return;
}
/* Cases: (1) a == 1.0, b == other or 0.0, (2) a == other or 0.0, b == 1.0 */
/* if a or b is 0.0, then user should have called N_VScale */
if ((test = (a == ONE)) || (b == ONE))
{
c = test ? b : a;
v1 = test ? y : x;
v2 = test ? x : y;
PFVLin1(c, v1, v2, z);
return;
}
/* Cases: (1) a == -1.0, b != 1.0, (2) a != 1.0, b == -1.0 */
if ((test = (a == -ONE)) || (b == -ONE))
{
c = test ? b : a;
v1 = test ? y : x;
v2 = test ? x : y;
PFVLin2(c, v1, v2, z);
return;
}
/* Case: a == b */
/* catches case both a and b are 0.0 - user should have called N_VConst */
if (a == b)
{
PFVScaleSum(a, x, y, z);
return;
}
/* Case: a == -b */
if (a == -b)
{
PFVScaleDiff(a, x, y, z);
return;
}
/* Do all cases not handled above:
* (1) a == other, b == 0.0 - user should have called N_VScale
* (2) a == 0.0, b == other - user should have called N_VScale
* (3) a,b == other, a !=b, a != -b */
ForSubgridI(sg, GridSubgrids(grid))
{
subgrid = GridSubgrid(grid, sg);
z_sub = VectorSubvector(z, sg);
x_sub = VectorSubvector(x, sg);
y_sub = VectorSubvector(y, sg);
ix = SubgridIX(subgrid);
iy = SubgridIY(subgrid);
iz = SubgridIZ(subgrid);
nx = SubgridNX(subgrid);
ny = SubgridNY(subgrid);
nz = SubgridNZ(subgrid);
nx_x = SubvectorNX(x_sub);
ny_x = SubvectorNY(x_sub);
nz_x = SubvectorNZ(x_sub);
nx_y = SubvectorNX(y_sub);
ny_y = SubvectorNY(y_sub);
nz_y = SubvectorNZ(y_sub);
nx_z = SubvectorNX(z_sub);
ny_z = SubvectorNY(z_sub);
nz_z = SubvectorNZ(z_sub);
zp = SubvectorElt(z_sub, ix, iy, iz);
xp = SubvectorElt(x_sub, ix, iy, iz);
yp = SubvectorElt(y_sub, ix, iy, iz);
i_x = 0;
i_y = 0;
i_z = 0;
BoxLoopI3(i, j, k, ix, iy, iz, nx, ny, nz,
i_x, nx_x, ny_x, nz_x, 1, 1, 1,
i_y, nx_y, ny_y, nz_y, 1, 1, 1,
i_z, nx_z, ny_z, nz_z, 1, 1, 1,
{
zp[i_z] = a * xp[i_x] + b * yp[i_y];
});
void PhaseDensity(
int phase, /* Phase */
Vector *phase_pressure, /* Vector of phase pressures at each block */
Vector *density_v, /* Vector of return densities at each block */
double *pressure_d, /* Double array of pressures */
double *density_d, /* Double array return density */
int fcn) /* Flag determining what to calculate
* fcn = CALCFCN => calculate the function value
* fcn = CALCDER => calculate the function
* derivative */
/* Module returns either a double array or Vector of densities.
* If density_v is NULL, then a double array is returned.
* This "overloading" was provided so that the density module written
* for the Richards' solver modules would be backward compatible with
* the Impes modules.
*/
{
PFModule *this_module = ThisPFModule;
PublicXtra *public_xtra = (PublicXtra *)PFModulePublicXtra(this_module);
Type0 *dummy0;
Type1 *dummy1;
Grid *grid;
Subvector *p_sub;
Subvector *d_sub;
double *pp;
double *dp;
Subgrid *subgrid;
int sg;
int ix, iy, iz;
int nx, ny, nz;
int nx_p, ny_p, nz_p;
int nx_d, ny_d, nz_d;
int i, j, k, ip, id;
switch((public_xtra -> type[phase]))
{
case 0:
{
double constant;
dummy0 = (Type0 *)(public_xtra -> data[phase]);
constant = (dummy0 -> constant);
if ( density_v != NULL)
{
grid = VectorGrid(density_v);
ForSubgridI(sg, GridSubgrids(grid))
{
subgrid = GridSubgrid(grid, sg);
d_sub = VectorSubvector(density_v, sg);
ix = SubgridIX(subgrid) - 1;
iy = SubgridIY(subgrid) - 1;
iz = SubgridIZ(subgrid) - 1;
nx = SubgridNX(subgrid) + 2;
ny = SubgridNY(subgrid) + 2;
nz = SubgridNZ(subgrid) + 2;
nx_d = SubvectorNX(d_sub);
ny_d = SubvectorNY(d_sub);
nz_d = SubvectorNZ(d_sub);
dp = SubvectorElt(d_sub, ix, iy, iz);
id = 0;
if ( fcn == CALCFCN )
{
BoxLoopI1(i, j, k, ix, iy, iz, nx, ny, nz,
id, nx_d, ny_d, nz_d, 1, 1, 1,
{
dp[id] = constant;
});
}
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] );
});
