source: inundation/pmesh/test_mesh_interface.py @ 3444

Last change on this file since 3444 was 3213, checked in by duncan, 19 years ago

name change
File size: 20.3 KB
Line 
1#!/usr/bin/env python
2#
3import tempfile
4import unittest
5import os
6from pmesh.mesh import importMeshFromFile
7from mesh_interface import *
8from load_mesh.loadASCII import *
9from utilities.polygon import is_inside_polygon
10from coordinate_transforms.geo_reference import Geo_reference,DEFAULT_ZONE
11
12class TestCase(unittest.TestCase):
13    def setUp(self):
14        pass
15   
16    def tearDown(self):
17        pass
18
19    def test_create_mesh_from_regions(self):
20        x=-500
21        y=-1000
22        mesh_geo = geo_reference=Geo_reference(56,x,y)
23
24        # These are the absolute values
25        polygon_absolute = [[0,0],[100,0],[100,100],[0,100]]
26       
27        x_p = -10
28        y_p = -40
29        geo_ref_poly = Geo_reference(56, x_p, y_p)
30        polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
31
32        boundary_tags = {'walls':[0,1],'bom':[2]}
33       
34        inner1_polygon_absolute = [[10,10],[20,10],[20,20],[10,20]]
35        inner1_polygon = geo_ref_poly. \
36                         change_points_geo_ref(inner1_polygon_absolute)
37
38        inner2_polygon_absolute = [[30,30],[40,30],[40,40],[30,40]]
39        inner2_polygon = geo_ref_poly. \
40                         change_points_geo_ref(inner2_polygon_absolute)
41       
42        interior_regions = [(inner1_polygon, 5),(inner2_polygon, 0.2)]
43        m = create_mesh_from_regions(polygon,
44                                     boundary_tags,
45                                     10000000,
46                                     interior_regions=interior_regions,
47                                     poly_geo_reference=geo_ref_poly,
48                                     mesh_geo_reference=mesh_geo)
49
50        # Test the mesh instance
51        self.failUnless(len(m.regions)==3,
52                        'FAILED!')
53        segs = m.getUserSegments()
54        self.failUnless(len(segs)==12,
55                        'FAILED!')
56        self.failUnless(len(m.userVertices)==12,
57                        'FAILED!') 
58        self.failUnless(segs[0].tag=='walls',
59                        'FAILED!') 
60        self.failUnless(segs[1].tag=='walls',
61                        'FAILED!') 
62         
63        self.failUnless(segs[2].tag=='bom',
64                        'FAILED!') 
65        self.failUnless(segs[3].tag=='',
66                        'FAILED!')
67
68        # Assuming the order of the region points is known.
69        # (This isn't true, if you consider create_mesh_from_regions
70        # a black box)
71        poly_point = m.getRegions()[0]
72       
73        #print "poly_point", poly_point
74        #print "polygon_absolute",polygon_absolute
75         
76        # poly_point values are relative to the mesh geo-ref
77        # make them absolute
78        self.failUnless(is_inside_polygon([poly_point.x+x,poly_point.y+y],
79                                          polygon_absolute, closed = False),
80                        'FAILED!')
81       
82        # Assuming the order of the region points is known.
83        # (This isn't true, if you consider create_mesh_from_regions
84        # a black box)
85        poly_point = m.getRegions()[1]
86       
87        #print "poly_point", poly_point
88        #print "polygon_absolute",polygon_absolute
89         
90        # poly_point values are relative to the mesh geo-ref
91        # make them absolute
92        self.failUnless(is_inside_polygon([poly_point.x+x,poly_point.y+y],
93                                          inner1_polygon_absolute,
94                                          closed = False),
95                        'FAILED!')
96       
97        # Assuming the order of the region points is known.
98        # (This isn't true, if you consider create_mesh_from_regions
99        # a black box)
100        poly_point = m.getRegions()[2]
101       
102        #print "poly_point", poly_point
103        #print "polygon_absolute",polygon_absolute
104         
105        # poly_point values are relative to the mesh geo-ref
106        # make them absolute
107        self.failUnless(is_inside_polygon([poly_point.x+x,poly_point.y+y],
108                                          inner2_polygon_absolute,
109                                          closed = False),
110                        'FAILED!')
111
112
113       
114    def test_create_mesh_from_regions2(self):
115
116        # These are the absolute values
117        min_x = -10 
118        min_y = -88
119        polygon_absolute = [[min_x,min_y],[1000,100],[1000,1000],[100,1000]]
120       
121        x_p = -10
122        y_p = -40
123        zone = 808
124        geo_ref_poly = Geo_reference(zone, x_p, y_p)
125        polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
126
127        boundary_tags = {'walls':[0,1],'bom':[2]}
128       
129        inner1_polygon_absolute = [[10,10],[20,10],[20,20],[10,20]]
130        inner1_polygon = geo_ref_poly. \
131                         change_points_geo_ref(inner1_polygon_absolute)
132
133        inner2_polygon_absolute = [[30,30],[40,30],[40,40],[30,40]]
134        inner2_polygon = geo_ref_poly. \
135                         change_points_geo_ref(inner2_polygon_absolute)
136       
137        interior_regions = [(inner1_polygon, 5),(inner2_polygon, 0.2)]
138        m = create_mesh_from_regions(polygon,
139                                     boundary_tags,
140                                     10000000,
141                                     interior_regions=interior_regions,
142                                     poly_geo_reference=geo_ref_poly)
143       
144
145        # Test the mesh instance
146        self.failUnless(len(m.regions)==3,
147                        'FAILED!')
148        segs = m.getUserSegments()
149        self.failUnless(len(segs)==12,
150                        'FAILED!')
151        self.failUnless(len(m.userVertices)==12,
152                        'FAILED!') 
153        self.failUnless(segs[0].tag=='walls',
154                        'FAILED!') 
155        self.failUnless(segs[1].tag=='walls',
156                        'FAILED!') 
157         
158        self.failUnless(segs[2].tag=='bom',
159                        'FAILED!') 
160        self.failUnless(segs[3].tag=='',
161                        'FAILED!')
162       
163        self.failUnless(m.geo_reference.get_zone()==zone,
164                        'FAILED!')
165        self.failUnless(m.geo_reference.get_xllcorner()==min_x,
166                        'FAILED!')
167        self.failUnless(m.geo_reference.get_yllcorner()==min_y,
168                        'FAILED!')
169
170       
171    def test_create_mesh_from_regions3(self):
172
173        # These are the absolute values
174        min_x = -10 
175        min_y = -88
176        polygon = [[min_x,min_y],[1000,100],[1000,1000],[100,1000]]
177       
178
179        x_p = -10
180        y_p = -40
181        geo_ref_poly = Geo_reference(56, x_p, y_p)
182       
183        boundary_tags = {'walls':[0,1],'bom':[2]}
184       
185        inner1_polygon_absolute = [[10,10],[20,10],[20,20],[10,20]]
186        inner1_polygon = geo_ref_poly. \
187                         change_points_geo_ref(inner1_polygon_absolute)
188
189        inner2_polygon_absolute = [[30,30],[40,30],[40,40],[30,40]]
190        inner2_polygon = geo_ref_poly. \
191                         change_points_geo_ref(inner2_polygon_absolute)
192       
193        interior_regions = [(inner1_polygon, 5),(inner2_polygon, 0.2)]
194        m = create_mesh_from_regions(polygon,
195                                     boundary_tags,
196                                     10000000,
197                                     interior_regions=interior_regions)
198       
199
200        # Test the mesh instance
201        self.failUnless(len(m.regions)==3,
202                        'FAILED!')
203        segs = m.getUserSegments()
204        self.failUnless(len(segs)==12,
205                        'FAILED!')
206        self.failUnless(len(m.userVertices)==12,
207                        'FAILED!') 
208        self.failUnless(segs[0].tag=='walls',
209                        'FAILED!') 
210        self.failUnless(segs[1].tag=='walls',
211                        'FAILED!') 
212         
213        self.failUnless(segs[2].tag=='bom',
214                        'FAILED!') 
215        self.failUnless(segs[3].tag=='',
216                        'FAILED!')
217       
218        self.failUnless(m.geo_reference.get_zone()==DEFAULT_ZONE,
219                        'FAILED!')
220        self.failUnless(m.geo_reference.get_xllcorner()==min_x,
221                        'FAILED!')
222        self.failUnless(m.geo_reference.get_yllcorner()==min_y,
223                        'FAILED!')
224
225    def test_create_mesh_from_regions4(self):
226
227        file_name = tempfile.mktemp(".tsh")
228       
229        # These are the absolute values
230        density_outer = 1000
231        min_outer = 0 
232        max_outer = 1000
233        polygon_outer = [[min_outer,min_outer],[max_outer,min_outer],
234                   [max_outer,max_outer],[min_outer,max_outer]]
235       
236        density_inner1 = 10000000
237        inner_buffer = 100
238        min_inner1 = min_outer + inner_buffer
239        max_inner1 = max_outer - inner_buffer
240        inner1_polygon = [[min_inner1,min_inner1],[max_inner1,min_inner1],
241                   [max_inner1,max_inner1],[min_inner1,max_inner1]]
242     
243       
244        boundary_tags = {'walls':[0,1],'bom':[2]}
245       
246        interior_regions = [(inner1_polygon, density_inner1)]
247        create_mesh_from_regions(polygon_outer
248                                     , boundary_tags
249                                     , density_outer
250                                     , interior_regions=interior_regions
251                                     ,filename=file_name
252                                     #,verbose=True
253                                     ,verbose=False
254                                     )
255       
256        m = importMeshFromFile(file_name)
257       
258        #print "file_name",file_name
259        self.failUnless(len(m.meshTriangles) <= 900,
260                        'Test mesh interface failed!')
261        self.failUnless(len(m.meshTriangles) >= 200,
262                        'Test mesh interface failed!')
263       
264        create_mesh_from_regions(polygon_outer
265                                     , boundary_tags
266                                     , interior_regions=interior_regions
267                                     ,filename=file_name
268                                     #,verbose=True
269                                     ,verbose=False
270                                     )
271       
272        m = importMeshFromFile(file_name)
273       
274        #print "len(m.meshTriangles)",len(m.meshTriangles)
275        self.failUnless(len(m.meshTriangles) <= 100,
276                        'Test mesh interface failed!')
277
278        os.remove(file_name)
279       
280    def test_create_mesh_from_regions5(self):
281
282        file_name = tempfile.mktemp(".tsh")
283       
284        # These are the absolute values
285        density_outer = 10000000 
286        min_outer = 0 
287        max_outer = 1000
288        polygon_outer = [[min_outer,min_outer],[max_outer,min_outer],
289                   [max_outer,max_outer],[min_outer,max_outer]]
290       
291        density_inner1 = 1000
292        inner_buffer = 100
293        min_inner1 = min_outer + inner_buffer
294        max_inner1 = max_outer - inner_buffer
295        inner1_polygon = [[min_inner1,min_inner1],[max_inner1,min_inner1],
296                   [max_inner1,max_inner1],[min_inner1,max_inner1]]
297     
298       
299        boundary_tags = {'walls':[0,1],'bom':[2]}
300       
301        interior_regions = [(inner1_polygon, density_inner1)]
302        create_mesh_from_regions(polygon_outer
303                                     , boundary_tags
304                                     , density_outer
305                                     , interior_regions=interior_regions
306                                     ,filename=file_name
307                                     #,verbose=True
308                                     ,verbose=False
309                                     )
310       
311        m = importMeshFromFile(file_name)
312        #print "file_name",file_name
313        #print "len(m.meshTriangles",len(m.meshTriangles)
314        self.failUnless(len(m.meshTriangles) <= 2000, 
315                        'Test mesh interface failed!')
316 
317        self.failUnless(len(m.meshTriangles) >= 900,
318                        'Test mesh interface failed!')
319
320        os.remove(file_name)
321       
322    def test_create_mesh_from_regions6(self):
323
324        file_name = tempfile.mktemp(".tsh")
325       
326        # These are the absolute values
327        density_outer = 1000
328        min_outer = 0 
329        max_outer = 1000
330        polygon_outer = [[min_outer,min_outer],[max_outer,min_outer],
331                   [max_outer,max_outer],[min_outer,max_outer]]
332
333        delta = 10
334        density_inner1 = 1000
335        min_inner1 = min_outer + delta
336        max_inner1 = max_outer - delta
337        inner1_polygon = [[min_inner1,min_inner1],[max_inner1,min_inner1],
338                   [max_inner1,max_inner1],[min_inner1,max_inner1]]
339     
340       
341        density_inner2 = 10000000 
342        min_inner2 = min_outer +  2*delta
343        max_inner2 = max_outer -  2*delta
344        inner2_polygon = [[min_inner2,min_inner2],[max_inner2,min_inner2],
345                   [max_inner2,max_inner2],[min_inner2,max_inner2]]
346       
347        boundary_tags = {'walls':[0,1],'bom':[2]}
348       
349        interior_regions = [(inner1_polygon, density_inner1),(inner2_polygon, density_inner2)]
350        create_mesh_from_regions(polygon_outer
351                                     , boundary_tags
352                                     , density_outer
353                                     , interior_regions=interior_regions
354                                     ,filename=file_name
355                                     #,verbose=True
356                                     ,verbose=False
357                                     )
358       
359        m = importMeshFromFile(file_name)
360        #print "file_name",file_name
361        #print "len(m.meshTriangles",len(m.meshTriangles)
362        self.failUnless(len(m.meshTriangles) <= 2000, 
363                        'Test mesh interface failed!')
364 
365        self.failUnless(len(m.meshTriangles) >= 900,
366                        'Test mesh interface failed!')
367
368        os.remove(file_name)
369       
370    def test_create_mesh_from_regions7(self):
371
372        file_name = tempfile.mktemp(".tsh")
373       
374        # These are the absolute values
375        density_outer = 1001
376        min_outer = 0 
377        max_outer = 1000
378        polygon_outer = [[min_outer,min_outer],[max_outer,min_outer],
379                   [max_outer,max_outer],[min_outer,max_outer]]
380
381        delta = 10
382        density_inner1 = 100000000
383        min_inner1 = min_outer + delta
384        max_inner1 = max_outer - delta
385        inner1_polygon = [[min_inner1,min_inner1],[max_inner1,min_inner1],
386                   [max_inner1,max_inner1],[min_inner1,max_inner1]]
387     
388       
389        density_inner2 = 1000 
390        min_inner2 = min_outer +  2*delta
391        max_inner2 = max_outer -  2*delta
392        inner2_polygon = [[min_inner2,min_inner2],[max_inner2,min_inner2],
393                   [max_inner2,max_inner2],[min_inner2,max_inner2]]
394       
395        boundary_tags = {'walls':[0,1],'bom':[2]}
396
397        #Note the list order is important
398        # The last region added will be the region triangle uses,
399        # if two regions points are in the same bounded area.
400        interior_regions = [(inner2_polygon, density_inner2),(inner1_polygon, density_inner1)]
401        create_mesh_from_regions(polygon_outer
402                                     , boundary_tags
403                                     , density_outer
404                                     , interior_regions=interior_regions
405                                     ,filename=file_name
406                                     #,verbose=True
407                                     ,verbose=False
408                                     )
409       
410        m = importMeshFromFile(file_name)
411        #print "file_name",file_name
412        #print "len(m.meshTriangles",len(m.meshTriangles)
413        self.failUnless(len(m.meshTriangles) <= 3000, 
414                        'Test mesh interface failed!')
415 
416        self.failUnless(len(m.meshTriangles) >= 2000,
417                        'Test mesh interface failed!')
418
419        os.remove(file_name)
420
421       
422    def test_create_mesh_from_regions_interior_regions(self):
423        """Test that create_mesh_from_regions fails when an interior region is
424         outside bounding polygon.       """
425       
426
427        # These are the absolute values
428        min_x = 10 
429        min_y = 88
430        polygon = [[min_x,min_y],[1000,100],[1000,1000],[100,1000]]
431
432       
433        boundary_tags = {'walls':[0,1],'bom':[2]}
434
435        # This one is inside bounding polygon - should pass
436        inner_polygon = [[800,400],[900,500],[800,600]]
437       
438        interior_regions = [(inner_polygon, 5)]
439        m = create_mesh_from_regions(polygon,
440                                     boundary_tags,
441                                     10000000,
442                                     interior_regions=interior_regions)
443
444
445        # This one sticks outside bounding polygon - should fail
446        inner_polygon = [[800,400],[1100,500],[800,600]]
447        interior_regions = [(inner_polygon, 5)]
448
449
450       
451        try:
452            m = create_mesh_from_regions(polygon,
453                                         boundary_tags,
454                                         10000000,
455                                         interior_regions=interior_regions,verbose=False)
456        except:
457            pass
458        else:
459            msg = 'Interior polygon sticking outside bounding polygon should '
460            msg += 'cause an Exception to be raised'
461            raise msg
462
463
464
465    def FIXME_test_create_mesh_with_multiply_tagged_segments(self):
466        """Test that create_mesh_from_regions fails when
467        segments are listed repeatedly in boundary_tags.
468        """
469       
470       
471       
472
473        # These are the absolute values
474        min_x = 10 
475        min_y = 88
476        polygon = [[min_x,min_y],[1000,100],[1000,1000],[100,1000]]
477
478       
479        boundary_tags = {'walls':[0,1],'bom':[1,2]}
480
481        # This one is inside bounding polygon - should pass
482        inner_polygon = [[800,400],[900,500],[800,600]]
483       
484        interior_regions = [(inner_polygon, 5)]
485        m = create_mesh_from_regions(polygon,
486                                     boundary_tags,
487                                     10000000,
488                                     interior_regions=interior_regions,verbose=False)
489
490
491        # This one sticks outside bounding polygon - should fail
492        inner_polygon = [[800,400],[900,500],[800,600]]
493        interior_regions = [(inner_polygon, 5)]
494
495
496
497        try:
498            m = create_mesh_from_regions(polygon,
499                                         boundary_tags,
500                                         10000000,
501                                         interior_regions=interior_regions)
502        except:
503            pass
504        else:
505            msg = 'Tags are listed repeatedly, but create mesh from regions '
506            msg += 'does not cause an Exception to be raised'
507            raise msg
508
509       
510
511
512    def test_create_mesh_from_regions_with_duplicate_verts(self):
513
514        # These are the absolute values
515       
516        polygon_absolute = [[0.0,0.0],
517                            [0,4.0],
518                            [4.0,4.0],
519                            [4.0,0.0],
520                            [4.0,0.0]]
521       
522        x_p = -10
523        y_p = -40
524        zone = 808
525        geo_ref_poly = Geo_reference(zone, x_p, y_p)
526        polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
527
528        boundary_tags = {'50':[0],
529                         '40':[1],
530                         '30':[2],
531                         'no where seg':[3],
532                         '20':[4]
533                         }
534       
535        m = create_mesh_from_regions(polygon,
536                                     boundary_tags,
537                                     10000000,
538                                     poly_geo_reference=geo_ref_poly,verbose=False)
539       
540
541        fileName = "badmesh.tsh"
542        #m.export_mesh_file(fileName)
543       
544#-------------------------------------------------------------
545if __name__ == "__main__":
546    suite = unittest.makeSuite(TestCase,'test')
547    #suite = unittest.makeSuite(meshTestCase,'test_asciiFile')
548    runner = unittest.TextTestRunner() #verbosity=2)
549    runner.run(suite)
550   
Note: See TracBrowser for help on using the repository browser.