[SCM] Gerris Flow Solver branch, upstream, updated. b3aa46814a06c9cb2912790b23916ffb44f1f203

Stephane Popinet popinet at users.sf.net
Fri May 15 02:53:35 UTC 2009


The following commit has been merged in the upstream branch:
commit b8dcc3953be6aad0a9af48fcc235e9b4a6dea00e
Author: Stephane Popinet <popinet at users.sf.net>
Date:   Fri Feb 3 12:13:12 2006 +1100

    VariableCurvature is defined only on the interface
    
    It now is defined as the curvature of the piece of interface cutting
    the cell. If the cell is not cut by the interface it is set to
    G_MAXDOUBLE.
    
    darcs-hash:20060203011312-d4795-79deaa308778c2ce41484bfda578f5c3bbb9f8bc.gz

diff --git a/src/levelset.c b/src/levelset.c
index 59215b6..0f200b6 100644
--- a/src/levelset.c
+++ b/src/levelset.c
@@ -157,3 +157,175 @@ GfsVariableClass * gfs_variable_levelset_class (void)
 
   return klass;
 }
+
+/* GfsVariableCurvature: object */
+
+static void variable_curvature_read (GtsObject ** o, GtsFile * fp)
+{
+  GfsDomain * domain;
+
+  (* GTS_OBJECT_CLASS (gfs_variable_curvature_class ())->parent_class->read) (o, fp);
+  if (fp->type == GTS_ERROR)
+    return;
+
+  if (fp->type != GTS_STRING) {
+    gts_file_error (fp, "expecting a string (d)");
+    return;
+  }
+  domain = GFS_DOMAIN (gfs_object_simulation (*o));
+  if (!(GFS_VARIABLE_CURVATURE (*o)->d = 
+	gfs_variable_from_name (domain->variables, fp->token->str))) {
+    gts_file_error (fp, "unknown variable `%s'", fp->token->str);
+    return;
+  }
+  if (!GFS_IS_VARIABLE_LEVELSET (GFS_VARIABLE_CURVATURE (*o)->d)) {
+    gts_file_error (fp, "variable `%s' is not a GfsVariableLevelSet", fp->token->str);
+    return;
+  }
+  gts_file_next_token (fp);
+
+  if (fp->type == '{') {
+    GtsFileVariable var[] = {
+      {GTS_DOUBLE, "sigma", TRUE},
+      {GTS_DOUBLE, "theta", TRUE},
+      {GTS_NONE}
+    };
+
+    var[0].data = &GFS_VARIABLE_CURVATURE (*o)->sigma;
+    var[1].data = &GFS_VARIABLE_CURVATURE (*o)->theta;
+    gts_file_assign_variables (fp, var);
+  }
+}
+
+static void variable_curvature_write (GtsObject * o, FILE * fp)
+{
+  GfsVariableCurvature * v = GFS_VARIABLE_CURVATURE (o);
+
+  (* GTS_OBJECT_CLASS (gfs_variable_curvature_class ())->parent_class->write) (o, fp);
+
+  fprintf (fp, " %s", v->d->name);
+  if (v->sigma != 1. || v->theta != 0.5)
+    fprintf (fp, " { sigma = %g theta = %g }", v->sigma, v->theta);
+}
+
+static void normal (FttCell * cell, gpointer * data)
+{
+  GfsVariable ** nv = data[0];
+  GfsVariable * d = GFS_VARIABLE_CURVATURE (data[1])->d;
+  GtsVector n = { 0., 0., 0. };
+  FttComponent c;
+
+  gfs_youngs_normal (cell, d, (FttVector *) n);
+  gts_vector_normalize (n);
+  for (c = 0; c < FTT_DIMENSION; c++)
+    GFS_VARIABLE (cell, nv[c]->i) = n[c];
+}
+
+static void curvature (FttCell * cell, gpointer * data)
+{
+  GfsVariable ** nv = data[0];
+  gdouble kappa = 0.;
+  FttComponent c;
+
+  for (c = 0; c < FTT_DIMENSION; c++)
+    kappa += gfs_center_gradient (cell, c, nv[c]->i);
+  GFS_VARIABLE (cell, nv[FTT_DIMENSION]->i) = kappa/ftt_cell_size (cell);
+}
+
+static void interface_curvature (FttCell * cell, gpointer * data)
+{
+  GfsVariable * v = data[1];
+  GfsVariableCurvature * k = GFS_VARIABLE_CURVATURE (v);
+  gdouble f = GFS_VARIABLE (cell, GFS_VARIABLE_LEVELSET (k->d)->v->i);
+
+  if (GFS_IS_FULL (f))
+    GFS_VARIABLE (cell, v->i) = G_MAXDOUBLE;
+  else {
+    GfsVariable ** nv = data[0];
+    FttComponent c;
+    FttVector p;
+    gdouble kappa;
+
+    ftt_cell_pos (cell, &p);
+    for (c = 0; c < FTT_DIMENSION; c++)
+      (&p.x)[c] -= GFS_VARIABLE (cell, k->d->i)*GFS_VARIABLE (cell, nv[c]->i);
+    kappa = k->sigma*gfs_interpolate (cell, p, nv[FTT_DIMENSION]);
+    if (GFS_VARIABLE (cell, v->i) < G_MAXDOUBLE)
+      GFS_VARIABLE (cell, v->i) = (k->a*kappa + (1. - k->a)*GFS_VARIABLE (cell, v->i));
+    else
+      GFS_VARIABLE (cell, v->i) = kappa;
+  }
+}
+
+static void variable_curvature_event_half (GfsEvent * event, GfsSimulation * sim)
+{
+  GfsVariable * n[FTT_DIMENSION + 1];
+  GfsDomain * domain = GFS_DOMAIN (sim);
+  gpointer data[2];
+  FttComponent c;
+
+  for (c = 0; c < FTT_DIMENSION + 1; c++) {
+    n[c] = gfs_temporary_variable (domain);
+    gfs_variable_set_vector (n[c], c);
+  }
+  data[0] = n;
+  data[1] = event;
+  gfs_domain_cell_traverse (domain, FTT_PRE_ORDER, FTT_TRAVERSE_LEAFS, -1,
+			    (FttCellTraverseFunc) normal, data);
+  for (c = 0; c < FTT_DIMENSION; c++)
+    gfs_domain_bc (domain, FTT_TRAVERSE_LEAFS, -1, n[c]);
+  gfs_domain_cell_traverse (domain, FTT_PRE_ORDER, FTT_TRAVERSE_LEAFS, -1,
+			    (FttCellTraverseFunc) curvature, data);
+  gfs_domain_cell_traverse (domain, FTT_PRE_ORDER, FTT_TRAVERSE_LEAFS, -1,
+			    (FttCellTraverseFunc) interface_curvature, data);
+  gfs_domain_bc (domain, FTT_TRAVERSE_LEAFS, -1, GFS_VARIABLE1 (event));
+  for (c = 0; c < FTT_DIMENSION + 1; c++)
+    gts_object_destroy (GTS_OBJECT (n[c]));
+}
+
+static gboolean variable_curvature_event (GfsEvent * event, GfsSimulation * sim)
+{
+  if ((* GFS_EVENT_CLASS (GTS_OBJECT_CLASS (gfs_variable_curvature_class ())->parent_class)->event)
+      (event, sim)) {
+    GFS_VARIABLE_CURVATURE (event)->a = 1.;
+    variable_curvature_event_half (event, sim);
+    GFS_VARIABLE_CURVATURE (event)->a = GFS_VARIABLE_CURVATURE (event)->theta;
+    return TRUE;
+  }
+  return FALSE;
+}
+
+static void variable_curvature_class_init (GtsObjectClass * klass)
+{
+  klass->read = variable_curvature_read;
+  klass->write = variable_curvature_write;
+  GFS_EVENT_CLASS (klass)->event = variable_curvature_event;
+  GFS_EVENT_CLASS (klass)->event_half = variable_curvature_event_half;
+}
+
+static void variable_curvature_init (GfsVariableCurvature * v)
+{
+  v->sigma = 1.;
+  v->theta = 0.5;
+}
+
+GfsVariableClass * gfs_variable_curvature_class (void)
+{
+  static GfsVariableClass * klass = NULL;
+
+  if (klass == NULL) {
+    GtsObjectClassInfo gfs_variable_curvature_info = {
+      "GfsVariableCurvature",
+      sizeof (GfsVariableCurvature),
+      sizeof (GfsVariableClass),
+      (GtsObjectClassInitFunc) variable_curvature_class_init,
+      (GtsObjectInitFunc) variable_curvature_init,
+      (GtsArgSetFunc) NULL,
+      (GtsArgGetFunc) NULL
+    };
+    klass = gts_object_class_new (GTS_OBJECT_CLASS (gfs_variable_class ()), 
+				  &gfs_variable_curvature_info);
+  }
+
+  return klass;
+}
diff --git a/src/levelset.h b/src/levelset.h
index 43eabd8..ceed8a8 100644
--- a/src/levelset.h
+++ b/src/levelset.h
@@ -48,6 +48,28 @@ struct _GfsVariableLevelSet {
 
 GfsVariableClass * gfs_variable_levelset_class  (void);
 
+/* GfsVariableCurvature: header */
+
+typedef struct _GfsVariableCurvature                GfsVariableCurvature;
+
+struct _GfsVariableCurvature {
+  /*< private >*/
+  GfsVariable parent;
+  gdouble a;
+
+  /*< public >*/
+  GfsVariable * d;
+  gdouble sigma, theta;
+};
+
+#define GFS_VARIABLE_CURVATURE(obj)            GTS_OBJECT_CAST (obj,\
+					           GfsVariableCurvature,\
+					           gfs_variable_curvature_class ())
+#define GFS_IS_VARIABLE_CURVATURE(obj)         (gts_object_is_from_class (obj,\
+					     gfs_variable_curvature_class ()))
+
+GfsVariableClass * gfs_variable_curvature_class  (void);
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/src/tension.c b/src/tension.c
index fade65a..684d870 100644
--- a/src/tension.c
+++ b/src/tension.c
@@ -22,6 +22,7 @@
 
 #include "tension.h"
 #include "vof.h"
+#include "levelset.h"
 
 /* GfsSourceTensionCSS: Object */
 
diff --git a/src/variable.c b/src/variable.c
index eb2f568..47479c8 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -601,60 +601,3 @@ GfsVariableClass * gfs_variable_curvature_class (void)
 
   return klass;
 }
-
-/* GfsDerivedVariable: object */
-
-static void gfs_derived_variable_destroy (GtsObject * object)
-{
-  g_free (GFS_DERIVED_VARIABLE (object)->name);
-  g_free (GFS_DERIVED_VARIABLE (object)->description);
-
-  (* GTS_OBJECT_CLASS (gfs_derived_variable_class ())->parent_class->destroy) (object);
-}
-
-static void gfs_derived_variable_class_init (GtsObjectClass * klass)
-{
-  klass->destroy = gfs_derived_variable_destroy;
-}
-
-GtsObjectClass * gfs_derived_variable_class (void)
-{
-  static GtsObjectClass * klass = NULL;
-
-  if (klass == NULL) {
-    GtsObjectClassInfo gfs_derived_variable_info = {
-      "GfsDerivedVariable",
-      sizeof (GfsDerivedVariable),
-      sizeof (GtsObjectClass),
-      (GtsObjectClassInitFunc) gfs_derived_variable_class_init,
-      (GtsObjectInitFunc) NULL,
-      (GtsArgSetFunc) NULL,
-      (GtsArgGetFunc) NULL
-    };
-    klass = gts_object_class_new (GTS_OBJECT_CLASS (gts_object_class ()), 
-				  &gfs_derived_variable_info);
-  }
-
-  return klass;
-}
-
-/**
- * gfs_derived_variable_from_name:
- * @i: a list of #GfsDerivedVariable.
- * @name: a name.
- *
- * Returns: the #GfsDerivedVariable @name of @list or %NULL.
- */
-GfsDerivedVariable * gfs_derived_variable_from_name (GSList * i, const gchar * name)
-{
-  g_return_val_if_fail (name != NULL, NULL);
-
-  while (i) {
-    GfsDerivedVariable * v = i->data;
-    if (!strcmp (v->name, name))
-      return v;
-    i = i->next;
-  }
-  return NULL;
-}
-
diff --git a/src/variable.h b/src/variable.h
index 1babfee..b999381 100644
--- a/src/variable.h
+++ b/src/variable.h
@@ -153,27 +153,6 @@ struct _GfsVariableCurvature {
 
 GfsVariableClass * gfs_variable_curvature_class  (void);
 
-/* GfsDerivedVariable: Header */
-
-struct _GfsDerivedVariable {
-  /*< private >*/
-  GtsObject parent;
-
-  /*< public >*/
-  gchar * name, * description;
-  gpointer func, data;
-};
-
-#define GFS_DERIVED_VARIABLE(obj)            GTS_OBJECT_CAST (obj,\
-					         GfsDerivedVariable,\
-					         gfs_derived_variable_class ())
-#define GFS_IS_DERIVED_VARIABLE(obj)         (gts_object_is_from_class (obj,\
-						 gfs_derived_variable_class ()))
-
-GtsObjectClass *     gfs_derived_variable_class            (void);
-GfsDerivedVariable * gfs_derived_variable_from_name        (GSList * i, 
-							    const gchar * name);
-
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */

-- 
Gerris Flow Solver



More information about the debian-science-commits mailing list