Changeset 6045

Timestamp:

Dec 5, 2008, 11:35:49 AM (16 years ago)

Author:

ole

Message:

Implemented, tested and documunted new boundary condition:

Transmissive_stage_zero_momentum_boundary

Renamed two others according to style guide but retained backward compatibility

Location:

anuga_core

Files:

• documentation/user_manual/anuga_user_manual.tex (modified) (2 diffs)
• source/anuga/shallow_water/__init__.py (modified) (1 diff)
• source/anuga/shallow_water/shallow_water_domain.py (modified) (6 diffs)
• source/anuga/shallow_water/test_shallow_water_domain.py (modified) (1 diff)

anuga_core/documentation/user_manual/anuga_user_manual.tex

@@ -2316 +2316 @@
 
 %%%
-\begin{classdesc}{Transmissive\_Momentum\_Set\_Stage\_boundary}{Boundary}
+%\begin{classdesc}{Transmissive\_Momentum\_Set\_Stage\_boundary}{Boundary}
+\begin{classdesc}{Transmissive\_momentum\_set\_stage\_boundary}{Boundary}
 Module: \module{shallow\_water}
 \label{pg: transmissive momentum set stage boundary}
@@ -2335 +2336 @@
 
 
-\begin{classdesc}{Dirichlet\_Discharge\_boundary}{Boundary}
+\begin{classdesc}{Transmissive\_stage\_zero\_momentum\_boundary}{Boundary}
+Module: \module{shallow\_water}
+\label{pg: transmissive stage zero momentum boundary}
+
+This boundary returns same stage conserved quantities as
+those present in its neighbour volume but sets momentum to zero.
+The underlying domain must be specified when boundary is instantiated
+
+This type of boundary is useful when stage is known at the boundary as a
+function of time, but momentum should be set to zero. This is for example the case where a boundary is needed in the ocean on the two sides perpendicular to the coast to maintain the wave height of the incoming wave.
+
+This class is specific to the shallow water equation as it works with the
+momentum quantities assumed to be the second and third conserved quantities.
+
+This boundary condition should not cause the numerical instabilities seen with the transmissive momentum 
+boundary conditions (see Page \pageref{pg: transmissive boundary} and Page \pageref{pg: transmissive momentum set stage boundary}).
+
+\end{classdesc}
+
+
+\begin{classdesc}{Dirichlet\_discharge\_boundary}{Boundary}
 Module: \module{shallow\_water}
 

anuga_core/source/anuga/shallow_water/__init__.py

@@ -10 +10 @@
     Transmissive_boundary, Reflective_boundary,\
     Dirichlet_boundary, Time_boundary, File_boundary,\
-    Transmissive_Momentum_Set_Stage_boundary,\
-    Dirichlet_Discharge_boundary,\
+    Transmissive_momentum_set_stage_boundary,\
+    Dirichlet_discharge_boundary,\
     Field_boundary
 
 
+# FIXME (Ole): Deprecate
+from shallow_water_domain import Transmissive_Momentum_Set_Stage_boundary
+from shallow_water_domain import Dirichlet_Discharge_boundary
+ 

anuga_core/source/anuga/shallow_water/shallow_water_domain.py

@@ -1108 +1108 @@
 
 
-class Transmissive_Momentum_Set_Stage_boundary(Boundary):
+
+class Transmissive_momentum_set_stage_boundary(Boundary):
     """Returns same momentum conserved quantities as
     those present in its neighbour volume.
@@ -1119 +1120 @@
         return sea_level + normalized_amplitude/cosh(t-25)**2
 
-    Bts = Transmissive_Momentum_Set_Stage_boundary(domain, waveform)
+    Bts = Transmissive_momentum_set_stage_boundary(domain, waveform)
     
 
@@ -1140 +1141 @@
 
     def __repr__(self):
-        return 'Transmissive_Momentum_Set_Stage_boundary(%s)' %self.domain
+        return 'Transmissive_momentum_set_stage_boundary(%s)' %self.domain
 
     def evaluate(self, vol_id, edge_id):
-        """Transmissive Momentum Set Stage boundaries return the edge momentum
+        """Transmissive momentum set stage boundaries return the edge momentum
         values of the volume they serve.
         """
@@ -1182 +1183 @@
 
 
-
-class Dirichlet_Discharge_boundary(Boundary):
+# Backward compatibility        
+# FIXME(Ole): Deprecate
+class Transmissive_Momentum_Set_Stage_boundary(Transmissive_momentum_set_stage_boundary):
+    pass
+
+     
+
+class Transmissive_stage_zero_momentum_boundary(Boundary):
+    """Return same stage as those present in its neighbour volume. Set momentum to zero.
+
+    Underlying domain must be specified when boundary is instantiated
+    """
+
+    def __init__(self, domain=None):
+        Boundary.__init__(self)
+
+        if domain is None:
+            msg = 'Domain must be specified for '
+            msg += 'Transmissive_stage_zero_momentum boundary'
+            raise Exception, msg
+
+        self.domain = domain
+
+    def __repr__(self):
+        return 'Transmissive_stage_zero_momentum_boundary(%s)' %self.domain
+
+    def evaluate(self, vol_id, edge_id):
+        """Transmissive boundaries return the edge values
+        of the volume they serve.
+        """
+
+        q = self.domain.get_conserved_quantities(vol_id, edge=edge_id)
+        
+        q[1] = q[2] = 0.0
+        return q
+
+
+        
+class Dirichlet_discharge_boundary(Boundary):
     """
     Sets stage (stage0)
@@ -1191 +1229 @@
     """
 
-    def __init__(self, domain = None, stage0=None, wh0=None):
+    def __init__(self, domain=None, stage0=None, wh0=None):
         Boundary.__init__(self)
 
@@ -1229 +1267 @@
 
 
+        
+# Backward compatibility        
+# FIXME(Ole): Deprecate
+class Dirichlet_Discharge_boundary(Dirichlet_discharge_boundary):
+    pass
+                                                   
+    
+
+        
+        
 class Field_boundary(Boundary):
     """Set boundary from given field represented in an sww file containing values

anuga_core/source/anuga/shallow_water/test_shallow_water_domain.py

@@ -558 +558 @@
 
         
-        
+
+        
+    def test_boundary_conditionsIII(self):
+        """test_boundary_conditionsIII
+        
+        Test Transmissive_stage_zero_momentum_boundary
+        """
+        
+        a = [0.0, 0.0]
+        b = [0.0, 2.0]
+        c = [2.0,0.0]
+        d = [0.0, 4.0]
+        e = [2.0, 2.0]
+        f = [4.0,0.0]
+
+        points = [a, b, c, d, e, f]
+        #bac, bce, ecf, dbe
+        vertices = [ [1,0,2], [1,2,4], [4,2,5], [3,1,4] ]
+        boundary = { (0, 0): 'Third',
+                     (0, 2): 'First',
+                     (2, 0): 'Second',
+                     (2, 1): 'Second',
+                     (3, 1): 'Second',
+                     (3, 2): 'Third'}
+
+
+        domain = Domain(points, vertices, boundary)
+        domain.check_integrity()
+
+
+        domain.set_quantity('stage', [[1,2,3], [5,5,5],
+                                      [0,0,9], [-6, 3, 3]])
+
+        domain.set_quantity('xmomentum', [[1,1,1], [2,2,2],
+                                          [3,3,3], [4, 4, 4]])
+
+        domain.set_quantity('ymomentum', [[10,10,10], [20,20,20],
+                                          [30,30,30], [40, 40, 40]])
+
+
+        D = Dirichlet_boundary([5,2,1])
+        T = Transmissive_stage_zero_momentum_boundary(domain)
+        R = Reflective_boundary(domain)
+        domain.set_boundary( {'First': D, 'Second': T, 'Third': R})
+
+        domain.update_boundary()
+
+        # Stage
+        assert domain.quantities['stage'].boundary_values[0] == 2.5
+        assert domain.quantities['stage'].boundary_values[0] ==\
+               domain.get_conserved_quantities(0, edge=0)[0] #Reflective (2.5)
+        assert domain.quantities['stage'].boundary_values[1] == 5. #Dirichlet
+        assert domain.quantities['stage'].boundary_values[2] ==\
+               domain.get_conserved_quantities(2, edge=0)[0] #Transmissive (4.5)
+        assert domain.quantities['stage'].boundary_values[3] ==\
+               domain.get_conserved_quantities(2, edge=1)[0] #Transmissive (4.5)
+        assert domain.quantities['stage'].boundary_values[4] ==\
+               domain.get_conserved_quantities(3, edge=1)[0] #Transmissive (-1.5)
+        assert domain.quantities['stage'].boundary_values[5] ==\
+               domain.get_conserved_quantities(3, edge=2)[0] #Reflective (-1.5)
+
+        # Xmomentum
+        assert domain.quantities['xmomentum'].boundary_values[0] == 1.0 #Reflective
+        assert domain.quantities['xmomentum'].boundary_values[1] == 2. #Dirichlet
+        assert domain.quantities['xmomentum'].boundary_values[2] == 0.0 
+        assert domain.quantities['xmomentum'].boundary_values[3] == 0.0 
+        assert domain.quantities['xmomentum'].boundary_values[4] == 0.0 
+        assert domain.quantities['xmomentum'].boundary_values[5] == -4.0  #Reflective
+
+        # Ymomentum
+        assert domain.quantities['ymomentum'].boundary_values[0] == -10.0 #Reflective
+        assert domain.quantities['ymomentum'].boundary_values[1] == 1.  #Dirichlet
+        assert domain.quantities['ymomentum'].boundary_values[2] == 0.0 
+        assert domain.quantities['ymomentum'].boundary_values[3] == 0.0 
+        assert domain.quantities['ymomentum'].boundary_values[4] == 0.0 
+        assert domain.quantities['ymomentum'].boundary_values[5] == 40. #Reflective
+
+                
+                
         
     def test_boundary_condition_time(self):