[SCM] Gerris Flow Solver branch, upstream, updated. b3aa46814a06c9cb2912790b23916ffb44f1f203
Stephane Popinet
popinet at users.sourceforge.net
Fri May 15 02:51:14 UTC 2009
The following commit has been merged in the upstream branch:
commit d9a2799dbb8112eca1d2ddff53c313f23bbad166
Author: Stephane Popinet <popinet at users.sourceforge.net>
Date: Mon Oct 11 11:39:00 2004 +1000
Control of diffusion bc on immersed boundaries (gerris--mainline--0.5--patch-3)
gerris--mainline--0.5--patch-3
Keywords:
Boundary conditions on immersed boundaries for the diffusion equation
can now be set in parameter files.
darcs-hash:20041011013900-aabb8-9931ecb0a5b931e5747170497f4ca66961591f80.gz
diff --git a/src/boundary.c b/src/boundary.c
index ceaf92f..3144016 100644
--- a/src/boundary.c
+++ b/src/boundary.c
@@ -371,7 +371,6 @@ static void match (FttCell * cell, GfsBoundary * boundary)
GFS_STATE (cell)->solid = g_malloc0 (sizeof (GfsSolidVector));
t = GFS_STATE (cell)->solid;
t->a = s->a;
- t->sa = s->sa;
for (d = 0; d < FTT_NEIGHBORS; d++)
if (d/2 == boundary->d/2)
t->s[d] = s->s[FTT_OPPOSITE_DIRECTION (d)];
diff --git a/src/domain.c b/src/domain.c
index aa4e75e..f53b6ee 100644
--- a/src/domain.c
+++ b/src/domain.c
@@ -654,18 +654,14 @@ void gfs_domain_match (GfsDomain * domain)
static void dirichlet_bc (FttCell * cell)
{
- if (GFS_IS_MIXED (cell)) {
- cell->flags |= GFS_FLAG_DIRICHLET;
- GFS_STATE (cell)->solid->fv = 0.;
- }
+ cell->flags |= GFS_FLAG_DIRICHLET;
+ GFS_STATE (cell)->solid->fv = 0.;
}
static void neumann_bc (FttCell * cell)
{
- if (GFS_IS_MIXED (cell)) {
- cell->flags &= ~GFS_FLAG_DIRICHLET;
- GFS_STATE (cell)->solid->fv = 0.;
- }
+ cell->flags &= ~GFS_FLAG_DIRICHLET;
+ GFS_STATE (cell)->solid->fv = 0.;
}
/**
@@ -681,15 +677,18 @@ void gfs_domain_surface_bc (GfsDomain * domain,
g_return_if_fail (domain != NULL);
g_return_if_fail (v != NULL);
- /* for the moment conditions are always Dirichlet u = v = w = 0 for
- the component of the velocity and Neumann f = 0 for all the other
- variables */
- if (GFS_VELOCITY_COMPONENT (v->i) < FTT_DIMENSION)
- gfs_domain_cell_traverse (domain, FTT_PRE_ORDER, FTT_TRAVERSE_ALL, -1,
- (FttCellTraverseFunc) dirichlet_bc, NULL);
- else
- gfs_domain_cell_traverse (domain, FTT_PRE_ORDER, FTT_TRAVERSE_ALL, -1,
- (FttCellTraverseFunc) neumann_bc, NULL);
+ if (v->surface_bc)
+ gfs_domain_traverse_mixed (domain, FTT_PRE_ORDER, FTT_TRAVERSE_ALL,
+ (FttCellTraverseFunc) GFS_SURFACE_GENERIC_BC_CLASS (GTS_OBJECT (v->surface_bc)->klass)->bc,
+ v->surface_bc);
+ else {
+ if (GFS_VELOCITY_COMPONENT (v->i) < FTT_DIMENSION)
+ gfs_domain_traverse_mixed (domain, FTT_PRE_ORDER, FTT_TRAVERSE_ALL,
+ (FttCellTraverseFunc) dirichlet_bc, NULL);
+ else
+ gfs_domain_traverse_mixed (domain, FTT_PRE_ORDER, FTT_TRAVERSE_ALL,
+ (FttCellTraverseFunc) neumann_bc, NULL);
+ }
}
static void box_traverse (GfsBox * box, gpointer * datum)
@@ -813,7 +812,7 @@ static void traverse_mixed (GfsBox * box, gpointer * datum)
* @func: the function to call for each visited #FttCell.
* @data: user data to pass to @func.
*
- * Calls @func for each leaf mixed cell of @domain.
+ * Calls @func for each mixed cell of @domain.
*/
void gfs_domain_traverse_mixed (GfsDomain * domain,
FttTraverseType order,
diff --git a/src/fluid.c b/src/fluid.c
index 2f0372e..27ea217 100644
--- a/src/fluid.c
+++ b/src/fluid.c
@@ -1775,7 +1775,7 @@ static void cell_traverse_mixed (FttCell * cell,
* @data: user data to pass to @func.
*
* Traverses a cell tree starting at the given root #FttCell. Calls
- * the given function for each leaf cell which is also a mixed cell.
+ * the given function for each mixed cell.
*/
void gfs_cell_traverse_mixed (FttCell * root,
FttTraverseType order,
@@ -1919,6 +1919,8 @@ static void gfs_variable_destroy (GtsObject * object)
g_free (v->name);
if (v->sources)
gts_object_destroy (GTS_OBJECT (v->sources));
+ if (v->surface_bc)
+ gts_object_destroy (GTS_OBJECT (v->surface_bc));
(* GTS_OBJECT_CLASS (gfs_variable_class ())->parent_class->destroy)
(object);
diff --git a/src/fluid.h b/src/fluid.h
index 496c240..a46ecc2 100644
--- a/src/fluid.h
+++ b/src/fluid.h
@@ -77,7 +77,7 @@ typedef enum {
struct _GfsSolidVector {
gdouble s[FTT_NEIGHBORS];
- gdouble a, sa, v, fv;
+ gdouble a, v, fv;
FttCell * merged;
FttVector cm, ca;
};
@@ -92,6 +92,8 @@ typedef enum {
/* GfsVariable: Header */
typedef struct _GfsVariable GfsVariable;
+typedef struct _GfsSurfaceGenericBc GfsSurfaceGenericBc;
+
typedef void (* GfsVariableDerivedFunc) (FttCell * cell, GfsVariable * v);
typedef void (* GfsVariableFineCoarseFunc) (FttCell * cell, GfsVariable * v);
@@ -106,6 +108,7 @@ struct _GfsVariable {
GfsVariableDerivedFunc derived;
GfsVariableFineCoarseFunc fine_coarse;
GtsContainer * sources;
+ GfsSurfaceGenericBc * surface_bc;
GfsVariable * next;
GtsObject * p;
};
diff --git a/src/init.c b/src/init.c
index f485b0c..6d07019 100644
--- a/src/init.c
+++ b/src/init.c
@@ -218,6 +218,8 @@ void gfs_init (int * argc, char *** argv)
gfs_variable_class ();
gfs_variable_tracer_class ();
+ gfs_surface_bc_class ();
+
gfs_box_class ();
gfs_box_not_adapt_class ();
gfs_gedge_class ();
diff --git a/src/poisson.c b/src/poisson.c
index 5720cfd..30df8bb 100644
--- a/src/poisson.c
+++ b/src/poisson.c
@@ -663,8 +663,7 @@ void gfs_diffusion_rhs (FttCell * cell, GfsVariable * v)
if (GFS_IS_MIXED (cell)) {
a = GFS_STATE (cell)->solid->a*GFS_STATE (cell)->g[0];
if (((cell)->flags & GFS_FLAG_DIRICHLET) != 0)
- f = gfs_cell_dirichlet_gradient_flux (cell, v->i, -1,
- GFS_STATE (cell)->solid->fv);
+ f = gfs_cell_dirichlet_gradient_flux (cell, v->i, -1, GFS_STATE (cell)->solid->fv);
else
f = GFS_STATE (cell)->solid->fv;
}
diff --git a/src/simulation.c b/src/simulation.c
index c302519..fc27698 100644
--- a/src/simulation.c
+++ b/src/simulation.c
@@ -106,6 +106,7 @@ static void simulation_write (GtsObject * object, FILE * fp)
{
GfsSimulation * sim = GFS_SIMULATION (object);
GSList * i;
+ GfsVariable * v;
(* GTS_OBJECT_CLASS (gfs_simulation_class ())->parent_class->write)
(object, fp);
@@ -137,6 +138,16 @@ static void simulation_write (GtsObject * object, FILE * fp)
i = i->next;
}
+ v = GFS_DOMAIN (sim)->variables;
+ while (v) {
+ if (v->surface_bc) {
+ fputs (" ", fp);
+ (* GTS_OBJECT (v->surface_bc)->klass->write) (GTS_OBJECT (v->surface_bc), fp);
+ fputc ('\n', fp);
+ }
+ v = v->next;
+ }
+
if (GFS_DOMAIN (sim)->max_depth_write < -1) {
i = sim->refines->items;
while (i) {
@@ -486,7 +497,8 @@ static void simulation_read (GtsObject ** object, GtsFile * fp)
if (klass == NULL ||
(!gts_object_class_is_from_class (klass, gfs_refine_class ()) &&
!gts_object_class_is_from_class (klass, gfs_event_class ()) &&
- !gts_object_class_is_from_class (klass, gfs_variable_class ()))) {
+ !gts_object_class_is_from_class (klass, gfs_variable_class ()) &&
+ !gts_object_class_is_from_class (klass, gfs_surface_generic_bc_class ()))) {
gts_file_error (fp, "unknown keyword `%s'", fp->token->str);
return;
}
@@ -523,6 +535,8 @@ static void simulation_read (GtsObject ** object, GtsFile * fp)
}
sim->variables = g_slist_append (sim->variables, v);
}
+ else if (GFS_IS_SURFACE_GENERIC_BC (object))
+ ;
else
g_assert_not_reached ();
}
diff --git a/src/source.c b/src/source.c
index aee48ee..2f1a42e 100644
--- a/src/source.c
+++ b/src/source.c
@@ -288,8 +288,8 @@ static void source_write (GtsObject * o, FILE * fp)
}
static gdouble source_value (GfsSourceGeneric * s,
- FttCell * cell,
- GfsVariable * v)
+ FttCell * cell,
+ GfsVariable * v)
{
FttVector p;
diff --git a/src/timestep.c b/src/timestep.c
index 20445ad..fcc8c52 100644
--- a/src/timestep.c
+++ b/src/timestep.c
@@ -456,6 +456,57 @@ void gfs_approximate_projection (GfsDomain * domain,
}
/**
+ * gfs_predicted_face_velocities:
+ * @domain: a #GfsDomain.
+ * @d: the number of dimensions (2 or 3).
+ * @par: the advection parameters.
+ *
+ * Fills the face (MAC) normal velocities of each leaf cell of @domain
+ * with the predicted values at time t + dt/2 using a godunov type
+ * advection scheme.
+ */
+void gfs_predicted_face_velocities (GfsDomain * domain,
+ guint d,
+ GfsAdvectionParams * par)
+{
+ FttComponent c;
+ FttCellTraverseFunc face_values;
+ GfsUpwinding upwinding;
+
+ g_return_if_fail (domain != NULL);
+ g_return_if_fail (par != NULL);
+
+ gfs_domain_timer_start (domain, "predicted_face_velocities");
+
+ gfs_domain_face_traverse (domain, d == 2 ? FTT_XY : FTT_XYZ,
+ FTT_PRE_ORDER, FTT_TRAVERSE_LEAFS, -1,
+ (FttFaceTraverseFunc) gfs_face_reset_normal_velocity,
+ NULL);
+ par->use_centered_velocity = TRUE;
+ if (par->scheme == GFS_NONE) {
+ face_values = (FttCellTraverseFunc) gfs_cell_non_advected_face_values;
+ upwinding = GFS_NO_UPWINDING;
+ }
+ else {
+ face_values = (FttCellTraverseFunc) gfs_cell_advected_face_values;
+ upwinding = GFS_CENTERED_UPWINDING;
+ }
+ par->v = gfs_variable_from_name (domain->variables, "U");
+ for (c = 0; c < d; c++, par->v = par->v->next) {
+ gfs_domain_cell_traverse (domain,
+ FTT_PRE_ORDER, FTT_TRAVERSE_LEAFS, -1,
+ face_values, par);
+ gfs_domain_face_bc (domain, c, par->v);
+ gfs_domain_face_traverse (domain, c,
+ FTT_PRE_ORDER, FTT_TRAVERSE_LEAFS, -1,
+ (FttFaceTraverseFunc) gfs_face_advected_normal_velocity,
+ &upwinding);
+ }
+
+ gfs_domain_timer_stop (domain, "predicted_face_velocities");
+}
+
+/**
* gfs_diffusion:
* @domain: a #GfsDomain.
* @par: the multilevel parameters.
@@ -678,53 +729,181 @@ void gfs_tracer_advection_diffusion (GfsDomain * domain,
gfs_domain_timer_stop (domain, "tracer_advection_diffusion");
}
-/**
- * gfs_predicted_face_velocities:
- * @domain: a #GfsDomain.
- * @d: the number of dimensions (2 or 3).
- * @par: the advection parameters.
- *
- * Fills the face (MAC) normal velocities of each leaf cell of @domain
- * with the predicted values at time t + dt/2 using a godunov type
- * advection scheme.
- */
-void gfs_predicted_face_velocities (GfsDomain * domain,
- guint d,
- GfsAdvectionParams * par)
+/* GfsSurfaceGenericBc: Object */
+
+static void gfs_surface_generic_bc_read (GtsObject ** o, GtsFile * fp)
{
- FttComponent c;
- FttCellTraverseFunc face_values;
- GfsUpwinding upwinding;
+ GfsDomain * domain = GFS_DOMAIN (gfs_object_simulation (*o));
+ GfsSurfaceGenericBc * bc = GFS_SURFACE_GENERIC_BC (*o);
+ GtsObjectClass * klass;
- g_return_if_fail (domain != NULL);
- g_return_if_fail (par != NULL);
+ if (GTS_OBJECT_CLASS (gfs_surface_generic_bc_class ())->parent_class->read)
+ (* GTS_OBJECT_CLASS (gfs_surface_generic_bc_class ())->parent_class->read)
+ (o, fp);
+ if (fp->type == GTS_ERROR)
+ return;
+ if (fp->type != GTS_STRING) {
+ gts_file_error (fp, "expecting a class name");
+ return;
+ }
+ if (!(klass = gfs_object_class_from_name (fp->token->str))) {
+ gts_file_error (fp, "unknown class `%s'", fp->token->str);
+ return;
+ }
+ if (!gts_object_class_is_from_class (klass, gfs_surface_generic_bc_class ())) {
+ gts_file_error (fp, "class `%s' is not a GfsSurfaceGenericClass", fp->token->str);
+ return;
+ }
+ gts_file_next_token (fp);
+ if (fp->type != GTS_STRING) {
+ gts_file_error (fp, "expecting a variable name");
+ return;
+ }
+ bc->v = gfs_variable_from_name (domain->variables, fp->token->str);
+ if (!bc->v) {
+ gts_file_error (fp, "unknown variable `%s'", fp->token->str);
+ return;
+ }
+ if (bc->v->surface_bc) {
+ gts_file_error (fp, "variable `%s' already has a surface boundary condition",
+ fp->token->str);
+ return;
+ }
+ bc->v->surface_bc = bc;
+ gts_file_next_token (fp);
+}
- gfs_domain_timer_start (domain, "predicted_face_velocities");
+static void gfs_surface_generic_bc_write (GtsObject * o, FILE * fp)
+{
+ if (GTS_OBJECT_CLASS (gfs_surface_generic_bc_class ())->parent_class->write)
+ (* GTS_OBJECT_CLASS (gfs_surface_generic_bc_class ())->parent_class->write)
+ (o, fp);
+ fprintf (fp, "%s %s", o->klass->info.name, GFS_SURFACE_GENERIC_BC (o)->v->name);
+}
- gfs_domain_face_traverse (domain, d == 2 ? FTT_XY : FTT_XYZ,
- FTT_PRE_ORDER, FTT_TRAVERSE_LEAFS, -1,
- (FttFaceTraverseFunc) gfs_face_reset_normal_velocity,
- NULL);
- par->use_centered_velocity = TRUE;
- if (par->scheme == GFS_NONE) {
- face_values = (FttCellTraverseFunc) gfs_cell_non_advected_face_values;
- upwinding = GFS_NO_UPWINDING;
+static void gfs_surface_generic_bc_class_init (GfsSurfaceGenericBcClass * klass)
+{
+ GTS_OBJECT_CLASS (klass)->read = gfs_surface_generic_bc_read;
+ GTS_OBJECT_CLASS (klass)->write = gfs_surface_generic_bc_write;
+}
+
+GfsSurfaceGenericBcClass * gfs_surface_generic_bc_class (void)
+{
+ static GfsSurfaceGenericBcClass * klass = NULL;
+
+ if (klass == NULL) {
+ GtsObjectClassInfo gfs_surface_generic_bc_info = {
+ "GfsSurfaceGenericBc",
+ sizeof (GfsSurfaceGenericBc),
+ sizeof (GfsSurfaceGenericBcClass),
+ (GtsObjectClassInitFunc) gfs_surface_generic_bc_class_init,
+ (GtsObjectInitFunc) NULL,
+ (GtsArgSetFunc) NULL,
+ (GtsArgGetFunc) NULL
+ };
+ klass = gts_object_class_new (GTS_OBJECT_CLASS (gts_object_class ()),
+ &gfs_surface_generic_bc_info);
+ }
+
+ return klass;
+}
+
+/* GfsSurfaceBc: Object */
+
+static void gfs_surface_bc_destroy (GtsObject * object)
+{
+ gts_object_destroy (GTS_OBJECT (GFS_SURFACE_BC (object)->type));
+ gts_object_destroy (GTS_OBJECT (GFS_SURFACE_BC (object)->val));
+
+ (* GTS_OBJECT_CLASS (gfs_surface_bc_class ())->parent_class->destroy) (object);
+}
+
+static void gfs_surface_bc_read (GtsObject ** o, GtsFile * fp)
+{
+ GfsSurfaceBc * bc = GFS_SURFACE_BC (*o);
+
+ if (GTS_OBJECT_CLASS (gfs_surface_bc_class ())->parent_class->read)
+ (* GTS_OBJECT_CLASS (gfs_surface_bc_class ())->parent_class->read) (o, fp);
+ if (fp->type == GTS_ERROR)
+ return;
+ if (!strcmp (fp->token->str, "Neumann")) {
+ bc->type->val = 0.;
+ gts_file_next_token (fp);
+ }
+ else if (!strcmp (fp->token->str, "Dirichlet")) {
+ bc->type->val = 1.;
+ gts_file_next_token (fp);
}
else {
- face_values = (FttCellTraverseFunc) gfs_cell_advected_face_values;
- upwinding = GFS_CENTERED_UPWINDING;
+ gfs_object_simulation (bc->type) = gfs_object_simulation (bc);
+ gfs_function_read (bc->type, fp);
+ if (fp->type == GTS_ERROR)
+ return;
}
- par->v = gfs_variable_from_name (domain->variables, "U");
- for (c = 0; c < d; c++, par->v = par->v->next) {
- gfs_domain_cell_traverse (domain,
- FTT_PRE_ORDER, FTT_TRAVERSE_LEAFS, -1,
- face_values, par);
- gfs_domain_face_bc (domain, c, par->v);
- gfs_domain_face_traverse (domain, c,
- FTT_PRE_ORDER, FTT_TRAVERSE_LEAFS, -1,
- (FttFaceTraverseFunc) gfs_face_advected_normal_velocity,
- &upwinding);
+ gfs_object_simulation (bc->val) = gfs_object_simulation (bc);
+ gfs_function_read (bc->val, fp);
+}
+
+static void gfs_surface_bc_write (GtsObject * o, FILE * fp)
+{
+ GfsSurfaceBc * bc = GFS_SURFACE_BC (o);
+
+ if (GTS_OBJECT_CLASS (gfs_surface_bc_class ())->parent_class->write)
+ (* GTS_OBJECT_CLASS (gfs_surface_bc_class ())->parent_class->write) (o, fp);
+ if (!bc->type->f)
+ fprintf (fp, " %s", bc->type->val ? "Dirichlet" : "Neumann");
+ else
+ gfs_function_write (bc->type, fp);
+ gfs_function_write (bc->val, fp);
+}
+
+static void gfs_surface_bc_bc (FttCell * cell, GfsSurfaceGenericBc * b)
+{
+ GfsSurfaceBc * bc = GFS_SURFACE_BC (b);
+ gdouble t = gfs_object_simulation (bc)->time.t;
+ gdouble val = gfs_function_value (bc->val, &GFS_STATE (cell)->solid->ca, t);
+
+ if (gfs_function_value (bc->type, &GFS_STATE (cell)->solid->ca, t) > 0.) {
+ cell->flags |= GFS_FLAG_DIRICHLET;
+ GFS_STATE (cell)->solid->fv = val;
}
+ else {
+ cell->flags &= ~GFS_FLAG_DIRICHLET;
+ GFS_STATE (cell)->solid->fv = val; /* fixme: scaling is probably wrong */
+ }
+}
- gfs_domain_timer_stop (domain, "predicted_face_velocities");
+static void gfs_surface_bc_class_init (GfsSurfaceGenericBcClass * klass)
+{
+ GTS_OBJECT_CLASS (klass)->read = gfs_surface_bc_read;
+ GTS_OBJECT_CLASS (klass)->write = gfs_surface_bc_write;
+ GTS_OBJECT_CLASS (klass)->destroy = gfs_surface_bc_destroy;
+ klass->bc = gfs_surface_bc_bc;
+}
+
+static void gfs_surface_bc_init (GfsSurfaceBc * object)
+{
+ object->type = gfs_function_new (gfs_function_class (), 0.);
+ object->val = gfs_function_new (gfs_function_class (), 0.);
+}
+
+GfsSurfaceGenericBcClass * gfs_surface_bc_class (void)
+{
+ static GfsSurfaceGenericBcClass * klass = NULL;
+
+ if (klass == NULL) {
+ GtsObjectClassInfo gfs_surface_bc_info = {
+ "GfsSurfaceBc",
+ sizeof (GfsSurfaceBc),
+ sizeof (GfsSurfaceGenericBcClass),
+ (GtsObjectClassInitFunc) gfs_surface_bc_class_init,
+ (GtsObjectInitFunc) gfs_surface_bc_init,
+ (GtsArgSetFunc) NULL,
+ (GtsArgGetFunc) NULL
+ };
+ klass = gts_object_class_new (GTS_OBJECT_CLASS (gfs_surface_generic_bc_class ()),
+ &gfs_surface_bc_info);
+ }
+
+ return klass;
}
diff --git a/src/timestep.h b/src/timestep.h
index 928e4a4..a460add 100644
--- a/src/timestep.h
+++ b/src/timestep.h
@@ -58,6 +58,10 @@ void gfs_correct_centered_velocities (GfsDomain * domain,
void gfs_approximate_projection (GfsDomain * domain,
GfsMultilevelParams * par,
GfsAdvectionParams * apar);
+void gfs_predicted_face_velocities (GfsDomain * domain,
+ guint d,
+ GfsAdvectionParams * par);
+
void gfs_diffusion (GfsDomain * domain,
GfsMultilevelParams * par,
GfsVariable * v);
@@ -69,9 +73,57 @@ void gfs_tracer_advection_diffusion (GfsDomain * domain,
GfsAdvectionParams * par,
GfsMultilevelParams * dpar,
GfsVariable * half);
-void gfs_predicted_face_velocities (GfsDomain * domain,
- guint d,
- GfsAdvectionParams * par);
+
+/* GfsSurfaceGenericBc: Header */
+
+struct _GfsSurfaceGenericBc {
+ /*< private >*/
+ GtsObject parent;
+
+ /*< public >*/
+ GfsVariable * v;
+};
+
+typedef struct _GfsSurfaceGenericBcClass GfsSurfaceGenericBcClass;
+
+struct _GfsSurfaceGenericBcClass {
+ /*< private >*/
+ GtsObjectClass parent_class;
+
+ /*< public >*/
+ void (* bc) (FttCell *, GfsSurfaceGenericBc *);
+};
+
+#define GFS_SURFACE_GENERIC_BC(obj) GTS_OBJECT_CAST (obj,\
+ GfsSurfaceGenericBc,\
+ gfs_surface_generic_bc_class ())
+#define GFS_SURFACE_GENERIC_BC_CLASS(klass) GTS_OBJECT_CLASS_CAST (klass,\
+ GfsSurfaceGenericBcClass,\
+ gfs_surface_generic_bc_class())
+#define GFS_IS_SURFACE_GENERIC_BC(obj) (gts_object_is_from_class (obj,\
+ gfs_surface_generic_bc_class ()))
+
+GfsSurfaceGenericBcClass * gfs_surface_generic_bc_class (void);
+
+/* GfsSurfaceBc: Header */
+
+typedef struct _GfsSurfaceBc GfsSurfaceBc;
+
+struct _GfsSurfaceBc {
+ /*< private >*/
+ GfsSurfaceGenericBc parent;
+
+ /*< public >*/
+ GfsFunction * type, * val;
+};
+
+#define GFS_SURFACE_BC(obj) GTS_OBJECT_CAST (obj,\
+ GfsSurfaceBc,\
+ gfs_surface_bc_class ())
+#define GFS_IS_SURFACE_BC(obj) (gts_object_is_from_class (obj,\
+ gfs_surface_bc_class ()))
+
+GfsSurfaceGenericBcClass * gfs_surface_bc_class (void);
#ifdef __cplusplus
}
diff --git a/src/utils.c b/src/utils.c
index a4e2ef6..b099bfb 100644
--- a/src/utils.c
+++ b/src/utils.c
@@ -100,6 +100,8 @@ static void function_read (GtsObject ** o, GtsFile * fp)
"#include <stdlib.h>\n"
"#include <stdio.h>\n"
"#include <math.h>\n"
+ "static double Dirichlet = 1.;\n"
+ "static double Neumann = 0.;\n"
"double f (double x, double y, double z, double t) {\n"
"#line %d \"GfsFunction\"\n",
fp->line);
--
Gerris Flow Solver
More information about the debian-science-commits
mailing list