Changeset 6902 for branches/numpy/anuga/abstract_2d_finite_volumes

Timestamp:

Apr 24, 2009, 5:22:14 PM (16 years ago)

Author:

rwilson

Message:

Back-merge from Numeric trunk to numpy branch.

Location:

branches/numpy/anuga/abstract_2d_finite_volumes

Files:

• domain.py (modified) (5 diffs)
• generic_boundary_conditions.py (modified) (2 diffs)
• mesh_factory.py (modified) (1 diff)
• quantity.py (modified) (1 diff)
• test_domain.py (modified) (3 diffs)

branches/numpy/anuga/abstract_2d_finite_volumes/domain.py

@@ -92 +92 @@
         """
 
+        number_of_full_nodes=None
+        number_of_full_triangles=None
+        
         # Determine whether source is a mesh filename or coordinates
         if type(source) == types.StringType:
@@ -117 +120 @@
 
         # Expose Mesh attributes (FIXME: Maybe turn into methods)
+        self.triangles = self.mesh.triangles        
         self.centroid_coordinates = self.mesh.centroid_coordinates
         self.vertex_coordinates = self.mesh.vertex_coordinates
@@ -205 +209 @@
         # the ghost triangles.
         if not num.allclose(self.tri_full_flag[:self.number_of_full_nodes], 1):
-            print ('WARNING:  '
-                   'Not all full triangles are store before ghost triangles')
+            if self.numproc>1:
+                print ('WARNING:  '
+                       'Not all full triangles are store before ghost triangles')
 
         # Defaults
@@ -306 +311 @@
     def get_normal(self, *args, **kwargs):
         return self.mesh.get_normal(*args, **kwargs)
+    def get_triangle_containing_point(self, *args, **kwargs):
+        return self.mesh.get_triangle_containing_point(*args, **kwargs)
 
     def get_intersecting_segments(self, *args, **kwargs):
@@ -1745 +1752 @@
 
     ##
-    # @brief ??
+    # @brief Sequential update of ghost cells 
     def update_ghosts(self):
-        pass
-
+        # We must send the information from the full cells and
+        # receive the information for the ghost cells
+        # We have a list with ghosts expecting updates
+
+        from Numeric import take,put
+
+
+        #Update of ghost cells
+        iproc = self.processor
+        if self.full_send_dict.has_key(iproc):
+
+            # now store full as local id, global id, value
+            Idf  = self.full_send_dict[iproc][0]
+
+            # now store ghost as local id, global id, value
+            Idg = self.ghost_recv_dict[iproc][0]
+
+            for i, q in enumerate(self.conserved_quantities):
+                Q_cv =  self.quantities[q].centroid_values
+                put(Q_cv,     Idg, take(Q_cv,     Idf))
+
+ 
     ##
     # @brief Extrapolate conserved quantities from centroid to vertices

branches/numpy/anuga/abstract_2d_finite_volumes/generic_boundary_conditions.py

@@ -82 +82 @@
     """Time dependent boundary returns values for the
     conserved quantities as a function of time.
-    Must specify domain to get access to model time and a function f(t)
-    which must return conserved quantities as a function time
+    Must specify domain to get access to model time and a function of t
+    which must return conserved quantities as a function time.
+    
+    Example:
+      B = Time_boundary(domain, 
+                        function=lambda t: [(60<t<3660)*2, 0, 0])
+      
+      This will produce a boundary condition with is a 2m high square wave
+      starting 60 seconds into the simulation and lasting one hour.
+      Momentum applied will be 0 at all times.
+                        
     """
 
@@ -98 +107 @@
         self.verbose = verbose
 
+        
+        # FIXME: Temporary code to deal with both f and function
+        if function is not None and f is not None:
+            raise Exception, 'Specify either function or f to Time_boundary'
+            
+        if function is None and f is None:
+            raise Exception, 'You must specify a function to Time_boundary'
+            
+        if f is None:
+            f = function
+        #####
+        
         try:
             q = f(0.0)

branches/numpy/anuga/abstract_2d_finite_volumes/mesh_factory.py

@@ -201 +201 @@
 
     return points, elements, boundary
+
+
+def rectangular_periodic(m_g, n_g, len1_g=1.0, len2_g=1.0, origin_g = (0.0, 0.0)):
+
+
+    """Setup a rectangular grid of triangles
+    with m+1 by n+1 grid points
+    and side lengths len1, len2. If side lengths are omitted
+    the mesh defaults to the unit square, divided between all the
+    processors
+
+    len1: x direction (left to right)
+    len2: y direction (bottom to top)
+
+    """
+
+    processor = 0
+    numproc   = 1
+
+    
+    n = n_g
+    m_low  = -1
+    m_high = m_g +1
+
+    m = m_high - m_low
+
+    delta1 = float(len1_g)/m_g
+    delta2 = float(len2_g)/n_g
+
+    len1 = len1_g*float(m)/float(m_g)
+    len2 = len2_g
+    origin = ( origin_g[0]+float(m_low)/float(m_g)*len1_g, origin_g[1] )
+
+    #Calculate number of points
+    Np = (m+1)*(n+1)
+
+    class VIndex:
+
+        def __init__(self, n,m):
+            self.n = n
+            self.m = m
+
+        def __call__(self, i,j):
+            return j+i*(self.n+1)
+
+    class EIndex:
+
+        def __init__(self, n,m):
+            self.n = n
+            self.m = m
+
+        def __call__(self, i,j):
+            return 2*(j+i*self.n)
+
+
+    I = VIndex(n,m)
+    E = EIndex(n,m)
+
+    points = num.zeros( (Np,2), num.Float)
+
+    for i in range(m+1):
+        for j in range(n+1):
+
+            points[I(i,j),:] = [i*delta1 + origin[0], j*delta2 + origin[1]]
+
+    #Construct 2 triangles per rectangular element and assign tags to boundary
+    #Calculate number of triangles
+    Nt = 2*m*n
+
+
+    elements = num.zeros( (Nt,3), num.Int)
+    boundary = {}
+    Idgl = []
+    Idfl = []
+    Idgr = []
+    Idfr = []
+
+    full_send_dict = {}
+    ghost_recv_dict = {}
+    nt = -1
+    for i in range(m):
+        for j in range(n):
+
+            i1 = I(i,j+1)
+            i2 = I(i,j)
+            i3 = I(i+1,j+1)
+            i4 = I(i+1,j)
+
+            #Lower Element
+            nt = E(i,j)
+            if i == 0:
+                Idgl.append(nt)
+
+            if i == 1:
+                Idfl.append(nt)
+
+            if i == m-2:
+                Idfr.append(nt)
+
+            if i == m-1:
+                Idgr.append(nt)
+
+            if i == m-1:
+                if processor == numproc-1:
+                    boundary[nt, 2] = 'right'
+                else:
+                    boundary[nt, 2] = 'ghost'
+        
+            if j == 0:
+                boundary[nt, 1] = 'bottom'
+            elements[nt,:] = [i4,i3,i2]
+
+            #Upper Element
+            nt = E(i,j)+1
+            if i == 0:
+                Idgl.append(nt)
+
+            if i == 1:
+                Idfl.append(nt)
+
+            if i == m-2:
+                Idfr.append(nt)
+
+            if i == m-1:
+                Idgr.append(nt)
+
+            if i == 0:
+                if processor == 0:
+                    boundary[nt, 2] = 'left'
+                else:
+                    boundary[nt, 2] = 'ghost'
+            if j == n-1:
+                boundary[nt, 1] = 'top'
+            elements[nt,:] = [i1,i2,i3]
+
+    Idfl.extend(Idfr)
+    Idgr.extend(Idgl)
+
+    Idfl = num.array(Idfl, num.Int)
+    Idgr = num.array(Idgr, num.Int)
+    
+    full_send_dict[processor]  = [Idfl, Idfl]
+    ghost_recv_dict[processor] = [Idgr, Idgr]
+
+
+    return  points, elements, boundary, full_send_dict, ghost_recv_dict
+
 
 def oblique(m, n, lenx = 1.0, leny = 1.0, theta = 8.95, origin = (0.0, 0.0)):

branches/numpy/anuga/abstract_2d_finite_volumes/quantity.py

@@ -1178 +1178 @@
         # Edges have already been deprecated in set_values, see changeset:5521,
         # but *might* be useful in get_values. Any thoughts anyone?
+        # YES (Ole): Edge values are necessary for volumetric balance check
 
         if location not in ['vertices', 'centroids',

branches/numpy/anuga/abstract_2d_finite_volumes/test_domain.py

@@ -397 +397 @@
                                       
     def test_setting_timestepping_method(self):
-        """test_set_quanitities_to_be_monitored
+        """test_setting_timestepping_method
         """
 
@@ -803 +803 @@
                              [ 11.0,  11.0,  11.0]])
                              
+    def test_rectangular_periodic_and_ghosts(self):
+
+        from mesh_factory import rectangular_periodic
+        
+
+        M=5
+        N=2
+        points, vertices, boundary, full_send_dict, ghost_recv_dict = rectangular_periodic(M, N)
+
+        assert num.allclose(ghost_recv_dict[0][0], [24, 25, 26, 27,  0,  1,  2,  3])
+        assert num.allclose(full_send_dict[0][0] , [ 4,  5,  6,  7, 20, 21, 22, 23])
+
+        #print 'HERE'
+        
+        conserved_quantities = ['quant1', 'quant2']
+        domain = Domain(points, vertices, boundary, conserved_quantities,
+                        full_send_dict=full_send_dict,
+                        ghost_recv_dict=ghost_recv_dict)
+
+
+
+
+        assert num.allclose(ghost_recv_dict[0][0], [24, 25, 26, 27,  0,  1,  2,  3])
+        assert num.allclose(full_send_dict[0][0] , [ 4,  5,  6,  7, 20, 21, 22, 23])
+
+        def xylocation(x,y):
+            return 15*x + 9*y
+
+        
+        domain.set_quantity('quant1',xylocation,location='centroids')
+        domain.set_quantity('quant2',xylocation,location='centroids')
+
+
+        assert num.allclose(domain.quantities['quant1'].centroid_values,
+                            [  0.5,   1.,   5.,    5.5,   3.5,   4.,    8.,    8.5,   6.5,  7.,   11.,   11.5,   9.5,
+                               10.,   14.,   14.5,  12.5,  13.,   17.,   17.5,  15.5,  16.,   20.,   20.5,
+                               18.5,  19.,   23.,   23.5])
+
+
+
+        assert num.allclose(domain.quantities['quant2'].centroid_values,
+                            [  0.5,   1.,   5.,    5.5,   3.5,   4.,    8.,    8.5,   6.5,  7.,   11.,   11.5,   9.5,
+                               10.,   14.,   14.5,  12.5,  13.,   17.,   17.5,  15.5,  16.,   20.,   20.5,
+                               18.5,  19.,   23.,   23.5])
+
+        domain.update_ghosts()
+
+
+        assert num.allclose(domain.quantities['quant1'].centroid_values,
+                            [  15.5,  16.,   20.,   20.5,   3.5,   4.,    8.,    8.5,   6.5,  7.,   11.,   11.5,   9.5,
+                               10.,   14.,   14.5,  12.5,  13.,   17.,   17.5,  15.5,  16.,   20.,   20.5,
+                                3.5,   4.,    8.,    8.5])
+
+
+
+        assert num.allclose(domain.quantities['quant2'].centroid_values,
+                            [  15.5,  16.,   20.,   20.5,   3.5,   4.,    8.,    8.5,   6.5,  7.,   11.,   11.5,   9.5,
+                               10.,   14.,   14.5,  12.5,  13.,   17.,   17.5,  15.5,  16.,   20.,   20.5,
+                                3.5,   4.,    8.,    8.5])
+
+        
+        assert num.allclose(domain.tri_full_flag, [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+                                                   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0])
+
+        #Test that points are arranged in a counter clock wise order
+        domain.check_integrity()
+
+
     def test_that_mesh_methods_exist(self):
         """test_that_mesh_methods_exist
@@ -828 +896 @@
         domain.get_number_of_nodes()
         domain.get_normal(0,0)
+        domain.get_triangle_containing_point([0.4,0.5])
         domain.get_intersecting_segments([[0.0, 0.0], [0.0, 1.0]])
         domain.get_disconnected_triangles()