void DUAL_ELLIPTIC_SOLVER::get_dual_D(
int *dual_ic,
double *D_nb)
{
int l,i,ii,jj,index;
int icl[MAXD],icu[MAXD],ic[MAXD];
double denom;
COMPONENT comp;
for (i = 0; i < dim; ++i)
{
icl[i] = dual_ic[i] + offset[i] - 1;
icu[i] = dual_ic[i] + offset[i];
}
switch (dim)
{
case 2:
for (l = 0; l < 4; ++l)
{
i = l/2;
ic[i] = (l%2 == 0) ? icl[i] : icu[i];
D_nb[l] = denom = 0.0;
for (ii = icl[(i+1)%dim]; ii <= icu[(i+1)%dim]; ++ii)
{
ic[(i+1)%dim] = ii;
index = d_index(ic,top_gmax,dim);
if (ij_to_I[ic[0]][ic[1]] != -1)
{
D_nb[l] += D[index];
denom += 1.0;
}
}
if (denom != 0.0)
D_nb[l] /= denom;
}
break;
case 3:
for (l = 0; l < 6; ++l)
{
i = l/2;
ic[i] = (l%2 == 0) ? icl[i] : icu[i];
D_nb[l] = denom = 0.0;
for (ii = icl[(i+1)%dim]; ii <= icu[(i+1)%dim]; ++ii)
for (jj = icl[(i+2)%dim]; jj <= icu[(i+2)%dim]; ++jj)
{
ic[(i+1)%dim] = ii;
ic[(i+2)%dim] = jj;
index = d_index(ic,top_gmax,dim);
if (ijk_to_I[ic[0]][ic[1]][ic[2]] != -1)
{
D_nb[l] += D[index];
denom += 1.0;
}
}
if (denom != 0.0)
D_nb[l] /= denom;
}
break;
}
} /* end get_dual_D */
SideIterator&
SideIterator::operator ++ ()
{
++d_index(0);
for (tbox::Dimension::dir_t i = 0; i < d_box.getDim().getValue() - 1; ++i) {
if (d_index(i) > d_box.upper(i)) {
d_index(i) = d_box.lower(i);
++d_index(i + 1);
} else {
break;
}
}
return *this;
}
ArrayDataIterator&
ArrayDataIterator::operator ++ ()
{
const tbox::Dimension& dim(d_box.getDim());
++d_index(0);
for (tbox::Dimension::dir_t i = 0; i < dim.getValue() - 1; ++i) {
if (d_index(i) > d_box.upper(i)) {
d_index(i) = d_box.lower(i);
++d_index(i + 1);
} else {
break;
}
}
return *this;
}
ArrayDataIterator::ArrayDataIterator(
const hier::Box& box,
bool begin):
d_index(box.lower()),
d_box(box)
{
if (!d_box.empty() && !begin) {
d_index(d_box.getDim().getValue() - 1) =
d_box.upper(static_cast<tbox::Dimension::dir_t>(d_box.getDim().getValue() - 1)) + 1;
}
}
NodeIterator::NodeIterator(
const hier::Box& box,
bool begin):
d_index(box.lower(), hier::IntVector::getZero(box.getDim())),
d_box(NodeGeometry::toNodeBox(box))
{
if (!d_box.empty() && !begin) {
d_index(d_box.getDim().getValue() - 1) =
d_box.upper(static_cast<tbox::Dimension::dir_t>(d_box.getDim().getValue() - 1)) + 1;
}
}
SideIterator::SideIterator(
const hier::Box& box,
const tbox::Dimension::dir_t axis,
bool begin):
d_index(box.lower(), axis, SideIndex::Lower),
d_box(SideGeometry::toSideBox(box, axis))
{
if (!d_box.empty() && !begin) {
d_index(d_box.getDim().getValue() - 1) =
d_box.upper(static_cast<tbox::Dimension::dir_t>(d_box.getDim().getValue() - 1)) + 1;
}
}
double DUAL_ELLIPTIC_SOLVER::checkSolver(
int *icoords,
boolean print_details)
{
int i,l,m;
int comp;
double w[2];
int id0,index_nb;
double dw[2],coefs[2],lhs,rhs;
GRID_DIRECTION dir[3][2] = {{WEST,EAST},{SOUTH,NORTH},{LOWER,UPPER}};
HYPER_SURF *hs;
double crx_coords[MAXD];
int status;
POINTER intfc_state;
int icnb[MAXD];
double denom = 0.0;
double D_nb[6];
if (print_details)
{
(void) printf("\nEntering checkSolver()\n");
(void) printf("icoords = ");
for (i = 0; i < dim; ++i)
(void) printf("%d ",icoords[i]);
(void) printf("\n");
}
id0 = d_index(icoords,ctop_gmax,dim);
comp = ctop_comp[id0];
lhs = 0;
get_dual_D(icoords,D_nb);
for (l = 0; l < dim; ++l)
{
if (print_details)
(void) printf("Direction %d:\n",l);
for (i = 0; i < dim; ++i)
icnb[i] = icoords[i];
for (m = 0; m < 2; ++m)
{
status = (*findStateAtCrossing)(front,icoords,dir[l][m],comp,
&intfc_state,&hs,crx_coords);
icnb[l] = (m == 0) ? icoords[l] - 1 : icoords[l] + 1;
index_nb = d_index(icnb,ctop_gmax,dim);
coefs[m] = D_nb[l*2+m];
switch(status)
{
case NO_PDE_BOUNDARY:
if (print_details)
(void) printf("Side %d NO_PDE_BOUNDARY\n",m);
w[0] = soln[id0];
w[1] = soln[index_nb];
break;
case CONST_V_PDE_BOUNDARY:
if (print_details)
(void) printf("Side %d CONST_V_PDE_BOUNDARY\n",m);
w[0] = soln[id0];
w[1] = soln[id0];
break;
case CONST_P_PDE_BOUNDARY:
if (print_details)
(void) printf("Side %d CONST_P_PDE_BOUNDARY\n",m);
w[0] = soln[id0];
w[1] = getStateVar(intfc_state);
break;
default:
(void) printf("Side %d Unknown BOUNDARY\n",m);
clean_up(ERROR);
}
dw[m] = (w[1] - w[0])/top_h[l];
if (denom < fabs(coefs[m]*dw[m]/2.0/top_h[l]))
denom = fabs(coefs[m]*dw[m]/2.0/top_h[l]);
}
if (print_details)
{
(void) printf("Coefs: %f %f\n",coefs[0],coefs[1]);
(void) printf("C*dw: %f %f\n",coefs[0]*dw[0],coefs[1]*dw[1]);
}
lhs += (coefs[1]*dw[1] + coefs[0]*dw[0])/top_h[l];
}
rhs = source[id0];
if (print_details)
{
(void) printf("Solution = %20.14f\n",soln[id0]);
(void) printf("LHS = %20.14f RHS = %20.14f\n",lhs,rhs);
(void) printf("LHS - RHS = %20.14f\n",lhs-rhs);
(void) printf("Relative error = %20.14g\n",fabs(lhs-rhs)/denom);
(void) printf("Leaving checkSolver()\n\n");
}
return fabs(lhs-rhs)/denom;
} /* end checkSolver */
