[SCM] Gerris Flow Solver branch, upstream, updated. b3aa46814a06c9cb2912790b23916ffb44f1f203
Cédric Pénard
cedric.penard at ifremer.fr
Fri May 15 02:54:04 UTC 2009
The following commit has been merged in the upstream branch:
commit c5c605605b98c00bb7d3a73c7eec6bc4468c0bfc
Author: Cédric Pénard <cedric.penard at ifremer.fr>
Date: Tue Mar 13 12:01:28 2007 +1100
New object GfsCartesianGrid
darcs-hash:20070313010128-85b74-9c54d39b154f1e0c6bba609c408a522d3da7166d.gz
diff --git a/src/Makefile.am b/src/Makefile.am
index 0654a04..773a117 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -51,8 +51,6 @@ GFS_HDS = \
vof.h \
utils.h \
ocean.h \
- levelset.h \
- isocube.h \
$(MPI_HDS)
pkginclude_HEADERS = \
@@ -85,9 +83,6 @@ SRC = \
vof.c \
utils.c \
ocean.c \
- levelset.c \
- myc.h \
- myc2d.h \
$(GFS_HDS)
libgfs3D_la_LDFLAGS = $(NO_UNDEFINED)\
diff --git a/src/cartesian.c b/src/cartesian.c
new file mode 100644
index 0000000..4f407f0
--- /dev/null
+++ b/src/cartesian.c
@@ -0,0 +1,226 @@
+#include <stdlib.h>
+#include "cartesian.h"
+
+/* GfsCartesianGrid: Object */
+
+static void gfs_cartesian_grid_read (GtsObject ** o, GtsFile * fp)
+{
+ GfsCartesianGrid * cgd = GFS_CARTESIAN_GRID (*o);
+ guint i, j, taille = 1, taille2 = 0;
+
+ /* call read method of parent */
+ if (GTS_OBJECT_CLASS (gfs_cartesian_grid_class ())->parent_class->read)
+ (* GTS_OBJECT_CLASS (gfs_cartesian_grid_class ())->parent_class->read)
+ (o, fp);
+ if (fp->type == GTS_ERROR)
+ return;
+
+ /* do object-specific read here */
+ if (fp->type == '\n')
+ gts_file_next_token (fp);
+ if (fp->type != GTS_INT) {
+ gts_file_error (fp, "expecting an integer (N)");
+ return;
+ }
+ cgd->N = atoi(fp->token->str);
+ gts_file_next_token (fp);
+
+ cgd->n = g_malloc(cgd->N*sizeof(guint));
+
+ for (i=0;i<cgd->N;i++) {
+ if (fp->type == '\n')
+ gts_file_next_token (fp);
+ if (fp->type != GTS_INT) {
+ gts_file_error (fp, "expecting an integer (n[%d])", i);
+ return;
+ }
+
+ cgd->n[i]=atoi(fp->token->str);
+ gts_file_next_token (fp);
+ taille *= cgd->n[i];
+ taille2 += cgd->n[i];
+ }
+
+ cgd->x = g_malloc(cgd->N*sizeof(gint));
+
+ for (i=0;i<cgd->N;i++) {
+ cgd->x[i] = g_malloc(cgd->n[i]*sizeof(gdouble));
+ for (j=0;j<cgd->n[i];j++) {
+ if (fp->type == '\n')
+ gts_file_next_token (fp);
+ if (fp->type != GTS_FLOAT && fp->type != GTS_INT) {
+ gts_file_error (fp, "expecting a double or integer (x[%d][%d])",i,j);
+ return;
+ }
+ cgd->x[i][j]=atof(fp->token->str);
+ gts_file_next_token (fp);
+ }
+ }
+
+ cgd->v = g_malloc(taille*sizeof(gdouble));
+
+ for (i=0;i<taille;i++) {
+ if (fp->type == '\n')
+ gts_file_next_token (fp);
+ if (fp->type != GTS_FLOAT && fp->type != GTS_INT) {
+ gts_file_error (fp, "expecting a double");
+ return;
+ }
+ cgd->v[i] = atof(fp->token->str);
+ gts_file_next_token (fp);
+ }
+}
+
+static void gfs_cartesian_grid_write (GtsObject * o, FILE * fp)
+{
+ GfsCartesianGrid * cgd = GFS_CARTESIAN_GRID (o);
+ guint i,j, taille = 1, taille2=0;
+ /* call write method of parent */
+ if (GTS_OBJECT_CLASS (gfs_cartesian_grid_class ())->parent_class->write)
+ (* GTS_OBJECT_CLASS (gfs_cartesian_grid_class ())->parent_class->write)
+ (o, fp);
+
+ /* do object specific write here */
+
+ for (i=0;i<cgd->N;i++) {
+ taille *= cgd->n[i];
+ taille2 += cgd->n[i];
+ }
+
+ fprintf (fp,"%d\n",cgd->N);
+ for (i=0;i<cgd->N;i++)
+ fprintf (fp,"%d\n",cgd->n[i]);
+
+ for (i=0;i<cgd->N;i++) {
+ for (j=0;j<cgd->n[i];j++) {
+ fprintf (fp,"%f\n",cgd->x[i][j]);
+ }
+ }
+
+ for (i=0;i<taille;i++)
+ fprintf (fp,"%f\n", cgd->v[i]);
+}
+
+static void gfs_cartesian_grid_destroy (GtsObject * object)
+{
+ /* do object-specific cleanup here */
+ GfsCartesianGrid * cgd = GFS_CARTESIAN_GRID (object);
+
+ g_free (cgd->n);
+ g_free (cgd->x);
+ g_free (cgd->v);
+
+ /* do not forget to call destroy method of the parent */
+ (* GTS_OBJECT_CLASS (gfs_cartesian_grid_class ())->parent_class->destroy)
+ (object);
+}
+
+static void gfs_cartesian_grid_class_init (GtsObjectClass * klass)
+{
+ /* define new methods and overload inherited methods here */
+
+ GTS_OBJECT_CLASS (klass)->read = gfs_cartesian_grid_read;
+ GTS_OBJECT_CLASS (klass)->write = gfs_cartesian_grid_write;
+ GTS_OBJECT_CLASS (klass)->destroy = gfs_cartesian_grid_destroy;
+}
+
+GtsObjectClass * gfs_cartesian_grid_class (void)
+{
+ static GtsObjectClass * klass = NULL;
+
+ if (klass == NULL) {
+ GtsObjectClassInfo gfs_cartesian_grid_info = {
+ "GfsCartesianGrid",
+ sizeof (GfsCartesianGrid),
+ sizeof (GtsObjectClass),
+ (GtsObjectClassInitFunc) gfs_cartesian_grid_class_init,
+ (GtsObjectInitFunc) NULL,
+ (GtsArgSetFunc) NULL,
+ (GtsArgGetFunc) NULL
+ };
+ klass = gts_object_class_new (GTS_OBJECT_CLASS (gts_object_class ()),
+ &gfs_cartesian_grid_info);
+ }
+
+ return klass;
+}
+
+GfsCartesianGrid * gfs_cartesian_grid_new (GtsObjectClass * klass)
+{
+ GfsCartesianGrid * object;
+
+ object = GFS_CARTESIAN_GRID (gts_object_new (GTS_OBJECT_CLASS (klass)));
+
+ return object;
+}
+
+
+
+static void slice (GfsCartesianGrid * g, guint p, GfsCartesianGrid * s)
+{
+ s->N = g->N - 1;
+ s->n = &g->n[1];
+ s->x = &g->x[1];
+ guint i;
+ gulong size = 1;
+ for (i = 1; i < g->N; i++)
+ size *= g->n[i];
+ s->v = &g->v[size*p];
+}
+
+static gint lookup (GfsCartesianGrid * g, gdouble x)
+{
+ guint min = 0, max = g->n[0] - 1;
+ if (x < g->x[0][min] || x > g->x[0][max])
+ return -1;
+ while (max > min + 1) {
+ guint n = (min + max)/2;
+ if (x > g->x[0][n])
+ min = n;
+ else
+ max = n;
+ }
+ return min;
+}
+
+/**
+ * gfs_cartesian_grid_interpolate:
+ * @g: a Cartesian grid.
+ * @p: a position vector of dimension @g->N.
+ * @val: the interpolated value at position @p.
+ *
+ * Returns: %TRUE if @val has been computed, %FALSE if @p is not
+ * contained within @g.
+ */
+gboolean gfs_cartesian_grid_interpolate (GfsCartesianGrid * g, gdouble * p, gdouble * val)
+{
+ g_return_val_if_fail (g != NULL, 0.);
+ g_return_val_if_fail (g->N > 0, 0.);
+ g_return_val_if_fail (p != NULL, 0.);
+
+
+
+ gint i = lookup (g, p[0]);
+
+
+ if (i < 0)
+ return FALSE;
+ gdouble v1, v2;
+ if (g->N > 1) {
+ GfsCartesianGrid g1;
+ slice (g, i, &g1);
+ if (!gfs_cartesian_grid_interpolate (&g1, &p[1], &v1))
+ return FALSE;
+ slice (g, i + 1, &g1);
+ if (!gfs_cartesian_grid_interpolate (&g1, &p[1], &v2))
+ return FALSE;
+ }
+ else {
+ v1 = g->v[i];
+ v2 = g->v[i + 1];
+ }
+
+ g_assert (g->x[0][i + 1] - g->x[0][i] != 0.);
+ *val = v1 + (v2 - v1)*(p[0] - g->x[0][i])/(g->x[0][i + 1] - g->x[0][i]);
+ return TRUE;
+}
diff --git a/src/cartesian.h b/src/cartesian.h
new file mode 100644
index 0000000..d91f6ce
--- /dev/null
+++ b/src/cartesian.h
@@ -0,0 +1,27 @@
+/* GfsCartesianGrid: Header */
+
+#include <gts.h>
+
+typedef struct _GfsCartesianGrid GfsCartesianGrid;
+
+struct _GfsCartesianGrid {
+ /*< private >*/
+ GtsObject parent;
+ guint N; // Number of dimension
+ guint * n; // Size of each dimension
+ gdouble ** x; // Position of each point in the grid
+ gdouble * v; // Data
+
+ /*< public >*/
+ /* add extra data here (if public) */
+};
+
+#define GFS_CARTESIAN_GRID(obj) GTS_OBJECT_CAST (obj,\
+ GfsCartesianGrid,\
+ gfs_cartesian_grid_class ())
+#define GFS_IS_CARTESIAN_GRID(obj) (gts_object_is_from_class (obj,\
+ gfs_cartesian_grid_class ()))
+
+GtsObjectClass * gfs_cartesian_grid_class (void);
+GfsCartesianGrid * gfs_cartesian_grid_new (GtsObjectClass * klass);
+gboolean gfs_cartesian_grid_interpolate (GfsCartesianGrid * g, gdouble * p, gdouble * val);
diff --git a/src/gfs.h b/src/gfs.h
index 50ec390..fc71186 100644
--- a/src/gfs.h
+++ b/src/gfs.h
@@ -37,5 +37,6 @@
#include <gerris/adaptive.h>
#include <gerris/source.h>
#include <gerris/vof.h>
+#include <gerris/cartesian.h>
#endif /* GFS_H */
--
Gerris Flow Solver
More information about the debian-science-commits
mailing list