VPUBLIC void Vdpbsl(double *abd, int *lda, int *n, int *m, double *b) {
double t;
int k, kb, la, lb, lm;
MAT2(abd, *lda, 1);
for (k=1; k<=*n; k++) {
lm = VMIN2(k-1, *m);
la = *m + 1 - lm;
lb = k - lm;
t = Vddot(lm, RAT2(abd, la, k ), 1, RAT(b, lb), 1 );
VAT(b, k) = (VAT(b, k) - t) / VAT2(abd, *m+1, k);
}
// Solve R*X = Y
for (kb=1; kb<=*n; kb++) {
k = *n + 1 - kb;
lm = VMIN2(k-1, *m);
la = *m + 1 - lm;
lb = k - lm;
VAT(b, k) /= VAT2(abd, *m+1, k);
t = -VAT(b, k);
Vdaxpy(lm, t, RAT2(abd, la, k), 1, RAT(b, lb), 1);
}
}
/* Calculate the gridpoints an atom spans */
VPRIVATE void Vclist_gridSpan(Vclist *thee,
Vatom *atom, /* Atom */
int imin[VAPBS_DIM], /* Set to min grid indices */
int imax[VAPBS_DIM] /* Set to max grid indices */
) {
int i;
double *coord, dc, idc, rtot;
/* Get the position in the grid's frame of reference */
coord = Vatom_getPosition(atom);
/* Get the range the atom radius + probe radius spans */
rtot = Vatom_getRadius(atom) + thee->max_radius;
/* Calculate the range of grid points the inflated atom spans in the x
* direction. */
for (i=0; i<VAPBS_DIM; i++) {
dc = coord[i] - (thee->lower_corner)[i];
idc = (dc + rtot)/(thee->spacs[i]);
imax[i] = (int)(ceil(idc));
imax[i] = VMIN2(imax[i], thee->npts[i]-1);
idc = (dc - rtot)/(thee->spacs[i]);
imin[i] = (int)(floor(idc));
imin[i] = VMAX2(imin[i], 0);
}
}
/*
* ***************************************************************************
* Routine: Vmem_realloc
*
* Purpose: A logged version of realloc (using this is usually a bad idea).
*
* Author: Michael Holst
* ***************************************************************************
*/
VPUBLIC void *Vmem_realloc(Vmem *thee, size_t num, size_t size, void **ram,
size_t newNum)
{
void *tee = Vmem_malloc(thee, newNum, size);
memcpy(tee, (*ram), size*VMIN2(num,newNum));
Vmem_free(thee, num, size, ram);
return tee;
}
VPUBLIC void Vnewton(int *nx, int *ny, int *nz,
double *x, int *iz,
double *w0, double *w1, double *w2, double *w3,
int *istop, int *itmax, int *iters, int *ierror,
int *nlev, int *ilev, int *nlev_real,
int *mgsolv, int *iok, int *iinfo,
double *epsiln, double *errtol, double *omega,
int *nu1, int *nu2, int *mgsmoo,
double *cprime, double *rhs, double *xtmp,
int *ipc, double *rpc,
double *pc, double *ac, double *cc, double *fc, double *tru) {
int level, lev;
int itmax_s, iters_s, ierror_s, iok_s, iinfo_s, istop_s;
double errtol_s, ord, bigc;
double rsden, rsnrm, orsnrm;
double xnorm_old, xnorm_new, damp, xnorm_med, xnorm_den;
double rho_max, rho_min, rho_max_mod, rho_min_mod, errtol_p;
int iter_d, itmax_d, mode, idamp, ipkey;
int itmax_p, iters_p, iok_p, iinfo_p;
// Utility and temproary parameters
double alpha;
MAT2(iz, 50, 1);
// Recover level information
level = 1;
lev = (*ilev - 1) + level;
// Do some i/o if requested
if (*iinfo > 1) {
VMESSAGE3("Starting: (%d, %d, %d)", *nx, *ny, *nz);
}
if (*iok != 0) {
Vprtstp(*iok, -1, 0.0, 0.0, 0.0);
}
/**************************************************************
*** note: if (iok!=0) then: use a stopping test. ***
*** else: use just the itmax to stop iteration. ***
**************************************************************
*** istop=0 most efficient (whatever it is) ***
*** istop=1 relative residual ***
*** istop=2 rms difference of successive iterates ***
*** istop=3 relative true error (provided for testing) ***
**************************************************************/
// Compute denominator for stopping criterion
if (*istop == 0) {
rsden = 1.0;
} else if (*istop == 1) {
// Compute initial residual with zero initial guess
// this is analogous to the linear case where one can
// simply take norm of rhs for a zero initial guess
Vazeros(nx, ny, nz, w1);
Vnmresid(nx, ny, nz,
RAT(ipc, VAT2(iz, 5, lev)), RAT(rpc, VAT2(iz, 6, lev)),
RAT( ac, VAT2(iz, 7, lev)), RAT( cc, VAT2(iz, 1, lev)),
RAT( fc, VAT2(iz, 1, lev)),
w1, w2, w3);
rsden = Vxnrm1(nx, ny, nz, w2);
} else if (*istop == 2) {
rsden = VSQRT( *nx * *ny * *nz);
} else if (*istop == 3) {
rsden = Vxnrm2(nx, ny, nz, RAT(tru, VAT2(iz, 1, lev)));
} else if (*istop == 4) {
rsden = Vxnrm2(nx, ny, nz, RAT(tru, VAT2(iz, 1, lev)));
} else if (*istop == 5) {
Vnmatvec(nx, ny, nz,
RAT(ipc, VAT2(iz, 5, lev)), RAT(rpc, VAT2(iz, 6, lev)),
RAT( ac, VAT2(iz, 7, lev)), RAT( cc, VAT2(iz, 1, lev)),
RAT(tru, VAT2(iz, 1, lev)),
w1, w2);
rsden = VSQRT(Vxdot(nx, ny, nz, RAT(tru, VAT2(iz, 1, lev)), w1));
} else {
VABORT_MSG1("Bad istop value: %d\n", *istop);
}
if (rsden == 0.0) {
rsden = 1.0;
VWARN_MSG0(rsden != 0, "rhs is zero");
}
rsnrm = rsden;
orsnrm = rsnrm;
if (*iok != 0) {
Vprtstp(*iok, 0, rsnrm, rsden, orsnrm);
}
/*********************************************************************
*** begin newton iteration
*********************************************************************/
// Now compute residual with the initial guess
Vnmresid(nx, ny, nz,
RAT(ipc, VAT2(iz, 5, lev)), RAT(rpc, VAT2(iz, 6, lev)),
RAT( ac, VAT2(iz, 7, lev)), RAT( cc, VAT2(iz, 1, lev)),
RAT( fc, VAT2(iz, 1, lev)), RAT( x, VAT2(iz, 1, lev)),
w0, w2);
xnorm_old = Vxnrm1(nx, ny, nz, w0);
if (*iok != 0) {
xnorm_den = rsden;
} else {
xnorm_den = xnorm_old;
}
/*********************************************************************
*** begin the loop
*********************************************************************/
// Setup for the looping
VMESSAGE0("Damping enabled");
idamp = 1;
*iters = 0;
//30
while(1) {
(*iters)++;
// Save iterate if stop test will use it on next iter
if (*istop == 2) {
Vxcopy(nx, ny, nz,
RAT(x, VAT2(iz, 1, lev)), RAT(tru, VAT2(iz, 1, lev)));
}
// Compute the current jacobian system and rhs
ipkey = VAT(ipc, 10);
Vgetjac(nx, ny, nz, nlev_real, iz, ilev, &ipkey,
x, w0, cprime, rhs, cc, pc);
// Determine number of correct digits in current residual
// Algorithm 5.3 in the thesis, test version (1')
// Global-superlinear convergence
bigc = 1.0;
ord = 2.0;
/* NAB 06-18-01: If complex problems are not converging, set this to
* machine epsilon. This makes it use the exact jacobian rather than
* the appropriate form (as here)
*/
errtol_s = VMIN2((0.9 * xnorm_old), (bigc * VPOW(xnorm_old, ord)));
VMESSAGE1("Using errtol_s: %f", errtol_s);
// Do a linear multigrid solve of the newton equations
Vazeros(nx, ny, nz, RAT(xtmp, VAT2(iz, 1, lev)));
itmax_s = 1000;
istop_s = 0;
iters_s = 0;
ierror_s = 0;
// NAB 06-18-01 -- What this used to be:
iok_s = 0;
iinfo_s = 0;
if ((*iinfo >= 2) && (*ilev == 1))
iok_s = 2;
// What it's changed to:
if (*iinfo >= 2)
iinfo_s = *iinfo;
iok_s = 2;
// End of NAB hack.
Vmvcs(nx, ny, nz,
xtmp, iz,
w0, w1, w2, w3,
&istop_s, &itmax_s, &iters_s, &ierror_s,
nlev, ilev, nlev_real, mgsolv,
&iok_s, &iinfo_s,
epsiln, &errtol_s, omega,
nu1, nu2, mgsmoo,
ipc, rpc, pc, ac, cprime, rhs, tru);
/**************************************************************
*** note: rhs and cprime are now available as temp vectors ***
**************************************************************/
// If damping is still enabled -- doit
if (idamp == 1) {
// Try the correction
Vxcopy(nx, ny, nz,
RAT(x, VAT2(iz, 1, lev)), w1);
damp = 1.0;
Vxaxpy(nx, ny, nz, &damp, RAT(xtmp, VAT2(iz, 1, lev)), w1);
Vnmresid(nx, ny, nz,
RAT(ipc, VAT2(iz, 5, lev)), RAT(rpc, VAT2(iz, 6, lev)),
RAT( ac, VAT2(iz, 7, lev)), RAT( cc, VAT2(iz, 1, lev)),
RAT( fc, VAT2(iz, 1, lev)),
w1, w0,
RAT(rhs, VAT2(iz, 1, lev)));
xnorm_new = Vxnrm1(nx, ny, nz, w0);
// Damping is still enabled -- doit
damp = 1.0;
iter_d = 0;
itmax_d = 10;
mode = 0;
VMESSAGE1("Attempting damping, relres = %f", xnorm_new / xnorm_den);
while(iter_d < itmax_d) {
if (mode == 0) {
if (xnorm_new < xnorm_old) {
mode = 1;
}
} else if (xnorm_new > xnorm_med) {
break;
}
// Keep old soln and residual around, and its norm
Vxcopy(nx, ny, nz, w1, w2);
Vxcopy(nx, ny, nz, w0, w3);
xnorm_med = xnorm_new;
// New damped correction, residual, and its norm
Vxcopy(nx, ny, nz,
RAT(x, VAT2(iz, 1, lev)), w1);
damp = damp / 2.0;
Vxaxpy(nx, ny, nz, &damp, RAT(xtmp, VAT2(iz, 1, lev)), w1);
Vnmresid(nx, ny, nz,
RAT(ipc, VAT2(iz, 5, lev)), RAT(rpc, VAT2(iz, 6, lev)),
RAT( ac, VAT2(iz, 7, lev)), RAT( cc, VAT2(iz, 1, lev)),
RAT( fc, VAT2(iz, 1, lev)),
w1, w0,
RAT(rhs, VAT2(iz, 1, lev)));
xnorm_new = Vxnrm1(nx, ny, nz, w0);
// Next iter...
iter_d = iter_d + 1;
VMESSAGE1("Attempting damping, relres = %f",
xnorm_new / xnorm_den);
}
Vxcopy(nx, ny, nz, w2, RAT(x, VAT2(iz, 1, lev)));
Vxcopy(nx, ny, nz, w3, w0);
xnorm_new = xnorm_med;
xnorm_old = xnorm_new;
VMESSAGE1("Damping accepted, relres = %f", xnorm_new / xnorm_den);
// Determine whether or not to disable damping
if ((iter_d - 1) == 0) {
VMESSAGE0("Damping disabled");
idamp = 0;
}
} else {
// Damping is disabled -- accept the newton step
damp = 1.0;
Vxaxpy(nx, ny, nz, &damp,
RAT(xtmp, VAT2(iz, 1, lev)), RAT(x, VAT2(iz, 1, lev)));
Vnmresid(nx, ny, nz,
RAT(ipc, VAT2(iz, 5, lev)), RAT(rpc, VAT2(iz, 6, lev)),
RAT( ac, VAT2(iz, 7, lev)), RAT( cc, VAT2(iz, 1, lev)),
RAT( fc, VAT2(iz, 1, lev)), RAT( x, VAT2(iz, 1, lev)),
w0,
RAT(rhs, VAT2(iz, 1, lev)));
xnorm_new = Vxnrm1(nx, ny, nz, w0);
xnorm_old = xnorm_new;
}
// Compute/check the current stopping test ***
if (iok != 0) {
orsnrm = rsnrm;
if (*istop == 0) {
rsnrm = xnorm_new;
} else if (*istop == 1) {
rsnrm = xnorm_new;
} else if (*istop == 2) {
Vxcopy(nx, ny, nz, RAT(tru, VAT2(iz, 1, lev)), w1);
alpha = -1.0;
Vxaxpy(nx, ny, nz, &alpha, RAT(x, VAT2(iz, 1, lev)), w1);
rsnrm = Vxnrm1(nx, ny, nz, w1);
} else if (*istop == 3) {
Vxcopy(nx, ny, nz, RAT(tru, VAT2(iz, 1, lev)), w1);
alpha = -1.0;
Vxaxpy(nx, ny, nz, &alpha, RAT(x, VAT2(iz, 1, lev)), w1);
rsnrm = Vxnrm2(nx, ny, nz, w1);
} else if (*istop == 4) {
Vxcopy(nx, ny, nz, RAT(tru, VAT2(iz, 1, lev)), w1);
alpha = -1.0;
Vxaxpy(nx, ny, nz, &alpha, RAT(x, VAT2(iz, 1, lev)), w1);
rsnrm = Vxnrm2(nx, ny, nz, w1);
} else if (*istop == 5) {
Vxcopy(nx, ny, nz, RAT(tru, VAT2(iz, 1, lev)), w1);
alpha = -1.0;
Vxaxpy(nx, ny, nz, &alpha, RAT(x, VAT2(iz, 1, lev)), w1);
Vnmatvec(nx, ny, nz,
RAT(ipc, VAT2(iz, 5, lev)), RAT(rpc, VAT2(iz, 6, lev)),
RAT( ac, VAT2(iz, 7, lev)), RAT( cc, VAT2(iz, 1, lev)),
w1, w2, w3);
rsnrm = VSQRT(Vxdot(nx, ny, nz, w1, w2));
} else {
VABORT_MSG1("Bad istop value: %d", *istop);
}
Vprtstp(*iok, *iters, rsnrm, rsden, orsnrm);
if ((rsnrm/rsden) <= *errtol)
break;
}
// Check iteration count ***
if (*iters >= *itmax)
break;
}
// Condition estimate of final jacobian
if (*iinfo > 2) {
Vnm_print(2, "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n");
Vnm_print(2, "% Vnewton: JACOBIAN ANALYSIS ==> (%d, %d, %d)\n",
*nx, *ny, *nz );
// Largest eigenvalue of the jacobian matrix
Vnm_print(2, "% Vnewton: Power calculating rho(JAC)\n");
itmax_p = 1000;
errtol_p = 1.0e-4;
iters_p = 0;
iinfo_p = *iinfo;
Vpower(nx, ny, nz,
iz, ilev,
ipc, rpc, ac, cprime,
w0, w1, w2, w3,
&rho_max, &rho_max_mod,
&errtol_p, &itmax_p, &iters_p, &iinfo_p);
Vnm_print(2, "% Vnewton: power iters = %d\n", iters_p);
Vnm_print(2, "% Vnewton: power eigmax = %d\n", rho_max);
Vnm_print(2, "% Vnewton: power (MODEL) = %d\n", rho_max_mod);
// Smallest eigenvalue of the system matrix A ***
Vnm_print(2, "% Vnewton: ipower calculating lambda_min(JAC)...\n");
itmax_p = 1000;
errtol_p = 1.0e-4;
iters_p = 0;
iinfo_p = *iinfo;
Vazeros(nx, ny, nz, xtmp);
Vipower(nx, ny, nz,
xtmp, iz,
w0, w1, w2, w3,
rhs, &rho_min, &rho_min_mod,
&errtol_p, &itmax_p, &iters_p,
nlev, ilev, nlev_real, mgsolv,
&iok_p, &iinfo_p,
epsiln, errtol, omega,
nu1, nu2, mgsmoo,
ipc, rpc,
pc, ac, cprime, tru);
Vnm_print(2, "% Vnewton: ipower iters = %d\n", iters_p);
Vnm_print(2, "% Vnewton: ipower eigmin = %d\n", rho_min);
Vnm_print(2, "% Vnewton: ipower (MODEL) = %d\n", rho_min_mod);
// Condition number estimate
Vnm_print(2, "% Vnewton: condition number = %f\n",
(double)rho_max / rho_min);
Vnm_print(2, "% Vnewton: condition (MODEL) = %f\n",
(double)rho_max_mod / rho_min_mod);
Vnm_print(2, "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n");
}
}
/* ///////////////////////////////////////////////////////////////////////////
// Routine: Vpee_markRefine
//
// Author: Nathan Baker (and Michael Holst: the author of AM_markRefine, on
// which this is based)
/////////////////////////////////////////////////////////////////////////// */
VPUBLIC int Vpee_markRefine(Vpee *thee,
AM *am,
int level,
int akey,
int rcol,
double etol,
int bkey
) {
Aprx *aprx;
int marked = 0,
markMe,
i,
smid,
count,
currentQ;
double minError = 0.0,
maxError = 0.0,
errEst = 0.0,
mlevel,
barrier;
SS *sm;
VASSERT(thee != VNULL);
/* Get the Aprx object from AM */
aprx = am->aprx;
/* input check and some i/o */
if ( ! ((-1 <= akey) && (akey <= 4)) ) {
Vnm_print(0,"Vpee_markRefine: bad refine key; simplices marked = %d\n",
marked);
return marked;
}
/* For uniform markings, we have no effect */
if ((-1 <= akey) && (akey <= 0)) {
marked = Gem_markRefine(thee->gm, akey, rcol);
return marked;
}
/* Informative I/O */
if (akey == 2) {
Vnm_print(0,"Vpee_estRefine: using Aprx_estNonlinResid().\n");
} else if (akey == 3) {
Vnm_print(0,"Vpee_estRefine: using Aprx_estLocalProblem().\n");
} else if (akey == 4) {
Vnm_print(0,"Vpee_estRefine: using Aprx_estDualProblem().\n");
} else {
Vnm_print(0,"Vpee_estRefine: bad key given; simplices marked = %d\n",
marked);
return marked;
}
if (thee->killFlag == 0) {
Vnm_print(0, "Vpee_markRefine: No error attenuation -- simplices in all partitions will be marked.\n");
} else if (thee->killFlag == 1) {
Vnm_print(0, "Vpee_markRefine: Maximum error attenuation -- only simplices in local partition will be marked.\n");
} else if (thee->killFlag == 2) {
Vnm_print(0, "Vpee_markRefine: Spherical error attenutation -- simplices within a sphere of %4.3f times the size of the partition will be marked\n",
thee->killParam);
} else if (thee->killFlag == 2) {
Vnm_print(0, "Vpee_markRefine: Neighbor-based error attenuation -- simplices in the local and neighboring partitions will be marked [NOT IMPLEMENTED]!\n");
VASSERT(0);
} else {
Vnm_print(2,"Vpee_markRefine: bogus killFlag given; simplices marked = %d\n",
marked);
return marked;
}
/* set the barrier type */
mlevel = (etol*etol) / Gem_numSS(thee->gm);
if (bkey == 0) {
barrier = (etol*etol);
Vnm_print(0,"Vpee_estRefine: forcing [err per S] < [TOL] = %g\n",
barrier);
} else if (bkey == 1) {
barrier = mlevel;
Vnm_print(0,"Vpee_estRefine: forcing [err per S] < [(TOL^2/numS)^{1/2}] = %g\n",
VSQRT(barrier));
} else {
Vnm_print(0,"Vpee_estRefine: bad bkey given; simplices marked = %d\n",
marked);
return marked;
}
/* timer */
Vnm_tstart(30, "error estimation");
/* count = num generations to produce from marked simplices (minimally) */
count = 1; /* must be >= 1 */
/* check the refinement Q for emptyness */
currentQ = 0;
if (Gem_numSQ(thee->gm,currentQ) > 0) {
Vnm_print(0,"Vpee_markRefine: non-empty refinement Q%d....clearing..",
currentQ);
Gem_resetSQ(thee->gm,currentQ);
Vnm_print(0,"..done.\n");
}
if (Gem_numSQ(thee->gm,!currentQ) > 0) {
Vnm_print(0,"Vpee_markRefine: non-empty refinement Q%d....clearing..",
!currentQ);
Gem_resetSQ(thee->gm,!currentQ);
Vnm_print(0,"..done.\n");
}
VASSERT( Gem_numSQ(thee->gm,currentQ) == 0 );
VASSERT( Gem_numSQ(thee->gm,!currentQ) == 0 );
/* clear everyone's refinement flags */
Vnm_print(0,"Vpee_markRefine: clearing all simplex refinement flags..");
for (i=0; i<Gem_numSS(thee->gm); i++) {
if ( (i>0) && (i % VPRTKEY) == 0 ) Vnm_print(0,"[MS:%d]",i);
sm = Gem_SS(thee->gm,i);
SS_setRefineKey(sm,currentQ,0);
SS_setRefineKey(sm,!currentQ,0);
SS_setRefinementCount(sm,0);
}
Vnm_print(0,"..done.\n");
/* NON-ERROR-BASED METHODS */
/* Simplex flag clearing */
if (akey == -1) return marked;
/* Uniform & user-defined refinement*/
if ((akey == 0) || (akey == 1)) {
smid = 0;
while ( smid < Gem_numSS(thee->gm)) {
/* Get the simplex and find out if it's markable */
sm = Gem_SS(thee->gm,smid);
markMe = Vpee_ourSimp(thee, sm, rcol);
if (markMe) {
if (akey == 0) {
marked++;
Gem_appendSQ(thee->gm,currentQ, sm);
SS_setRefineKey(sm,currentQ,1);
SS_setRefinementCount(sm,count);
} else if (Vpee_userDefined(thee, sm)) {
marked++;
Gem_appendSQ(thee->gm,currentQ, sm);
SS_setRefineKey(sm,currentQ,1);
SS_setRefinementCount(sm,count);
}
}
smid++;
}
}
/* ERROR-BASED METHODS */
/* gerror = global error accumulation */
aprx->gerror = 0.;
/* traverse the simplices and process the error estimates */
Vnm_print(0,"Vpee_markRefine: estimating error..");
smid = 0;
while ( smid < Gem_numSS(thee->gm)) {
/* Get the simplex and find out if it's markable */
sm = Gem_SS(thee->gm,smid);
markMe = Vpee_ourSimp(thee, sm, rcol);
if ( (smid>0) && (smid % VPRTKEY) == 0 ) Vnm_print(0,"[MS:%d]",smid);
/* Produce an error estimate for this element if it is in the set */
if (markMe) {
if (akey == 2) {
errEst = Aprx_estNonlinResid(aprx, sm, am->u,am->ud,am->f);
} else if (akey == 3) {
errEst = Aprx_estLocalProblem(aprx, sm, am->u,am->ud,am->f);
} else if (akey == 4) {
errEst = Aprx_estDualProblem(aprx, sm, am->u,am->ud,am->f);
}
VASSERT( errEst >= 0. );
/* if error estimate above tol, mark element for refinement */
if ( errEst > barrier ) {
marked++;
Gem_appendSQ(thee->gm,currentQ, sm); /*add to refinement Q*/
SS_setRefineKey(sm,currentQ,1); /* note now on refine Q */
SS_setRefinementCount(sm,count); /* refine X many times? */
}
/* keep track of min/max errors over the mesh */
minError = VMIN2( VSQRT(VABS(errEst)), minError );
maxError = VMAX2( VSQRT(VABS(errEst)), maxError );
/* store the estimate */
Bvec_set( aprx->wev, smid, errEst );
/* accumlate into global error (errEst is SQUAREd already) */
aprx->gerror += errEst;
/* otherwise store a zero for the estimate */
} else {
Bvec_set( aprx->wev, smid, 0. );
}
smid++;
}
/* do some i/o */
Vnm_print(0,"..done. [marked=<%d/%d>]\n",marked,Gem_numSS(thee->gm));
Vnm_print(0,"Vpee_estRefine: TOL=<%g> Global_Error=<%g>\n",
etol, aprx->gerror);
Vnm_print(0,"Vpee_estRefine: (TOL^2/numS)^{1/2}=<%g> Max_Ele_Error=<%g>\n",
VSQRT(mlevel),maxError);
Vnm_tstop(30, "error estimation");
/* check for making the error tolerance */
if ((bkey == 1) && (aprx->gerror <= etol)) {
Vnm_print(0,
"Vpee_estRefine: *********************************************\n");
Vnm_print(0,
"Vpee_estRefine: Global Error criterion met; setting marked=0.\n");
Vnm_print(0,
"Vpee_estRefine: *********************************************\n");
marked = 0;
}
/* return */
return marked;
}
