Changeset 5563 for anuga_work/development/anuga_1d/comp_flux_ext.c

Timestamp:

Jul 23, 2008, 4:38:10 PM (16 years ago)

Author:

steve

Message:

Working version of comp_flux_ext

File:

• anuga_work/development/anuga_1d/comp_flux_ext.c (modified) (5 diffs)

anuga_work/development/anuga_1d/comp_flux_ext.c

@@ -5 +5 @@
 const double pi = 3.14159265358979;
 
-double max(double a, double b) {
-        double z;
-        z=(a>b)?a:b;
-        return z;}
-        
-double min(double a, double b) {
-        double z;
-        z=(a<b)?a:b;
-        return z;}
+// Shared code snippets
+#include "util_ext.h"
+
+
+/* double max(double a, double b) { */
+/*      double z; */
+/*      z=(a>b)?a:b; */
+/*      return z;} */
+        
+/* double min(double a, double b) { */
+/*      double z; */
+/*      z=(a<b)?a:b; */
+/*      return z;} */
         
 
@@ -154 +158 @@
                                 
                                 normal = normals[ki];
-                                _flux_function(ql, qr, zl, zr, normal, g, epsilon, flux, &max_speed);
+                                _flux_function(ql, qr, zl, zr, normal, g, epsilon, edgeflux, &max_speed);
                                 flux[0] -= edgeflux[0];
                                 flux[1] -= edgeflux[1];
@@ -189 +193 @@
 //=========================================================================
 PyObject *compute_fluxes_ext(PyObject *self, PyObject *args) {
-  PyArrayObject *neighbours, 
+  
+    PyArrayObject 
+        *neighbours, 
         *neighbour_vertices,
-    *normals, 
+        *normals, 
         *areas,
-    *stage_edge_values,
-    *xmom_edge_values,
-    *bed_edge_values,
-    *stage_boundary_values,
-    *xmom_boundary_values,
+        *stage_edge_values,
+        *xmom_edge_values,
+        *bed_edge_values,
+        *stage_boundary_values,
+        *xmom_boundary_values,
         *stage_explicit_update,
         *xmom_explicit_update,
@@ -231 +237 @@
   // the explicit update arrays 
   timestep = _compute_fluxes_ext(timestep,
-                                     epsilon,
-                                     g,
-                                     (long*) neighbours -> data,
-                                     (long*) neighbour_vertices -> data,
-                                     (double*) normals -> data,
-                                     (double*) areas -> data,
-                                     (double*) stage_edge_values -> data,
-                                     (double*) xmom_edge_values -> data,
-                                     (double*) bed_edge_values -> data,
-                                     (double*) stage_boundary_values -> data,
-                                     (double*) xmom_boundary_values -> data,
-                                         (double*) stage_explicit_update -> data,
-                                         (double*) xmom_explicit_update -> data,
-                                         number_of_elements,
-                                         (double*) max_speed_array -> data);
+                                 epsilon,
+                                 g,
+                                 (long*) neighbours -> data,
+                                 (long*) neighbour_vertices -> data,
+                                 (double*) normals -> data,
+                                 (double*) areas -> data,
+                                 (double*) stage_edge_values -> data,
+                                 (double*) xmom_edge_values -> data,
+                                 (double*) bed_edge_values -> data,
+                                 (double*) stage_boundary_values -> data,
+                                 (double*) xmom_boundary_values -> data,
+                                 (double*) stage_explicit_update -> data,
+                                 (double*) xmom_explicit_update -> data,
+                                 number_of_elements,
+                                 (double*) max_speed_array -> data);
+
   // Return updated flux timestep
   return Py_BuildValue("d", timestep);
 }
 
+
+PyObject *compute_fluxes_ext_short(PyObject *self, PyObject *args) {
+  
+   PyObject 
+        *domain,
+        *stage, 
+        *xmom, 
+        *bed;
+
+    PyArrayObject 
+        *neighbours, 
+        *neighbour_vertices,
+        *normals, 
+        *areas,
+        *stage_vertex_values,
+        *xmom_vertex_values,
+        *bed_vertex_values,
+        *stage_boundary_values,
+        *xmom_boundary_values,
+        *stage_explicit_update,
+        *xmom_explicit_update,
+        *max_speed_array;
+    
+  double timestep, epsilon, g;
+  int number_of_elements;
+
+    
+  // Convert Python arguments to C
+  if (!PyArg_ParseTuple(args, "dOOOO",
+                        &timestep,
+                        &domain,
+                        &stage,
+                        &xmom,
+                        &bed)) {
+      PyErr_SetString(PyExc_RuntimeError, "comp_flux_ext.c: compute_fluxes_ext_short could not parse input");
+      return NULL;
+  }
+
+
+    epsilon           = get_python_double(domain,"epsilon");
+    g                 = get_python_double(domain,"g");
+ 
+    
+    neighbours        = get_consecutive_array(domain, "neighbours");
+    neighbour_vertices= get_consecutive_array(domain, "neighbour_vertices"); 
+    normals           = get_consecutive_array(domain, "normals");
+    areas             = get_consecutive_array(domain, "areas");    
+    max_speed_array   = get_consecutive_array(domain, "max_speed_array");
+    
+    stage_vertex_values = get_consecutive_array(stage, "vertex_values");    
+    xmom_vertex_values  = get_consecutive_array(xmom, "vertex_values");    
+    bed_vertex_values   = get_consecutive_array(bed, "vertex_values");    
+
+    stage_boundary_values = get_consecutive_array(stage, "boundary_values");    
+    xmom_boundary_values  = get_consecutive_array(xmom, "boundary_values");    
+
+
+    stage_explicit_update = get_consecutive_array(stage, "explicit_update");    
+    xmom_explicit_update  = get_consecutive_array(xmom, "explicit_update");    
+
+
+
+    number_of_elements = stage_vertex_values -> dimensions[0];
+
+
+ 
+    // Call underlying flux computation routine and update 
+    // the explicit update arrays 
+    timestep = _compute_fluxes_ext(timestep,
+                                 epsilon,
+                                 g,
+                                 (long*) neighbours -> data,
+                                 (long*) neighbour_vertices -> data,
+                                 (double*) normals -> data,
+                                 (double*) areas -> data,
+                                 (double*) stage_vertex_values -> data,
+                                 (double*) xmom_vertex_values -> data,
+                                 (double*) bed_vertex_values -> data,
+                                 (double*) stage_boundary_values -> data,
+                                 (double*) xmom_boundary_values -> data,
+                                 (double*) stage_explicit_update -> data,
+                                 (double*) xmom_explicit_update -> data,
+                                 number_of_elements,
+                                 (double*) max_speed_array -> data);
+
+
+  Py_DECREF(neighbours);
+  Py_DECREF(neighbour_vertices);
+  Py_DECREF(normals);
+  Py_DECREF(areas);
+  Py_DECREF(stage_vertex_values);
+  Py_DECREF(xmom_vertex_values);
+  Py_DECREF(bed_vertex_values);
+  Py_DECREF(stage_boundary_values);
+  Py_DECREF(xmom_boundary_values);
+  Py_DECREF(stage_explicit_update);
+  Py_DECREF(xmom_explicit_update);
+  Py_DECREF(max_speed_array);
+
+
+
+
+  // Return updated flux timestep
+  return Py_BuildValue("d", timestep);
+}
+
  
 
@@ -259 +372 @@
 static struct PyMethodDef MethodTable[] = {
   {"compute_fluxes_ext", compute_fluxes_ext, METH_VARARGS, "Print out"},
+  {"compute_fluxes_ext_short", compute_fluxes_ext_short, METH_VARARGS, "Print out"},
   {NULL, NULL}
 };