anuga 1.3.5__zip

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/parallel/parallel_weir_orifice_trapezoid_operator.py

@@ -0,0 +1,281 @@
+import anuga
+import math
+
+from anuga.structures.weir_orifice_trapezoid_operator import weir_orifice_trapezoid_function 
+
+from parallel_inlet_operator import Parallel_Inlet_operator
+from parallel_structure_operator import Parallel_Structure_operator
+
+class Parallel_Weir_orifice_trapezoid_operator(Parallel_Structure_operator):
+    """Culvert flow - transfer water from one trapezoid section to another.
+    Sets up the geometry of problem
+    
+    This is the base class for culverts. Inherit from this class (and overwrite
+    compute_discharge method for specific subclasses)
+    
+    Input: Two points, pipe_size (either diameter or width, height),
+    mannings_rougness,
+    """
+
+    def __init__(self,
+                 domain,
+                 losses,
+                 width,
+                 height=None,
+                 z1=None,
+                 z2=None,
+                 end_points=None,
+                 exchange_lines=None,
+                 enquiry_points=None,
+                 invert_elevations=None,
+                 apron=0.1,
+                 manning=0.013,
+                 enquiry_gap=0.0,
+                 use_momentum_jet=True,
+                 use_velocity_head=True,
+                 description=None,
+                 label=None,
+                 structure_type='weir_orifice_trapezoid',
+                 logging=False,
+                 verbose=False,
+                 master_proc = 0,
+                 procs = None,
+                 inlet_master_proc = [0,0],
+                 inlet_procs = None,
+                 enquiry_proc = [0,0]):
+                     
+        Parallel_Structure_operator.__init__(self,
+                                          domain=domain,
+                                          end_points=end_points,
+                                          exchange_lines=exchange_lines,
+                                          enquiry_points=enquiry_points,
+                                          invert_elevations=invert_elevations,
+                                          width=width,
+                                          height=height,
+                                          z1=z1,
+                                          z2=z2,
+                                          diameter= None,
+                                          apron=apron,
+                                          manning=manning,
+                                          enquiry_gap=enquiry_gap,
+                                          use_momentum_jet=use_momentum_jet,
+                                          zero_outflow_momentum=(not use_momentum_jet),
+                                          use_old_momentum_method=True,
+                                          force_constant_inlet_elevations=False,
+                                          description=description,
+                                          label=label,
+                                          structure_type=structure_type,
+                                          logging=logging,
+                                          verbose=verbose,
+                                          master_proc=master_proc,
+                                          procs=procs,
+                                          inlet_master_proc=inlet_master_proc,
+                                          inlet_procs=inlet_procs,
+                                          enquiry_proc=enquiry_proc)
+        
+        if isinstance(losses, dict):
+            self.sum_loss = sum(losses.values())
+        elif isinstance(losses, list):
+            self.sum_loss = sum(losses)
+        else:
+            self.sum_loss = losses
+        
+        self.use_momentum_jet = use_momentum_jet
+        self.zero_outflow_momentum = (not use_momentum_jet)
+        self.use_old_momentum_method = True
+        self.use_velocity_head = use_velocity_head
+        
+        self.culvert_length = self.get_culvert_length()
+        self.culvert_width = self.get_culvert_width()
+        self.culvert_height = self.get_culvert_height()
+        
+        self.culvert_z1 = self.get_culvert_z1()
+        self.culvert_z2 = self.get_culvert_z2()
+        
+        self.max_velocity = 10.0
+
+        self.inlets = self.get_inlets()
+
+
+        # Stats
+        
+        self.discharge = 0.0
+        self.velocity = 0.0
+        
+        self.case = 'N/A'
+
+        '''
+        print "ATTRIBUTES OF PARALLEL WEIR ORIFICE TRAPEZOID::"
+        for attr in dir(self):
+            print "obj.%s = %s" % (attr, getattr(self, attr))
+        '''
+
+
+    def parallel_safe(self):
+
+        return True
+
+
+
+    def discharge_routine(self):
+
+        import pypar
+
+        local_debug = False
+
+        #Send attributes of both enquiry points to the master proc
+        if self.myid == self.master_proc:
+
+            if self.myid == self.enquiry_proc[0]:
+                enq_total_energy0 = self.inlets[0].get_enquiry_total_energy()
+                enq_stage0 = self.inlets[0].get_enquiry_stage()
+            else:
+                enq_total_energy0 = pypar.receive(self.enquiry_proc[0])
+                enq_stage0 = pypar.receive(self.enquiry_proc[0])
+
+
+            if self.myid == self.enquiry_proc[1]:
+                enq_total_energy1 = self.inlets[1].get_enquiry_total_energy()
+                enq_stage1 = self.inlets[1].get_enquiry_stage()
+            else:
+                enq_total_energy1 = pypar.receive(self.enquiry_proc[1])
+                enq_stage1 = pypar.receive(self.enquiry_proc[1])
+
+        else:
+            if self.myid == self.enquiry_proc[0]:
+                pypar.send(self.inlets[0].get_enquiry_total_energy(), self.master_proc)
+                pypar.send(self.inlets[0].get_enquiry_stage(), self.master_proc)
+
+            if self.myid == self.enquiry_proc[1]:
+                pypar.send(self.inlets[1].get_enquiry_total_energy(), self.master_proc)
+                pypar.send(self.inlets[1].get_enquiry_stage(), self.master_proc)
+
+
+        # Determine the direction of the flow
+        if self.myid == self.master_proc:
+            if self.use_velocity_head:
+                self.delta_total_energy = enq_total_energy0 - enq_total_energy1
+            else:
+                self.delta_total_energy = enq_stage0 - enq_stage1
+
+        self.inflow_index = 0
+        self.outflow_index = 1
+        # master proc orders reversal if applicable
+        if self.myid == self.master_proc:
+
+
+            # Reverse the inflow and outflow direction?
+            if self.delta_total_energy < 0:
+                self.inflow_index = 1
+                self.outflow_index = 0
+
+                self.delta_total_energy = -self.delta_total_energy
+
+                for i in self.procs:
+                    if i == self.master_proc: continue
+                    pypar.send(True, i)
+            else:
+                for i in self.procs:
+                    if i == self.master_proc: continue
+                    pypar.send(False, i)
+
+            #print "ZZZZ: Delta total energy = %f" %(self.delta_total_energy)
+        else:
+            reverse = pypar.receive(self.master_proc)
+
+            if reverse:
+                self.inflow_index = 1
+                self.outflow_index = 0
+
+        # Get attribute from inflow enquiry point
+        if self.myid == self.master_proc:
+
+            if self.myid == self.enquiry_proc[self.inflow_index]:
+                    inflow_enq_depth = self.inlets[self.inflow_index].get_enquiry_depth()
+                    inflow_enq_specific_energy = self.inlets[self.inflow_index].get_enquiry_specific_energy()
+            else:
+                    inflow_enq_depth = pypar.receive(self.enquiry_proc[self.inflow_index])
+                    inflow_enq_specific_energy = pypar.receive(self.enquiry_proc[self.inflow_index])
+        else:
+            if self.myid == self.enquiry_proc[self.inflow_index]:
+                pypar.send(self.inlets[self.inflow_index].get_enquiry_depth(), self.master_proc)
+                pypar.send(self.inlets[self.inflow_index].get_enquiry_specific_energy(), self.master_proc)
+
+        # Get attribute from outflow enquiry point
+        if self.myid == self.master_proc:
+            
+            if self.myid == self.enquiry_proc[self.outflow_index]:
+                outflow_enq_depth = self.inlets[self.outflow_index].get_enquiry_depth()
+            else:
+                outflow_enq_depth = pypar.receive(self.enquiry_proc[self.outflow_index])
+
+            #print "ZZZZZ: outflow_enq_depth = %f" %(outflow_enq_depth)
+
+        else:
+            if self.myid == self.enquiry_proc[self.outflow_index]:
+                pypar.send(self.inlets[self.outflow_index].get_enquiry_depth(), self.master_proc)
+
+
+
+
+        # Master proc computes return values
+        if self.myid == self.master_proc:
+
+            #inflow_enq_specific_energy
+
+
+            if inflow_enq_depth > 0.01: #this value was 0.01:
+                if local_debug:
+                    anuga.log.critical('Specific E & Deltat Tot E = %s, %s'
+                                 % (str(inflow_enq_specific_energy),
+                                    str(self.delta_total_energy)))
+
+                    anuga.log.critical('culvert type = %s' % str(culvert_type))
+
+                # Water has risen above inlet
+
+
+                msg = 'Specific energy at inlet is negative'
+                assert inflow_enq_specific_energy >= 0.0, msg
+
+                if self.use_velocity_head :
+                    self.driving_energy = inflow_enq_specific_energy
+                else:
+                    self.driving_energy = inflow_enq_depth
+                    
+            
+                Q, barrel_velocity, outlet_culvert_depth, flow_area, case = \
+                              weir_orifice_trapezoid_function(depth               =self.culvert_height,
+                                                width               =self.culvert_width,
+                                                z1                  =self.culvert_z1,
+                                                z2                  =self.culvert_z2,                                                
+                                                flow_width          =self.culvert_width,
+                                                length              =self.culvert_length,
+                                                driving_energy      =self.driving_energy,
+                                                delta_total_energy  =self.delta_total_energy,
+                                                outlet_enquiry_depth=outflow_enq_depth,
+                                                sum_loss            =self.sum_loss,
+                                                manning             =self.manning)
+
+                
+            # END CODE BLOCK for DEPTH  > Required depth for CULVERT Flow
+
+            else: # self.inflow.get_enquiry_depth() < 0.01:
+                Q = barrel_velocity = outlet_culvert_depth = 0.0
+                case = 'Inlet dry'
+
+
+            self.case = case
+
+            # Temporary flow limit
+            if barrel_velocity > self.max_velocity:
+                barrel_velocity = self.max_velocity
+                Q = flow_area * barrel_velocity
+
+            
+
+            return Q, barrel_velocity, outlet_culvert_depth
+        else:
+            return None, None, None
+        
+        

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/parallel/print_stats.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python
+#########################################################
+#
+#
+# Calculate and print the norms of the domain
+#
+#
+#  The routines defined here are intended for debugging
+# use. They print the norms of the quantities in the
+# domain. As opposed to the definitions given
+# in utiltites.norms these calculations take a
+# parallel domain into account.
+#
+#  Authors: Linda Stals and April 2006
+#
+#
+#########################################################
+
+import sys
+
+import pypar
+
+from numpy import array, zeros, ones, take, nonzero, float
+from anuga.utilities.norms import l1_norm, l2_norm, linf_norm
+
+#########################################################
+#
+# Find out which triangles are full triangles (only these
+# triangles should be included in the norm calculations)
+#
+# *)
+#
+# -------------------------------------------------------
+#
+# *) A 1-D array, tri_full_flag, is returned.
+#
+# *) The size of tri_full_flag is the same as the number
+# of vertices in the domain
+#
+# *) If tri_full_flag[i] = 1, then triangle number i is
+# a full triangle, if tri_full_flag[i] = 0  the triangle
+# is a ghost triangle
+#
+#########################################################
+
+def build_full_flag(domain, ghost_recv_dict):
+
+    tri_full_flag = ones(len(domain.get_triangles()), Int8)
+    for i in ghost_recv_dict.keys():
+        for id in ghost_recv_dict[i][0]:
+            tri_full_flag[id] = 0
+        
+
+    return tri_full_flag
+
+#########################################################
+#
+# Print the l1 norm of the given quantity
+#
+# *) The quantity is an array containing three columns
+#
+# -------------------------------------------------------
+#
+# *) The l1 norm is calculated along each axis
+#
+# *) The l1 norm is printed
+#
+# *) Processor 0 prints the results
+#
+#
+#########################################################
+def print_l1_stats(full_edge):
+
+    numprocs = pypar.size()
+    myid = pypar.rank()
+    
+    tri_norm = zeros(3, Float)
+    recv_norm = zeros(3, Float)
+    tri_norm[0] = l1_norm(full_edge[:, 0])
+    tri_norm[1] = l1_norm(full_edge[:, 1])
+    tri_norm[2] = l1_norm(full_edge[:, 2])
+    if myid == 0:
+        for p in range(numprocs-1):
+            pypar.receive(p+1, recv_norm)
+            tri_norm[0] = tri_norm[0]+recv_norm[0]
+            tri_norm[1] = tri_norm[1]+recv_norm[1]
+            tri_norm[2] = tri_norm[2]+recv_norm[2]
+        print 'l1_norm along each axis : [', tri_norm[0],', ', tri_norm[1], ', ', tri_norm[2], ']'
+
+    else:
+        pypar.send(tri_norm, 0)
+
+#########################################################
+#
+# Print the l2 norm of the given quantity
+#
+# *) The quantity is an array containing three columns
+#
+# -------------------------------------------------------
+#
+# *) The l2 norm is calculated along each axis
+#
+# *) The l2 norm is printed
+#
+# *) Processor 0 prints the results
+#
+#
+#########################################################
+def print_l2_stats(full_edge):
+
+    numprocs = pypar.size()
+    myid = pypar.rank()
+    
+    tri_norm = zeros(3, Float)
+    recv_norm = zeros(3, Float)
+    tri_norm[0] = pow(l2_norm(full_edge[:, 0]), 2)
+    tri_norm[1] = pow(l2_norm(full_edge[:, 1]), 2)
+    tri_norm[2] = pow(l2_norm(full_edge[:, 2]), 2)
+    if myid == 0:
+        for p in range(numprocs-1):
+            pypar.receive(p+1, recv_norm)
+            tri_norm[0] = tri_norm[0]+recv_norm[0]
+            tri_norm[1] = tri_norm[1]+recv_norm[1]
+            tri_norm[2] = tri_norm[2]+recv_norm[2]
+        print 'l2_norm along each axis : [', pow(tri_norm[0], 0.5),', ', pow(tri_norm[1], 0.5), \
+              ', ', pow(tri_norm[2], 0.5), ']'
+    else:
+        pypar.send(tri_norm, 0)
+
+
+#########################################################
+#
+# Print the linf norm of the given quantity
+#
+# *) The quantity is an array containing three columns
+#
+# -------------------------------------------------------
+#
+# *) The linf norm is calculated along each axis
+#
+# *) The linf norm is printed
+#
+# *) Processor 0 prints the results
+#
+#
+#########################################################
+def print_linf_stats(full_edge):
+
+    numprocs = pypar.size()
+    myid = pypar.rank()
+    
+    tri_norm = zeros(3, Float)
+    recv_norm = zeros(3, Float)
+        
+    tri_norm[0] = linf_norm(full_edge[:, 0])
+    tri_norm[1] = linf_norm(full_edge[:, 1])
+    tri_norm[2] = linf_norm(full_edge[:, 2])
+    if myid == 0:
+        for p in range(numprocs-1):
+            pypar.receive(p+1, recv_norm)
+            tri_norm[0] = max(tri_norm[0], recv_norm[0])
+            tri_norm[1] = max(tri_norm[1], recv_norm[1])
+            tri_norm[2] = max(tri_norm[2], recv_norm[2])
+        print 'linf_norm along each axis : [', tri_norm[0],', ', tri_norm[1], ', ', tri_norm[2], ']'
+    else:
+        pypar.send(tri_norm, 0)
+
+       
+#########################################################
+#
+# Print the norms of the quantites assigned to the domain
+# (this is useful for checking the numerical results
+# in the parallel computation)
+#
+# *) tri_full_flag states which of the triangles are
+# full triangles
+#
+#
+# -------------------------------------------------------
+#
+# *) For each quantity, the l1, l2 and linf norms are
+# printed
+#
+# *) The size of tri_full_flag is the same as the number
+# of vertices in the domain
+#
+# *) Only the full triangles are used in the norm
+# calculations
+#
+# *) Processor 0 prints the results
+#
+#########################################################
+def print_test_stats(domain, tri_full_flag):
+
+    myid = pypar.rank()
+
+    for k in domain.quantities.keys():
+        TestStage = domain.quantities[k]
+        if myid == 0:
+            print " ===== ", k, " ===== "
+        full_edge = take(TestStage.edge_values, nonzero(tri_full_flag))
+        print_l1_stats(full_edge)
+        print_l2_stats(full_edge)
+        print_linf_stats(full_edge)
+