Changeset 648


Ignore:
Timestamp:
Dec 1, 2004, 4:36:33 PM (20 years ago)
Author:
ole
Message:

Refactoring boundary structure to allow None Boundary object for internal boundaries.

Location:
inundation/ga/storm_surge/pyvolution
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • inundation/ga/storm_surge/pyvolution/domain.py

    r590 r648  
    180180        More entries may point to the same boundary object
    181181       
    182         Schematically the mapping is:
    183 
    184         self.boundary_segments: k: (vol_id, edge_id)
     182        Schematically the mapping is from two dictionaries to one list
     183        where the index is used as pointer to the boundary_values arrays
     184        within each quantity.
     185
    185186        self.boundary:          (vol_id, edge_id): tag
    186187        boundary_map (input):   tag: boundary_object
    187188        ----------------------------------------------
    188         self.boundary_objects:  k: boundary_object
     189        self.boundary_objects:  ((vol_id, edge_id), boundary_object)
    189190       
    190191
    191192        Pre-condition:
    192           self.boundary and self.boundary_segments have been built.
     193          self.boundary has been built.
    193194
    194195        Post-condition:
    … …  
    199200        However, if a tag is not used to the domain, no error is thrown.
    200201        FIXME: This would lead to implementation of a
    201         default boundary condition
     202        default boundary condition       
     203
     204        Note: If a segment is listed in the boundary dictionary and if it is
     205        not None, it *will* become a boundary -
     206        even if there is a neighbouring triangle.
     207        This would be the case for internal boundaries
     208       
     209        Boundary objects that are None will be skipped.
     210
     211        FIXME: If set_boundary is called multiple times and if Boundary
     212        object is changed into None, the neighbour structure will not be
     213        restored!!!
     214       
     215
    202216        """
    203217
    204218        self.boundary_objects = []
    205         for k, (vol_id, edge_id) in enumerate(self.boundary_segments):
     219
     220        #FIXME: Try to remove the sorting and fix test_mesh.py
     221        x = self.boundary.keys()
     222        x.sort()
     223        for k, (vol_id, edge_id) in enumerate(x):
    206224            tag = self.boundary[ (vol_id, edge_id) ]
    207225
    208226            if boundary_map.has_key(tag):
    209227                B = boundary_map[tag]
    210                 self.boundary_objects.append(B)               
     228
     229                if B is not None:
     230                    self.boundary_objects.append( ((vol_id, edge_id), B) )
     231                    self.neighbours[vol_id, edge_id] = -len(self.boundary_objects)
     232                else:
     233                    pass
     234                    #FIXME: Check and perhaps fix neighbour structure
     235                   
    211236
    212237            else:
    … …  
    379404
    380405        #FIXME: Update only those that change (if that can be worked out)
    381         for i, B in enumerate(self.boundary_objects):
    382             vol_id, edge_id = self.boundary_segments[i]
     406        for i, ((vol_id, edge_id), B) in enumerate(self.boundary_objects):
    383407            q = B.evaluate(vol_id, edge_id)
    384408

  • inundation/ga/storm_surge/pyvolution/mesh.py

    r645 r648  
    131131       
    132132        #Update boundary indices
    133         self.build_boundary_structure()       
     133        #self.build_boundary_structure()       
    134134
    135135       
    … …  
    313313        """
    314314
     315        #FIXME: Maybe obsolete
     316
    315317        if self.boundary is None:
    316318            msg = 'Boundary dictionary must be defined before '
    … …  
    436438        #Check that all boundaries have
    437439        # unique, consecutive, negative indices                   
    438         L = len(self.boundary)
    439         for i in range(L):
    440             id, edge = self.boundary_segments[i]
    441             assert self.neighbours[id, edge] == -i-1
     440
     441        #L = len(self.boundary)
     442        #for i in range(L):
     443        #    id, edge = self.boundary_segments[i]
     444        #    assert self.neighbours[id, edge] == -i-1
    442445
    443446
    … …  
    445448        #FIXME: Look into this further.
    446449        #FIXME (Ole): In pyvolution mark 3 this is OK again
    447         for id, edge in self.boundary:
    448             assert self.neighbours[id,edge] < 0
     450        #NOTE: No longer works because neighbour structure is modified by
     451        #      domain set_boundary.
     452        #for id, edge in self.boundary:
     453        #    assert self.neighbours[id,edge] < 0
    449454
    450455

  • inundation/ga/storm_surge/pyvolution/test_advection.py

    r195 r648  
    4646        domain.check_integrity()
    4747
    48         assert allclose(domain.neighbours, [[-1,-2,-3]])       
    49                
     48
    5049        #Populate boundary array with dirichlet conditions.
     50        domain.neighbours = array([[-1,-2,-3]])         
    5151        domain.quantities['level'].boundary_values[:] = 1.0
    5252
    … …  
    100100        domain.check_integrity()
    101101
    102         assert allclose(domain.neighbours, [[-1,-2,-3]])       
    103102               
    104103        #Populate boundary array with dirichlet conditions.
     104        domain.neighbours = array([[-1,-2,-3]])                 
    105105        domain.quantities['level'].boundary_values[0] = 1.0
    106106       
    … …  
    131131        domain.check_integrity()
    132132
    133         assert allclose(domain.neighbours, [[1,-1,-2], [0,-3,-4]])     
    134133
    135134        #Populate boundary array with dirichlet conditions.
    136 
     135        domain.neighbours = array([[1,-1,-2], [0,-3,-4]])
    137136        domain.set_quantity('level', [1.0, 0.0], 'centroids')
    138137        domain.distribute_to_vertices_and_edges()

  • inundation/ga/storm_surge/pyvolution/test_domain.py

    r546 r648  
    137137        assert allclose(q, [-1.5, -1.5, 0.])                   
    138138
     139
     140    def test_boundary_indices(self):
     141
     142        from config import default_boundary_tag
     143
     144       
     145        a = [0.0, 0.5]
     146        b = [0.0, 0.0]               
     147        c = [0.5, 0.5]
     148
     149        points = [a, b, c]
     150        vertices = [ [0,1,2] ]
     151        domain = Domain(points, vertices)
     152
     153        domain.set_boundary( {default_boundary_tag: Dirichlet_boundary([5,2,1])} )
     154
     155       
     156        domain.check_integrity()
     157
     158        assert allclose(domain.neighbours, [[-1,-2,-3]])       
     159               
    139160
    140161
    … …  
    185206        assert domain.quantities['level'].boundary_values[5] ==\
    186207               domain.get_conserved_quantities(3, edge=2)[0] #Transmissive (-1.5)         
     208
     209        #Check enumeration
     210        for k, ((vol_id, edge_id), _) in enumerate(domain.boundary_objects):
     211            assert domain.neighbours[vol_id, edge_id] == -k-1
     212
    187213
    188214

  • inundation/ga/storm_surge/pyvolution/test_generic_boundary_conditions.py

    r625 r648  
    9191        domain.set_boundary( {default_boundary_tag: T} )
    9292
    93         assert len(domain.boundary) == len(domain.boundary_segments)
    94         assert len(domain.boundary_objects) == len(domain.boundary_segments)
     93
     94        #FIXME: should not necessarily be true always.
     95        #E.g. with None as a boundary object.
     96        assert len(domain.boundary) == len(domain.boundary_objects)
    9597
    9698        q = T.evaluate(0, 2)  #Vol=0, edge=2

  • inundation/ga/storm_surge/pyvolution/test_mesh.py

    r601 r648  
    209209
    210210
    211     def test_boundary_indices(self):
    212         a = [0.0, 0.5]
    213         b = [0.0, 0.0]               
    214         c = [0.5, 0.5]
    215 
    216         points = [a, b, c]
    217         vertices = [ [0,1,2] ]
    218         mesh = Mesh(points, vertices)       
    219         mesh.check_integrity()
    220 
    221         assert allclose(mesh.neighbours, [[-1,-2,-3]]) 
    222                
    223211
    224212
    … …  
    490478
    491479        #Check enumeration
    492         for k, (vol_id, edge_id) in enumerate(mesh.boundary_segments):       
    493             b = -k-1
    494             assert mesh.neighbours[vol_id, edge_id] == b
     480        #for k, (vol_id, edge_id) in enumerate(mesh.boundary_segments):       
     481        #    b = -k-1
     482        #    assert mesh.neighbours[vol_id, edge_id] == b
    495483
    496484
    … …  
    525513
    526514        #Check enumeration
    527         for k, (vol_id, edge_id) in enumerate(mesh.boundary_segments):       
    528             b = -k-1
    529             assert mesh.neighbours[vol_id, edge_id] == b
     515        #for k, (vol_id, edge_id) in enumerate(mesh.boundary_segments):       
     516        #    b = -k-1
     517        #    assert mesh.neighbours[vol_id, edge_id] == b
    530518
    531519    def test_boundary_inputs_using_all_defaults(self):
    … …  
    563551
    564552        #Check enumeration
    565         for k, (vol_id, edge_id) in enumerate(mesh.boundary_segments):       
    566             b = -k-1
    567             assert mesh.neighbours[vol_id, edge_id] == b
     553        #for k, (vol_id, edge_id) in enumerate(mesh.boundary_segments):       
     554        #    b = -k-1
     555        #    assert mesh.neighbours[vol_id, edge_id] == b
    568556
    569557

  • inundation/ga/storm_surge/pyvolution/test_shallow_water.py

    r646 r648  
    297297        T = Transmissive_boundary(domain)
    298298        R = Reflective_boundary(domain)
    299         domain.set_boundary( {'First': D, 'Second': T, 'Third': R, 'Internal':None})
    300        
     299        domain.set_boundary( {'First': D, 'Second': T,
     300                              'Third': R, 'Internal': None})
     301
    301302        domain.update_boundary()
    302 
    303         #Level
    304         assert domain.quantities['level'].boundary_values[0] == 2.5
    305         assert domain.quantities['level'].boundary_values[0] ==\
    306                domain.get_conserved_quantities(0, edge=0)[0] #Reflective (2.5)
    307         assert domain.quantities['level'].boundary_values[1] == 5. #Dirichlet
    308         assert domain.quantities['level'].boundary_values[2] ==\
    309                domain.get_conserved_quantities(2, edge=0)[0] #Transmissive (4.5)
    310         assert domain.quantities['level'].boundary_values[3] ==\
    311                domain.get_conserved_quantities(2, edge=1)[0] #Transmissive (4.5)
    312         assert domain.quantities['level'].boundary_values[4] ==\
    313                domain.get_conserved_quantities(3, edge=1)[0] #Transmissive (-1.5)
    314         assert domain.quantities['level'].boundary_values[5] ==\
    315                domain.get_conserved_quantities(3, edge=2)[0] #Reflective (-1.5)
    316 
    317         #Xmomentum
    318         assert domain.quantities['xmomentum'].boundary_values[0] == 1.0 #Reflective
    319         assert domain.quantities['xmomentum'].boundary_values[1] == 2. #Dirichlet
    320         assert domain.quantities['xmomentum'].boundary_values[2] ==\
    321                domain.get_conserved_quantities(2, edge=0)[1] #Transmissive
    322         assert domain.quantities['xmomentum'].boundary_values[3] ==\
    323                domain.get_conserved_quantities(2, edge=1)[1] #Transmissive
    324         assert domain.quantities['xmomentum'].boundary_values[4] ==\
    325                domain.get_conserved_quantities(3, edge=1)[1] #Transmissive
    326         assert domain.quantities['xmomentum'].boundary_values[5] == -4.0  #Reflective
    327        
    328         #Ymomentum
    329         assert domain.quantities['ymomentum'].boundary_values[0] == -10.0 #Reflective
    330         assert domain.quantities['ymomentum'].boundary_values[1] == 1.  #Dirichlet
    331         assert domain.quantities['ymomentum'].boundary_values[2] == 30. #Transmissive
    332         assert domain.quantities['ymomentum'].boundary_values[3] == 30. #Transmissive
    333         assert domain.quantities['ymomentum'].boundary_values[4] == 40. #Transmissive
    334         assert domain.quantities['ymomentum'].boundary_values[5] == 40. #Reflective
     303        domain.check_integrity()
    335304
    336305
Note: See TracChangeset for help on using the changeset viewer.