Ignore:
Timestamp:
May 27, 2013, 7:33:37 PM (12 years ago)
Author:
steve
Message:

Setting up parallel_structure to allow enquiry of data

Location:
trunk/anuga_core/source/anuga_parallel
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/anuga_core/source/anuga_parallel/parallel_boyd_box_operator.py

    r8833 r8875  
    104104
    105105
    106 #    def debug_discharge_routine(self):
    107 #        local_debug ='false'
    108 #
    109 #        if self.use_velocity_head:
    110 #            self.delta_total_energy = self.inlets[0].get_enquiry_total_energy() - self.inlets[1].get_enquiry_total_energy()
    111 #        else:
    112 #            self.delta_total_energy = self.inlets[0].get_enquiry_stage() - self.inlets[1].get_enquiry_stage()
    113 #
    114 #        self.inflow  = self.inlets[0]
    115 #        self.outflow = self.inlets[1]
    116 #
    117 #        self.inflow_index = 0
    118 #        self.outflow_index = 1
    119 #
    120 #        if self.delta_total_energy < 0:
    121 #            self.inflow  = self.inlets[1]
    122 #            self.outflow = self.inlets[0]
    123 #            self.delta_total_energy = -self.delta_total_energy
    124 #            self.inflow_index = 1
    125 #            self.outflow_index = 0
    126 #
    127 #
    128 #        if self.inflow.get_enquiry_depth() > 0.01: #this value was 0.01:
    129 #            if local_debug =='true':
    130 #                anuga.log.critical('Specific E & Deltat Tot E = %s, %s'
    131 #                             % (str(self.inflow.get_enquiry_specific_energy()),
    132 #                                str(self.delta_total_energy)))
    133 #                anuga.log.critical('culvert type = %s' % str(culvert_type))
    134 #            # Water has risen above inlet
    135 #
    136 #
    137 #            msg = 'Specific energy at inlet is negative'
    138 #            assert self.inflow.get_enquiry_specific_energy() >= 0.0, msg
    139 #
    140 #            if self.use_velocity_head :
    141 #                self.driving_energy = self.inflow.get_enquiry_specific_energy()
    142 #            else:
    143 #                self.driving_energy = self.inflow.get_enquiry_depth()
    144 #
    145 #            depth = self.culvert_height
    146 #            width = self.culvert_width
    147 #            flow_width = self.culvert_width
    148 #            # intially assume the culvert flow is controlled by the inlet
    149 #            # check unsubmerged and submerged condition and use Min Q
    150 #            # but ensure the correct flow area and wetted perimeter are used
    151 #            Q_inlet_unsubmerged = 0.544*anuga.g**0.5*width*self.driving_energy**1.50 # Flow based on Inlet Ctrl Inlet Unsubmerged
    152 #            Q_inlet_submerged = 0.702*anuga.g**0.5*width*depth**0.89*self.driving_energy**0.61  # Flow based on Inlet Ctrl Inlet Submerged
    153 #
    154 #            # FIXME(Ole): Are these functions really for inlet control?
    155 #            if Q_inlet_unsubmerged < Q_inlet_submerged:
    156 #                Q = Q_inlet_unsubmerged
    157 #                dcrit = (Q**2/anuga.g/width**2)**0.333333
    158 #                if dcrit > depth:
    159 #                    dcrit = depth
    160 #                    flow_area = width*dcrit
    161 #                    perimeter= 2.0*(width+dcrit)
    162 #                else: # dcrit < depth
    163 #                    flow_area = width*dcrit
    164 #                    perimeter= 2.0*dcrit+width
    165 #                outlet_culvert_depth = dcrit
    166 #                self.case = 'Inlet unsubmerged Box Acts as Weir'
    167 #            else: # Inlet Submerged but check internal culvert flow depth
    168 #                Q = Q_inlet_submerged
    169 #                dcrit = (Q**2/anuga.g/width**2)**0.333333
    170 #                if dcrit > depth:
    171 #                    dcrit = depth
    172 #                    flow_area = width*dcrit
    173 #                    perimeter= 2.0*(width+dcrit)
    174 #                else: # dcrit < depth
    175 #                    flow_area = width*dcrit
    176 #                    perimeter= 2.0*dcrit+width
    177 #                outlet_culvert_depth = dcrit
    178 #                self.case = 'Inlet submerged Box Acts as Orifice'
    179 #
    180 #            dcrit = (Q**2/anuga.g/width**2)**0.333333
    181 #            # May not need this .... check if same is done above
    182 #            outlet_culvert_depth = dcrit
    183 #            if outlet_culvert_depth > depth:
    184 #                outlet_culvert_depth = depth  # Once again the pipe is flowing full not partfull
    185 #                flow_area = width*depth  # Cross sectional area of flow in the culvert
    186 #                perimeter = 2*(width+depth)
    187 #                self.case = 'Inlet CTRL Outlet unsubmerged PIPE PART FULL'
    188 #            else:
    189 #                flow_area = width * outlet_culvert_depth
    190 #                perimeter = width+2*outlet_culvert_depth
    191 #                self.case = 'INLET CTRL Culvert is open channel flow we will for now assume critical depth'
    192 #            # Initial Estimate of Flow for Outlet Control using energy slope
    193 #            #( may need to include Culvert Bed Slope Comparison)
    194 #            hyd_rad = flow_area/perimeter
    195 #            culvert_velocity = math.sqrt(self.delta_total_energy/((self.sum_loss/2/anuga.g)+(self.manning**2*self.culvert_length)/hyd_rad**1.33333))
    196 #            Q_outlet_tailwater = flow_area * culvert_velocity
    197 #
    198 #
    199 #            if self.delta_total_energy < self.driving_energy:
    200 #                # Calculate flows for outlet control
    201 #
    202 #                # Determine the depth at the outlet relative to the depth of flow in the Culvert
    203 #                if self.outflow.get_enquiry_depth() > depth:        # The Outlet is Submerged
    204 #                    outlet_culvert_depth=depth
    205 #                    flow_area=width*depth       # Cross sectional area of flow in the culvert
    206 #                    perimeter=2.0*(width+depth)
    207 #                    self.case = 'Outlet submerged'
    208 #                else:   # Here really should use the Culvert Slope to calculate Actual Culvert Depth & Velocity
    209 #                    dcrit = (Q**2/anuga.g/width**2)**0.333333
    210 #                    outlet_culvert_depth=dcrit   # For purpose of calculation assume the outlet depth = Critical Depth
    211 #                    if outlet_culvert_depth > depth:
    212 #                        outlet_culvert_depth=depth
    213 #                        flow_area=width*depth
    214 #                        perimeter=2.0*(width+depth)
    215 #                        self.case = 'Outlet is Flowing Full'
    216 #                    else:
    217 #                        flow_area=width*outlet_culvert_depth
    218 #                        perimeter=(width+2.0*outlet_culvert_depth)
    219 #                        self.case = 'Outlet is open channel flow'
    220 #
    221 #                hyd_rad = flow_area/perimeter
    222 #
    223 #
    224 #
    225 #                # Final Outlet control velocity using tail water
    226 #                culvert_velocity = math.sqrt(self.delta_total_energy/((self.sum_loss/2/anuga.g)+(self.manning**2*self.culvert_length)/hyd_rad**1.33333))
    227 #                Q_outlet_tailwater = flow_area * culvert_velocity
    228 #
    229 #                Q = min(Q, Q_outlet_tailwater)
    230 #            else:
    231 #
    232 #                pass
    233 #                #FIXME(Ole): What about inlet control?
    234 #
    235 #            culv_froude=math.sqrt(Q**2*flow_width/(anuga.g*flow_area**3))
    236 #
    237 #            if local_debug =='true':
    238 #                anuga.log.critical('FLOW AREA = %s' % str(flow_area))
    239 #                anuga.log.critical('PERIMETER = %s' % str(perimeter))
    240 #                anuga.log.critical('Q final = %s' % str(Q))
    241 #                anuga.log.critical('FROUDE = %s' % str(culv_froude))
    242 #
    243 #            # Determine momentum at the outlet
    244 #            barrel_velocity = Q/(flow_area + anuga.velocity_protection/flow_area)
    245 #
    246 #        # END CODE BLOCK for DEPTH  > Required depth for CULVERT Flow
    247 #
    248 #        else: # self.inflow.get_enquiry_depth() < 0.01:
    249 #            Q = barrel_velocity = outlet_culvert_depth = 0.0
    250 #
    251 #        # Temporary flow limit
    252 #        if barrel_velocity > self.max_velocity:
    253 #            barrel_velocity = self.max_velocity
    254 #            Q = flow_area * barrel_velocity
    255 #
    256 #        return Q, barrel_velocity, outlet_culvert_depth
    257106
    258107    def discharge_routine(self):
    … …  
    381230                    self.driving_energy = inflow_enq_depth
    382231                   
    383                 #print "ZZZZZ: driving energy = %f" %(self.driving_energy)
    384 
    385 #                depth = self.culvert_height
    386 #                width = self.culvert_width
    387 #                flow_width = self.culvert_width
    388 #                driving_energy = self.driving_energy
    389 #                sum_loss = self.sum_loss
    390 #                culvert_length= self.culvert_length
    391 #                manning = self.manning
    392 #                delta_total_energy = self.delta_total_energy
    393 
    394 
    395232           
    396233                Q, barrel_velocity, outlet_culvert_depth, flow_area, case = \

  • trunk/anuga_core/source/anuga_parallel/parallel_inlet.py

    r8833 r8875  
    2626    """
    2727
    28     def __init__(self, domain, line, master_proc = 0, procs = None, verbose=False):
     28    def __init__(self, domain, poly, master_proc = 0, procs = None, verbose=False):
    2929
    3030        self.domain = domain
    31         self.line = line
     31        self.poly = num.asarray(poly, dtype=num.float64)
    3232        self.verbose = verbose
     33
     34        self.line = True
     35        if len(self.poly) > 2:
     36            self.line = False
     37
    3338        self.master_proc = master_proc
    3439
    … …  
    4348        self.compute_triangle_indices()
    4449        self.compute_area()
    45         self.compute_inlet_length()
     50        #self.compute_inlet_length()
    4651
    4752
    … …  
    4954    def compute_triangle_indices(self):
    5055
    51         # Get boundary of full triangles (in absolute coordinates)
     56
     57        domain_centroids = self.domain.get_centroid_coordinates(absolute=True)
    5258        vertex_coordinates = self.domain.get_full_vertex_coordinates(absolute=True)
    5359
    54         # PETE: we can assume that the ghost triangles in this domain exist in another
    55         # domain, therefore any part of the inlet corresponding to them are accounted for.
    56 
    57         self.triangle_indices = line_intersect(vertex_coordinates, self.line)
     60
     61        if self.line: # poly is a line
     62            self.triangle_indices = line_intersect(vertex_coordinates, self.poly)
     63
     64        else: # poly is a polygon
     65
     66            self.triangle_indices = inside_polygon(domain_centroids, self.poly)
     67
    5868
    5969        for i in self.triangle_indices:
    6070            assert self.domain.tri_full_flag[i] == 1
     71           
    6172
    6273    def compute_area(self):
    … …  
    150161        local_stage = num.sum(self.get_stages()*self.get_areas())
    151162        global_area = self.get_global_area()
     163
     164
     165
    152166        global_stage = local_stage
    153167
    … …  
    162176
    163177
    164         return global_stage/global_area
     178        if global_area > 0.0:
     179            return global_stage/global_area
     180        else:
     181            return 0.0
    165182
    166183    def get_elevations(self):
    … …  
    170187    def get_average_elevation(self):
    171188        # LOCAL
    172         return num.sum(self.get_elevations()*self.get_areas())/self.area
     189
     190        if self.area > 0:
     191            return num.sum(self.get_elevations()*self.get_areas())/self.area
     192        else:
     193            return 0.0
    173194
    174195
    … …  
    180201    def get_average_xmom(self):
    181202        # LOCAL
    182         return num.sum(self.get_xmoms()*self.get_areas())/self.area
     203
     204        if self.area > 0:
     205            return num.sum(self.get_xmoms()*self.get_areas())/self.area
     206        else:
     207            return 0.0
    183208
    184209    def get_global_average_xmom(self):
    … …  
    202227
    203228
    204         return global_xmoms/global_area
     229        if global_area > 0.0:
     230            return global_xmoms/global_area
     231        else:
     232            return 0.0
     233
    205234
    206235    def get_ymoms(self):
    … …  
    233262
    234263
    235         return global_ymoms/global_area
     264        if global_area > 0.0:
     265            return global_ymoms/global_area
     266        else:
     267            return 0.0
    236268
    237269    def get_depths(self):
    … …  
    267299    def get_average_depth(self):
    268300        # LOCAL
    269         return self.get_total_water_volume()/self.area
     301
     302        if self.area > 0.0:
     303            return self.get_total_water_volume()/self.area
     304        else:
     305            return 0.0
    270306
    271307    def get_global_average_depth(self):
    … …  
    277313        total_water_volume = self.get_global_total_water_volume()
    278314
    279         return total_water_volume / area
     315
     316        if area > 0.0:
     317            return total_water_volume / area
     318        else:
     319            return 0.0
    280320
    281321
    282322    def get_velocities(self):
    283323        #LOCAL
    284             depths = self.get_depths()
    285             u = self.get_xmoms()/(depths + velocity_protection/depths)
    286             v = self.get_ymoms()/(depths + velocity_protection/depths)
    287 
    288             return u, v
     324        depths = self.get_depths()
     325        u = depths*self.get_xmoms()/(depths**2 + velocity_protection)
     326        v = depths*self.get_ymoms()/(depths**2 + velocity_protection)
     327
     328        return u, v
    289329
    290330
    291331    def get_xvelocities(self):
    292332        #LOCAL
    293             depths = self.get_depths()
    294             return self.get_xmoms()/(depths + velocity_protection/depths)
     333        depths = self.get_depths()
     334        return depth*self.get_xmoms()/(depths**2 + velocity_protection)
    295335
    296336    def get_yvelocities(self):
    297337        #LOCAL
    298             depths = self.get_depths()
    299             return self.get_ymoms()/(depths + velocity_protection/depths)
     338        depths = self.get_depths()
     339        return depths*self.get_ymoms()/(depths**2 + velocity_protection)
    300340
    301341
    302342    def get_average_speed(self):
    303343        #LOCAL
    304             u, v = self.get_velocities()
    305 
    306             average_u = num.sum(u*self.get_areas())/self.area
    307             average_v = num.sum(v*self.get_areas())/self.area
    308 
    309             return math.sqrt(average_u**2 + average_v**2)
     344        u, v = self.get_velocities()
     345
     346        average_u = num.sum(u*self.get_areas())/self.area
     347        average_v = num.sum(v*self.get_areas())/self.area
     348
     349        return math.sqrt(average_u**2 + average_v**2)
    310350
    311351

  • trunk/anuga_core/source/anuga_parallel/parallel_inlet_enquiry.py

    r8833 r8875  
    1818    """
    1919
    20     def __init__(self, domain, polyline, enquiry_pt, master_proc = 0, procs = None, enquiry_proc = -1,
    21                 outward_culvert_vector=None, verbose=False):
     20    def __init__(self, domain, polyline, enquiry_pt,
     21                 invert_elevation = None,
     22                 outward_culvert_vector=None,
     23                 master_proc = 0,
     24                 procs = None,
     25                 enquiry_proc = -1,
     26                 verbose=False):
    2227
    2328   
    … …  
    2833
    2934        self.enquiry_pt = enquiry_pt
     35        self.invert_elevation = invert_elevation
    3036        self.outward_culvert_vector = outward_culvert_vector
    3137        self.master_proc = master_proc
    … …  
    123129
    124130        if self.enquiry_index >= 0:
     131            return max(self.get_enquiry_stage() - self.get_enquiry_invert_elevation(), 0.0)
     132        else:
     133            return None
     134
     135    def get_enquiry_water_depth(self):
     136        # WARNING: Must be called by processor containing inlet enquiry point to have effect
     137
     138        if self.enquiry_index >= 0:
    125139            return self.get_enquiry_stage() - self.get_enquiry_elevation()
    126140        else:
    127141            return None
    128142
     143    def get_enquiry_invert_elevation(self):
     144        # WARNING: Must be called by processor containing inlet enquiry point to have effect
     145
     146        if self.enquiry_index >= 0:
     147            if  self.invert_elevation is None:
     148                return self.get_enquiry_elevation()
     149            else:
     150                return self.invert_elevation
     151        else:
     152            return None
    129153
    130154    def get_enquiry_velocity(self):
    … …  
    132156
    133157        if self.enquiry_index >= 0:
    134             depth = self.get_enquiry_depth()
    135             u = self.get_enquiry_xmom()/(depth + velocity_protection/depth)
    136             v = self.get_enquiry_ymom()/(depth + velocity_protection/depth)
     158            depth = self.get_enquiry_water_depth()
     159            u = depth*self.get_enquiry_xmom()/(depth**2 + velocity_protection)
     160            v = depth*self.get_enquiry_ymom()/(depth**2 + velocity_protection)
    137161
    138162            return u, v
    … …  
    145169
    146170        if self.enquiry_index >= 0:
    147             depth = self.get_enquiry_depth()
    148             return self.get_enquiry_xmom()/(depth + velocity_protection/depth)
     171            depth = self.get_enquiry_water_depth()
     172            return depth*self.get_enquiry_xmom()/(depth**2 + velocity_protection)
    149173        else:
    150174            return None
    … …  
    154178
    155179        if self.enquiry_index >= 0:
    156             depth = self.get_enquiry_depth()
    157             return self.get_enquiry_ymom()/(depth + velocity_protection/depth)
     180            depth = self.get_enquiry_water_depth()
     181            return depth*self.get_enquiry_ymom()/(depth**2 + velocity_protection)
    158182        else:
    159183            return None

  • trunk/anuga_core/source/anuga_parallel/parallel_inlet_operator.py

    r8833 r8875  
    3333    def __init__(self,
    3434                 domain,
    35                  line,
     35                 poly,
    3636                 Q = 0.0,
    3737                 velocity = None,
    … …  
    4747        self.domain = domain
    4848        self.domain.set_fractional_step_operator(self)
    49         self.line = numpy.array(line, dtype='d')
     49        self.poly = numpy.array(poly, dtype='d')
    5050        self.master_proc = master_proc
    5151
    … …  
    8080            Inlet_operator.counter += 1
    8181
    82         self.enquiry_point = 0.5*(self.line[0] + self.line[1])
    83 
    84         self.outward_vector = self.line
    85         self.inlet = parallel_inlet.Parallel_Inlet(self.domain, self.line, master_proc = master_proc,
     82
     83        n = len(self.poly)
     84        self.enquiry_point = numpy.sum(self.poly,axis=1)/float(n)
     85   
     86
     87        #self.outward_vector = self.poly
     88        self.inlet = parallel_inlet.Parallel_Inlet(self.domain, self.poly, master_proc = master_proc,
    8689                                                    procs = procs, verbose= verbose)
     90
     91        if velocity is not None:
     92            assert len(velocity)==2
     93
     94        self.velocity = velocity
     95
     96        self.applied_Q = 0.0
     97
    8798        self.set_logging(logging)
    8899
    89 
    90100        self.set_default(default)
    91 
    92         self.velocity = velocity
    93 
    94         self.applied_Q = 0.0
    95101
    96102    def __call__(self):

  • trunk/anuga_core/source/anuga_parallel/parallel_operator_factory.py

    r8833 r8875  
    4141
    4242def Inlet_operator(domain,
    43                    line,
     43                   poly,
    4444                   Q,
    4545                   velocity = None,
    … …  
    5656        if verbose: print "Allocating non parallel inlet operator ....."
    5757        return anuga.structures.inlet_operator.Inlet_operator(domain,
    58                                                               line,
     58                                                              poly,
    5959                                                              Q,
    6060                                                              velocity = velocity,
    … …  
    7171    myid = pypar.rank()
    7272
    73     line = num.array(line, dtype='d')
     73    poly = num.array(poly, dtype='d')
    7474
    7575    alloc, inlet_master_proc, inlet_procs, enquiry_proc = allocate_inlet_procs(domain,
    76                                                                                line,
     76                                                                               poly,
    7777                                                                               master_proc = master_proc,
    7878                                                                               procs = procs,
    … …  
    9090
    9191        return Parallel_Inlet_operator(domain,
    92                                        line,
     92                                       poly,
    9393                                       Q,
    9494                                       velocity = velocity,

  • trunk/anuga_core/source/anuga_parallel/parallel_structure_operator.py

    r8833 r8875  
    154154
    155155        if self.myid in self.inlet_procs[0]:
    156             line0 = self.exchange_lines[0]
     156            line0 = self.exchange_lines[0]
     157
     158            if self.invert_elevations is None:
     159                invert_elevation0 = None
     160            else:
     161                invert_elevation0 = self.invert_elevations[0]
     162
    157163            enquiry_point0 = self.enquiry_points[0]
    158164            outward_vector0 = self.culvert_vector
    159165
    160             self.inlets.append(parallel_inlet_enquiry.Parallel_Inlet_enquiry(self.domain, line0,
    161                                enquiry_point0, self.inlet_master_proc[0], self.inlet_procs[0],
    162                                self.enquiry_proc[0], outward_vector0, self.verbose))
     166            self.inlets.append(parallel_inlet_enquiry.Parallel_Inlet_enquiry(
     167                               self.domain,
     168                               line0,
     169                               enquiry_point0,
     170                               invert_elevation = invert_elevation0,
     171                               outward_culvert_vector = outward_vector0,
     172                               master_proc = self.inlet_master_proc[0],
     173                               procs = self.inlet_procs[0],
     174                               enquiry_proc = self.enquiry_proc[0],
     175                               verbose = self.verbose))
    163176        else:
    164177            self.inlets.append(None)
    … …  
    166179        if self.myid in self.inlet_procs[1]:
    167180            line1 = self.exchange_lines[1]
     181
     182            if self.invert_elevations is None:
     183                invert_elevation1 = None
     184            else:
     185                invert_elevation1 = self.invert_elevations[1]
     186
     187
    168188            enquiry_point1 = self.enquiry_points[1]
    169189            outward_vector1  = - self.culvert_vector
    170190
    171             self.inlets.append(parallel_inlet_enquiry.Parallel_Inlet_enquiry(self.domain, line1,
    172                                enquiry_point1, self.inlet_master_proc[1],
    173                                self.inlet_procs[1], self.enquiry_proc[1], outward_vector1, self.verbose))
     191
     192            self.inlets.append(parallel_inlet_enquiry.Parallel_Inlet_enquiry(
     193                               self.domain,
     194                               line1,
     195                               enquiry_point1,
     196                               invert_elevation = invert_elevation1,
     197                               outward_culvert_vector = outward_vector1,
     198                               master_proc = self.inlet_master_proc[1],
     199                               procs = self.inlet_procs[1],
     200                               enquiry_proc = self.enquiry_proc[1],
     201                               verbose = self.verbose))
     202
    174203        else:
    175204            self.inlets.append(None)
    … …  
    508537    def get_culvert_length(self):
    509538        return self.culvert_length
    510        
    511        
     539
     540
    512541    def get_culvert_width(self):       
    513542        return self.width
    … …  
    534563
    535564    # Get id of processors associated with first and second inlet enquiry points
    536     def get_enquiry_proc(self):
    537         return self.enquiry_proc
    538 
     565    def get_enquiry_proc(self, id=None):
     566
     567        if id is none:
     568            return self.enquiry_proc
     569        else:
     570            return self.enquiry_proc[id]
     571
     572
     573    def set_culvert_height(self, height):
     574
     575        self.culvert_height = height
     576
     577    def set_culvert_width(self, width):
     578
     579        self.culvert_width = width
     580
     581       
    539582
    540583    def parallel_safe(self):
    … …  
    542585
    543586
    544 
     587    def get_enquiry_stages(self):
     588        # Should be called from all processors associated with operator
     589
     590        import pypar
     591       
     592
     593        get0 = 'self.inlets[0].get_enquiry_stage()'
     594        get1 = 'self.inlets[1].get_enquiry_stage()'
     595
     596        if self.myid == self.master_proc:
     597
     598            if self.myid == self.enquiry_proc[0]:
     599                enq0 = eval(get0)
     600            else:
     601                enq0 = pypar.receive(self.enquiry_proc[0])
     602
     603
     604            if self.myid == self.enquiry_proc[1]:
     605                enq1 = eval(get1)
     606            else:
     607                enq1 = pypar.receive(self.enquiry_proc[1])
     608
     609        else:
     610            if self.myid == self.enquiry_proc[0]:
     611                enq0 = eval(get0)
     612                pypar.send(enq0, self.master_proc)
     613
     614            if self.myid == self.enquiry_proc[1]:
     615                enq1 = eval(get1)
     616                pypar.send(enq1, self.master_proc)
     617
     618
     619        return [enq0, enq1]
     620
     621    def get_enquiry_depths(self):
     622        # Should be called from all processors associated with operator
     623
     624        import pypar
     625
     626
     627        get0 = 'self.inlets[0].get_enquiry_depth()'
     628        get1 = 'self.inlets[1].get_enquiry_depth()'
     629
     630        if self.myid == self.master_proc:
     631
     632            if self.myid == self.enquiry_proc[0]:
     633                enq0 = eval(get0)
     634            else:
     635                enq0 = pypar.receive(self.enquiry_proc[0])
     636
     637
     638            if self.myid == self.enquiry_proc[1]:
     639                enq1 = eval(get1)
     640            else:
     641                enq1 = pypar.receive(self.enquiry_proc[1])
     642
     643        else:
     644            if self.myid == self.enquiry_proc[0]:
     645                enq0 = eval(get0)
     646                pypar.send(enq0, self.master_proc)
     647
     648            if self.myid == self.enquiry_proc[1]:
     649                enq1 = eval(get1)
     650                pypar.send(enq1, self.master_proc)
     651
     652
     653        return [enq0, enq1]
     654
     655
     656
     657    def get_enquiry_positions(self):
     658
     659        import pypar
     660
     661        get0 = 'self.inlets[0].get_enquiry_position()'
     662        get1 = 'self.inlets[1].get_enquiry_position()'
     663
     664
     665        if self.myid == self.master_proc:
     666
     667            if self.myid == self.enquiry_proc[0]:
     668                enq0 = eval(get0)
     669            else:
     670                enq0 = pypar.receive(self.enquiry_proc[0])
     671
     672
     673            if self.myid == self.enquiry_proc[1]:
     674                enq1 = eval(get1)
     675            else:
     676                enq1 = pypar.receive(self.enquiry_proc[1])
     677
     678        else:
     679            if self.myid == self.enquiry_proc[0]:
     680                enq0 = eval(get0)
     681                pypar.send(enq0, self.master_proc)
     682
     683            if self.myid == self.enquiry_proc[1]:
     684                enq1 = eval(get1)
     685                pypar.send(enq1, self.master_proc)
     686
     687
     688        return [enq0, enq1]
     689
     690
     691    def get_enquiry_xmoms(self):
     692
     693        get0 = 'self.inlets[0].get_enquiry_xmom()'
     694        get1 = 'self.inlets[1].get_enquiry_xmom()'
     695
     696        import pypar
     697
     698
     699        if self.myid == self.master_proc:
     700
     701            if self.myid == self.enquiry_proc[0]:
     702                enq0 = eval(get0)
     703            else:
     704                enq0 = pypar.receive(self.enquiry_proc[0])
     705
     706
     707            if self.myid == self.enquiry_proc[1]:
     708                enq1 = eval(get1)
     709            else:
     710                enq1 = pypar.receive(self.enquiry_proc[1])
     711
     712        else:
     713            if self.myid == self.enquiry_proc[0]:
     714                enq0 = eval(get0)
     715                pypar.send(enq0, self.master_proc)
     716
     717            if self.myid == self.enquiry_proc[1]:
     718                enq1 = eval(get1)
     719                pypar.send(enq1, self.master_proc)
     720
     721
     722        return [enq0, enq1]
     723
     724    def get_enquiry_ymoms(self):
     725
     726        get0 = 'self.inlets[0].get_enquiry_ymom()'
     727        get1 = 'self.inlets[1].get_enquiry_ymom()'
     728
     729        import pypar
     730
     731
     732        if self.myid == self.master_proc:
     733
     734            if self.myid == self.enquiry_proc[0]:
     735                enq0 = eval(get0)
     736            else:
     737                enq0 = pypar.receive(self.enquiry_proc[0])
     738
     739
     740            if self.myid == self.enquiry_proc[1]:
     741                enq1 = eval(get1)
     742            else:
     743                enq1 = pypar.receive(self.enquiry_proc[1])
     744
     745        else:
     746            if self.myid == self.enquiry_proc[0]:
     747                enq0 = eval(get0)
     748                pypar.send(enq0, self.master_proc)
     749
     750            if self.myid == self.enquiry_proc[1]:
     751                enq1 = eval(get1)
     752                pypar.send(enq1, self.master_proc)
     753
     754
     755        return [enq0, enq1]
     756
     757
     758    def get_enquiry_elevations(self):
     759
     760        get0 = 'self.inlets[0].get_enquiry_elevation()'
     761        get1 = 'self.inlets[1].get_enquiry_elevation()'
     762
     763        import pypar
     764
     765
     766        if self.myid == self.master_proc:
     767
     768            if self.myid == self.enquiry_proc[0]:
     769                enq0 = eval(get0)
     770            else:
     771                enq0 = pypar.receive(self.enquiry_proc[0])
     772
     773
     774            if self.myid == self.enquiry_proc[1]:
     775                enq1 = eval(get1)
     776            else:
     777                enq1 = pypar.receive(self.enquiry_proc[1])
     778
     779        else:
     780            if self.myid == self.enquiry_proc[0]:
     781                enq0 = eval(get0)
     782                pypar.send(enq0, self.master_proc)
     783
     784            if self.myid == self.enquiry_proc[1]:
     785                enq1 = eval(get1)
     786                pypar.send(enq1, self.master_proc)
     787
     788
     789        return [enq0, enq1]
     790
     791
     792
     793    def get_enquiry_water_depths(self):
     794
     795        get0 = 'self.inlets[0].get_enquiry_water_depth()'
     796        get1 = 'self.inlets[1].get_enquiry_water_depth()'
     797
     798        import pypar
     799
     800
     801        if self.myid == self.master_proc:
     802
     803            if self.myid == self.enquiry_proc[0]:
     804                enq0 = eval(get0)
     805            else:
     806                enq0 = pypar.receive(self.enquiry_proc[0])
     807
     808
     809            if self.myid == self.enquiry_proc[1]:
     810                enq1 = eval(get1)
     811            else:
     812                enq1 = pypar.receive(self.enquiry_proc[1])
     813
     814        else:
     815            if self.myid == self.enquiry_proc[0]:
     816                enq0 = eval(get0)
     817                pypar.send(enq0, self.master_proc)
     818
     819            if self.myid == self.enquiry_proc[1]:
     820                enq1 = eval(get1)
     821                pypar.send(enq1, self.master_proc)
     822
     823
     824        return [enq0, enq1]
     825
     826
     827    def get_enquiry_invert_elevations(self):
     828
     829        get0 = 'self.inlets[0].get_enquiry_invert_elevation()'
     830        get1 = 'self.inlets[1].get_enquiry_invert_elevation()'
     831
     832        import pypar
     833
     834
     835        if self.myid == self.master_proc:
     836
     837            if self.myid == self.enquiry_proc[0]:
     838                enq0 = eval(get0)
     839            else:
     840                enq0 = pypar.receive(self.enquiry_proc[0])
     841
     842
     843            if self.myid == self.enquiry_proc[1]:
     844                enq1 = eval(get1)
     845            else:
     846                enq1 = pypar.receive(self.enquiry_proc[1])
     847
     848        else:
     849            if self.myid == self.enquiry_proc[0]:
     850                enq0 = eval(get0)
     851                pypar.send(enq0, self.master_proc)
     852
     853            if self.myid == self.enquiry_proc[1]:
     854                enq1 = eval(get1)
     855                pypar.send(enq1, self.master_proc)
     856
     857
     858        return [enq0, enq1]
     859
     860
     861    def get_enquiry_velocitys(self):
     862
     863        get0 = 'self.inlets[0].get_enquiry_velocity()'
     864        get1 = 'self.inlets[1].get_enquiry_velocity()'
     865
     866        import pypar
     867
     868
     869        if self.myid == self.master_proc:
     870
     871            if self.myid == self.enquiry_proc[0]:
     872                enq0 = eval(get0)
     873            else:
     874                enq0 = pypar.receive(self.enquiry_proc[0])
     875
     876
     877            if self.myid == self.enquiry_proc[1]:
     878                enq1 = eval(get1)
     879            else:
     880                enq1 = pypar.receive(self.enquiry_proc[1])
     881
     882        else:
     883            if self.myid == self.enquiry_proc[0]:
     884                enq0 = eval(get0)
     885                pypar.send(enq0, self.master_proc)
     886
     887            if self.myid == self.enquiry_proc[1]:
     888                enq1 = eval(get1)
     889                pypar.send(enq1, self.master_proc)
     890
     891
     892        return [enq0, enq1]
     893
     894
     895    def get_enquiry_xvelocitys(self):
     896
     897        get0 = 'self.inlets[0].get_enquiry_xvelocity()'
     898        get1 = 'self.inlets[1].get_enquiry_xvelocity()'
     899
     900        import pypar
     901
     902
     903        if self.myid == self.master_proc:
     904
     905            if self.myid == self.enquiry_proc[0]:
     906                enq0 = eval(get0)
     907            else:
     908                enq0 = pypar.receive(self.enquiry_proc[0])
     909
     910
     911            if self.myid == self.enquiry_proc[1]:
     912                enq1 = eval(get1)
     913            else:
     914                enq1 = pypar.receive(self.enquiry_proc[1])
     915
     916        else:
     917            if self.myid == self.enquiry_proc[0]:
     918                enq0 = eval(get0)
     919                pypar.send(enq0, self.master_proc)
     920
     921            if self.myid == self.enquiry_proc[1]:
     922                enq1 = eval(get1)
     923                pypar.send(enq1, self.master_proc)
     924
     925
     926        return [enq0, enq1]
     927
     928    def get_enquiry_yvelocitys(self):
     929
     930        get0 = 'self.inlets[0].get_enquiry_yvelocity()'
     931        get1 = 'self.inlets[1].get_enquiry_yvelocity()'
     932
     933        import pypar
     934
     935        if self.myid == self.master_proc:
     936
     937            if self.myid == self.enquiry_proc[0]:
     938                enq0 = eval(get0)
     939            else:
     940                enq0 = pypar.receive(self.enquiry_proc[0])
     941
     942
     943            if self.myid == self.enquiry_proc[1]:
     944                enq1 = eval(get1)
     945            else:
     946                enq1 = pypar.receive(self.enquiry_proc[1])
     947
     948        else:
     949            if self.myid == self.enquiry_proc[0]:
     950                enq0 = eval(get0)
     951                pypar.send(enq0, self.master_proc)
     952
     953            if self.myid == self.enquiry_proc[1]:
     954                enq1 = eval(get1)
     955                pypar.send(enq1, self.master_proc)
     956
     957
     958        return [enq0, enq1]
     959
     960
     961    def get_enquiry_speeds(self):
     962
     963        get0 = 'self.inlets[0].get_enquiry_speed()'
     964        get1 = 'self.inlets[1].get_enquiry_speed()'
     965
     966        import pypar
     967
     968
     969        if self.myid == self.master_proc:
     970
     971            if self.myid == self.enquiry_proc[0]:
     972                enq0 = eval(get0)
     973            else:
     974                enq0 = pypar.receive(self.enquiry_proc[0])
     975
     976
     977            if self.myid == self.enquiry_proc[1]:
     978                enq1 = eval(get1)
     979            else:
     980                enq1 = pypar.receive(self.enquiry_proc[1])
     981
     982        else:
     983            if self.myid == self.enquiry_proc[0]:
     984                enq0 = eval(get0)
     985                pypar.send(enq0, self.master_proc)
     986
     987            if self.myid == self.enquiry_proc[1]:
     988                enq1 = eval(get1)
     989                pypar.send(enq1, self.master_proc)
     990
     991
     992        return [enq0, enq1]
     993
     994
     995    def get_enquiry_velocity_heads(self):
     996
     997        get0 = 'self.inlets[0].get_enquiry_velocity_head()'
     998        get1 = 'self.inlets[1].get_enquiry_velocity_head()'
     999
     1000        import pypar
     1001
     1002
     1003        if self.myid == self.master_proc:
     1004
     1005            if self.myid == self.enquiry_proc[0]:
     1006                enq0 = eval(get0)
     1007            else:
     1008                enq0 = pypar.receive(self.enquiry_proc[0])
     1009
     1010
     1011            if self.myid == self.enquiry_proc[1]:
     1012                enq1 = eval(get1)
     1013            else:
     1014                enq1 = pypar.receive(self.enquiry_proc[1])
     1015
     1016        else:
     1017            if self.myid == self.enquiry_proc[0]:
     1018                enq0 = eval(get0)
     1019                pypar.send(enq0, self.master_proc)
     1020
     1021            if self.myid == self.enquiry_proc[1]:
     1022                enq1 = eval(get1)
     1023                pypar.send(enq1, self.master_proc)
     1024
     1025
     1026        return [enq0, enq1]
     1027
     1028
     1029    def get_enquiry_total_energys(self):
     1030
     1031        get0 = 'self.inlets[0].get_enquiry_total_energy()'
     1032        get1 = 'self.inlets[1].get_enquiry_total_energy()'
     1033
     1034        import pypar
     1035
     1036
     1037        if self.myid == self.master_proc:
     1038
     1039            if self.myid == self.enquiry_proc[0]:
     1040                enq0 = eval(get0)
     1041            else:
     1042                enq0 = pypar.receive(self.enquiry_proc[0])
     1043
     1044
     1045            if self.myid == self.enquiry_proc[1]:
     1046                enq1 = eval(get1)
     1047            else:
     1048                enq1 = pypar.receive(self.enquiry_proc[1])
     1049
     1050        else:
     1051            if self.myid == self.enquiry_proc[0]:
     1052                enq0 = eval(get0)
     1053                pypar.send(enq0, self.master_proc)
     1054
     1055            if self.myid == self.enquiry_proc[1]:
     1056                enq1 = eval(get1)
     1057                pypar.send(enq1, self.master_proc)
     1058
     1059
     1060        return [enq0, enq1]
     1061
     1062
     1063    def get_enquiry_specific_energys(self):
     1064
     1065        get0 = 'self.inlets[0].get_enquiry_specific_energy()'
     1066        get1 = 'self.inlets[1].get_enquiry_specific_energy()'
     1067
     1068        import pypar
     1069
     1070
     1071        if self.myid == self.master_proc:
     1072
     1073            if self.myid == self.enquiry_proc[0]:
     1074                enq0 = eval(get0)
     1075            else:
     1076                enq0 = pypar.receive(self.enquiry_proc[0])
     1077
     1078
     1079            if self.myid == self.enquiry_proc[1]:
     1080                enq1 = eval(get1)
     1081            else:
     1082                enq1 = pypar.receive(self.enquiry_proc[1])
     1083
     1084        else:
     1085            if self.myid == self.enquiry_proc[0]:
     1086                enq0 = eval(get0)
     1087                pypar.send(enq0, self.master_proc)
     1088
     1089            if self.myid == self.enquiry_proc[1]:
     1090                enq1 = eval(get1)
     1091                pypar.send(enq1, self.master_proc)
     1092
     1093
     1094        return [enq0, enq1]
     1095
     1096
Note: See TracChangeset for help on using the changeset viewer.