Changeset 4975

Timestamp:

Jan 25, 2008, 5:37:46 PM (17 years ago)

Author:

steve

Message:

Seems to be touble passing back the f2py array back to python. Will hand code teh interface.

Location:

anuga_core/source/anuga/advection

Files:

• advection.py (modified) (3 diffs)
• advection_ext.c (modified) (4 diffs)
• advection_ext.pyf (modified) (1 diff)

anuga_core/source/anuga/advection/advection.py

@@ -232 +232 @@
         from anuga.config import max_timestep
 
-        N = len(self)
+        ntri = len(self)
 
         timestep = max_timestep
@@ -256 +256 @@
         v = self.velocity
 
+        nbdry = len(stage_bdry)
+
         from advection_ext import compute_fluxes
 
-
-        #print 'N = ',N
-        #print 'timestep = ',timestep
-        #print 'huge_timestep = ',huge_timestep
+        print "stage_update",stage_update
+        print "stage_edge",stage_edge
+        print "stage_bdry",stage_bdry
+        print "neighbours",neighbours
+        print "neighbour_edges",neighbour_edges
+        print "normals",normals
+        print "areas",areas
+        print "radii",radii
+        print "edgelengths",edgelengths
+        print "tri_full_flag",tri_full_flag
+        print "huge_timestep",huge_timestep
+        print "max_timestep",max_timestep
+        print "v",v
+        print "ntri",ntri
+        print "nbdry",nbdry
+
+
                 
         timestep = compute_fluxes(stage_update,stage_edge,stage_bdry,
@@ -267 +282 @@
                                   areas,radii,edgelengths,
                                   tri_full_flag,
-                                  huge_timestep,max_timestep,v,N)
+                                  huge_timestep,max_timestep,v,ntri,nbdry)
+
+        print "stage_update",stage_update        
         
         #print 'timestep out2 =',timestep

anuga_core/source/anuga/advection/advection_ext.c

@@ -1 +1 @@
 #include "math.h"
 #include "stdio.h"
+
+void  print_double_array(char* name, double* array, int n, int m){
+
+    int k,i,km;
+
+    printf("%s = [",name);
+    for (k=0; k<n; k++){
+        km = m*k;
+        printf("[");
+        for (i=0; i<m ; i++){
+            printf("%g ",array[km+i]);
+        }
+        if (k==(n-1))
+            printf("]");
+        else
+            printf("]\n");
+    }
+    printf("]\n");
+}
+
+void  print_int_array(char* name, int* array, int n, int m){
+
+    int k,i,km;
+
+    printf("%s = [",name);
+    for (k=0; k<n; k++){
+        km = m*k;
+        printf("[");
+        for (i=0; i<m ; i++){
+            printf("%i ",array[km+i]);
+        }
+        if (k==(n-1))
+            printf("]");
+        else
+            printf("]\n");
+    }
+    printf("]\n");
+}
+
 
 double compute_fluxes(
@@ -12 +51 @@
                     double* radii,
                     double* edgelengths,
-                    int*    tri_full_flag,
+                    int*   tri_full_flag,
                     double  huge_timestep,
                     double  max_timestep,
                     double* v,
-                    int N){
+                    int ntri,
+                    int nbdry){
         //Loop
 
@@ -26 +66 @@
         double optimal_timestep;
         double timestep;
-        int k_i,n_m,k_i_j;
+        int  k_i,n_m,k_i_j;
         int k,i,j,n,m;
+        int k3;
         
         timestep = max_timestep;
 
-        //printf("N = %i\n",N);
-        //printf("timestep = %g\n",timestep);
-        //printf("huge_timestep = %g\n",huge_timestep);
 
-        for (k=0; k<N; k++){
+        printf("======================================================\n");
+        printf("INSIDE compute_fluxes\n");
+
+
+        print_double_array( "stage_update",stage_update, ntri, 1);
+        print_double_array( "stage_edge",stage_edge, ntri, 3);
+        print_double_array( "stage_bdry",stage_bdry, nbdry, 1);
+        print_int_array( "neighbours",neighbours, ntri, 3);
+        print_int_array( "neighbour_edges",neighbour_edges, ntri, 3);
+        print_double_array( "normals",normals, ntri, 6);
+        print_double_array( "areas",areas, ntri, 1);
+        print_double_array( "radii",radii, ntri, 1);
+        print_double_array( "edgelengths",edgelengths, ntri, 3);
+        print_int_array( "tri_full_flag",tri_full_flag, ntri, 1);
+        printf("huge_timestep = %g\n",huge_timestep);
+        printf("max_timestep = %g\n",max_timestep);
+        print_double_array( "v",v, 2, 1);
+        printf("ntri = %i\n",ntri);
+        printf("nbdry = %i\n",nbdry);
+
+
+        for (k=0; k<ntri; k++){
             optimal_timestep = huge_timestep;
-            flux = 0.0; 
+            flux = 0.0;
+            k3 = 3*k;
             for (i=0; i<3; i++){
-                k_i = 3*k+i;
+                k_i = k3+i;
                 //Quantities inside volume facing neighbour i
                 ql = stage_edge[k_i];
-                //printf("stage_edge[%i] = %g\n",k_i,stage_edge[k_i]);
+
 
                 //Quantities at neighbour on nearest face
@@ -94 +154 @@
         //printf("timestep out = %g\n",timestep);
 
+
+
+        printf("INSIDE compute_fluxes, end \n");
+
+        print_double_array( "stage_update",stage_update, ntri, 1);
+
+        printf("FINISHED compute_fluxes\n");
+        printf("======================================================\n");
+
+
         return timestep;
 }

anuga_core/source/anuga/advection/advection_ext.pyf

@@ -3 +3 @@
 python module advection_ext
 interface
-        double precision function compute_fluxes(stage_update,stage_edge,stage_bdry,&
+        function compute_fluxes(stage_update,stage_edge,stage_bdry,&
                         neighbours,neighbour_edges,&
                         normals,areas,radii,edgelengths,&
-                        tri_full_flag,huge_timestep,max_timestep,v,n)
+                        tri_full_flag,huge_timestep,max_timestep,v,n,nbdry)
                 intent(c) compute_fluxes
-                intent(c)
+                double precision compute_fluxes
 
-                double precision dimension(n) ::      stage_update,     
-                double precision dimension(3,n) ::    stage_edge
-                double precision dimension(3,n) ::    stage_bdry,
-                integer dimension(3,n) ::             neighbours,
-                integer dimension(3,n) ::             neighbour_edges,
-                double precision dimension(6,n) ::    normals
-                double precision dimension(n) ::      areas
-                double precision dimension(n) ::      radii
-                double precision dimension(3,n) ::    edgelengths
-                integer dimension(n) ::               tri_full_flag
-                double precision   ::                 huge_timestep
-                double precision   ::                 max_timestep
-                double precision dimension(2) ::      v
-                integer  ::                           n
+                double precision stage_update(n)        
+                intent(in,out)    stage_update
+                intent(c)         stage_update  
+                double precision stage_edge(n,3)
+                double precision stage_bdry(nbdry)
+                integer           neighbours(n,3)
+                integer           neighbour_edges(n,3)
+                double precision normals(n,6)
+                double precision areas(n)
+                double precision radii(n)
+                double precision edgelengths(n,3)
+                integer          tri_full_flag(n)
+                double precision huge_timestep, max_timestep
+                intent(c)        huge_timestep, max_timestep
+                double precision v(2)
+                integer          n, nbdry
+                intent(c)        n, nbdry
+
 
         end function compute_fluxes