[SCM] Gerris Flow Solver branch, upstream, updated. e8f73a07832050124d2b8bf6c6f35b33180e65a8
Stephane Popinet
popinet at users.sf.net
Tue Nov 24 12:25:24 UTC 2009
The following commit has been merged in the upstream branch:
commit 03e9a57c07bc9ec6eddb0de4ab3525ff943a77e2
Author: Stephane Popinet <popinet at users.sf.net>
Date: Thu Oct 29 09:48:18 2009 +1100
Godunov advection scheme takes metric into account
darcs-hash:20091028224818-d4795-75f23c6d185c25b063cbc36e5d4b25f750b9513a.gz
diff --git a/src/advection.c b/src/advection.c
index 59ae339..c0e9f50 100644
--- a/src/advection.c
+++ b/src/advection.c
@@ -22,13 +22,13 @@
#include "source.h"
static gdouble transverse_term (FttCell * cell,
- gdouble size,
+ gdouble * msize,
FttComponent c,
const GfsAdvectionParams * par)
{
GfsStateVector * s = GFS_STATE (cell);
gdouble vtan = par->use_centered_velocity ?
- GFS_VARIABLE (cell, par->u[c]->i) :
+ GFS_VALUE (cell, par->u[c]) :
(s->f[2*c].un + s->f[2*c + 1].un)/2.;
FttCellFace f;
GfsGradient gf;
@@ -38,9 +38,9 @@ static gdouble transverse_term (FttCell * cell,
f.cell = cell;
f.neighbor = ftt_cell_neighbor (cell, f.d);
gfs_face_gradient (&f, &gf, par->v->i, -1);
- g = gf.b - gf.a*GFS_VARIABLE (cell, par->v->i);
+ g = gf.b - gf.a*GFS_VALUE (cell, par->v);
if (vtan > 0.) g = - g;
- return par->dt*vtan*g/(2.*size);
+ return par->dt*vtan*g/(2.*msize[c]);
}
/**
@@ -55,34 +55,39 @@ static gdouble transverse_term (FttCell * cell,
void gfs_cell_advected_face_values (FttCell * cell,
const GfsAdvectionParams * par)
{
- FttComponent c;
- gdouble size;
- GfsStateVector * s;
-
g_return_if_fail (cell != NULL);
g_return_if_fail (par != NULL);
- s = GFS_STATE (cell);
- size = ftt_cell_size (cell);
+ GfsStateVector * s = GFS_STATE (cell);
+ gdouble size = ftt_cell_size (cell), msize[FTT_DIMENSION];
+
+ FttComponent c;
+ if (par->v->domain->scale_metric)
+ for (c = 0; c < FTT_DIMENSION; c++)
+ msize[c] = size*(* par->v->domain->scale_metric) (par->v->domain, cell, c);
+ else
+ for (c = 0; c < FTT_DIMENSION; c++)
+ msize[c] = size;
+
for (c = 0; c < FTT_DIMENSION; c++) {
gdouble unorm = par->use_centered_velocity ?
- par->dt*GFS_VARIABLE (cell, par->u[c]->i)/size :
- par->dt*(s->f[2*c].un + s->f[2*c + 1].un)/(2.*size);
+ par->dt*GFS_VALUE (cell, par->u[c])/msize[c] :
+ par->dt*(s->f[2*c].un + s->f[2*c + 1].un)/(2.*msize[c]);
gdouble g = (* par->gradient) (cell, c, par->v->i);
- gdouble vl = GFS_VARIABLE (cell, par->v->i) + MIN ((1. - unorm)/2., 0.5)*g;
- gdouble vr = GFS_VARIABLE (cell, par->v->i) + MAX ((- 1. - unorm)/2., -0.5)*g;
+ gdouble vl = GFS_VALUE (cell, par->v) + MIN ((1. - unorm)/2., 0.5)*g;
+ gdouble vr = GFS_VALUE (cell, par->v) + MAX ((- 1. - unorm)/2., -0.5)*g;
gdouble src = par->dt*gfs_variable_mac_source (par->v, cell)/2.;
gdouble dv;
#if FTT_2D
- dv = transverse_term (cell, size, FTT_ORTHOGONAL_COMPONENT (c), par);
+ dv = transverse_term (cell, msize, FTT_ORTHOGONAL_COMPONENT (c), par);
#else /* FTT_3D */
static FttComponent orthogonal[FTT_DIMENSION][2] = {
{FTT_Y, FTT_Z}, {FTT_X, FTT_Z}, {FTT_X, FTT_Y}
};
- dv = transverse_term (cell, size, orthogonal[c][0], par);
- dv += transverse_term (cell, size, orthogonal[c][1], par);
+ dv = transverse_term (cell, msize, orthogonal[c][0], par);
+ dv += transverse_term (cell, msize, orthogonal[c][1], par);
#endif /* FTT_3D */
s->f[2*c].v = vl + src - dv;
@@ -111,8 +116,8 @@ void gfs_cell_non_advected_face_values (FttCell * cell,
s = GFS_STATE (cell);
for (c = 0; c < FTT_DIMENSION; c++) {
gdouble g = (* par->gradient) (cell, c, par->v->i);
- gdouble vl = GFS_VARIABLE (cell, par->v->i) + g/2.;
- gdouble vr = GFS_VARIABLE (cell, par->v->i) - g/2.;
+ gdouble vl = GFS_VALUE (cell, par->v) + g/2.;
+ gdouble vr = GFS_VALUE (cell, par->v) - g/2.;
gdouble src = par->dt*gfs_variable_mac_source (par->v, cell)/2.;
s->f[2*c].v = vl + src;
@@ -394,16 +399,17 @@ void gfs_face_advection_flux (const FttCellFace * face,
flux = gfs_domain_face_fraction (par->v->domain, face)*GFS_FACE_NORMAL_VELOCITY (face)*par->dt*
gfs_face_upwinded_value (face, GFS_FACE_UPWINDING, NULL)/ftt_cell_size (face->cell);
+
if (!FTT_FACE_DIRECT (face))
flux = - flux;
- GFS_VARIABLE (face->cell, par->fv->i) -= flux;
+ GFS_VALUE (face->cell, par->fv) -= flux;
switch (ftt_face_type (face)) {
case FTT_FINE_FINE:
- GFS_VARIABLE (face->neighbor, par->fv->i) += flux;
+ GFS_VALUE (face->neighbor, par->fv) += flux;
break;
case FTT_FINE_COARSE:
- GFS_VARIABLE (face->neighbor, par->fv->i) += flux/FTT_CELLS;
+ GFS_VALUE (face->neighbor, par->fv) += flux/FTT_CELLS;
break;
default:
g_assert_not_reached ();
@@ -450,14 +456,14 @@ void gfs_face_velocity_advection_flux (const FttCellFace * face,
#endif
if (!FTT_FACE_DIRECT (face))
flux = - flux;
- GFS_VARIABLE (face->cell, par->fv->i) -= flux;
+ GFS_VALUE (face->cell, par->fv) -= flux;
switch (ftt_face_type (face)) {
case FTT_FINE_FINE:
- GFS_VARIABLE (face->neighbor, par->fv->i) += flux;
+ GFS_VALUE (face->neighbor, par->fv) += flux;
break;
case FTT_FINE_COARSE:
- GFS_VARIABLE (face->neighbor, par->fv->i) += flux/FTT_CELLS;
+ GFS_VALUE (face->neighbor, par->fv) += flux/FTT_CELLS;
break;
default:
g_assert_not_reached ();
@@ -507,18 +513,18 @@ void gfs_face_velocity_convective_flux (const FttCellFace * face,
u *= par->dt/(2.*ftt_cell_size (face->cell));
if (!FTT_FACE_DIRECT (face))
u = - u;
- GFS_VARIABLE (face->cell, par->fv->i) -=
+ GFS_VALUE (face->cell, par->fv) -=
u*(GFS_STATE (face->cell)->f[face->d].un +
GFS_STATE (face->cell)->f[FTT_OPPOSITE_DIRECTION (face->d)].un);
switch (ftt_face_type (face)) {
case FTT_FINE_FINE:
- GFS_VARIABLE (face->neighbor, par->fv->i) +=
+ GFS_VALUE (face->neighbor, par->fv) +=
u*(GFS_STATE (face->neighbor)->f[face->d].un +
GFS_STATE (face->neighbor)->f[FTT_OPPOSITE_DIRECTION (face->d)].un);
break;
case FTT_FINE_COARSE:
- GFS_VARIABLE (face->neighbor, par->fv->i) +=
+ GFS_VALUE (face->neighbor, par->fv) +=
u*(GFS_STATE (face->neighbor)->f[face->d].un +
GFS_STATE (face->neighbor)->f[FTT_OPPOSITE_DIRECTION (face->d)].un)
/FTT_CELLS;
@@ -992,9 +998,8 @@ void gfs_advection_params_read (GfsAdvectionParams * par, GtsFile * fp)
gts_file_assign_variables (fp, var);
- if (fp->type != GTS_ERROR && (par->cfl <= 0. || par->cfl > 1.))
- gts_file_variable_error (fp, var, "cfl",
- "cfl `%g' is out of range `]0,1]'", par->cfl);
+ if (fp->type != GTS_ERROR && par->cfl <= 0.)
+ gts_file_variable_error (fp, var, "cfl", "cfl must be strictly positive");
if (gradient) {
if (!strcmp (gradient, "gfs_center_gradient"))
diff --git a/src/domain.c b/src/domain.c
index afe2ee6..2704105 100644
--- a/src/domain.c
+++ b/src/domain.c
@@ -2541,10 +2541,10 @@ static void minimum_mac_cfl (FttCellFace * face, CflData * p)
gdouble un = GFS_STATE (face->cell)->f[face->d].un;
gdouble length = ftt_cell_size (face->cell);
if (p->domain->cell_metric) {
- gdouble fm = (* p->domain->face_metric) (p->domain, face, p->domain->metric_data);
+ gdouble fm = (* p->domain->face_metric) (p->domain, face);
if (fm <= 0.) /* e.g. Axi metric on the axis */
return;
- length *= (* p->domain->cell_metric) (p->domain, face->cell, p->domain->metric_data)/fm;
+ length *= (* p->domain->cell_metric) (p->domain, face->cell)/fm;
}
if (un != 0.) {
gdouble cflu = length/fabs (un);
@@ -2573,7 +2573,7 @@ static void minimum_cfl (FttCell * cell, CflData * p)
{
gdouble length = ftt_cell_size (cell);
if (p->domain->cell_metric)
- length *= (* p->domain->cell_metric) (p->domain, cell, p->domain->metric_data);
+ length *= (* p->domain->cell_metric) (p->domain, cell);
FttComponent c;
for (c = 0; c < FTT_DIMENSION; c++) {
@@ -2581,9 +2581,9 @@ static void minimum_cfl (FttCell * cell, CflData * p)
if (p->domain->face_metric) {
FttCellFace f;
f.cell = cell; f.d = 2*c;
- gdouble fm1 = (* p->domain->face_metric) (p->domain, &f, p->domain->metric_data);
+ gdouble fm1 = (* p->domain->face_metric) (p->domain, &f);
f.d = 2*c + 1;
- gdouble fm2 = (* p->domain->face_metric) (p->domain, &f, p->domain->metric_data);
+ gdouble fm2 = (* p->domain->face_metric) (p->domain, &f);
fm = MAX (fm1, fm2);
}
else
diff --git a/src/domain.h b/src/domain.h
index b4c0bb4..f7cd455 100644
--- a/src/domain.h
+++ b/src/domain.h
@@ -76,9 +76,10 @@ struct _GfsDomain {
/* coordinate metrics */
gpointer metric_data;
- gdouble (* face_metric) (const GfsDomain *, const FttCellFace *, const gpointer);
- gdouble (* cell_metric) (const GfsDomain *, const FttCell *, const gpointer);
- gdouble (* solid_metric) (const GfsDomain *, const FttCell *, const gpointer);
+ gdouble (* face_metric) (const GfsDomain *, const FttCellFace *);
+ gdouble (* cell_metric) (const GfsDomain *, const FttCell *);
+ gdouble (* solid_metric) (const GfsDomain *, const FttCell *);
+ gdouble (* scale_metric) (const GfsDomain *, const FttCell *, FttComponent);
};
struct _GfsDomainClass {
@@ -349,7 +350,7 @@ gdouble gfs_domain_face_fraction (const GfsDomain * domain, const FttCellFace *
{
gdouble f = GFS_FACE_FRACTION (face);
if (domain->face_metric)
- f *= (* domain->face_metric) (domain, face, domain->metric_data);
+ f *= (* domain->face_metric) (domain, face);
return f;
}
@@ -369,7 +370,7 @@ gdouble gfs_domain_face_fraction_right (const GfsDomain * domain, const FttCellF
FttCellFace face1;
face1.cell = face->neighbor;
face1.d = FTT_OPPOSITE_DIRECTION (face->d);
- f *= (* domain->face_metric) (domain, &face1, domain->metric_data);
+ f *= (* domain->face_metric) (domain, &face1);
}
return f;
}
@@ -387,7 +388,7 @@ gdouble gfs_domain_cell_fraction (const GfsDomain * domain, const FttCell * cell
{
gdouble a = GFS_IS_MIXED (cell) ? GFS_STATE (cell)->solid->a : 1.;
if (domain->cell_metric)
- a *= (* domain->cell_metric) (domain, cell, domain->metric_data);
+ a *= (* domain->cell_metric) (domain, cell);
return a;
}
@@ -403,7 +404,7 @@ static inline
gdouble gfs_domain_solid_metric (const GfsDomain * domain, const FttCell * cell)
{
if (domain->solid_metric)
- return (* domain->solid_metric) (domain, cell, domain->metric_data);
+ return (* domain->solid_metric) (domain, cell);
return 1.;
}
diff --git a/src/fluid.c b/src/fluid.c
index c7ab1b0..8ffdd94 100644
--- a/src/fluid.c
+++ b/src/fluid.c
@@ -1699,7 +1699,7 @@ void gfs_cell_coarse_fine (FttCell * parent, GfsVariable * v)
if (v->domain->cell_metric) {
gdouble a[FTT_CELLS], sa = 0.;
for (n = 0; n < FTT_CELLS; n++) {
- a[n] = (* v->domain->cell_metric) (v->domain, child.c[n], v->domain->metric_data);
+ a[n] = (* v->domain->cell_metric) (v->domain, child.c[n]);
sa += a[n];
}
sa *= 2.;
diff --git a/src/metric.c b/src/metric.c
index 937046d..6b5124a 100644
--- a/src/metric.c
+++ b/src/metric.c
@@ -344,28 +344,34 @@ static GfsMapClass * gfs_map_cubed_class (void)
/* GfsMetricCubed: Object */
-static gdouble metric_cubed_face_metric (const GfsDomain * domain, const FttCellFace * face,
- const gpointer data)
+static gdouble cubed_face_metric (const GfsDomain * domain, const FttCellFace * face)
{
if (face->d/2 > 1)
return 1.;
- return GFS_VALUE (face->cell, GFS_METRIC_CUBED (data)->h[face->d]);
+ return GFS_VALUE (face->cell, GFS_METRIC_CUBED (domain->metric_data)->h[face->d]);
}
-static gdouble metric_cubed_cell_metric (const GfsDomain * domain, const FttCell * cell,
- const gpointer data)
+static gdouble cubed_cell_metric (const GfsDomain * domain, const FttCell * cell)
{
- return GFS_VALUE (cell, GFS_METRIC_CUBED (data)->a);
+ return GFS_VALUE (cell, GFS_METRIC_CUBED (domain->metric_data)->a);
}
-static gdouble metric_cubed_solid_metric (const GfsDomain * domain, const FttCell * cell,
- const gpointer data)
+static gdouble cubed_solid_metric (const GfsDomain * domain, const FttCell * cell)
{
g_assert (GFS_IS_MIXED (cell));
g_assert_not_implemented ();
return 1.;
}
+static gdouble cubed_scale_metric (const GfsDomain * domain, const FttCell * cell, FttComponent c)
+{
+ if (c > FTT_Y)
+ return 1.;
+ FttComponent d = FTT_ORTHOGONAL_COMPONENT (c);
+ return (GFS_VALUE (cell, GFS_METRIC_CUBED (domain->metric_data)->h[2*d]) +
+ GFS_VALUE (cell, GFS_METRIC_CUBED (domain->metric_data)->h[2*d + 1]))/2.;
+}
+
static void none (FttCell * parent, GfsVariable * v)
{
}
@@ -564,9 +570,10 @@ static void metric_cubed_read (GtsObject ** o, GtsFile * fp)
gts_container_add (GTS_CONTAINER (GFS_SIMULATION (domain)->maps), GTS_CONTAINEE (map));
domain->metric_data = cubed;
- domain->face_metric = metric_cubed_face_metric;
- domain->cell_metric = metric_cubed_cell_metric;
- domain->solid_metric = metric_cubed_solid_metric;
+ domain->face_metric = cubed_face_metric;
+ domain->cell_metric = cubed_cell_metric;
+ domain->solid_metric = cubed_solid_metric;
+ domain->scale_metric = cubed_scale_metric;
}
static void metric_cubed_class_init (GtsObjectClass * klass)
@@ -688,30 +695,34 @@ static void metric_lon_lat_write (GtsObject * o, FILE * fp)
fprintf (fp, " %g", GFS_METRIC_LON_LAT (o)->r);
}
-static gdouble metric_lon_lat_face_metric (const GfsDomain * domain, const FttCellFace * face,
- const gpointer data)
+static gdouble lon_lat_face_metric (const GfsDomain * domain, const FttCellFace * face)
{
if (face->d/2 != FTT_Y)
return 1.;
return face->d == 2 ?
- GFS_VALUE (face->cell, GFS_METRIC_LON_LAT (data)->h2) :
- GFS_VALUE (face->cell, GFS_METRIC_LON_LAT (data)->h3);
+ GFS_VALUE (face->cell, GFS_METRIC_LON_LAT (domain->metric_data)->h2) :
+ GFS_VALUE (face->cell, GFS_METRIC_LON_LAT (domain->metric_data)->h3);
}
-static gdouble metric_lon_lat_cell_metric (const GfsDomain * domain, const FttCell * cell,
- const gpointer data)
+static gdouble lon_lat_cell_metric (const GfsDomain * domain, const FttCell * cell)
{
- return GFS_VALUE (cell, GFS_METRIC_LON_LAT (data)->a);
+ return GFS_VALUE (cell, GFS_METRIC_LON_LAT (domain->metric_data)->a);
}
-static gdouble metric_lon_lat_solid_metric (const GfsDomain * domain, const FttCell * cell,
- const gpointer data)
+static gdouble lon_lat_solid_metric (const GfsDomain * domain, const FttCell * cell)
{
g_assert (GFS_IS_MIXED (cell));
g_assert_not_implemented ();
return 1.;
}
+static gdouble lon_lat_scale_metric (const GfsDomain * domain, const FttCell * cell, FttComponent c)
+{
+ if (c != FTT_X)
+ return 1.;
+ return GFS_VALUE (cell, GFS_METRIC_LON_LAT (domain->metric_data)->a);
+}
+
static void lonlat_coarse_fine (FttCell * parent, GfsVariable * a)
{
if (GFS_CELL_IS_BOUNDARY (parent))
@@ -796,9 +807,10 @@ static void metric_lon_lat_read (GtsObject ** o, GtsFile * fp)
GFS_MAP_LONLAT (map)->r = GFS_METRIC_LON_LAT (*o)->r;
domain->metric_data = *o;
- domain->face_metric = metric_lon_lat_face_metric;
- domain->cell_metric = metric_lon_lat_cell_metric;
- domain->solid_metric = metric_lon_lat_solid_metric;
+ domain->face_metric = lon_lat_face_metric;
+ domain->cell_metric = lon_lat_cell_metric;
+ domain->solid_metric = lon_lat_solid_metric;
+ domain->scale_metric = lon_lat_scale_metric;
}
static void metric_lon_lat_class_init (GtsObjectClass * klass)
diff --git a/src/river.c b/src/river.c
index e892ac0..c4ca052 100644
--- a/src/river.c
+++ b/src/river.c
@@ -187,10 +187,10 @@ static void sources (FttCell * cell, GfsRiver * r)
GfsDomain * domain = GFS_DOMAIN (r);
FttCellFace face = { cell };
for (face.d = 0; face.d < FTT_NEIGHBORS; face.d++)
- fm[face.d] = (* domain->face_metric) (domain, &face, domain->metric_data);
+ fm[face.d] = (* domain->face_metric) (domain, &face);
gdouble dh_dl = fm[FTT_RIGHT] - fm[FTT_LEFT];
gdouble dh_dt = fm[FTT_TOP] - fm[FTT_BOTTOM];
- cm = (* domain->cell_metric) (domain, cell, domain->metric_data)*ftt_cell_size (cell);
+ cm = (* domain->cell_metric) (domain, cell)*ftt_cell_size (cell);
gdouble dldh = cm*GFS_SIMULATION (r)->physical_params.L;
gdouble
phiu = GFS_VALUE (cell, r->v1[1]),
@@ -387,9 +387,9 @@ static gdouble maximum_face_metric (FttCell * cell, GfsDomain * domain, FttCompo
if (domain->face_metric) {
FttCellFace f;
f.cell = cell; f.d = 2*c;
- gdouble fm1 = (* domain->face_metric) (domain, &f, domain->metric_data);
+ gdouble fm1 = (* domain->face_metric) (domain, &f);
f.d = 2*c + 1;
- gdouble fm2 = (* domain->face_metric) (domain, &f, domain->metric_data);
+ gdouble fm2 = (* domain->face_metric) (domain, &f);
return MAX (fm1, fm2);
}
else
@@ -403,7 +403,7 @@ static void minimum_cfl (FttCell * cell, GfsRiver * r)
GfsDomain * domain = GFS_DOMAIN (r);
gdouble vol = ftt_cell_size (cell);
if (domain->cell_metric)
- vol *= (* domain->cell_metric) (domain, cell, domain->metric_data);
+ vol *= (* domain->cell_metric) (domain, cell);
gdouble cg = sqrt (r->g*h);
FttComponent c;
for (c = FTT_X; c <= FTT_Y; c++) {
diff --git a/src/simulation.c b/src/simulation.c
index 120d53d..26e3c93 100644
--- a/src/simulation.c
+++ b/src/simulation.c
@@ -1968,24 +1968,21 @@ static void axi_read (GtsObject ** object, GtsFile * fp)
GFS_DOMAIN (*object)->refpos.y = 0.5;
}
-static gdouble axi_face_metric (const GfsDomain * domain, const FttCellFace * face,
- const gpointer data)
+static gdouble axi_face_metric (const GfsDomain * domain, const FttCellFace * face)
{
FttVector p;
ftt_face_pos (face, &p);
return p.y;
}
-static gdouble axi_cell_metric (const GfsDomain * domain, const FttCell * cell,
- const gpointer data)
+static gdouble axi_cell_metric (const GfsDomain * domain, const FttCell * cell)
{
FttVector p;
gfs_cell_cm (cell, &p);
return p.y;
}
-static gdouble axi_solid_metric (const GfsDomain * domain, const FttCell * cell,
- const gpointer data)
+static gdouble axi_solid_metric (const GfsDomain * domain, const FttCell * cell)
{
g_assert (GFS_IS_MIXED (cell));
return GFS_STATE (cell)->solid->ca.y;
diff --git a/src/variable.c b/src/variable.c
index 3a4a15e..184df36 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -640,7 +640,7 @@ static gdouble face_metric (FttCell * cell, FttDirection d, GfsDomain * domain)
FttCellFace f;
f.cell = cell;
f.d = d;
- return (* domain->face_metric) (domain, &f, domain->metric_data);
+ return (* domain->face_metric) (domain, &f);
}
else
return 1.;
diff --git a/test/axiadvection/axi.sh b/test/axiadvection/axi.sh
index 6472ca9..771af68 100644
--- a/test/axiadvection/axi.sh
+++ b/test/axiadvection/axi.sh
@@ -39,7 +39,7 @@ BEGIN { min = 1000.; max = -1000.; }{
END {
e = 2.*(max - min)/(max + min);
print "Standard:", e;
- if (e > 2.5e-6)
+ if (e > 1.5e-7)
exit (1);
}' < srt1; then :
else
diff --git a/test/axiadvection/axiadvection.gfs b/test/axiadvection/axiadvection.gfs
index 35f4879..a8b61fb 100644
--- a/test/axiadvection/axiadvection.gfs
+++ b/test/axiadvection/axiadvection.gfs
@@ -7,7 +7,7 @@
# flow illustrated in Figure \ref{vof}. As the torus is flattened
# against the right-hand-side wall, its cross-sectional surface area
# decreases but the volume should remain constant. This is indeed the
-# case to within 0.05\% for the VOF tracer and $2\times 10^{-4}$\% for
+# case to within 0.04\% for the VOF tracer and $1.5\times 10^{-5}$\% for
# the standard tracer.
#
# \begin{figure}[htbp]
diff --git a/test/axiadvection/solid/axi.sh b/test/axiadvection/solid/axi.sh
index b634e9c..d4f967b 100644
--- a/test/axiadvection/solid/axi.sh
+++ b/test/axiadvection/solid/axi.sh
@@ -25,7 +25,7 @@ BEGIN { min = 1000.; max = -1000.; }{
END {
e = 2.*(max - min)/(max + min);
print "Standard:", e;
- if (e > 3e-5)
+ if (e > 0.)
exit (1);
}' < srt1; then :
else
--
Gerris Flow Solver
More information about the debian-science-commits
mailing list