Ignore:
Timestamp:
Feb 10, 2009, 11:11:04 AM (16 years ago)
Author:
rwilson
Message:

Initial commit of numpy changes. Still a long way to go.

Location:
branches/numpy
Files:
1 edited
1 copied

Legend:

Unmodified
Added
Removed

  • branches/numpy/anuga/pmesh/test_mesh_interface.py

    r6199 r6304  
    11#!/usr/bin/env python
    2 #
     2
    33import tempfile
    44import unittest
    … …  
    1313from anuga.coordinate_transforms.geo_reference import Geo_reference,DEFAULT_ZONE
    1414
     15
    1516class TestCase(unittest.TestCase):
    1617    def setUp(self):
    1718        pass
    18    
     19
    1920    def tearDown(self):
    2021        pass
    … …  
    2324        x=-500
    2425        y=-1000
    25         mesh_geo = geo_reference=Geo_reference(56,x,y)
    26        
    27         # These are the absolute values
    28         polygon_absolute = [[0,0],[100,0],[100,100],[0,100]]
    29        
     26        mesh_geo = geo_reference=Geo_reference(56, x, y)
     27
     28        # These are the absolute values
     29        polygon_absolute = [[0,0], [100,0], [100,100], [0,100]]
     30
    3031        x_p = -10
    3132        y_p = -40
    … …  
    3334        polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
    3435
    35         boundary_tags = {'walls':[0,1],'bom':[2,3]}
    36        
    37         inner1_polygon_absolute = [[10,10],[20,10],[20,20],[10,20]]
    38         inner1_polygon = geo_ref_poly. \
    39                          change_points_geo_ref(inner1_polygon_absolute)
    40 
    41         inner2_polygon_absolute = [[30,30],[40,30],[40,40],[30,40]]
    42         inner2_polygon = geo_ref_poly. \
    43                          change_points_geo_ref(inner2_polygon_absolute)
    44        
    45         interior_regions = [(inner1_polygon, 5),(inner2_polygon, 10)]
    46        
    47         #print polygon
    48         #print boundary_tags
    49        
     36        boundary_tags = {'walls': [0,1], 'bom': [2,3]}
     37
     38        inner1_polygon_absolute = [[10,10], [20,10], [20,20], [10,20]]
     39        inner1_polygon = geo_ref_poly.\
     40                            change_points_geo_ref(inner1_polygon_absolute)
     41
     42        inner2_polygon_absolute = [[30,30], [40,30], [40,40], [30,40]]
     43        inner2_polygon = geo_ref_poly.\
     44                            change_points_geo_ref(inner2_polygon_absolute)
     45
     46        interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
     47
    5048        m = create_mesh_from_regions(polygon,
    5149                                     boundary_tags,
    … …  
    5654
    5755        # Test the mesh instance
    58         self.failUnless(len(m.regions)==3,
    59                         'FAILED!')
     56        self.failUnless(len(m.regions)==3, 'FAILED!')
    6057        segs = m.getUserSegments()
    61         self.failUnless(len(segs)==12,
    62                         'FAILED!')
    63         self.failUnless(len(m.userVertices)==12,
    64                         'FAILED!')
    65         self.failUnless(segs[0].tag=='walls',
    66                         'FAILED!') 
    67         self.failUnless(segs[1].tag=='walls',
    68                         'FAILED!')
    69          
    70         self.failUnless(segs[2].tag=='bom',
    71                         'FAILED!')
    72         self.failUnless(segs[3].tag=='bom',
    73                         'FAILED!')
     58        self.failUnless(len(segs)==12, 'FAILED!')
     59        self.failUnless(len(m.userVertices)==12, 'FAILED!')
     60        self.failUnless(segs[0].tag=='walls', 'FAILED!')
     61        self.failUnless(segs[1].tag=='walls', 'FAILED!')
     62        self.failUnless(segs[2].tag=='bom', 'FAILED!')
     63        self.failUnless(segs[3].tag=='bom', 'FAILED!')
    7464
    7565        # Assuming the order of the region points is known.
    … …  
    7767        # a black box)
    7868        poly_point = m.getRegions()[0]
    79        
    80         #print "poly_point", poly_point
    81         #print "polygon_absolute",polygon_absolute
    82          
     69
    8370        # poly_point values are relative to the mesh geo-ref
    8471        # make them absolute
    85         self.failUnless(is_inside_polygon([poly_point.x+x,poly_point.y+y],
    86                                           polygon_absolute, closed = False),
     72        self.failUnless(is_inside_polygon([poly_point.x+x, poly_point.y+y],
     73                                          polygon_absolute, closed=False),
    8774                        'FAILED!')
    88        
     75
    8976        # Assuming the order of the region points is known.
    9077        # (This isn't true, if you consider create_mesh_from_regions
    9178        # a black box)
    9279        poly_point = m.getRegions()[1]
    93        
    94         #print "poly_point", poly_point
    95         #print "polygon_absolute",polygon_absolute
    96          
     80
    9781        # poly_point values are relative to the mesh geo-ref
    9882        # make them absolute
    99         self.failUnless(is_inside_polygon([poly_point.x+x,poly_point.y+y],
     83        self.failUnless(is_inside_polygon([poly_point.x+x, poly_point.y+y],
    10084                                          inner1_polygon_absolute,
    101                                           closed = False),
     85                                          closed=False),
    10286                        'FAILED!')
    103        
     87
    10488        # Assuming the order of the region points is known.
    10589        # (This isn't true, if you consider create_mesh_from_regions
    10690        # a black box)
    10791        poly_point = m.getRegions()[2]
    108        
    109         #print "poly_point", poly_point
    110         #print "polygon_absolute",polygon_absolute
    111          
     92
    11293        # poly_point values are relative to the mesh geo-ref
    11394        # make them absolute
    114         self.failUnless(is_inside_polygon([poly_point.x+x,poly_point.y+y],
     95        self.failUnless(is_inside_polygon([poly_point.x+x, poly_point.y+y],
    11596                                          inner2_polygon_absolute,
    116                                           closed = False),
     97                                          closed=False),
    11798                        'FAILED!')
    118 
    11999
    120100    def test_create_mesh_from_regions_with_caching(self):
    121101        x=-500
    122102        y=-1000
    123         mesh_geo = geo_reference=Geo_reference(56,x,y)
    124        
    125         # These are the absolute values
    126         polygon_absolute = [[0,0],[100,0],[100,100],[0,100]]
    127        
     103        mesh_geo = geo_reference=Geo_reference(56, x, y)
     104
     105        # These are the absolute values
     106        polygon_absolute = [[0,0], [100,0], [100,100], [0,100]]
     107
    128108        x_p = -10
    129109        y_p = -40
    … …  
    131111        polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
    132112
    133         boundary_tags = {'walls':[0,1],'bom':[2,3]}
    134        
    135         inner1_polygon_absolute = [[10,10],[20,10],[20,20],[10,20]]
    136         inner1_polygon = geo_ref_poly. \
    137                          change_points_geo_ref(inner1_polygon_absolute)
    138 
    139         inner2_polygon_absolute = [[30,30],[40,30],[40,40],[30,40]]
    140         inner2_polygon = geo_ref_poly. \
    141                          change_points_geo_ref(inner2_polygon_absolute)
    142        
    143         interior_regions = [(inner1_polygon, 5),(inner2_polygon, 10)]
     113        boundary_tags = {'walls': [0,1], 'bom': [2,3]}
     114
     115        inner1_polygon_absolute = [[10,10], [20,10], [20,20], [10,20]]
     116        inner1_polygon = geo_ref_poly.\
     117                            change_points_geo_ref(inner1_polygon_absolute)
     118
     119        inner2_polygon_absolute = [[30,30], [40,30], [40,40], [30,40]]
     120        inner2_polygon = geo_ref_poly.\
     121                             change_points_geo_ref(inner2_polygon_absolute)
     122
     123        interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
    144124
    145125        interior_holes = None
    … …  
    147127        # Clear cache first
    148128        from anuga.caching import cache
     129
    149130        cache(_create_mesh_from_regions,
    150131              (polygon, boundary_tags),
    … …  
    159140              clear=1)
    160141
    161         #print polygon
    162         #print boundary_tags
    163        
    164142        m = create_mesh_from_regions(polygon,
    165143                                     boundary_tags,
    … …  
    173151
    174152        # Test the mesh instance
    175         self.failUnless(len(m.regions)==3,
    176                         'FAILED!')
     153        self.failUnless(len(m.regions)==3, 'FAILED!')
    177154        segs = m.getUserSegments()
    178         self.failUnless(len(segs)==12,
    179                         'FAILED!')
    180         self.failUnless(len(m.userVertices)==12,
    181                         'FAILED!')
    182         self.failUnless(segs[0].tag=='walls',
    183                         'FAILED!') 
    184         self.failUnless(segs[1].tag=='walls',
    185                         'FAILED!')
    186          
    187         self.failUnless(segs[2].tag=='bom',
    188                         'FAILED!')
    189         self.failUnless(segs[3].tag=='bom',
    190                         'FAILED!')
     155        self.failUnless(len(segs)==12, 'FAILED!')
     156        self.failUnless(len(m.userVertices)==12, 'FAILED!')
     157        self.failUnless(segs[0].tag=='walls', 'FAILED!')
     158        self.failUnless(segs[1].tag=='walls', 'FAILED!')
     159        self.failUnless(segs[2].tag=='bom', 'FAILED!')
     160        self.failUnless(segs[3].tag=='bom', 'FAILED!')
    191161
    192162        # Assuming the order of the region points is known.
    … …  
    194164        # a black box)
    195165        poly_point = m.getRegions()[0]
    196        
    197         #print "poly_point", poly_point
    198         #print "polygon_absolute",polygon_absolute
    199          
     166
    200167        # poly_point values are relative to the mesh geo-ref
    201168        # make them absolute
    202         self.failUnless(is_inside_polygon([poly_point.x+x,poly_point.y+y],
    203                                           polygon_absolute, closed = False),
     169        self.failUnless(is_inside_polygon([poly_point.x+x, poly_point.y+y],
     170                                          polygon_absolute,
     171                                          closed=False),
    204172                        'FAILED!')
    205        
     173
    206174        # Assuming the order of the region points is known.
    207175        # (This isn't true, if you consider create_mesh_from_regions
    208176        # a black box)
    209177        poly_point = m.getRegions()[1]
    210        
    211         #print "poly_point", poly_point
    212         #print "polygon_absolute",polygon_absolute
    213          
     178
    214179        # poly_point values are relative to the mesh geo-ref
    215180        # make them absolute
    216         self.failUnless(is_inside_polygon([poly_point.x+x,poly_point.y+y],
     181        self.failUnless(is_inside_polygon([poly_point.x+x, poly_point.y+y],
    217182                                          inner1_polygon_absolute,
    218                                           closed = False),
     183                                          closed=False),
    219184                        'FAILED!')
    220        
     185
    221186        # Assuming the order of the region points is known.
    222187        # (This isn't true, if you consider create_mesh_from_regions
    223188        # a black box)
    224189        poly_point = m.getRegions()[2]
    225        
    226         #print "poly_point", poly_point
    227         #print "polygon_absolute",polygon_absolute
    228          
     190
    229191        # poly_point values are relative to the mesh geo-ref
    230192        # make them absolute
    231         self.failUnless(is_inside_polygon([poly_point.x+x,poly_point.y+y],
     193        self.failUnless(is_inside_polygon([poly_point.x+x, poly_point.y+y],
    232194                                          inner2_polygon_absolute,
    233                                           closed = False),
     195                                          closed=False),
    234196                        'FAILED!')
    235 
    236197
    237198        # Now create m using cached values
    … …  
    245206                                           use_cache=True)
    246207
    247 
    248 
    249        
    250208    def test_create_mesh_from_regions2(self):
    251 
    252         # These are the absolute values
    253         min_x = -10
     209        # These are the absolute values
     210        min_x = -10
    254211        min_y = -88
    255         polygon_absolute = [[min_x,min_y],[1000,100],[1000,1000],[100,1000]]
    256        
     212        polygon_absolute = [[min_x,min_y], [1000,100], [1000,1000], [100,1000]]
     213
    257214        x_p = -10
    258215        y_p = -40
    … …  
    261218        polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
    262219
    263         boundary_tags = {'walls':[0,1],'bom':[2,3]}
    264        
    265         inner1_polygon_absolute = [[10,10],[20,10],[20,20],[10,20]]
    266         inner1_polygon = geo_ref_poly. \
    267                          change_points_geo_ref(inner1_polygon_absolute)
    268 
    269         inner2_polygon_absolute = [[30,30],[40,30],[40,40],[30,40]]
    270         inner2_polygon = geo_ref_poly. \
    271                          change_points_geo_ref(inner2_polygon_absolute)
    272        
    273         interior_regions = [(inner1_polygon, 5),(inner2_polygon, 10)]
     220        boundary_tags = {'walls': [0,1], 'bom': [2,3]}
     221
     222        inner1_polygon_absolute = [[10,10], [20,10], [20,20], [10,20]]
     223        inner1_polygon = geo_ref_poly.\
     224                            change_points_geo_ref(inner1_polygon_absolute)
     225
     226        inner2_polygon_absolute = [[30,30], [40,30], [40,40], [30,40]]
     227        inner2_polygon = geo_ref_poly.\
     228                            change_points_geo_ref(inner2_polygon_absolute)
     229
     230        interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
    274231        m = create_mesh_from_regions(polygon,
    275232                                     boundary_tags,
    … …  
    277234                                     interior_regions=interior_regions,
    278235                                     poly_geo_reference=geo_ref_poly)
    279        
    280236
    281237        # Test the mesh instance
    282         self.failUnless(len(m.regions)==3,
    283                         'FAILED!')
     238        self.failUnless(len(m.regions)==3, 'FAILED!')
    284239        segs = m.getUserSegments()
    285         self.failUnless(len(segs)==12,
    286                         'FAILED!')
    287         self.failUnless(len(m.userVertices)==12,
    288                         'FAILED!')
    289         self.failUnless(segs[0].tag=='walls',
    290                         'FAILED!') 
    291         self.failUnless(segs[1].tag=='walls',
    292                         'FAILED!')
    293          
    294         self.failUnless(segs[2].tag=='bom',
    295                         'FAILED!')
    296         self.failUnless(segs[3].tag=='bom',
    297                         'FAILED!')
    298        
    299         self.failUnless(m.geo_reference.get_zone()==zone,
    300                         'FAILED!')
    301         self.failUnless(m.geo_reference.get_xllcorner()==min_x,
    302                         'FAILED!')
    303         self.failUnless(m.geo_reference.get_yllcorner()==min_y,
    304                         'FAILED!')
    305 
    306        
     240        self.failUnless(len(segs)==12, 'FAILED!')
     241        self.failUnless(len(m.userVertices)==12, 'FAILED!')
     242        self.failUnless(segs[0].tag=='walls', 'FAILED!')
     243        self.failUnless(segs[1].tag=='walls', 'FAILED!')
     244        self.failUnless(segs[2].tag=='bom', 'FAILED!')
     245        self.failUnless(segs[3].tag=='bom', 'FAILED!')
     246        self.failUnless(m.geo_reference.get_zone()==zone, 'FAILED!')
     247        self.failUnless(m.geo_reference.get_xllcorner()==min_x, 'FAILED!')
     248        self.failUnless(m.geo_reference.get_yllcorner()==min_y, 'FAILED!')
     249
    307250    def test_create_mesh_from_regions3(self):
    308 
    309         # These are the absolute values
    310         min_x = -10
     251        # These are the absolute values
     252        min_x = -10
    311253        min_y = -88
    312         polygon = [[min_x,min_y],[1000,100],[1000,1000],[100,1000]]
    313        
     254        polygon = [[min_x,min_y], [1000,100], [1000,1000], [100,1000]]
     255
    314256
    315257        x_p = -10
    316258        y_p = -40
    317259        geo_ref_poly = Geo_reference(56, x_p, y_p)
    318        
    319         boundary_tags = {'walls':[0,1],'bom':[2,3]}
    320        
    321         inner1_polygon_absolute = [[10,10],[20,10],[20,20],[10,20]]
    322         inner1_polygon = geo_ref_poly. \
    323                          change_points_geo_ref(inner1_polygon_absolute)
    324 
    325         inner2_polygon_absolute = [[30,30],[40,30],[40,40],[30,40]]
    326         inner2_polygon = geo_ref_poly. \
    327                          change_points_geo_ref(inner2_polygon_absolute)
    328        
    329         interior_regions = [(inner1_polygon, 5),(inner2_polygon, 10)]
     260
     261        boundary_tags = {'walls': [0,1], 'bom': [2,3]}
     262
     263        inner1_polygon_absolute = [[10,10], [20,10], [20,20], [10,20]]
     264        inner1_polygon = geo_ref_poly.\
     265                            change_points_geo_ref(inner1_polygon_absolute)
     266
     267        inner2_polygon_absolute = [[30,30], [40,30], [40,40], [30,40]]
     268        inner2_polygon = geo_ref_poly.\
     269                            change_points_geo_ref(inner2_polygon_absolute)
     270
     271        interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
    330272        m = create_mesh_from_regions(polygon,
    331273                                     boundary_tags,
    332274                                     10000000,
    333275                                     interior_regions=interior_regions)
    334        
    335276
    336277        # Test the mesh instance
    337         self.failUnless(len(m.regions)==3,
    338                         'FAILED!')
     278        self.failUnless(len(m.regions) == 3, 'FAILED!')
    339279        segs = m.getUserSegments()
    340         self.failUnless(len(segs)==12,
    341                         'FAILED!')
    342         self.failUnless(len(m.userVertices)==12,
    343                         'FAILED!')
    344         self.failUnless(segs[0].tag=='walls',
    345                         'FAILED!') 
    346         self.failUnless(segs[1].tag=='walls',
    347                         'FAILED!')
    348          
    349         self.failUnless(segs[2].tag=='bom',
    350                         'FAILED!')
    351         self.failUnless(segs[3].tag=='bom',
    352                         'FAILED!')
    353        
    354         self.failUnless(m.geo_reference.get_zone()==DEFAULT_ZONE,
    355                         'FAILED!')
    356         self.failUnless(m.geo_reference.get_xllcorner()==min_x,
    357                         'FAILED!')
    358         self.failUnless(m.geo_reference.get_yllcorner()==min_y,
    359                         'FAILED!')
     280        self.failUnless(len(segs) == 12, 'FAILED!')
     281        self.failUnless(len(m.userVertices) == 12, 'FAILED!')
     282        self.failUnless(segs[0].tag == 'walls', 'FAILED!')
     283        self.failUnless(segs[1].tag == 'walls', 'FAILED!')
     284        self.failUnless(segs[2].tag == 'bom', 'FAILED!')
     285        self.failUnless(segs[3].tag == 'bom', 'FAILED!')
     286        self.failUnless(m.geo_reference.get_zone() == DEFAULT_ZONE, 'FAILED!')
     287        self.failUnless(m.geo_reference.get_xllcorner() == min_x, 'FAILED!')
     288        self.failUnless(m.geo_reference.get_yllcorner() == min_y, 'FAILED!')
    360289
    361290    def test_create_mesh_from_regions4(self):
    362 
    363         file_name = tempfile.mktemp(".tsh")
    364        
     291        file_name = tempfile.mktemp('.tsh')
     292
    365293        # These are the absolute values
    366294        density_outer = 1000
    367         min_outer = 0 
     295        min_outer = 0
    368296        max_outer = 1000
    369         polygon_outer = [[min_outer,min_outer],[max_outer,min_outer],
    370                    [max_outer,max_outer],[min_outer,max_outer]]
    371        
     297        polygon_outer = [[min_outer,min_outer], [max_outer,min_outer],
     298                         [max_outer,max_outer], [min_outer,max_outer]]
     299
    372300        density_inner1 = 10000000
    373301        inner_buffer = 100
    374302        min_inner1 = min_outer + inner_buffer
    375303        max_inner1 = max_outer - inner_buffer
    376         inner1_polygon = [[min_inner1,min_inner1],[max_inner1,min_inner1],
    377                    [max_inner1,max_inner1],[min_inner1,max_inner1]]
    378      
    379        
    380         boundary_tags = {'walls':[0,1],'bom':[2,3]}
    381        
     304        inner1_polygon = [[min_inner1,min_inner1], [max_inner1,min_inner1],
     305                          [max_inner1,max_inner1], [min_inner1,max_inner1]]
     306
     307        boundary_tags = {'walls': [0,1], 'bom': [2,3]}
     308
    382309        interior_regions = [(inner1_polygon, density_inner1)]
    383         create_mesh_from_regions(polygon_outer
    384                                      , boundary_tags
    385                                      , density_outer
    386                                      , interior_regions=interior_regions
    387                                      ,filename=file_name
    388                                      #,verbose=True
    389                                      ,verbose=False
    390                                      )
    391        
     310        create_mesh_from_regions(polygon_outer,
     311                                 boundary_tags,
     312                                 density_outer,
     313                                 interior_regions=interior_regions,
     314                                 filename=file_name, verbose=False)
     315
    392316        m = importMeshFromFile(file_name)
    393        
    394         #print "file_name",file_name
     317
    395318        self.failUnless(len(m.getTriangulation()) <= 900,
    396319                        'Test mesh interface failed!')
    397320        self.failUnless(len(m.getTriangulation()) >= 200,
    398321                        'Test mesh interface failed!')
    399        
    400         create_mesh_from_regions(polygon_outer
    401                                      , boundary_tags
    402                                      , interior_regions=interior_regions
    403                                      ,filename=file_name
    404                                      #,verbose=True
    405                                      ,verbose=False
    406                                      )
    407        
     322
     323        create_mesh_from_regions(polygon_outer,
     324                                 boundary_tags,
     325                                 interior_regions=interior_regions,
     326                                 filename=file_name,
     327                                 verbose=False)
     328
    408329        m = importMeshFromFile(file_name)
    409        
    410         #print "len(m.meshTriangles)",len(m.meshTriangles)
     330
    411331        self.failUnless(len(m.getTriangulation()) <= 100,
    412332                        'Test mesh interface failed!')
    413333
    414334        os.remove(file_name)
    415        
     335
    416336    def test_create_mesh_from_regions5(self):
    417 
    418         file_name = tempfile.mktemp(".tsh")
    419        
    420         # These are the absolute values
    421         density_outer = 10000000
    422         min_outer = 0
     337        file_name = tempfile.mktemp('.tsh')
     338
     339        # These are the absolute values
     340        density_outer = 10000000
     341        min_outer = 0
    423342        max_outer = 1000
    424         polygon_outer = [[min_outer,min_outer],[max_outer,min_outer],
    425                    [max_outer,max_outer],[min_outer,max_outer]]
    426        
     343        polygon_outer = [[min_outer,min_outer], [max_outer,min_outer],
     344                         [max_outer,max_outer], [min_outer,max_outer]]
     345
    427346        density_inner1 = 1000
    428347        inner_buffer = 100
    429348        min_inner1 = min_outer + inner_buffer
    430349        max_inner1 = max_outer - inner_buffer
    431         inner1_polygon = [[min_inner1,min_inner1],[max_inner1,min_inner1],
    432                    [max_inner1,max_inner1],[min_inner1,max_inner1]]
    433      
    434        
    435         boundary_tags = {'walls':[0,1],'bom':[2,3]}
    436        
     350        inner1_polygon = [[min_inner1,min_inner1], [max_inner1,min_inner1],
     351                          [max_inner1,max_inner1], [min_inner1,max_inner1]]
     352
     353        boundary_tags = {'walls': [0,1], 'bom': [2,3]}
     354
    437355        interior_regions = [(inner1_polygon, density_inner1)]
    438         create_mesh_from_regions(polygon_outer
    439                                      , boundary_tags
    440                                      , density_outer
    441                                      , interior_regions=interior_regions
    442                                      ,filename=file_name
    443                                      #,verbose=True
    444                                      ,verbose=False
    445                                      )
    446        
     356        create_mesh_from_regions(polygon_outer,
     357                                 boundary_tags,
     358                                 density_outer,
     359                                 interior_regions=interior_regions,
     360                                 filename=file_name,
     361                                 verbose=False)
     362
    447363        m = importMeshFromFile(file_name)
    448         #print "file_name",file_name
    449         #print "len(m.meshTriangles",len(m.meshTriangles)
    450         self.failUnless(len(m.getTriangulation()) <= 2000,
     364        self.failUnless(len(m.getTriangulation()) <= 2000,
    451365                        'Test mesh interface failed!')
    452  
    453366        self.failUnless(len(m.getTriangulation()) >= 900,
    454367                        'Test mesh interface failed!')
    455368
    456369        os.remove(file_name)
    457        
     370
    458371    def test_create_mesh_from_regions6(self):
    459 
    460         file_name = tempfile.mktemp(".tsh")
    461        
     372        file_name = tempfile.mktemp('.tsh')
     373
    462374        # These are the absolute values
    463375        density_outer = 1000
    464         min_outer = 0 
     376        min_outer = 0
    465377        max_outer = 1000
    466         polygon_outer = [[min_outer,min_outer],[max_outer,min_outer],
    467                          [max_outer,max_outer],[min_outer,max_outer]]
     378        polygon_outer = [[min_outer,min_outer], [max_outer,min_outer],
     379                         [max_outer,max_outer], [min_outer,max_outer]]
    468380
    469381        delta = 10
    … …  
    471383        min_inner1 = min_outer + delta
    472384        max_inner1 = max_outer - delta
    473         inner1_polygon = [[min_inner1,min_inner1],[max_inner1,min_inner1],
    474                           [max_inner1,max_inner1],[min_inner1,max_inner1]]
    475      
    476        
    477         density_inner2 = 10000000
     385        inner1_polygon = [[min_inner1,min_inner1], [max_inner1,min_inner1],
     386                          [max_inner1,max_inner1], [min_inner1,max_inner1]]
     387
     388        density_inner2 = 10000000
    478389        min_inner2 = min_outer +  2*delta
    479390        max_inner2 = max_outer -  2*delta
    480         inner2_polygon = [[min_inner2,min_inner2],[max_inner2,min_inner2],
    481                           [max_inner2,max_inner2],[min_inner2,max_inner2]]
    482        
    483         boundary_tags = {'walls':[0,1],'bom':[2,3]}
    484        
     391        inner2_polygon = [[min_inner2,min_inner2], [max_inner2,min_inner2],
     392                          [max_inner2,max_inner2], [min_inner2,max_inner2]]
     393
     394        boundary_tags = {'walls': [0,1], 'bom': [2,3]}
     395
    485396        interior_regions = [(inner1_polygon, density_inner1),
    486397                            (inner2_polygon, density_inner2)]
    … …  
    491402                                 filename=file_name,
    492403                                 verbose=False)
    493        
     404
    494405        m = importMeshFromFile(file_name)
    495         #print "file_name",file_name
    496         #print "len(m.meshTriangles",len(m.meshTriangles)
    497         self.failUnless(len(m.getTriangulation()) <= 2000,
     406        self.failUnless(len(m.getTriangulation()) <= 2000,
    498407                        'Test mesh interface failed!')
    499  
    500408        self.failUnless(len(m.getTriangulation()) >= 900,
    501409                        'Test mesh interface failed!')
    502410
    503411        os.remove(file_name)
    504        
     412
    505413    def test_create_mesh_from_regions7(self):
    506 
    507         file_name = tempfile.mktemp(".tsh")
    508        
     414        file_name = tempfile.mktemp('.tsh')
     415
    509416        # These are the absolute values
    510417        density_outer = 1001
    511         min_outer = 0 
     418        min_outer = 0
    512419        max_outer = 1000
    513         polygon_outer = [[min_outer,min_outer],[max_outer,min_outer],
    514                    [max_outer,max_outer],[min_outer,max_outer]]
     420        polygon_outer = [[min_outer,min_outer], [max_outer,min_outer],
     421                         [max_outer,max_outer], [min_outer,max_outer]]
    515422
    516423        delta = 10
    … …  
    518425        min_inner1 = min_outer + delta
    519426        max_inner1 = max_outer - delta
    520         inner1_polygon = [[min_inner1,min_inner1],[max_inner1,min_inner1],
    521                    [max_inner1,max_inner1],[min_inner1,max_inner1]]
    522      
    523        
    524         density_inner2 = 1000
     427        inner1_polygon = [[min_inner1,min_inner1], [max_inner1,min_inner1],
     428                          [max_inner1,max_inner1], [min_inner1,max_inner1]]
     429
     430        density_inner2 = 1000
    525431        min_inner2 = min_outer +  2*delta
    526432        max_inner2 = max_outer -  2*delta
    527         inner2_polygon = [[min_inner2,min_inner2],[max_inner2,min_inner2],
    528                    [max_inner2,max_inner2],[min_inner2,max_inner2]]
    529        
    530         boundary_tags = {'walls':[0,1],'bom':[2,3]}
    531 
    532         #Note the list order is important
     433        inner2_polygon = [[min_inner2,min_inner2], [max_inner2,min_inner2],
     434                          [max_inner2,max_inner2], [min_inner2,max_inner2]]
     435
     436        boundary_tags = {'walls': [0,1], 'bom': [2,3]}
     437
     438        # Note the list order is important
    533439        # The last region added will be the region triangle uses,
    534440        # if two regions points are in the same bounded area.
    535         interior_regions = [(inner2_polygon, density_inner2),(inner1_polygon, density_inner1)]
     441        interior_regions = [(inner2_polygon, density_inner2),
     442                            (inner1_polygon, density_inner1)]
    536443        create_mesh_from_regions(polygon_outer,
    537444                                 boundary_tags,
    … …  
    540447                                 filename=file_name,
    541448                                 verbose=False)
    542        
     449
    543450        m = importMeshFromFile(file_name)
    544         #print "file_name",file_name
    545         #print "len(m.meshTriangles",len(m.meshTriangles)
    546         self.failUnless(len(m.getTriangulation()) <= 3000,
     451        self.failUnless(len(m.getTriangulation()) <= 3000,
    547452                        'Test mesh interface failed!')
    548  
    549453        self.failUnless(len(m.getTriangulation()) >= 2000,
    550454                        'Test mesh interface failed!')
    … …  
    552456        os.remove(file_name)
    553457
    554        
    555458    def test_create_mesh_from_regions_interior_regions(self):
    556         """Test that create_mesh_from_regions fails when an interior region is
    557          outside bounding polygon.       """
    558        
    559 
    560         # These are the absolute values
    561         min_x = 10 
     459        '''Test that create_mesh_from_regions fails when an interior
     460        region is outside bounding polygon.
     461        '''
     462
     463        # These are the absolute values
     464        min_x = 10
    562465        min_y = 88
    563         polygon = [[min_x,min_y],[1000,100],[1000,1000],[100,1000]]
    564        
    565         boundary_tags = {'walls':[0,1],'bom':[2,3]}
    566 #        boundary_tags = {'walls':[0,1]}
     466        polygon = [[min_x,min_y], [1000,100], [1000,1000], [100,1000]]
     467
     468        boundary_tags = {'walls': [0,1], 'bom': [2,3]}
     469
    567470        # This one is inside bounding polygon - should pass
    568         inner_polygon = [[800,400],[900,500],[800,600]]
     471        inner_polygon = [[800,400], [900,500], [800,600]]
    569472
    570473        interior_regions = [(inner_polygon, 5)]
    … …  
    574477                                     interior_regions=interior_regions)
    575478
    576 
    577479        # This one sticks outside bounding polygon - should fail
    578         inner_polygon = [[800,400],[900,500],[800,600], [200, 995]]
    579         inner_polygon1 = [[800,400],[1100,500],[800,600]]
     480        inner_polygon = [[800,400], [900,500], [800,600], [200, 995]]
     481        inner_polygon1 = [[800,400], [1100,500], [800,600]]
    580482        interior_regions = [[inner_polygon, 50], [inner_polygon1, 50]]
    581483
    582 
    583        
    584484        try:
    585485            m = create_mesh_from_regions(polygon,
    … …  
    593493            msg = 'Interior polygon sticking outside bounding polygon should '
    594494            msg += 'cause an Exception to be raised'
    595             raise msg
     495            raise Exception, msg
    596496
    597497    def test_create_mesh_from_regions_interior_regions1(self):
    598         """Test that create_mesh_from_regions fails when an interior region is
    599          outside bounding polygon.       """
    600        
     498        '''Test that create_mesh_from_regions fails
     499        when an interior region is outside bounding polygon.
     500        '''
    601501
    602502        # These are the values
    603 
    604503        d0 = [310000, 7690000]
    605504        d1 = [280000, 7690000]
    … …  
    609508        d5 = [300000, 7590000]
    610509        d6 = [340000, 7610000]
    611 
    612510        poly_all = [d0, d1, d2, d3, d4, d5, d6]
    613        
     511
    614512        i0 = [304000, 7607000]
    615513        i1 = [302000, 7605000]
    … …  
    619517#        i4 = [310000, 7580000]
    620518        i5 = [307000, 7606000]
    621 
    622519        poly_onslow = [i0, i1, i2, i3, i4, i5]
    623520
    624         #Thevenard Island
     521        # Thevenard Island
    625522        j0 = [294000, 7629000]
    626523        j1 = [285000, 7625000]
    627524        j2 = [294000, 7621000]
    628525        j3 = [299000, 7625000]
    629 
    630526        poly_thevenard = [j0, j1, j2, j3]
    631527
    632         #med res around onslow
     528        # med res around onslow
    633529        l0 = [300000, 7610000]
    634530        l1 = [285000, 7600000]
    635531        l2 = [300000, 7597500]
    636         l3 = [310000, 7770000] #this one is outside
    637 #        l3 = [310000, 7630000] #this one is NOT outside
     532        l3 = [310000, 7770000] # this one is outside
     533#        l3 = [310000, 7630000] # this one is NOT outside
    638534        l4 = [315000, 7610000]
    639535        poly_coast = [l0, l1, l2, l3, l4]
    640536
    641         #general coast and local area to onslow region
     537        # general coast and local area to onslow region
    642538        m0 = [270000, 7581000]
    643539        m1 = [300000, 7591000]
    … …  
    646542        m4 = [290000, 7640000]
    647543        m5 = [260000, 7600000]
    648 
    649544        poly_region = [m0, m1, m2, m3, m4, m5]
    650545
    651546        # This one sticks outside bounding polygon - should fail
    652 
    653         interior_regions = [[poly_onslow, 50000], [poly_region, 50000], [poly_coast,100000], [poly_thevenard, 100000]]
    654 
    655         boundary_tags = {'walls':[0,1],'bom':[2]}
    656        
     547        interior_regions = [[poly_onslow, 50000], [poly_region, 50000],
     548                            [poly_coast, 100000], [poly_thevenard, 100000]]
     549        boundary_tags = {'walls': [0,1], 'bom': [2]}
     550
    657551        try:
    658552            m = create_mesh_from_regions(poly_all,
    … …  
    666560            msg = 'Interior polygon sticking outside bounding polygon should '
    667561            msg += 'cause an Exception to be raised'
    668             raise msg
    669 
    670 
     562            raise Exception, msg
    671563
    672564    def FIXME_test_create_mesh_with_multiply_tagged_segments(self):
    673         """Test that create_mesh_from_regions fails when
     565        '''Test that create_mesh_from_regions fails when
    674566        segments are listed repeatedly in boundary_tags.
    675         """
    676        
    677        
    678        
    679 
    680         # These are the absolute values
    681         min_x = 10
     567        '''
     568
     569        # These are the absolute values
     570        min_x = 10
    682571        min_y = 88
    683         polygon = [[min_x,min_y],[1000,100],[1000,1000],[100,1000]]
    684 
    685        
    686         boundary_tags = {'walls':[0,1],'bom':[1,2]}
     572        polygon = [[min_x,min_y], [1000,100], [1000,1000], [100,1000]]
     573        boundary_tags = {'walls': [0,1], 'bom': [1,2]}
    687574
    688575        # This one is inside bounding polygon - should pass
    689         inner_polygon = [[800,400],[900,500],[800,600]]
    690        
     576        inner_polygon = [[800,400], [900,500], [800,600]]
    691577        interior_regions = [(inner_polygon, 5)]
    692578        m = create_mesh_from_regions(polygon,
    693579                                     boundary_tags,
    694580                                     10000000,
    695                                      interior_regions=interior_regions,verbose=False)
    696 
     581                                     interior_regions=interior_regions,
     582                                     verbose=False)
    697583
    698584        # This one sticks outside bounding polygon - should fail
    699         inner_polygon = [[800,400],[900,500],[800,600]]
     585        inner_polygon = [[800,400], [900,500], [800,600]]
    700586        interior_regions = [(inner_polygon, 5)]
    701 
    702 
    703 
    704587        try:
    705588            m = create_mesh_from_regions(polygon,
    … …  
    712595            msg = 'Tags are listed repeatedly, but create mesh from regions '
    713596            msg += 'does not cause an Exception to be raised'
    714             raise msg
    715 
    716        
    717 
     597            raise Exception, msg
    718598
    719599    def test_create_mesh_from_regions_with_duplicate_verts(self):
    720 
    721         # These are the absolute values
    722        
    723         polygon_absolute = [[0.0,0.0],
    724                             [0,4.0],
    725                             [4.0,4.0],
    726                             [4.0,0.0],
    727                             [4.0,0.0]]
    728        
     600        # These are the absolute values
     601        polygon_absolute = [[0.0, 0.0],
     602                            [0, 4.0],
     603                            [4.0, 4.0],
     604                            [4.0, 0.0],
     605                            [4.0, 0.0]]
    729606        x_p = -10
    730607        y_p = -40
    … …  
    732609        geo_ref_poly = Geo_reference(zone, x_p, y_p)
    733610        polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
    734 
    735         boundary_tags = {'50':[0],
    736                          '40':[1],
    737                          '30':[2],
    738                          'no where seg':[3],
    739                          '20':[4]
    740                          }
    741        
     611        boundary_tags = {'50': [0],
     612                         '40': [1],
     613                         '30': [2],
     614                         'no where seg': [3],
     615                         '20': [4]}
    742616        m = create_mesh_from_regions(polygon,
    743617                                     boundary_tags,
    744618                                     10000000,
    745                                      poly_geo_reference=geo_ref_poly,verbose=False)
    746        
    747 
    748         fileName = "badmesh.tsh"
     619                                     poly_geo_reference=geo_ref_poly,
     620                                     verbose=False)
     621
     622        fileName = 'badmesh.tsh'
    749623        #m.export_mesh_file(fileName)
    750  
    751        
     624
    752625    def concept_create_mesh_from_regions_with_ungenerate(self):
    753626        x=0
    754627        y=0
    755         mesh_geo = geo_reference=Geo_reference(56,x,y)
    756        
    757         # These are the absolute values
    758         polygon_absolute = [[0,0],[100,0],[100,100],[0,100]]
    759        
     628        mesh_geo = geo_reference=Geo_reference(56, x, y)
     629
     630        # These are the absolute values
     631        polygon_absolute = [[0,0], [100,0], [100,100], [0,100]]
    760632        x_p = -10
    761633        y_p = -40
    … …  
    763635        polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
    764636
    765         boundary_tags = {'walls':[0,1],'bom':[2]}
    766        
    767         inner1_polygon_absolute = [[10,10],[20,10],[20,20],[10,20]]
    768         inner1_polygon = geo_ref_poly. \
    769                          change_points_geo_ref(inner1_polygon_absolute)
    770 
    771         inner2_polygon_absolute = [[30,30],[40,30],[40,40],[30,40]]
    772         inner2_polygon = geo_ref_poly. \
    773                          change_points_geo_ref(inner2_polygon_absolute)
    774        
     637        boundary_tags = {'walls': [0,1], 'bom': [2]}
     638
     639        inner1_polygon_absolute = [[10,10], [20,10], [20,20], [10,20]]
     640        inner1_polygon = geo_ref_poly.\
     641                            change_points_geo_ref(inner1_polygon_absolute)
     642
     643        inner2_polygon_absolute = [[30,30], [40,30], [40,40], [30,40]]
     644        inner2_polygon = geo_ref_poly.\
     645                            change_points_geo_ref(inner2_polygon_absolute)
     646
    775647        max_area = 10000000
    776         interior_regions = [(inner1_polygon, 5),(inner2_polygon, 10)]
     648        interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
    777649        m = create_mesh_from_regions(polygon,
    778650                                     boundary_tags,
    … …  
    781653                                     poly_geo_reference=geo_ref_poly,
    782654                                     mesh_geo_reference=mesh_geo)
    783                    
    784         m.export_mesh_file('a_test_mesh_iknterface.tsh')                 
    785        
    786         fileName = tempfile.mktemp(".txt")
    787         file = open(fileName,"w")
    788         file.write("         1       ??      ??\n\
     655
     656        m.export_mesh_file('a_test_mesh_iknterface.tsh')
     657
     658        fileName = tempfile.mktemp('.txt')
     659        file = open(fileName, 'w')
     660        file.write('         1       ??      ??\n\
    789661       90.0       90.0\n\
    790662       81.0       90.0\n\
    … …  
    799671       10.0       80.0\n\
    800672END\n\
    801 END\n")
    802         file.close() 
    803        
     673END\n')
     674        file.close()
     675
    804676        m.import_ungenerate_file(fileName, tag='wall')
    805677        os.remove(fileName)
    806         m.generate_mesh(maximum_triangle_area=max_area,verbose=False)
     678        m.generate_mesh(maximum_triangle_area=max_area, verbose=False)
    807679        m.export_mesh_file('b_test_mesh_iknterface.tsh')
    808680
    809681    def concept_ungenerateII(self):
    810        
    811682        from anuga.shallow_water import Domain, Reflective_boundary, \
    812683                            Dirichlet_boundary
     684
    813685        x=0
    814686        y=0
    815         mesh_geo = geo_reference=Geo_reference(56,x,y)
    816        
    817         # These are the absolute values
    818         polygon_absolute = [[0,0],[100,0],[100,100],[0,100]]
    819        
     687        mesh_geo = geo_reference=Geo_reference(56, x, y)
     688
     689        # These are the absolute values
     690        polygon_absolute = [[0,0], [100,0], [100,100], [0,100]]
    820691        x_p = -10
    821692        y_p = -40
    … …  
    823694        polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
    824695
    825         boundary_tags = {'wall':[0,1,3],'wave':[2]}
    826        
    827         inner1_polygon_absolute = [[10,10],[20,10],[20,20],[10,20]]
    828         inner1_polygon = geo_ref_poly. \
    829                          change_points_geo_ref(inner1_polygon_absolute)
    830 
    831         inner2_polygon_absolute = [[30,30],[40,30],[40,40],[30,40]]
    832         inner2_polygon = geo_ref_poly. \
    833                          change_points_geo_ref(inner2_polygon_absolute)
    834        
     696        boundary_tags = {'wall': [0,1,3], 'wave': [2]}
     697
     698        inner1_polygon_absolute = [[10,10], [20,10], [20,20], [10,20]]
     699        inner1_polygon = geo_ref_poly.\
     700                            change_points_geo_ref(inner1_polygon_absolute)
     701
     702        inner2_polygon_absolute = [[30,30], [40,30], [40,40], [30,40]]
     703        inner2_polygon = geo_ref_poly.\
     704                            change_points_geo_ref(inner2_polygon_absolute)
     705
    835706        max_area = 1
    836         interior_regions = [(inner1_polygon, 5),(inner2_polygon, 10)]
     707        interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
    837708        m = create_mesh_from_regions(polygon,
    838709                                     boundary_tags,
    … …  
    841712                                     poly_geo_reference=geo_ref_poly,
    842713                                     mesh_geo_reference=mesh_geo)
    843                    
    844         m.export_mesh_file('a_test_mesh_iknterface.tsh')                 
    845        
    846         fileName = tempfile.mktemp(".txt")
    847         file = open(fileName,"w")
    848         file.write("         1       ??      ??\n\
     714
     715        m.export_mesh_file('a_test_mesh_iknterface.tsh')
     716
     717        fileName = tempfile.mktemp('.txt')
     718        file = open(fileName, 'w')
     719        file.write('         1       ??      ??\n\
    849720       90.0       90.0\n\
    850721       81.0       90.0\n\
    … …  
    859730       10.0       80.0\n\
    860731END\n\
    861 END\n")
    862         file.close() 
    863        
    864         m.import_ungenerate_file(fileName) #, tag='wall')
     732END\n')
     733        file.close()
     734
     735        m.import_ungenerate_file(fileName)      #, tag='wall')
    865736        os.remove(fileName)
    866         m.generate_mesh(maximum_triangle_area=max_area,verbose=False)
    867         mesh_filename = "bento_b.tsh"
     737        m.generate_mesh(maximum_triangle_area=max_area, verbose=False)
     738        mesh_filename = 'bento_b.tsh'
    868739        m.export_mesh_file(mesh_filename)
    869740
    870741        domain = Domain(mesh_filename, use_cache = False)
    871        
     742
    872743        Br = Reflective_boundary(domain)
    873         Bd = Dirichlet_boundary([3,0,0])
    874         domain.set_boundary( {'wall': Br, 'wave': Bd} )
     744        Bd = Dirichlet_boundary([3, 0, 0])
     745        domain.set_boundary({'wall': Br, 'wave': Bd})
    875746        yieldstep = 0.1
    876747        finaltime = 10
    877         for t in domain.evolve(yieldstep, finaltime):   
     748        for t in domain.evolve(yieldstep, finaltime):
    878749            domain.write_time()
    879    
     750
    880751    def concept_ungenerateIII(self):
    881        
    882752        from anuga.shallow_water import Domain, Reflective_boundary, \
    883753                            Dirichlet_boundary
    884        
    885754        from anuga.pmesh.mesh_interface import create_mesh_from_regions
    886        
    887         # These are the absolute values
    888         polygon = [[0,0],[100,0],[100,100],[0,100]]
    889        
    890         boundary_tags = {'wall':[0,1,3],'wave':[2]}
    891        
    892         inner1_polygon = [[10,10],[20,10],[20,20],[10,20]]
    893        
    894 
    895         inner2_polygon = [[30,30],[40,30],[40,40],[30,40]]
    896        
    897        
     755
     756        # These are the absolute values
     757        polygon = [[0,0], [100,0], [100,100], [0,100]]
     758
     759        boundary_tags = {'wall': [0,1,3], 'wave': [2]}
     760        inner1_polygon = [[10,10], [20,10], [20,20], [10,20]]
     761        inner2_polygon = [[30,30], [40,30], [40,40], [30,40]]
     762
    898763        max_area = 1
    899         interior_regions = [(inner1_polygon, 5),(inner2_polygon, 10)]
     764        interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
    900765        m = create_mesh_from_regions(polygon,
    901766                                     boundary_tags,
    902767                                     max_area,
    903768                                     interior_regions=interior_regions)
    904                    
    905         fileName = tempfile.mktemp(".txt")
    906         file = open(fileName,"w")
    907         file.write("         1       ??      ??\n\
     769
     770        fileName = tempfile.mktemp('.txt')
     771        file = open(fileName, 'w')
     772        file.write('         1       ??      ??\n\
    908773       90.0       90.0\n\
    909774       81.0       90.0\n\
    … …  
    918783       10.0       80.0\n\
    919784END\n\
    920 END\n")
    921         file.close() 
    922        
    923         m.import_ungenerate_file(fileName) 
     785END\n')
     786        file.close()
     787
     788        m.import_ungenerate_file(fileName)
    924789        os.remove(fileName)
    925         m.generate_mesh(maximum_triangle_area=max_area,verbose=False)
    926         mesh_filename = "mesh.tsh"
     790        m.generate_mesh(maximum_triangle_area=max_area, verbose=False)
     791        mesh_filename = 'mesh.tsh'
    927792        m.export_mesh_file(mesh_filename)
    928793
    929         domain = Domain(mesh_filename, use_cache = False)
    930        
     794        domain = Domain(mesh_filename, use_cache=False)
     795
    931796        Br = Reflective_boundary(domain)
    932         Bd = Dirichlet_boundary([3,0,0])
    933         domain.set_boundary( {'wall': Br, 'wave': Bd} )
     797        Bd = Dirichlet_boundary([3, 0, 0])
     798        domain.set_boundary({'wall': Br, 'wave': Bd})
    934799        yieldstep = 0.1
    935800        finaltime = 10
    936         for t in domain.evolve(yieldstep, finaltime):   
     801        for t in domain.evolve(yieldstep, finaltime):
    937802            domain.write_time()
    938803
    939            
    940        
    941804    def test_create_mesh_from_regions_check_segs(self):
    942         """Test that create_mesh_from_regions fails when an interior region is
    943          outside bounding polygon.       """
    944        
    945 
    946         # These are the absolute values
    947         min_x = 10 
     805        '''Test that create_mesh_from_regions fails
     806        when an interior region is outside bounding polygon.
     807        '''
     808
     809        # These are the absolute values
     810        min_x = 10
    948811        min_y = 88
    949         polygon = [[min_x,min_y],[1000,100],[1000,1000],[100,1000]]
    950        
    951         boundary_tags = {'walls':[0,1,3],'bom':[2]}
    952 #        boundary_tags = {'walls':[0,1]}
     812        polygon = [[min_x,min_y], [1000,100], [1000,1000], [100,1000]]
     813        boundary_tags = {'walls': [0,1,3], 'bom': [2]}
     814
    953815        # This one is inside bounding polygon - should pass
    954         inner_polygon = [[800,400],[900,500],[800,600]]
    955 
     816        inner_polygon = [[800,400], [900,500], [800,600]]
    956817        interior_regions = [(inner_polygon, 5)]
    957818        m = create_mesh_from_regions(polygon,
    … …  
    960821                                     interior_regions=interior_regions)
    961822
    962         boundary_tags = {'walls':[0,1,3,4],'bom':[2]}
    963        
     823        boundary_tags = {'walls': [0,1,3,4], 'bom': [2]}
    964824        try:
    965825            m = create_mesh_from_regions(polygon,
    … …  
    970830            pass
    971831        else:
    972             msg = 'segment out of bounds not caught '
    973             raise msg
    974 
    975        
     832            msg = 'Segment out of bounds not caught '
     833            raise Exception, msg
     834
     835
    976836#-------------------------------------------------------------
    977837if __name__ == "__main__":
    978838    suite = unittest.makeSuite(TestCase,'test')
    979     #suite = unittest.makeSuite(TestCase,'test_create_mesh_from_regions_check_segs')
    980839    runner = unittest.TextTestRunner() #verbosity=2)
    981840    runner.run(suite)
    982    
     841
Note: See TracChangeset for help on using the changeset viewer.