anuga 1.3.5__zip

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/operators/change_friction_operator.py

@@ -0,0 +1,240 @@
+"""
+Erosion operators
+
+
+"""
+
+__author__="steve"
+__date__ ="$09/03/2012 4:46:39 PM$"
+
+
+from anuga import Domain
+from anuga import Quantity
+import numpy as num
+import anuga.utilities.log as log
+
+from anuga.geometry.polygon import inside_polygon
+
+from anuga.operators.base_operator import Operator
+from anuga.fit_interpolate.interpolate import Modeltime_too_early, \
+                                              Modeltime_too_late
+from anuga import indent
+
+
+
+class Erosion_operator(Operator):
+    """
+    Simple erosion operator in a region (careful to maintain continuitiy of elevation)
+
+    indices: None == all triangles, Empty list [] no triangles
+
+    rate can be a function of time.
+
+    """
+
+    def __init__(self,
+                 domain,
+                 threshold= 0.0,
+                 indices=None,
+                 description = None,
+                 label = None,
+                 logging = False,
+                 verbose = False):
+
+
+        Operator.__init__(self, domain, description, label, logging, verbose)
+
+        #------------------------------------------
+        # Local variables
+        #------------------------------------------
+        self.threshold = threshold
+        self.indices = indices
+
+
+    def __call__(self):
+        """
+        Apply rate to those triangles defined in indices
+
+        indices == [], then don't apply anywhere
+        indices == None, then apply everywhere
+        otherwise apply for the specific indices
+        """
+
+
+
+        if self.indices is []:
+            return
+
+
+
+        #elevation = self.get_elevation()
+
+#        if self.verbose is True:
+#            log.critical('Bed of %s at time = %.2f = %f'
+#                         % (self.quantity_name, domain.get_time(), elevation))
+
+        #if self.indices is None:
+        #    self.elev_c[:] = elevation
+        #else:
+        #    self.elev_c[self.indices] = elevation
+
+        t = self.get_time()
+        dt = self.get_timestep()
+
+
+
+
+        self.elev_v  = self.domain.quantities['elevation'].vertex_values
+        self.stage_v = self.domain.quantities['stage'].vertex_values
+
+
+        # Need to store water heights before change to ensure
+        # no water lost or produced
+        height_c = self.stage_c - self.elev_c
+
+        #--------------------------------------------
+        # Here we do the actual erosion
+        #--------------------------------------------
+        if self.indices is None:
+            self.elev_v[:] = self.elev_v + 0.0
+        else:
+            self.elev_v[self.indices] -= 0.1*dt
+
+
+        # FIXME SR: At present need to ensure the elevation is continuous
+        # In future with discontinuous bed we will not need to do this.
+        self.domain.quantities['elevation'].smooth_vertex_values()
+        self.domain.quantities['elevation'].interpolate()
+
+        #self.elev_c = self.domain.quantities['elevation'].centroid_values
+
+#        # Fix up water conservation
+        self.stage_c[:] = self.elev_c +  height_c
+#        self.domain.distribute_to_vertices_and_edges()
+
+        print 'time in erosion ',self.get_time(), dt
+
+
+
+    def parallel_safe(self):
+        """Operator is applied independently on each cell and
+        so is parallel safe.
+        """
+        return False
+
+    def statistics(self):
+
+        message = self.label + ': Erosion_operator'
+        message = message + ' on triangles '+ str(self.indices)
+        return message
+
+
+    def timestepping_statistics(self):
+
+        message  = indent + self.label + ': Erosion_operator'
+        return 'test'
+
+
+
+
+#===============================================================================
+# Specific Erosion Operator for circular region.
+#===============================================================================
+class Circular_erosion_operator(Erosion_operator):
+    """
+    Erosion over a circular region
+
+    """
+
+    def __init__(self, domain,
+                 threshold=0.0,
+                 center=None,
+                 radius=None,
+                 verbose=False):
+
+        assert center is not None
+        assert radius is not None
+
+
+        # Determine indices in update region
+        N = domain.get_number_of_triangles()
+        points = domain.get_centroid_coordinates(absolute=True)
+
+
+        indices = []
+
+        c = center
+        r = radius
+
+        self.center = center
+        self.radius = radius
+
+        intersect = False
+        for k in range(N):
+            x, y = points[k,:]    # Centroid
+
+            if ((x-c[0])**2+(y-c[1])**2) < r**2:
+                intersect = True
+                indices.append(k)
+
+
+        msg = 'No centroids intersect circle center'+str(center)+' radius '+str(radius)
+        assert intersect, msg
+
+
+
+
+        # It is possible that circle doesn't intersect with mesh (as can happen
+        # for parallel runs
+
+
+        Erosion_operator.__init__(self,
+                                  domain,
+                                  threshold,
+                                  indices=indices,
+                                  verbose=verbose)
+
+
+
+
+
+#===============================================================================
+# Specific Bed Operators for polygonal region.
+#===============================================================================
+class Polygonal_erosion_operator(Erosion_operator):
+    """
+    Erosion over a ploygon
+
+    """
+
+    def __init__(self, domain,
+                 threshold=0.0,
+                 polygon=None,
+                 verbose=False):
+
+
+        # Determine indices in update region
+        N = domain.get_number_of_triangles()
+        points = domain.get_centroid_coordinates(absolute=True)
+
+
+        indices = inside_polygon(points, polygon)
+        self.polygon = polygon
+
+        # It is possible that circle doesn't intersect with mesh (as can happen
+        # for parallel runs
+
+
+        Erosion_operator.__init__(self,
+                                  domain,
+                                  threshold=threshold,
+                                  indices=indices,
+                                  verbose=verbose)
+
+
+
+        
+
+
+
+

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/operators/collect_max_quantities_operator.py

@@ -0,0 +1,142 @@
+"""
+Collect stage quantity stage info
+
+
+"""
+
+__author__="gareth"
+__date__ ="$01/08/2014 4:46:39 PM$"
+
+
+
+import numpy as num
+from anuga.geometry.polygon import inside_polygon
+from anuga.operators.base_operator import Operator
+from anuga import Quantity
+from anuga.parallel import myid
+from anuga.config import velocity_protection
+
+
+class collect_max_quantities_operator(Operator):
+    """
+    Simple operator to collect the max stage, depth, speed, and speed*depth during a run.
+
+    Maxima are updated every update_frequency timesteps [any integer >=1 is
+    ok], after t exceeds collection_start_time.
+   
+    In theory this might save time (??), since computing e.g. velocity/momentum etc in python might be expensive
+    
+    Optionally velocities can be zeroed below velocity_zero_height (defaults to minimum_allowed_height if not required) 
+    """
+
+    def __init__(self,
+                 domain,
+                 update_frequency=1,
+                 collection_start_time=0.,
+                 velocity_zero_height=None,
+                 description = None,
+                 label = None,
+                 logging = False,
+                 verbose = False):
+
+
+        Operator.__init__(self, domain, description, label, logging, verbose)
+
+        self.domain=domain
+
+        #------------------------------------------
+        # Setup a quantity to store max_stage
+        #------------------------------------------
+        self.max_stage = num.zeros(len(domain.centroid_coordinates[:,0]))
+        self.max_depth = num.zeros(len(domain.centroid_coordinates[:,0]))
+        self.max_speed = num.zeros(len(domain.centroid_coordinates[:,0]))
+        self.max_speedDepth = num.zeros(len(domain.centroid_coordinates[:,0]))
+
+        #------------------------------------------
+        # Aliases for stage quantity
+        #------------------------------------------
+        self.xy=domain.centroid_coordinates
+        self.stage  = domain.quantities['stage']
+        self.elev   = domain.quantities['elevation']
+        self.xmom   = domain.quantities['xmomentum']
+        self.ymom   = domain.quantities['ymomentum']
+
+        #------------------------------------------
+        # Counter so we don't have to update every timestep
+        #------------------------------------------        
+        self.counter=0
+        assert update_frequency>0, 'Update frequency must be >=1'
+        self.update_frequency=update_frequency
+        self.collection_start_time = collection_start_time
+
+        #------------------------------------------
+        # Can (rarely) get high velocities being recorded
+        # (e.g. in 3 cells out of 170000 for a 48 hour simulation,
+        #  which are not persistent -- probably just spikes from nearly dry cells)
+        # Try to remove this by zeroing velocity in very shallow cells
+        #------------------------------------------
+        if velocity_zero_height is not None:
+            self.velocity_zero_height=velocity_zero_height
+        else:
+            self.velocity_zero_height=domain.minimum_allowed_height
+
+
+    def __call__(self):
+        """
+        Calculate max_quantities at every 'update_frequency' timesteps once time > collection_start_time
+        """
+
+        if(self.domain.time > self.collection_start_time):
+            self.counter+=1
+
+            if(self.counter==self.update_frequency):
+            
+                self.max_stage=num.maximum(self.max_stage, self.stage.centroid_values)
+
+                momNorm = (self.xmom.centroid_values**2 + self.ymom.centroid_values**2)**0.5
+                self.max_speedDepth=num.maximum(self.max_speedDepth, momNorm)
+                
+                localDepth=num.maximum(self.stage.centroid_values-self.elev.centroid_values, self.domain.minimum_allowed_height) 
+                self.max_depth = num.maximum(self.max_depth,localDepth)
+
+                #velMax=(momNorm/(localDepth+velocity_protection/localDepth))*(localDepth>self.domain.minimum_allowed_height)
+                velMax=(momNorm/localDepth)*(localDepth>self.velocity_zero_height)
+                self.max_speed = num.maximum(self.max_speed, velMax)
+
+                self.counter=0
+
+    def parallel_safe(self):
+        """Operator is applied independently on each cell and
+        so is parallel safe.
+        """
+        return True
+
+    def statistics(self):
+
+        message = self.label + ': Collect_max_quantity operator'
+        return message
+
+
+    def timestepping_statistics(self):
+        from anuga import indent
+
+        message  = indent + self.label + ': Collecting_max_quantity'
+        return message
+
+
+    def export_max_quantities_to_csv(self, filename_start='Max_Quantities_'):
+        """
+
+        Export max-quantities to a csv 
+
+        """
+        fullInds=self.domain.tri_full_flag.nonzero()[0]
+        outArray=num.vstack([self.xy[fullInds,0]+self.domain.geo_reference.xllcorner, 
+                             self.xy[fullInds,1]+self.domain.geo_reference.yllcorner, 
+                             self.max_stage[fullInds], self.max_depth[fullInds], 
+                             self.max_speed[fullInds], self.max_speedDepth[fullInds]]).transpose()
+
+        outname=filename_start+'P'+str(myid)+'_X_Y_Stage_Depth_Speed_UH_MAX.csv'
+        num.savetxt(outname, outArray,delimiter=',')
+        return
+

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/operators/collect_max_stage_operator.py

@@ -0,0 +1,85 @@
+"""
+Collect stage max stage info
+
+
+"""
+
+__author__="steve"
+__date__ ="$09/03/2012 4:46:39 PM$"
+
+
+
+import numpy as num
+from anuga.geometry.polygon import inside_polygon
+from anuga.operators.base_operator import Operator
+from anuga import Quantity
+
+
+class Collect_max_stage_operator(Operator):
+    """
+    Simple operator to collect the max stage during a run
+
+    """
+
+    def __init__(self,
+                 domain,
+                 description = None,
+                 label = None,
+                 logging = False,
+                 verbose = False):
+
+
+        Operator.__init__(self, domain, description, label, logging, verbose)
+
+        #------------------------------------------
+        # Setup a quantity to store max_stage
+        #------------------------------------------
+        self.max_stage = Quantity(domain, name = 'max_stage', register=True)
+        self.max_stage.set_values(-1.0e+100)
+
+        #------------------------------------------
+        # Aliases for stage quantity
+        #------------------------------------------
+        self.stage  = domain.quantities['stage']
+
+        
+
+    def __call__(self):
+        """
+        Calculate max_stage at each timestep
+        """
+
+        self.max_stage.maximum(self.stage)
+
+
+    def parallel_safe(self):
+        """Operator is applied independently on each cell and
+        so is parallel safe.
+        """
+        return True
+
+    def statistics(self):
+
+        message = self.label + ': Collect_max_stage operator'
+        return message
+
+
+    def timestepping_statistics(self):
+        from anuga import indent
+
+        message  = indent + self.label + ': Collecting_max_stage'
+        return message
+
+
+    def save_centroid_data_to_csv(self, filename=None):
+
+        self.max_stage.save_centroid_data_to_csv(filename)
+
+
+    def plot_quantity(self, filename=None, show=True):
+
+        self.max_stage.plot_quantity(filename=filename, show=show)
+
+
+
+

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/operators/compile_all.py

@@ -0,0 +1,16 @@
+""" Script to compile all C extensions in ANUGA. """
+
+import os
+
+BUILDROOT = os.getcwd()
+
+#Attempt to compile all extensions
+
+execfile('..' + os.sep + 'utilities' + os.sep + 'compile.py')
+
+
+os.chdir(BUILDROOT)    
+
+    
+if sys.platform == 'win32':
+    raw_input('Press the RETURN key')