source: anuga_core/source/anuga/pmesh/test_mesh.py @ 4905

Last change on this file since 4905 was 4905, checked in by duncan, 16 years ago

minor mod

File size: 87.3 KB
Line 
1#!/usr/bin/env python
2#
3import tempfile
4import unittest
5
6#try:
7from anuga.pmesh.mesh import *
8#except ImportError: 
9#    from mesh import *
10
11
12from load_mesh.loadASCII import *
13from anuga.coordinate_transforms.geo_reference import Geo_reference
14from anuga.geospatial_data.geospatial_data import Geospatial_data
15from anuga.utilities.polygon import  is_inside_polygon ### inside_polygon
16
17class meshTestCase(unittest.TestCase):
18    def setUp(self):
19        pass
20   
21    def tearDown(self):
22        pass
23
24    def testPointDistance(self):
25        a = Point(0.0, 0.0)
26        b = Point(0.0, 10.0)
27       
28        self.failUnless( a.DistanceToPoint(b) == 10.0,
29                        'Point DistanceToPoint is wrong!')
30   
31    def testVertexDistance(self):
32        a = Vertex (0.0, 0.0)
33        b = Vertex (0.0, 10.0)
34       
35        self.failUnless( a.DistanceToPoint(b) == 10.0,
36                        'Point DistanceToPoint is wrong!')
37       
38    def testTriangle(self):
39        a = Vertex (0.0, 0.0)
40        b = Vertex (0.0, 2.0)
41        c = Vertex (2.0,0.0)
42        d = Vertex (0.0, 4.0)
43        e = Vertex (2.0, 2.0)
44        f = Vertex (4.0,0.0)
45       
46        t1 = Triangle(b,a,c)       
47        t2 = Triangle(b,c,e)     
48        t3 = Triangle(e,c,f)     
49        t4 = Triangle(d,b,e)
50        t2.setNeighbors(t3,t4,t1)
51       
52        self.failUnless( t2.neighbors[2].vertices[0] == b, 'Triangle initialisation is wrong!')
53   
54       
55    def testSegment(self):
56        a = Vertex (0.0, 0.0)
57        b = Vertex (0.0, 10.0)
58        s = Segment(a,b, tag = 20)     
59       
60        self.failUnless( s.vertices[0].DistanceToPoint(s.vertices[1]) == 10.0,
61                        'vertices in a segment are wrong')
62       
63        self.failUnless( s.tag == 20.0,
64                        'tag in a segment are wrong')
65
66    def testdeleteUserVertex(self):
67
68       
69        mesh = Mesh()
70        a = mesh.addUserVertex(0.0, 0.0)
71        b = mesh.addUserVertex (0.0, 2.0)
72        c = mesh.addUserVertex (2.0,0.0)
73       
74        s1 = mesh.addUserSegment(a,b)
75        s2 = mesh.addUserSegment(a,c)
76        s3 = mesh.addUserSegment(c,b)
77
78        mesh.deleteMeshObject (a) 
79        self.failUnless(mesh.userSegments[0] == s3,
80                        'Bad segment. ')       
81        self.failUnless(len(mesh.userSegments) ==1,
82                        'Segments not deleted.')
83        self.failUnless(len(mesh.userVertices) == 2,
84                        'Vertex not deleted.')
85       
86 
87    # FIXME add test for minAngle   
88    def testgenerateMesh(self):
89        a = Vertex (0.0, 0.0)
90        d = Vertex (0.0, 4.0)
91        f = Vertex (4.0,0.0)
92
93        s1 = Segment(a,d)
94        s2 = Segment(d,f)
95        s3 = Segment(a,f)
96
97        r1 = Region(0.3, 0.3,tag = 1.3,maxArea = .6)
98        #print r1
99        m = Mesh(userVertices=[a,d,f], userSegments=[s1,s2,s3], regions=[r1] )
100       
101        m.generateMesh("Q", maxArea = 2.1 )         
102
103        #print m
104
105        #m.plotMeshTriangle()
106
107        result = 1.414214
108        delta  = 0.00001
109        tri = m.getTriangulation()
110        verts = m.getMeshVertices()
111        x = verts[tri[1][0]][0]
112        #self.failUnless((m.meshTriangles[1].vertices[0].x < result + delta) or
113         #               (m.meshTriangles[1].vertices[0].x > result - delta),
114          #              'generated mesh is wrong!')
115
116        self.failUnless((x < result + delta) or
117                        (x > result - delta),
118                        'generated mesh is wrong!')
119       
120    def test_regionalMaxArea(self):
121        v0 = Vertex (0.0, 0.0)
122        v1 = Vertex (6.0, 0.0)
123        v2 = Vertex (6.0,6.0)
124        v3 = Vertex (0.0,6.0)
125
126        s1 = Segment(v0,v1)
127        s2 = Segment(v1,v2)
128        s3 = Segment(v3,v2)
129        s4 = Segment(v3,v0)
130        s5 = Segment(v2,v0)
131
132        r1 = Region(3, 1,tag = 1.3)
133        #print r1
134        m = Mesh(userVertices=[v0,v1,v2,v3], userSegments=[s1,s2,s3,s4,s5], regions=[r1] )
135       
136        m.generateMesh("Q", maxArea = 36 )         
137
138        #m.plotMeshTriangle()
139        #print "len(m.meshTriangles)",len(m.meshTriangles)
140
141        self.failUnless(len(m.getTriangulation()) == 2, 
142                        'test_regionalMaxArea 1:generated mesh is wrong!')
143       
144        ## Another test case
145        r1 = Region(3, 1,tag = 1.3)
146        r2 = Region(1, 3,tag = 1.3, maxArea = 8)
147        m = Mesh(userVertices=[v0,v1,v2,v3], userSegments=[s1,s2,s3,s4,s5],
148                 regions=[r1,r2] )
149        m.generateMesh("Q", maxArea = 36 )
150       
151        self.failUnless(len(m.getTriangulation()) >= 6,
152                        'testregion_with_maxarea 2: # of tris is wrong!')   
153       
154               
155        ## Another test case
156        r1 = Region(3, 1, tag = 1.3, maxArea = 8)
157        r2 = Region(1, 3, tag = 1.3, maxArea = 8)
158        m = Mesh(userVertices=[v0,v1,v2,v3], userSegments=[s1,s2,s3,s4,s5],
159                 regions=[r1,r2] )
160        m.generateMesh("Q", maxArea = 36 ) 
161        #print "len(m.meshTriangles)",len(m.meshTriangles)
162       
163        self.failUnless(len(m.getTriangulation()) >= 8,
164                        'testregion_with_maxarea 3: # of tris is wrong!')
165               
166               
167        ## Another test case
168        r1 = Region(3, 1, tag = 1.3 )
169        r2 = Region(1, 3, tag = 1.3, maxArea = 8)
170        m = Mesh(userVertices=[v0,v1,v2,v3], userSegments=[s1,s2,s3,s4,s5],
171                 regions=[r1,r2] )
172        m.generateMesh("Q", maxArea = 8 ) 
173        self.failUnless(len(m.getTriangulation()) >= 8,
174                        'testregion_with_maxarea 4: # of tris is wrong!')   
175
176       
177        ## Another test case
178        r1 = Region(3, 1,tag = 1.3, maxArea = 8)
179        r2 = Region(1, 3,tag = 1.3, maxArea = 8)
180        m = Mesh(userVertices=[v0,v1,v2,v3], userSegments=[s1,s2,s3,s4,s5],
181                 regions=[r1,r2] )
182        m.generateMesh("Q", maxArea = 36,isRegionalMaxAreas = False )     
183        self.failUnless(len(m.getTriangulation()) == 2, 
184                        'test_regionalMaxArea 5:generated mesh is wrong!')
185       
186        ## Another test case
187        r1 = Region(3, 1,tag = 1.3, maxArea = 8)
188        r2 = Region(1, 3,tag = 1.3, maxArea = 8)
189        m = Mesh(userVertices=[v0,v1,v2,v3], userSegments=[s1,s2,s3,s4,s5],
190                 regions=[r1,r2] )
191        m.generateMesh("Q",isRegionalMaxAreas = False )
192        self.failUnless(len(m.getTriangulation()) == 2, 
193                        'test_regionalMaxArea 5:generated mesh is wrong!')
194       
195    def test_generate_mesh(self):
196        v0 = Vertex (0.0, 0.0)
197        v1 = Vertex (6.0, 0.0)
198        v2 = Vertex (6.0,6.0)
199        v3 = Vertex (0.0,6.0)
200
201        s1 = Segment(v0,v1)
202        s2 = Segment(v1,v2)
203        s3 = Segment(v3,v2)
204        s4 = Segment(v3,v0)
205        s5 = Segment(v2,v0)
206
207        r1 = Region(3, 1,tag = 1.3)
208        #print r1
209        m = Mesh(userVertices=[v0,v1,v2,v3], userSegments=[s1,s2,s3,s4,s5],
210                 regions=[r1] )
211       
212        m.generate_mesh(maximum_triangle_area=36,verbose=False)         
213
214        self.failUnless(len(m.getTriangulation()) == 2, 
215                        'test_regionalMaxArea 1:generated mesh is wrong!')
216       
217        ## Another test case
218        r1 = Region(3, 1,tag = 1.3)
219        r2 = Region(1, 3,tag = 1.3, maxArea = 8)
220        m = Mesh(userVertices=[v0,v1,v2,v3], userSegments=[s1,s2,s3,s4,s5],
221                 regions=[r1,r2] )
222        m.generate_mesh(maximum_triangle_area=36,verbose=False) 
223       
224        self.failUnless(len(m.getTriangulation()) >= 6,
225                        'testregion_with_maxarea 2: # of tris is wrong!')   
226               
227        ## Another test case
228        r1 = Region(3, 1, tag = 1.3, maxArea = 8)
229        r2 = Region(1, 3, tag = 1.3, maxArea = 8)
230        m = Mesh(userVertices=[v0,v1,v2,v3], userSegments=[s1,s2,s3,s4,s5],
231                 regions=[r1,r2] )
232        m.generate_mesh(maximum_triangle_area=36,verbose=False)         
233        #print "len(m.getTriangulation())",len(m.getTriangulation())
234       
235        self.failUnless(len(m.getTriangulation()) >= 8,
236                        'testregion_with_maxarea 3: # of tris is wrong!')
237                         
238        ## Another test case
239        r1 = Region(3, 1, tag = 1.3 )
240        r2 = Region(1, 3, tag = 1.3, maxArea = 8)
241        m = Mesh(userVertices=[v0,v1,v2,v3], userSegments=[s1,s2,s3,s4,s5],
242                 regions=[r1,r2] )
243        m.generate_mesh(maximum_triangle_area=8,verbose=False)   
244        self.failUnless(len(m.getTriangulation()) >= 8,
245                        'testregion_with_maxarea 4: # of tris is wrong!')   
246
247        ## Another test case r1 = Region(3, 1,tag = 1.3, maxArea = 8)
248        r2 = Region(1, 3,tag = 1.3, maxArea = 8)
249        m = Mesh(userVertices=[v0,v1,v2,v3],
250        userSegments=[s1,s2,s3,s4,s5], regions=[r1,r2] )
251        m.generate_mesh(verbose=False)
252        #print "en(m.getTriangulation())", len(m.getTriangulation())
253        self.failUnless(len(m.getTriangulation()) >= 8,
254        'You have issues!')
255       
256    def testdeleteUserVertex(self):
257        mesh = Mesh()
258        a = mesh.addUserVertex(0.0, 0.0)
259        b = mesh.addUserVertex (0.0, 2.0)
260        c = mesh.addUserVertex (2.0,0.0)
261       
262        s1 = mesh.addUserSegment(a,b)
263        s2 = mesh.addUserSegment(a,c)
264        s3 = mesh.addUserSegment(c,b)
265
266        mesh.deleteMeshObject (s2)
267       
268        #print ",s2 in mesh.userSegments" ,s2 in mesh.userSegments
269        self.failUnless(not(s2 in mesh.userSegments),
270                        'Bad segment. ')       
271        self.failUnless(len(mesh.userSegments) ==2,
272                        'Segments not deleted.')
273        self.failUnless(len(mesh.userVertices) == 3,
274                        'Vertex deleted, instead of segment.')
275
276    def testTriangleArea(self):
277        a = Vertex (10.0, 10.0)
278        b = Vertex (10.0, 20.0)
279        c = Vertex (20.0,10.0)
280       
281        d = Vertex (-20.0, 0.0)
282        e = Vertex (-20.0, -20.0)
283        f = Vertex (20.0,-20.0)
284       
285        t1 = Triangle(b,a,c)     
286        t2 = Triangle(e,d,f)
287       
288#         print "t1", t1
289#         print "t1 area ", t1.calcArea()
290#         print "t2", t2
291#         print "t2 area ", t2.calcArea()
292        self.failUnless( t1.calcArea() == 50 and t2.calcArea() == 400, 'Triangle area is wrong!')
293    def testisUserSegmentNew (self):
294        mesh = Mesh()
295        a = mesh.addUserVertex(0.0, 0.0)
296        b = mesh.addUserVertex (0.0, 2.0)
297        c = mesh.addUserVertex (2.0,0.0)
298        d = mesh.addUserVertex (2.0,3.0)
299       
300        s1 = mesh.addUserSegment(a,b)
301        s2 = mesh.addUserSegment(a,c)
302        s3 = mesh.addUserSegment(c,b)
303
304        self.failUnless(mesh.isUserSegmentNew(a,d) ,
305                        'Segment should be new. ')
306        self.failUnless(not(mesh.isUserSegmentNew(a,b)) ,
307                        'Segment should not be new. ')
308
309
310    def testisUserSegmentNewII (self):
311        mesh = Mesh()
312        a = mesh.addUserVertex(0.0, 0.0)
313        b = mesh.addUserVertex (0.0, 2.0)
314        c = mesh.addUserVertex (2.0,0.0)
315        d = mesh.addUserVertex (2.0,3.0)
316       
317        s1 = mesh.addUserSegment(a,b)
318        s2 = mesh.addUserSegment(a,c)
319        s3 = mesh.addUserSegment(c,b)
320
321        self.failUnless(mesh.representedUserSegment(a,d) == None,
322                        'Segment should be new. ')
323        self.failUnless(mesh.representedUserSegment(a,b) == s1 ,
324                        'Segment should not be new. ')
325       
326    def testauto_segment(self):
327        p0 = Vertex (0.0, 0.0)
328        p1 = Vertex (0.0, 4.0)
329        p2 = Vertex (4.0,4.0)
330        p3 = Vertex (4.0,0.0)
331
332        s1 = Segment(p0,p1)
333       
334        m = Mesh(userVertices=[p0, p1, p2, p3], userSegments=[s1] ) 
335        m.auto_segment()
336       
337        #print 'Len', len(m.userSegments)
338        self.failUnless(len(m.getUserSegments()) == 4 ,
339                        'userSegments is wrong!')
340     
341        m.auto_segment()
342        self.failUnless(len(m.getUserSegments()) == 4 ,
343                        'userSegments is wrong!')
344     
345    def testauto_segmentII(self):
346        p1 = Vertex (3.0, 4.0)
347        p2 = Vertex (3.0,2.0)
348        p3 = Vertex (3.0,0.0)
349        p4 = Vertex (6.0, 4.0)
350        p5 = Vertex (6.0,2.0)
351        p0 = Vertex (6.0,0.0)
352
353
354        s1 = Segment(p2,p3)
355        s2 = Segment(p4,p5)
356       
357        m = Mesh(userVertices=[p0, p1, p2, p3, p4, p5],
358                 userSegments=[s1, s2])     
359
360        m.auto_segment()
361       
362        s3 = m.representedAlphaUserSegment(p3,p0)
363        self.failUnless(not (s3 == None) ,
364                        'userSegments is wrong!')
365
366       
367        s6 = m.representedAlphaUserSegment(p1,p4)       
368        self.failUnless(not (s6 == None) ,
369                        'userSegments is wrong!')
370       
371        # remove a segment, add a point, auto_segment
372        m.alphaUserSegments.remove(s3)
373        p6 = Vertex (1.0, 2.0)
374        m.userVertices.append(p6)
375       
376        m.auto_segment()
377       
378        s1_now = m.representedUserSegment(p3,p2)
379        self.failUnless(s1_now == s1 ,
380                        'userSegments is wrong!')
381       
382        s2_now = m.representedUserSegment(p5,p4)       
383        self.failUnless(s2_now == s2 ,
384                        'userSegments is wrong!')
385       
386        s3 = m.representedAlphaUserSegment(p3,p6)       
387        self.failUnless(not (s3 == None) ,
388                        'userSegments is wrong!')
389       
390        s4 = m.representedAlphaUserSegment(p3,p6)       
391        self.failUnless(not (s4 == None) ,
392                        'userSegments is wrong!')
393       
394        s5 = m.representedAlphaUserSegment(p4,p6)       
395        self.failUnless(s5 == None ,
396                        'userSegments is wrong!')
397        #print m
398       
399    def testRegions(self):
400        a = Vertex (0.0, 0.0)
401        b = Vertex (0.0, 2.0)
402        c = Vertex (2.0,0.0)
403        d = Vertex (0.0, 4.0)
404        e = Vertex (2.0, 2.0)
405        f = Vertex (4.0,0.0)
406        g = Vertex (0.0,-2.0)
407       
408        Segment.set_default_tag("")
409        s1 = Segment(a,b)
410        s2 = Segment(b,e)
411        s3 = Segment(e,c)
412        s4 = Segment(c,a)
413        s5 = Segment(b,d)
414        s6 = Segment(e,d)
415        s7 = Segment(e,f)
416        s8 = Segment(c,f)
417        s9 = Segment(g,c)
418        s10 = Segment(g,a)
419
420        r1 = Region(0.1,0.1,tag="22")
421        r2 = Region(0.1,2.1,tag="11")
422        r3 = Region(2.1,0.1)
423       
424        m = Mesh(userVertices=[a,b,c,d,e,f,g], userSegments=[s1,s2,s3,s4,s5,s6,s7,s8,s9,s10], regions=[r1,r2,r3] )
425        m.generateMesh("Q", maxArea = 2.1 )
426
427        # FIXME test the region
428        #Triangulation =  m.getTriangulation()
429        Triangulation = m.tri_mesh.triangle_tags
430        #print Triangulation[0].attribute
431        #print Triangulation[1].attribute
432        #print Triangulation[2].attribute
433        #print Triangulation[3].attribute
434        #print Triangulation[4].attribute
435       
436        self.failUnless(Triangulation[0] == "" and
437                        Triangulation[1] == "22" and
438                        Triangulation[2] == "" and
439                        Triangulation[3] == "11" and
440                        Triangulation[4] == "22" ,
441                        'region attributes are wrong!')   
442
443    def test_vertexAttribs(self):
444        a = Vertex (0.0, 0.0, attributes = [12.0,2.0])
445        d = Vertex (0.0, 4.0, attributes = [9.0,7.0])
446        f = Vertex (4.0,0.0, attributes = [14.0,3.0])
447   
448        Segment.set_default_tag("")
449        s1 = Segment(a,d)
450        s2 = Segment(d,f)
451        s3 = Segment(a,f)
452     
453        r1 = Region(0.3, 0.3, tag = 88.9)
454     
455        m = Mesh(userVertices=[a,d,f], userSegments=[s1,s2,s3], regions=[r1])
456
457        m.generateMesh("Q", maxArea = 2.1)
458
459        vert = m.getMeshVerticeAttributes()
460       
461        self.failUnless(vert[0] == [12.0, 2.0] and
462                        vert[1] == [9.0, 7.0] and
463                        vert[2] == [14.0,3.0] and
464                        vert[3] == [12.232233047033631, 4.4142135623730949] and
465                        vert[4] == [13.0, 2.5] ,
466                        'vertex attributes are wrong!')
467
468       
469    def test_vertexAttribs2(self):
470   
471        a = Vertex (0.0, 0.0)
472        d = Vertex (0.0, 4.0)
473        f = Vertex (4.0,0.0)
474   
475        Segment.set_default_tag("")
476        s1 = Segment(a,d)
477        s2 = Segment(d,f)
478        s3 = Segment(a,f)
479     
480        r1 = Region(0.3, 0.3, tag = 88.9)
481     
482        m = Mesh(userVertices=[a,d,f], userSegments=[s1,s2,s3], regions=[r1])
483
484        m.generateMesh("Q", maxArea = 2.1 )
485
486        vert = m.getMeshVerticeAttributes()
487        #print "vert", vert
488        self.failUnless(vert == [],
489                        'vertex attributes are wrong!')
490
491    def test_segtag(self):
492   
493        a = Vertex (0.0, 0.0)
494        d = Vertex (0.0, 4.0)
495        f = Vertex (4.0,0.0)
496   
497        s1 = Segment(a,d,tag = 5)
498        s2 = Segment(d,f,tag = 7)
499        s3 = Segment(a,f,tag = 9)
500     
501        m = Mesh(userVertices=[a,d,f], userSegments=[s1,s2,s3])
502
503        m.generateMesh("Q", maxArea = 2.1 )
504
505        #m.export_mesh_file("from_test_mesh.tsh")
506        seg = m.getMeshSegmentTags()
507        #print "seg",seg
508        #print "seg[0].tag"
509        #print seg[0].tag
510        #print "seg[0].tag"
511       
512        self.failUnless(seg[0] == 5 and
513                        seg[1] == 7 and
514                        seg[2] == 9 and
515                        seg[3] == 7 and
516                        seg[4] == 9,
517                        'seg tags are wrong')
518           
519
520    def test_segtag2(self):
521   
522        a = Vertex (0.0, 0.0)
523        d = Vertex (0.0, 4.0)
524        f = Vertex (4.0,0.0)
525        e = Vertex (1.0,1.0)
526   
527        s1 = Segment(a,d)
528        s2 = Segment(d,f)
529        s3 = Segment(a,f)
530        s4 = Segment(a,e)
531     
532        m = Mesh(userVertices=[a,d,f,e], userSegments=[s1,s2,s3,s4])
533
534        m.generateMesh("Q", maxArea = 2.1)
535
536        seg = m.getMeshSegmentTags()
537        self.failUnless(seg[0] == "exterior" and
538                        seg[1] == "exterior" and
539                        seg[2] == "exterior" and
540                        seg[3] == "" and
541                        seg[4] == "exterior",
542                        '2nd seg tags are wrong')
543
544    def test_asciiFile(self):
545   
546        a = Vertex (0.0, 0.0)  #, attributes = [1.1])
547        d = Vertex (0.0, 4.0)  #, attributes = [1.2])
548        f = Vertex (4.0,0.0)  #, attributes = [1.3])
549        e = Vertex (1.0,1.0)  #, attributes = [1.4])
550   
551        s1 = Segment(a,d)
552        s2 = Segment(d,f)
553        s3 = Segment(a,f)
554        s4 = Segment(a,e)
555     
556        m = Mesh(userVertices=[a,d,f,e], userSegments=[s1,s2,s3,s4])
557
558        m.generateMesh("Q", maxArea = 2.1 )
559        seg = m.getMeshSegments()
560       
561        fileName = tempfile.mktemp(".tsh")
562        m.export_mesh_file(fileName)
563        file = open(fileName)
564        lFile = file.read().split('\n')
565        file.close()
566        os.remove(fileName)
567       
568        #print "@^@^"
569        #for l in lFile:
570        #    print l,"<"
571        #print "@^@^"
572
573        # no need to check the title again
574        #self.failUnless(lFile[0] == "5 0 # <vertex #> <x> <y> [attributes] ...Triangulation Vertices..."
575          #              ,'Ascii file is wrong, vertex title')
576        self.failUnless(lFile[1] == "0 0.0 0.0 " and #1.1 " and
577                        lFile[2] == "1 0.0 4.0 " and #1.2 " and
578                        lFile[3] == "2 4.0 0.0 " and #1.3 " and
579                        lFile[4] == "3 1.0 1.0 " and #1.4 " and
580                        lFile[5] == "4 2.0 2.0 "  #1.25 "
581                        ,
582                        'Ascii file is wrong, vertex')
583       
584        #self.failUnless(lFile[6] == "# attribute column titles ...Triangulation Vertex Titles..."
585          #              ,'Ascii file is wrong, attribute column title')
586        self.failUnless(lFile[8] == "0 3 2 4 -1 2 3  " and
587                        lFile[9] == "1 1 0 3 3 2 -1  " and
588                        lFile[10] == "2 3 4 1 -1 1 0  " and
589                        lFile[11] == "3 2 3 0 1 -1 0  "
590                        ,
591                        'Ascii file is wrong, triangle') 
592
593        self.failUnless( lFile[13] == "0 0 1 exterior" and
594                        lFile[14] == "1 1 4 exterior" and
595                        lFile[15] == "2 2 0 exterior" and
596                        lFile[16] == "3 0 3 " and
597                        lFile[17] == "4 4 2 exterior" ,
598                        'Ascii file is wrong, segment')
599       
600       # self.failUnless(lFile[18] == '4 0 # <vertex #> <x> <y> [attributes] ...Mesh Vertices...',
601        #                'Ascii file is wrong, Mesh Vertices Title')
602       
603        self.failUnless(lFile[19] == '0 0.0 0.0 ' and #1.1 ' and
604                        lFile[20] == '1 0.0 4.0 ' and #1.2 ' and
605                        lFile[21] == '2 4.0 0.0 ' and #1.3 ' and
606                        lFile[22] == '3 1.0 1.0 ' #1.4 '
607                        ,
608                        'Ascii file is wrong, Mesh Vertices II')
609       
610        self.failUnless(lFile[24] == '0 0 1 ' and
611                        lFile[25] == '1 1 2 ' and
612                        lFile[26] == '2 0 2 ' and
613                        lFile[27] == '3 0 3 '
614                        ,'Ascii file is wrong, Mesh Segments')       
615
616 
617    def test_ascii_file(self):
618   
619        a = Vertex (0.0, 0.0) #, attributes = [1.1])
620        d = Vertex (0.0, 4.0) #, attributes = [1.2])
621        f = Vertex (4.0,0.0) #, attributes = [1.3])
622        e = Vertex (1.0,1.0) #, attributes = [1.4])
623   
624        s1 = Segment(a,d)
625        s2 = Segment(d,f)
626        s3 = Segment(a,f)
627        s4 = Segment(a,e)
628     
629        m = Mesh(userVertices=[a,d,f,e], userSegments=[s1,s2,s3,s4])
630
631        m.generateMesh("Q", maxArea = 2.1 )
632
633        seg = m.getMeshSegments()
634       
635        fileName = tempfile.mktemp(".tsh")
636        m.export_mesh_file(fileName)
637        file = open(fileName)
638        lFile = file.read().split('\n')
639        file.close()
640        os.remove(fileName)
641       
642        #print "@^@^"
643        #for l in lFile:
644        #    print l,"<"
645        #print "@^@^"
646        self.failUnless(lFile[0] == "5 0 # <# of verts> <# of vert attributes>, next lines <vertex #> <x> <y> [attributes] ...Triangulation Vertices..."
647                        ,
648                        'Ascii file is wrong, vertex title')
649        self.failUnless(lFile[1] == "0 0.0 0.0 " and #1.1 " and
650                        lFile[2] == "1 0.0 4.0 " and #1.2 " and
651                        lFile[3] == "2 4.0 0.0 " and #1.3 " and
652                        lFile[4] == "3 1.0 1.0 " and #1.4 " and
653                        lFile[5] == "4 2.0 2.0 "  #1.25 "
654                        ,
655                        'Ascii file is wrong, vertex')
656       
657        self.failUnless(lFile[6] == "# attribute column titles ...Triangulation Vertex Titles..."
658                        ,
659                        'Ascii file is wrong, attribute column title')
660        self.failUnless(lFile[7] == "4 # <# of triangles>, next lines <triangle #> [<vertex #>] [<neigbouring triangle #>] [attribute of region] ...Triangulation Triangles..." and
661                        lFile[8] == "0 3 2 4 -1 2 3  " and
662                        lFile[9] == "1 1 0 3 3 2 -1  " and
663                        lFile[10] == "2 3 4 1 -1 1 0  " and
664                        lFile[11] == "3 2 3 0 1 -1 0  "
665                        ,
666                        'Ascii file is wrong, triangle') 
667
668        self.failUnless(lFile[12] == "5 # <# of segments>, next lines <segment #> <vertex #>  <vertex #> [boundary tag] ...Triangulation Segments..." and
669                        lFile[13] == "0 0 1 exterior" and
670                        lFile[14] == "1 1 4 exterior" and
671                        lFile[15] == "2 2 0 exterior" and
672                        lFile[16] == "3 0 3 " and
673                        lFile[17] == "4 4 2 exterior" ,
674                        'Ascii file is wrong, segment')
675       
676        self.failUnless(lFile[18] == '4 0 # <# of verts> <# of vert attributes>, next lines <vertex #> <x> <y> [attributes] ...Mesh Vertices...',
677                        'Ascii file is wrong, Mesh Vertices Title')
678       
679        self.failUnless(lFile[19] == '0 0.0 0.0 ' and #1.1 ' and
680                        lFile[20] == '1 0.0 4.0 ' and #1.2 ' and
681                        lFile[21] == '2 4.0 0.0 ' and #1.3 ' and
682                        lFile[22] == '3 1.0 1.0 ' #1.4 '
683                        ,
684                        'Ascii file is wrong, Mesh Vertices II')
685       
686        self.failUnless(lFile[23] == '4 # <# of segments>, next lines <segment #> <vertex #>  <vertex #> [boundary tag] ...Mesh Segments...' and
687                        lFile[24] == '0 0 1 ' and
688                        lFile[25] == '1 1 2 ' and
689                        lFile[26] == '2 0 2 ' and
690                        lFile[27] == '3 0 3 ' and
691                        lFile[28] == '0 # <# of holes>, next lines <Hole #> <x> <y> ...Mesh Holes...' and
692                        lFile[29] == '0 # <# of regions>, next lines <Region #> <x> <y> <tag>...Mesh Regions...'
693                        ,
694                        'Ascii file is wrong, Mesh Segments')       
695 
696
697    def test_thinoutVertices(self):
698
699        v1 = Vertex(-20,-20)
700        v2 = Vertex(-11,-11)
701        v3 = Vertex(-10,-10)
702        v4 = Vertex(-9,-1)
703        v5 = Vertex(-8,2)
704        v6 = Vertex(6,3)
705        v7 = Vertex(12,9)
706        v8 = Vertex(15,3)
707        v9 = Vertex(24,3)
708        m = Mesh(userVertices = [v1,v2,v3,v4,v5,v6,v7,v8,v9])
709        m.thinoutVertices(10)
710         
711        self.failUnless(v1 in m.userVertices,
712                        'test_thinoutVertices, test 1 failed')
713        self.failUnless(v3 in m.userVertices,
714                        'test_thinoutVertices, test 2 failed')
715        self.failUnless(v4 in m.userVertices,
716                        'test_thinoutVertices, test 3 failed')
717        self.failUnless(v6 in m.userVertices,
718                        'test_thinoutVertices, test 4 failed')
719        self.failUnless(v7 in m.userVertices,
720                        'test_thinoutVertices, test 5 failed')
721        self.failUnless(v9 in m.userVertices,
722                        'test_thinoutVertices, test 6 failed')
723        self.failUnless(v5 not in m.userVertices,
724                        'test_thinoutVertices, test 7 failed')
725        self.failUnless(v2 not in m.userVertices,
726                        'test_thinoutVertices, test 8 failed')
727        self.failUnless(v8 not in m.userVertices,
728                        'test_thinoutVertices, test 9 failed')
729
730    def test_same_x_y(self):
731        v = Point(7,8)
732        f = Point(7,8)
733        f.same_x_y(v)
734
735        self.failUnless(f.same_x_y(v),
736                        'same_x_y True failed')
737        e = Point(7,9)
738        self.failUnless(not f.same_x_y(e),
739                        'same_x_y False failed')
740
741    def test_import_tsh(self):
742       
743        a_att = [5.0,2.0]
744        d_att =[4.0,2.0]
745        f_att = [3.0,2.0]
746        e_att = [2.0,2.0]
747        a_xy = [0.0, 0.0]
748        a = Vertex ( a_xy[0],a_xy[1]) #, attributes =a_att)
749        d = Vertex (0.0, 4.0) #, attributes =d_att)
750        f = Vertex (4.0,0.0) #, attributes =f_att)
751        e = Vertex (1.0,1.0) #, attributes =e_att)
752   
753        s1 = Segment(a,d, tag = "50")
754        s2 = Segment(d,f, tag = "40")
755        s3 = Segment(a,f, tag = "30")
756        s4 = Segment(a,e, tag = "20")
757     
758        r1 = Region(0.3, 0.3,tag = "1.3")
759        geo = Geo_reference(8.9,8.9,65)
760        m = Mesh(userVertices=[a,d,f,e],
761                 userSegments=[s1,s2,s3,s4],
762                 regions=[r1],
763                 geo_reference=geo)
764
765        m.generateMesh("Q", maxArea = 2.1)
766        fileName = tempfile.mktemp(".tsh")
767        #print "dgs!!!"
768        #print "****************** fileName", fileName
769        m.export_mesh_file(fileName)
770        #print "******************"
771        #print "m", m
772        #print "******************"
773        m_returned = importMeshFromFile(fileName)
774        #print "m_returned",m_returned
775        #print "******************"
776        #print "****************** fileName", fileName
777        os.remove(fileName)
778        self.failUnless(0 == m.__cmp__(m_returned),
779                        'loading and saving of a mesh failed')
780        # do this when .msh supports geo_refs
781        #self.failUnless(m.geo_reference == m_returned.geo_reference,
782        #                'loading and saving of a mesh geo refs failed')
783
784    def test_import_mesh(self):
785       
786        a_att = [5.0,2.0]
787        d_att =[4.0,2.0]
788        f_att = [3.0,2.0]
789        e_att = [2.0,2.0]
790        a_xy = [0.0, 0.0]
791        a = Vertex ( a_xy[0],a_xy[1]) #, attributes =a_att)
792        d = Vertex (0.0, 4.0) #, attributes =d_att)
793        f = Vertex (4.0,0.0) #, attributes =f_att)
794        e = Vertex (1.0,1.0) #, attributes =e_att)
795   
796        s1 = Segment(a,d, tag = "50")
797        s2 = Segment(d,f, tag = "40")
798        s3 = Segment(a,f, tag = "30")
799        s4 = Segment(a,e, tag = "20")
800     
801        r1 = Region(0.3, 0.3,tag = "1.3")
802        geo = Geo_reference(65,8.9,8.9)
803        m = Mesh(userVertices=[a,d,f,e],
804                 userSegments=[s1,s2,s3,s4],
805                 regions=[r1],
806                 geo_reference=geo)
807
808        m.generateMesh("Q", maxArea = 2.1)
809        fileName = tempfile.mktemp(".msh")
810        #print "dgs!!!"
811        #print "****************** fileName", fileName
812        m.export_mesh_file(fileName)
813        #print "******************"
814        #print "m", m
815        #print "******************"
816        m_returned = importMeshFromFile(fileName)
817        #print "m_returned",m_returned
818        #print "******************"
819        #print "****************** fileName", fileName
820        os.remove(fileName)
821        #print "m.geo_reference",m.geo_reference
822        #print "m_returned.geo_reference,",m_returned.geo_reference
823        self.failUnless(0 == m.__cmp__(m_returned),
824                        'loading and saving of a mesh failed')
825        self.failUnless(m.geo_reference == m_returned.geo_reference,
826                        'loading and saving of a mesh geo refs failed')
827
828    def DONTtest_normaliseMesh(self):
829       
830        a_att = [5.0,2.0]
831        d_att =[4.0,2.0]
832        f_att = [3.0,2.0]
833        e_att = [2.0,2.0]
834        a_xy = [10.0, 10.0]
835        a = Vertex ( a_xy[0],a_xy[1], attributes =a_att)
836        d = Vertex (15.0, 10.0, attributes =d_att)
837        f = Vertex (10.0,20.0, attributes =f_att)
838        e = Vertex (15.0,20.0, attributes =e_att)
839   
840        s1 = Segment(a,d, tag = 50)
841        s2 = Segment(d,e, tag = 40)
842        s3 = Segment(e,f, tag = 30)
843        s4 = Segment(f,a, tag = 20)
844     
845        r1 = Region(0.3, 0.3,tag = 1.3)
846        m = Mesh(userVertices=[a,d,f,e],
847                 userSegments=[s1,s2,s3,s4],
848                 regions=[r1])
849        m.normaliseMesh(1,0,1)
850        [xmin, ymin, xmax, ymax] = m.boxsize()
851        [attmin, attmax] = m.maxMinVertAtt(0)
852        self.failUnless(attmin == 0.0 and attmax == 1.0,
853                        'normalise failed')
854        self.failUnless(xmin == 0.0 and ymin == 0.0 and xmax == 0.5 and ymax == 1.0,
855                        'normalise failed')
856        m.normaliseMesh(200,-100,5)
857        [xmin, ymin, xmax, ymax] = m.boxsize()
858        [attmin, attmax] = m.maxMinVertAtt(0)
859        self.failUnless(attmin == 0.0 and attmax == 5.0,
860                        'normalise failed')
861        self.failUnless(xmin == -100.0 and ymin == -100.0 and xmax == 0.0 and ymax == 100.0,
862                        'normalise failed')
863       
864    def test_exportASCIIsegmentoutlinefile(self):
865        a = Vertex (0,0)
866        b = Vertex (0,3)
867        c = Vertex (3,3)
868        d = Vertex (1,2)
869        e = Vertex (3,1)
870     
871        s1 = Segment(a,b, tag = "50")
872        s2 = Segment(b,c, tag = "40")
873        s3 = Segment(c,a, tag = "30")
874     
875        r1 = Region(2, 1,tag = "1.3")
876        h1 = Hole(1,4)
877        m = Mesh(userVertices=[a,b,c,d,e],
878                 userSegments=[s1,s2,s3],
879                 regions=[r1],
880                 holes = [h1])     
881
882        # vertex e is outside of the outline, so
883        # it is a loner and it is removed.
884        m.generateMesh("Q", maxArea = 2.1)
885        #print "mesh ***************dsg*", m
886
887        fileName = tempfile.mktemp(".tsh")
888        m.exportASCIIsegmentoutlinefile(fileName)
889       
890        m_returned = importMeshFromFile(fileName)
891
892        #print "m_returned ****",m_returned
893        #print "****************** fileName", fileName
894        os.remove(fileName)
895
896        #Trim mesh, so it should like like m_returned
897        m.tri_mesh = None
898        m.userVertices=[a,b,c]
899        #print "mesh ***************dsg*", m
900        #print "(m.__cmp__(m_returned)", m.__cmp__(m_returned)
901        self.failUnless(0 == m.__cmp__(m),
902                        'test_exportASCIIsegmentoutlinefile:loading and saving of a mesh failed')
903        # Having problems with this on linux.
904        #The ordering of the dictionary values wasn't the same as the windows
905        #returned value (verts.values())
906        #self.failUnless(0 == m.__cmp__(m_returned),
907        #                'test_exportASCIIsegmentoutlinefile:loading and saving of a mesh failed')
908       
909        self.failUnless(3 == len(m_returned.userVertices),
910                        'segmentoutlinefile:IO of a mesh failed')
911        self.failUnless(len(m.userSegments) == len(m_returned.userSegments),
912                        'segmentoutlinefile:IO of a mesh failed')
913        for i in range(len(m.userSegments)):
914            self.failUnless(m.userSegments[i].vertices[0].x ==
915                            m_returned.userSegments[i].vertices[0].x,
916                        'loading and saving of a mesh outline fialed')
917            self.failUnless(m.userSegments[i].vertices[0].y ==
918                            m_returned.userSegments[i].vertices[0].y,
919                        'loading and saving of a mesh outline fialed')
920            self.failUnless(m.userSegments[i].vertices[1].x ==
921                            m_returned.userSegments[i].vertices[1].x,
922                        'loading and saving of a mesh outline fialed')
923            self.failUnless(m.userSegments[i].vertices[1].y ==
924                            m_returned.userSegments[i].vertices[1].y,
925                        'loading and saving of a mesh outline fialed')
926
927 
928    def test_exportASCIIsegmentoutlinefile2(self):
929        a = Vertex (0,0)
930        b = Vertex (0,1)
931        c = Vertex (1,0)
932        d = Vertex (1,1)
933        e = Vertex (0.5,0.5)
934        f  = Vertex (0.6,0.6)
935     
936        s1 = Segment(a,e, tag = "50")
937        s2 = Segment(b,e, tag = "40")
938        s3 = Segment(c,e, tag = "30")
939        s4 = Segment(d,e, tag = "30")
940     
941        r1 = Region(2, 1,tag = "1.3")
942        h1 = Hole(1,4)
943        m = Mesh(userVertices=[a,b,c,d,e],
944                 userSegments=[s1,s2,s3,s4],
945                 regions=[r1],
946                 holes = [h1])     
947       
948        fileName = tempfile.mktemp(".tsh")
949        m.exportASCIIsegmentoutlinefile(fileName)
950       
951        m_returned = importMeshFromFile(fileName)
952        #print "****************** fileName", fileName
953        os.remove(fileName)
954
955        #Trim mesh, so it should look like m_returned
956        m.meshVertices = []
957        m.meshTriangles = []
958        m.meshSegments = []
959        m.userVertices=[a,e,d,b,c]
960        #print "mesh ***************dsg*", m
961        #print "(m.__cmp__(m_returned)", m.__cmp__(m_returned)
962        self.failUnless(0 == m.__cmp__(m),
963                        'loading and saving of a mesh failed')
964
965        self.failUnless(5 == len(m_returned.userVertices),
966                        'segmentoutlinefile:IO of a mesh failed')
967        self.failUnless(len(m.userSegments) == len(m_returned.userSegments),
968                        'segmentoutlinefile:IO of a mesh failed')
969        for i in range(len(m.userSegments)):
970            self.failUnless(m.userSegments[i].vertices[0].x ==
971                            m_returned.userSegments[i].vertices[0].x,
972                        'loading and saving of a mesh outline fialed')
973            self.failUnless(m.userSegments[i].vertices[0].y ==
974                            m_returned.userSegments[i].vertices[0].y,
975                        'loading and saving of a mesh outline fialed')
976            self.failUnless(m.userSegments[i].vertices[1].x ==
977                            m_returned.userSegments[i].vertices[1].x,
978                        'loading and saving of a mesh outline fialed')
979            self.failUnless(m.userSegments[i].vertices[1].y ==
980                            m_returned.userSegments[i].vertices[1].y,
981                        'loading and saving of a mesh outline fialed')
982
983
984    def test_load_csv(self):
985        """
986        To test the mesh side of loading csv files.
987        Not the loading of csv files
988        """
989        import os
990        import tempfile
991       
992        fileName = tempfile.mktemp(".csv")
993        file = open(fileName,"w")
994        file.write("x,y,elevation, speed \n\
9951.0, 0.0, 10.0, 0.0\n\
9960.0, 1.0, 0.0, 10.0\n\
9971.0, 0.0, 10.4, 40.0\n")
998        file.close()
999        #print fileName
1000        m = importMeshFromFile(fileName)
1001        os.remove(fileName)
1002        self.failUnless(m.userVertices[0].x == 1.0,
1003                        'loadxy, test 1 failed')
1004        self.failUnless(m.userVertices[0].y == 0.0,
1005                        'loadxy, test 2 failed')
1006        #self.failUnless(m.userVertices[0].attributes == [10.0,0.0],
1007        #                'loadxy, test 2.2 failed')
1008        self.failUnless(m.userVertices[1].x == 0.0,
1009                        'loadxy, test 3 failed')
1010        self.failUnless(m.userVertices[1].y == 1.0,
1011                        'loadxy, test 4 failed')
1012        #self.failUnless(m.userVertices[1].attributes == [0.0,10.0],
1013        #                'loadxy, test 5 failed')
1014       
1015    def test_exportPointsFile(self):
1016        a = Vertex (0,0)
1017        b = Vertex (0,3)
1018        c = Vertex (3,3)
1019        d = Vertex (1,2)
1020        e = Vertex (3,1)
1021        #f = Vertex (3,1)
1022     
1023        s1 = Segment(a,b, tag = 50)
1024        s2 = Segment(b,c, tag = 40)
1025        s3 = Segment(c,a, tag = 30)
1026     
1027        r1 = Region(2, 1,tag = 1.3)
1028        h1 = Hole(1,4)
1029        # Warning mesh can't produce this type of data structure its self
1030        m = Mesh(userVertices=[a,b,c,d,e],
1031                 userSegments=[s1,s2,s3],
1032                 regions=[r1],
1033                 holes = [h1])
1034       
1035        fileName = tempfile.mktemp(".txt")
1036        #fileName = 't.csv'
1037        #os.remove(fileName)
1038        m.exportPointsFile(fileName)
1039        file = open(fileName)
1040        lFile = file.read().split('\n')
1041        file.close()
1042        os.remove(fileName)
1043        self.failUnless(lFile[0] == "x,y," and
1044                        lFile[1] == "0.0,0.0" and
1045                        lFile[2] == "0.0,3.0" and
1046                        lFile[3] == "3.0,3.0" 
1047                        ,
1048                        'exported Ascii csv file is wrong')
1049        self.failUnless(lFile[4] == "1.0,2.0" and
1050                        lFile[5] == "3.0,1.0" 
1051                        ,
1052                        'exported Ascii csv file is wrong')
1053       
1054        # vertex e is outside of the outline, so
1055        # it is a loner and it is removed.
1056        m.generateMesh("Q", maxArea = 2.1)
1057        fileName = tempfile.mktemp(".txt")
1058        #fileName = 't.csv'
1059        #m.export_mesh_file('m.tsh')
1060        m.exportPointsFile(fileName)
1061        file = open(fileName)
1062        lFile = file.read().split('\n')
1063        file.close()
1064        os.remove(fileName)
1065       
1066        self.failUnless(lFile[0] == "x,y," and
1067                        lFile[1] == "0.0,0.0" and
1068                        lFile[2] == "0.0,3.0" and
1069                        lFile[3] == "3.0,3.0" and
1070                        lFile[4] == "1.0,2.0"
1071                        ,
1072                        'exported Ascii csv file is wrong')
1073     
1074    def to_be_test_lone_vert_in_mesh_gen_c_layer(self):
1075        # currently just a copy of the above test
1076        a = Vertex (0,0)
1077        b = Vertex (0,3)
1078        c = Vertex (3,3)
1079        d = Vertex (1,2)
1080        e = Vertex (3,1)
1081        #f = Vertex (3,1)
1082     
1083        s1 = Segment(a,b, tag = 50)
1084        s2 = Segment(b,c, tag = 40)
1085        s3 = Segment(c,a, tag = 30)
1086     
1087        r1 = Region(2, 1,tag = 1.3)
1088        h1 = Hole(1,4)
1089        # Warning mesh can't produce this type of data structure its self
1090        m = Mesh(userVertices=[a,b,c,d,e],
1091                 userSegments=[s1,s2,s3],
1092                 regions=[r1],
1093                 holes = [h1])
1094       
1095        fileName = tempfile.mktemp(".csv")
1096        #fileName = 't.csv'
1097        #os.remove(fileName)
1098        m.exportPointsFile(fileName)
1099        file = open(fileName)
1100        lFile = file.read().split('\n')
1101        file.close()
1102
1103        os.remove(fileName)
1104        self.failUnless(lFile[0] == "x,y" and
1105                        lFile[1] == "0,0" and
1106                        lFile[2] == "0,3" and
1107                        lFile[3] == "3,3" 
1108                        ,
1109                        'exported Ascii csv file is wrong')
1110        self.failUnless(lFile[4] == "1,2" and
1111                        lFile[5] == "3,1" 
1112                        ,
1113                        'exported Ascii csv file is wrong')
1114       
1115        # vertex e is outside of the outline, so
1116        # it is a loner and it is removed.
1117        m.generateMesh("Q", maxArea = 2.1)
1118        fileName = tempfile.mktemp(".csv")
1119        #fileName = 't.csv'
1120        #m.export_mesh_file('m.tsh')
1121        m.exportPointsFile(fileName)
1122        file = open(fileName)
1123        lFile = file.read().split('\n')
1124        file.close()
1125        os.remove(fileName)
1126       
1127        self.failUnless(lFile[0] == "x,y" and
1128                        lFile[1] == "0.0,0.0" and
1129                        lFile[2] == "0.0,3.0" and
1130                        lFile[3] == "3.0,3.0" and
1131                        lFile[4] == "1.0,2.0"
1132                        ,
1133                        'exported Ascii csv file is wrong')
1134       
1135    def NOT_test_exportPointsFilefile2(self):
1136        #geospatial needs at least one point
1137        m = Mesh()
1138       
1139        fileName = tempfile.mktemp(".csv")
1140        m.exportPointsFile(fileName)
1141        file = open(fileName)
1142        lFile = file.read().split('\n')
1143        file.close()
1144
1145        os.remove(fileName)
1146        #print "************* test_mesh exportPointsFilefile"
1147        #print "lFile",lFile
1148        #print "************* test_mesh exportPointsFilefile"
1149        self.failUnless(lFile[0] == "" 
1150                        ,
1151                        'exported Ascii csv file is wrong')
1152       
1153    def test_strings2ints(self):
1154        list = ["sea","river inlet","","sea","","moat"]
1155        preset = ["moat", "internal boundary"]
1156        [intlist, converter] = segment_strings2ints(list,preset )
1157        self.failUnless(intlist == [2,3 ,0 ,2 ,0 ,0 ]
1158                        ,
1159                        'test_strings2ints produces bad intlist')
1160        self.failUnless(converter == ['moat', 'internal boundary',
1161                                      'sea', 'river inlet']
1162                        ,
1163                        'test_strings2ints produces bad converter')
1164       
1165    def test_ints2strings(self):
1166        list = ["internal boundary","sea","river inlet",
1167            "","sea","","moat","internal boundary"]
1168        outlist = ['internal boundary', 'sea', 'river inlet', 'moat',
1169                   'sea', 'moat', 'moat', 'internal boundary']
1170        preset = ["moat", "internal boundary"]
1171        [intlist, converter] = segment_strings2ints(list,preset )
1172        newlist = segment_ints2strings(intlist, converter)
1173        self.failUnless(outlist == newlist
1174                        ,
1175                        'test_strings2ints produces bad intlist')
1176        self.failUnless(converter == ['moat', 'internal boundary',
1177                                      'sea', 'river inlet']
1178                        ,
1179                        'test_strings2ints produces bad converter')
1180       
1181    def test_ints2strings2(self):
1182        list = ["","",""]
1183        preset = ["moat", "internal boundary"]
1184        [intlist, converter] = segment_strings2ints(list,preset )
1185        newlist = segment_ints2strings(intlist, converter)
1186        outlist = ['moat', 'moat', 'moat']
1187        self.failUnless(outlist == newlist
1188                        ,
1189                        'test_strings2ints produces bad intlist')
1190        self.failUnless(converter == ['moat', 'internal boundary']
1191                        ,
1192                        'test_strings2ints produces bad converter')
1193
1194       
1195    def test_removeDuplicatedVertices(self):
1196        a = Vertex (0,0)
1197        a.index = 0
1198        b = Vertex (0,3)
1199        b.index = 1
1200        c = Vertex (3,3)
1201        c.index = 2
1202        d = Vertex (1,1)
1203        d.index = 3
1204        e = Vertex (3,1)
1205        e.index = 4
1206        f = Vertex (1,1)
1207        f.index = 5
1208        g = Vertex (1,1)
1209        g.index = 6
1210        inputVerts_noDups = [a,b,c,d,e]
1211       
1212        m = Mesh(userVertices=[a,b,c,d,e,f,g])
1213        counter = m.removeDuplicatedUserVertices()
1214        UserVerts = m.getUserVertices()
1215       
1216         
1217        self.failUnless(UserVerts == inputVerts_noDups,
1218                            'duplicate verts not removed')
1219        #for userVert, inputVert in map(None, UserVerts, inputVerts_noDups):
1220        #    self.failUnless(userVert.x == inputVert.x,
1221        #                    'x duplicate verts not removed')
1222        #    self.failUnless(userVert.y == inputVert.y,
1223        #                    'y duplicate verts not removed')
1224
1225       
1226    def test_ungenerateFileLoading(self):
1227       
1228        fileName = tempfile.mktemp(".txt")
1229        file = open(fileName,"w")
1230        file.write("         1       ??      ??\n\
1231       0.0       0.0\n\
1232       1.0       0.0\n\
1233       1.0       1.0\n\
1234       0.0       1.0\n\
1235       0.0       0.0\n\
1236END\n\
1237         2      ?? ??\n\
1238       10.0       10.0\n\
1239       10.0       20.0\n\
1240       20.0       20.0\n\
1241       10.0       10.0\n\
1242END\n\
1243END\n")
1244        file.close()
1245       
1246       
1247        a = Vertex (0.0, 0.0) #, attributes = [1.1])
1248        b = Vertex (0.0, 40.0) #, attributes = [1.2])
1249        c = Vertex (40.0,40.0) #, attributes = [1.3])
1250        d = Vertex (40.0,0.0) #, attributes = [1.4])
1251   
1252        s1 = Segment(a,b)
1253        s2 = Segment(b,c)
1254        s3 = Segment(c,d)
1255        s4 = Segment(d,a)
1256     
1257        m = Mesh(userVertices=[a,b,c,d], userSegments=[s1,s2,s3,s4])
1258        dict = importUngenerateFile(fileName)
1259        #os.remove(fileName)
1260
1261        tag = "DSG"
1262        Segment.set_default_tag(tag)
1263        m.addVertsSegs(dict)
1264
1265        # have to reset this , since it's a class attribute
1266        Segment.set_default_tag("")
1267           
1268        self.failUnless(len(m.userSegments) ==11,
1269                        'Wrong segment list length.')
1270        self.failUnless(len(m.userVertices) == 11,
1271                        'Wrong vertex list length.')
1272        self.failUnless(m.userSegments[10].vertices[0] == m.userVertices[10],
1273                        'bad vertex on segment.')
1274        self.failUnless(m.userSegments[10].vertices[1] == m.userVertices[8],
1275                        'Bad segment.')
1276        self.failUnless(m.userSegments[10].tag == tag,
1277                        'wrong tag.')
1278
1279        ## let's test the method
1280        a = Vertex (0.0, 0.0) #, attributes = [1.1])
1281        b = Vertex (0.0, 40.0) #, attributes = [1.2])
1282        c = Vertex (40.0,40.0) #, attributes = [1.3])
1283        d = Vertex (40.0,0.0) #, attributes = [1.4])
1284   
1285        s1 = Segment(a,b)
1286        s2 = Segment(b,c)
1287        s3 = Segment(c,d)
1288        s4 = Segment(d,a)
1289     
1290        m = Mesh(userVertices=[a,b,c,d], userSegments=[s1,s2,s3,s4])
1291
1292        tag = "DSG"       
1293        initial_tag = "PIG"
1294        Segment.set_default_tag(initial_tag)
1295        m.import_ungenerate_file(fileName, tag=tag)
1296
1297        os.remove(fileName)
1298
1299        self.failUnless(Segment.get_default_tag() == initial_tag,
1300                        'Wrong segment list length.')
1301       
1302
1303        # have to reset this , since it's a class attribute
1304        Segment.set_default_tag("")
1305           
1306        self.failUnless(len(m.userSegments) ==11,
1307                        'Wrong segment list length.')
1308        self.failUnless(len(m.userVertices) == 11,
1309                        'Wrong vertex list length.')
1310        self.failUnless(m.userSegments[10].vertices[0] == m.userVertices[10],
1311                        'bad vertex on segment.')
1312        self.failUnless(m.userSegments[10].vertices[1] == m.userVertices[8],
1313                        'Bad segment.')
1314        self.failUnless(m.userSegments[10].tag == tag,
1315                        'wrong tag.')
1316       
1317    def test_ungenerateFileLoadingII(self):
1318       
1319        fileName = tempfile.mktemp(".txt")
1320        file = open(fileName,"w")
1321        file.write("         1       ??      ??\n\
1322       0.0       0.0\n\
1323       1.0       0.0\n\
1324       1.0       1.0\n\
1325       0.0       1.0\n\
1326       0.0       0.0\n\
1327END\n\
1328         2      ?? ??\n\
1329       10.0       10.0\n\
1330       10.0       20.0\n\
1331       20.0       20.0\n\
1332END\n\
1333END\n")
1334        file.close()
1335       
1336       
1337        a = Vertex (0.0, 0.0) #, attributes = [1.1])
1338        b = Vertex (0.0, 40.0) #, attributes = [1.2])
1339        c = Vertex (40.0,40.0) #, attributes = [1.3])
1340        d = Vertex (40.0,0.0) #, attributes = [1.4])
1341   
1342        s1 = Segment(a,b)
1343        s2 = Segment(b,c)
1344        s3 = Segment(c,d)
1345        s4 = Segment(d,a)
1346     
1347        m = Mesh(userVertices=[a,b,c,d], userSegments=[s1,s2,s3,s4])
1348        dict = importUngenerateFile(fileName)
1349        #os.remove(fileName)
1350
1351        tag = "DSG"
1352        Segment.set_default_tag(tag)
1353        m.addVertsSegs(dict)
1354
1355        self.failUnless(len(m.userSegments) ==10,
1356                        'Wrong segment list length.')
1357        self.failUnless(len(m.userVertices) == 11,
1358                        'Wrong vertex list length.')
1359
1360        # Test the method
1361        a = Vertex (0.0, 0.0) #, attributes = [1.1])
1362        b = Vertex (0.0, 40.0) #, attributes = [1.2])
1363        c = Vertex (40.0,40.0) #, attributes = [1.3])
1364        d = Vertex (40.0,0.0) #, attributes = [1.4])
1365   
1366        s1 = Segment(a,b)
1367        s2 = Segment(b,c)
1368        s3 = Segment(c,d)
1369        s4 = Segment(d,a)
1370     
1371        m = Mesh(userVertices=[a,b,c,d], userSegments=[s1,s2,s3,s4])
1372        tag = "DSG"       
1373        initial_tag = "PIG"
1374        Segment.set_default_tag(initial_tag)
1375        m.import_ungenerate_file(fileName, tag=tag)
1376
1377        os.remove(fileName)
1378
1379        self.failUnless(Segment.get_default_tag() == initial_tag,
1380                        'Wrong segment list length.')
1381       
1382       
1383        self.failUnless(len(m.userSegments) ==10,
1384                        'Wrong segment list length.')
1385        self.failUnless(len(m.userVertices) == 11,
1386                        'Wrong vertex list length.')
1387       
1388        # have to reset this , since it's a class attribute
1389        Segment.set_default_tag("")
1390       
1391    def test_addVertsSegs(self):
1392        m = Mesh()
1393        Segment.set_default_tag("food")
1394        dict = {}
1395        dict['points'] = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0]]
1396        dict['segments'] = [[0, 1], [1, 2]]
1397        dict['segment_tags'] = ['','do-op']
1398        m.addVertsSegs(dict)
1399        # have to reset this , since it's a class attribute
1400        Segment.set_default_tag("")
1401
1402       
1403        self.failUnless(len(m.userSegments) ==2,
1404                        'Wrong segment list length.')
1405        self.failUnless(len(m.userVertices) == 3,
1406                        'Wrong vertex list length.')
1407        self.failUnless(m.userSegments[0].tag =='food',
1408                        'Wrong segment tag length.')
1409        self.failUnless(m.userSegments[1].tag =='do-op',
1410                        'Wrong segment tag.')
1411       
1412    def test_addVertsSegs2(self):
1413        geo = Geo_reference(56,5,10)
1414        m = Mesh(geo_reference=geo)
1415        dict = {}
1416        dict['points'] = [[2.0, 1.0], [3.0, 1.0], [2.0, 2.0]]
1417        dict['segments'] = [[0, 1], [1, 2], [2,0]]
1418        dict['segment_tags'] = ['','do-op','']
1419        m.addVertsSegs(dict)
1420
1421    def test_addVertsSegs_done_twice(self):
1422        m = Mesh()
1423        dict = {}
1424        dict['points'] = [[0.0, 0.0], [5.0, 0.0], [5.0, 5.0]]
1425        dict['segments'] = [[0, 1], [1, 2], [2,0]]
1426        dict['segment_tags'] = ['0','1','2']
1427        m.addVertsSegs(dict)
1428       
1429        dict = {}
1430        dict['points'] = [[2.0, 1.0], [4.0, 1.0], [4.0, 3.0]]
1431        dict['segments'] = [[0, 1], [1, 2], [2,0]]
1432        dict['segment_tags'] = ['3','4','5']
1433        m.addVertsSegs(dict)
1434
1435       
1436        self.failUnless(m.userSegments[5].vertices[0].y == 3,
1437                        'Wrong vertex connected.')
1438        self.failUnless(m.userSegments[5].vertices[1].y == 1,
1439                        'Wrong vertex connected.')
1440           
1441    def test_add_points_and_segments(self):
1442        m = Mesh()
1443        Segment.set_default_tag("food")
1444        dict = {}
1445        points =  [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0]]
1446        segments = [[0, 1], [1, 2]]
1447        segment_tags = {'do-op':[1]}
1448        m.add_points_and_segments(points,
1449                                    segments, segment_tags)
1450        # have to reset this , since it's a class attribute
1451        Segment.set_default_tag("")
1452
1453       
1454        self.failUnless(len(m.userSegments) ==2,
1455                        'Wrong segment list length.')
1456        self.failUnless(len(m.userVertices) == 3,
1457                        'Wrong vertex list length.')
1458        self.failUnless(m.userSegments[0].tag =='food',
1459                        'Wrong segment tag length.')
1460        self.failUnless(m.userSegments[1].tag =='do-op',
1461                        'Wrong segment tag.')
1462       
1463    def test_exportASCIImeshfile(self):
1464   
1465        #a_att = [5,2]
1466        #d_att =[4,2]
1467        #f_att = [3,2]
1468        #e_att = [2,2]
1469        a_xy = [0.0, 0.0]
1470        a = Vertex ( a_xy[0],a_xy[1]) #, attributes =a_att)
1471        d = Vertex (0.0, 4.0) #, attributes =d_att)
1472        f = Vertex (4.0,0.0) #, attributes =f_att)
1473        e = Vertex (1.0,1.0) #, attributes =e_att)
1474   
1475        s1 = Segment(a,d, tag = "50")
1476        s2 = Segment(d,f, tag = "40")
1477        s3 = Segment(a,f, tag = "30")
1478        s4 = Segment(a,e, tag = "20")
1479     
1480        r1 = Region(0.3, 0.3,tag = "1.3", maxArea = 36)
1481
1482
1483        h1 = Hole(0.2,0.6)
1484       
1485        m = Mesh(userVertices=[a,d,f,e],
1486                 userSegments=[s1,s2,s3,s4],
1487                 regions=[r1],
1488                 holes=[h1])
1489
1490        seg = m.getUserSegments()
1491        points = m.getUserVertices()
1492        holes = m.getHoles()
1493        regions = m.getRegions()
1494        fileName = tempfile.mktemp(".tsh")
1495        m.export_mesh_file(fileName)
1496        #print "***************************fileName", fileName
1497        new_m = importMeshFromFile(fileName)
1498        os.remove(fileName)
1499       
1500
1501        #print '**@@@@@******'
1502        #print "new_m",new_m
1503        #print '**@@@@@******'
1504        #print "m",m
1505        #print '**@@@@@******'
1506       
1507        self.failUnless( new_m == m,
1508                         'loadASCIITestCase failed. test new 1')
1509           
1510    def test_Mesh2MeshList(self):
1511
1512        a_att = [5,2]
1513        d_att =[4,2]
1514        f_att = [3,2]
1515        e_att = [2,2]
1516        a_xy = [0.0, 0.0]
1517        a = Vertex ( a_xy[0],a_xy[1]) #, attributes =a_att)
1518        d = Vertex (0.0, 4.0) #, attributes =d_att)
1519        f = Vertex (4.0,0.0) #, attributes =f_att)
1520        e = Vertex (1.0,1.0) #, attributes =e_att)
1521   
1522        s1 = Segment(a,d, tag = "50")
1523        s2 = Segment(d,f, tag = "40")
1524        s3 = Segment(a,f, tag = "30")
1525        s4 = Segment(a,e, tag = "20")
1526     
1527        r1 = Region(0.3, 0.3,tag = "1.3", maxArea = 45)
1528        m = Mesh(userVertices=[a,d,f,e],
1529                 userSegments=[s1,s2,s3,s4],
1530                 regions=[r1])
1531
1532        m.generateMesh("Qa2.1")
1533
1534        seg = m.getMeshSegments()
1535        points = m.getMeshVertices()
1536        dict = m.Mesh2MeshList()
1537        #print "dict",dict
1538        # test not finished...
1539 
1540    def test_Mesh2IOTriangulationDict(self):
1541
1542        a_att = [5,2]
1543        d_att =[4,2]
1544        f_att = [3,2]
1545        e_att = [2,2]
1546        a_xy = [0.0, 0.0]
1547        a = Vertex ( a_xy[0],a_xy[1] , attributes =a_att)
1548        d = Vertex (0.0, 4.0 , attributes =d_att)
1549        f = Vertex (4.0,0.0 , attributes =f_att)
1550        e = Vertex (1.0,1.0 , attributes =e_att)
1551   
1552        s1 = Segment(a,d, tag = "50")
1553        s2 = Segment(d,f, tag = "40")
1554        s3 = Segment(a,f, tag = "30")
1555        s4 = Segment(a,e, tag = "20")
1556     
1557        r1 = Region(0.3, 0.3,tag = "1.3", maxArea = 45)
1558        m = Mesh(userVertices=[a,d,f,e],
1559                 userSegments=[s1,s2,s3,s4],
1560                 regions=[r1])
1561        titles = ['ele','friction'] #Feed in directly!
1562        m.attributeTitles = titles
1563        m.generateMesh("Qa2.1")
1564
1565        seg = m.getMeshSegments()
1566        verts = m.getMeshVertices()
1567        vert_as = m.getMeshVerticeAttributes()
1568        seg_tags = m.getMeshSegmentTags()
1569        dict = m.Mesh2IOTriangulationDict()
1570        #print "dict",dict
1571       
1572        self.failUnless( dict['vertex_attribute_titles'] == titles,
1573                         'test_Mesh2IOTriangulationDict failed. test 1')
1574        answer = [a_xy,[0.0, 4.0],[4.0,0.0], [1.0,1.0], [2.0,2.0]]
1575        #print "answer",answer
1576        #print "dict['vertices']",dict['vertices']
1577       
1578        self.failUnless( dict['vertices'] == answer,
1579                         'test_Mesh2IOTriangulationDict failed. test 2')
1580
1581        self.failUnless( dict['vertices'] == verts,
1582                         'test_Mesh2IOTriangulationDict failed. test vert')
1583        self.failUnless( dict['vertex_attributes'] == vert_as,
1584                         'test_Mesh2IOTriangulationDict failed. test vert ats')
1585
1586        self.failUnless( dict['segments'][0] == [0,1],
1587                        'test_Mesh2IODict failed. test 3')
1588       
1589        self.failUnless( dict['segment_tags'] == seg_tags,
1590                        'test_Mesh2IODict failed. test 3')
1591        #print " dict['triangles'][0]", dict['triangles'][0]
1592        self.failUnless( dict['triangles'][0] == [3,2,4],
1593                        'test_Mesh2IODict failed. test 5')
1594        self.failUnless( dict['triangle_neighbors'][0] == [-1,2,3],
1595                        'test_Mesh2IODict failed. test 6')
1596        #print "dict['triangle_tags'][0]", dict['triangle_tags'][0]
1597        self.failUnless( dict['triangle_tags'][0] == "1.3",
1598                         'test_Mesh2IODict failed. test 7')
1599
1600 
1601    def test_Mesh2IODict(self):
1602
1603        a_att = [5,2]
1604        d_att =[4,2]
1605        f_att = [3,2]
1606        e_att = [2,2]
1607        a_xy = [0.0, 0.0]
1608        a = Vertex ( a_xy[0],a_xy[1] , attributes =a_att)
1609        d = Vertex (0.0, 4.0 , attributes =d_att)
1610        f = Vertex (4.0,0.0 , attributes =f_att)
1611        e = Vertex (1.0,1.0 , attributes =e_att)
1612   
1613        s1 = Segment(a,d, tag = "50")
1614        s2 = Segment(d,f, tag = "40")
1615        s3 = Segment(a,f, tag = "30")
1616        s4 = Segment(a,e, tag = "20")
1617     
1618        r1 = Region(0.3, 0.3,tag = "1.3", maxArea = 45)
1619        m = Mesh(userVertices=[a,d,f,e],
1620                 userSegments=[s1,s2,s3,s4],
1621                 regions=[r1])
1622        titles = ['ele','friction']
1623        m.attributeTitles = titles
1624        m.generateMesh("Qa2.1")
1625
1626        seg = m.getMeshSegments()
1627        verts = m.getMeshVertices()
1628        vert_as = m.getMeshVerticeAttributes()
1629        dict = m.Mesh2IODict()
1630        seg_tags = m.getMeshSegmentTags()
1631        #print "dict",dict
1632       
1633        self.failUnless( dict['vertex_attribute_titles'] == titles,
1634                         'test_Mesh2IOTriangulationDict failed. test 1')
1635        answer = [a_xy,[0.0, 4.0],[4.0,0.0], [1.0,1.0], [2.0,2.0]]
1636        #print "answer",answer
1637        #print "dict['vertices']",dict['vertices']
1638       
1639        self.failUnless( dict['vertices'] == answer,
1640                         'test_Mesh2IOTriangulationDict failed. test 2')
1641
1642        self.failUnless( dict['vertices'] == verts,
1643                         'test_Mesh2IOTriangulationDict failed. test vert')
1644        self.failUnless( dict['vertex_attributes'] == vert_as,
1645                         'test_Mesh2IOTriangulationDict failed. test vert ats')
1646
1647        self.failUnless( dict['segments'][0] == [0,1],
1648                        'test_Mesh2IODict failed. test 3')
1649       
1650        self.failUnless( dict['segment_tags'] == seg_tags,
1651                        'test_Mesh2IODict failed. test 3')
1652        #print " dict['triangles'][0]", dict['triangles'][0]
1653        self.failUnless( dict['triangles'][0] == [3,2,4],
1654                        'test_Mesh2IODict failed. test 5')
1655        self.failUnless( dict['triangle_neighbors'][0] == [-1,2,3],
1656                        'test_Mesh2IODict failed. test 6')
1657        #print "dict['triangle_tags'][0]", dict['triangle_tags'][0]
1658        self.failUnless( dict['triangle_tags'][0] == "1.3",
1659                         'test_Mesh2IODict failed. test 7')
1660
1661        seg = m.getUserSegments()
1662        points = m.getUserVertices()
1663        holes = m.getHoles()
1664        regions = m.getRegions()
1665       
1666        for pimport,pactual,pimpatt in map(None,dict['points'],points,dict['point_attributes']):
1667            self.failUnless( pimport == [pactual.x,pactual.y],
1668                        'test_Mesh2IODict failed. test 1')
1669            self.failUnless( pimpatt == pactual.attributes,
1670                        'test_Mesh2IODict failed. test 1.1')
1671        self.failUnless( dict['outline_segments'][0] == [0,1],
1672                        'test_Mesh2IODict failed. test 3')
1673        for segimp,segactual in map(None,dict['outline_segment_tags'],seg):
1674            self.failUnless( segimp == segactual.tag,
1675                        'test_Mesh2IODict failed. test 4')
1676        for holeimp,holeactual in map(None,dict['holes'],holes):
1677            self.failUnless( holeimp == [holeactual.x,holeactual.y],
1678                        'test_Mesh2IODict failed. test 5')
1679       
1680        for regimp,regactual,regattimp, regmaxarea in map(None,dict['regions'],regions, dict['region_tags'], dict['region_max_areas']):
1681            self.failUnless( regimp == [regactual.x,regactual.y],
1682                        'loadASCIITestCase failed. test 6')
1683            self.failUnless( regattimp == regactual.getTag(),
1684                        'loadASCIITestCase failed. test 7')
1685            self.failUnless( regmaxarea == regactual.getMaxArea(),
1686                        'loadASCIITestCase failed. test 7')
1687   
1688           
1689       
1690    def test_Mesh2IOOutlineDict(self):
1691
1692        a_att = [5,2]
1693        d_att =[4,2]
1694        f_att = [3,2]
1695        e_att = [2,2]
1696        a_xy = [0.0, 0.0]
1697        a = Vertex ( a_xy[0],a_xy[1] , attributes =a_att)
1698        d = Vertex (0.0, 4.0 , attributes =d_att)
1699        f = Vertex (4.0,0.0 , attributes =f_att)
1700        e = Vertex (1.0,1.0 , attributes =e_att)
1701   
1702        s1 = Segment(a,d, tag = "50")
1703        s2 = Segment(d,f, tag = "40")
1704        s3 = Segment(a,f, tag = "30")
1705        s4 = Segment(a,e, tag = "20")
1706     
1707        r1 = Region(0.3, 0.3,tag = "1.3", maxArea = 45)
1708        m = Mesh(userVertices=[a,d,f,e],
1709                 userSegments=[s1,s2,s3,s4],
1710                 regions=[r1])
1711        titles = ['ele','friction']
1712        m.attributeTitles = titles
1713        m.generateMesh("Qa2.1")
1714
1715        seg = m.getMeshSegments()
1716        verts = m.getMeshVertices()
1717        dict = m.Mesh2IOOutlineDict()
1718       
1719        seg = m.getUserSegments()
1720        points = m.getUserVertices()
1721        holes = m.getHoles()
1722        regions = m.getRegions()
1723       
1724        for pimport,pactual,pimpatt in map(None,dict['points'],points,dict['point_attributes']):
1725            self.failUnless( pimport == [pactual.x,pactual.y],
1726                        'loadASCIITestCase failed. test 1')
1727            self.failUnless( pimpatt == pactual.attributes,
1728                        'loadASCIITestCase failed. test 1.1')
1729        self.failUnless( dict['outline_segments'][0] == [0,1],
1730                        'loadASCIITestCase failed. test 3')
1731        for segimp,segactual in map(None,dict['outline_segment_tags'],seg):
1732            self.failUnless( segimp == segactual.tag,
1733                        'loadASCIITestCase failed. test 4')
1734        for holeimp,holeactual in map(None,dict['holes'],holes):
1735            self.failUnless( holeimp == [holeactual.x,holeactual.y],
1736                        'loadASCIITestCase failed. test 5')
1737        #for regimp,regactual in map(None,dict['regions'],regions):
1738         #   self.failUnless( [regimp[0],regimp[1]]==[regactual.x,regactual.y],
1739          #              'loadASCIITestCase failed. test 6')
1740           # self.failUnless( regimp[2] == regactual.getTag(),
1741            #            'loadASCIITestCase failed. test 7')
1742            #self.failUnless( regimp[3] == regactual.getMaxArea(),
1743             #           'loadASCIITestCase failed. test 7')
1744
1745           
1746        for regimp,regactual,regattimp, regmaxarea in map(None,dict['regions'],regions, dict['region_tags'], dict['region_max_areas']):
1747            self.failUnless( regimp == [regactual.x,regactual.y],
1748                        'loadASCIITestCase failed. test 6')
1749            self.failUnless( regattimp == regactual.getTag(),
1750                        'loadASCIITestCase failed. test 7')
1751            self.failUnless( regmaxarea == regactual.getMaxArea(),
1752                        'loadASCIITestCase failed. test 7')
1753
1754
1755#___________beginning of Peters tests
1756
1757    def test_set_stuff(self):
1758        """
1759        Documentation
1760        """
1761        #making a test mesh
1762        p0=[0.,2.]
1763        p1=[1.,2.]
1764        p2=[0.,1.]
1765        p3=[1.,1.]
1766        p4=[0.,0.]
1767        p5=[2.,0.]
1768        p6=[-1.,1.]
1769        point_list = [p0,p1,p2,p3,p4,p5,p6]
1770
1771        a0=[0]
1772        a1=[0]
1773        a2=[100]
1774        a3=[0]
1775        a4=[0]
1776        a5=[0]
1777        a6=[0]
1778        attribute=[a0,a1,a2,a3,a4,a5,a6]
1779       
1780        t0=[0,3,1]
1781        t1=[0,2,3]
1782        t2=[2,4,3]
1783        t3=[4,5,3]
1784        t4=[1,3,5]
1785        t5=[2,6,4]
1786
1787        n0=[4,-1,2]
1788        n1=[2,0,-1]
1789        n2=[3,1,5]
1790        n3=[4,2,-1]
1791        n4=[3,-1,0]
1792        n5=[-1,2,-1]
1793
1794        tri_list = [t0,t1,t2,t3,t4,t5]
1795        n_list = [n0,n1,n2,n3,n4,n5]
1796        for i in range(6):
1797            for j in (0,1,2):
1798                a=attribute[tri_list[i][j]]
1799                tri_list[i][j]=point_list[tri_list[i][j]]
1800                tri_list[i][j]=Vertex(tri_list[i][j][0]\
1801                                      ,tri_list[i][j][1],a)
1802            neighbours=n_list[i]
1803            tri_list[i]=Triangle(tri_list[i][0],\
1804                                 tri_list[i][1],tri_list[i][2]\
1805                                ,neighbors=neighbours)
1806
1807        #testing selectAll
1808        mesh = Mesh()
1809        mesh.attributeTitles=['attrib']
1810
1811        mesh.meshTriangles=tri_list
1812
1813        mesh.selectAllTriangles()
1814        A=mesh.sets[mesh.setID['All']]
1815        assert list_comp(tri_list,A)
1816
1817       #testing threshold
1818        mesh = Mesh()
1819        mesh.attributeTitles=['attrib']
1820
1821        mesh.meshTriangles=tri_list
1822        mesh.selectAllTriangles()
1823        mesh.threshold('All',min=30,max=35,attribute_name = 'attrib')
1824        A = [tri_list[1],tri_list[2],tri_list[5]]
1825        B = mesh.sets[mesh.setID['All']]
1826        assert list_comp(A,B)
1827       
1828
1829        A = [tri_list[3],tri_list[2],tri_list[5]]
1830        assert not list_comp(A,B)
1831
1832        #testing
1833
1834    def test_Discretised_Tuple_Set_rounding(self):
1835        #This is the hardest bit of DST
1836
1837        tol = 0.1
1838        a=Discretised_Tuple_Set(p_rel=1,t_rel= tol)
1839        m = 0.541
1840        m_up = 0.6
1841        m_down = 0.5
1842        assert m_up == a.round_up_rel(m)
1843        assert m_down == a.round_down_rel(m)
1844
1845        tol = 0.1
1846        a=Discretised_Tuple_Set(p_rel=1,t_rel = tol)
1847        m = 0.539
1848        m_up = 0.5
1849        m_down = 0.5
1850        assert m_up == a.round_up_rel(m)
1851        assert m_down == a.round_down_rel(m)
1852
1853        tol = 0.5
1854        a=Discretised_Tuple_Set(p_rel=1,t_rel = tol)
1855
1856
1857        m = 0.6
1858        m_up = 0.7
1859        m_down = 0.5
1860        assert m_up == a.round_up_rel(m)
1861        assert m_down == a.round_down_rel(m)
1862
1863        m = 0.599
1864        m_up = 0.6
1865        m_down = 0.5
1866        assert m_up == a.round_up_rel(m)
1867        assert m_down == a.round_down_rel(m)
1868
1869    def test_Discretised_Tuple_Set_get(self):
1870       
1871        tol = 0.25
1872        a=Discretised_Tuple_Set(p_rel=1,t_rel = tol)
1873        b = (1.1,1.1)
1874        a.append(b)
1875        list = [(1.2,1.),(1.,1.),(1.,1.2),(1.2,1.2)]
1876        for key in list:
1877            assert a[key][0]==b
1878            assert len(a[key])==1
1879       
1880        c = (2.1,1.)
1881        a.append(c)
1882        assert a[(2.,1.)][0]==c
1883        assert a[(2.2,1.)][0]==c
1884
1885    def test_mapped_Discretised_Tuple_Set(self):
1886
1887        def map(sequence):
1888            return [len(sequence)]
1889
1890        tol = 0.5
1891        a=Mapped_Discretised_Tuple_Set(map,p_rel=1,t_rel = tol)
1892        b = range(20)
1893        a.append(b)
1894        assert b in a[range(17)] 
1895        assert b in a[range(22)]
1896
1897        tol = 0.01
1898        a=Mapped_Discretised_Tuple_Set(map,p_rel=1,t_rel = tol)
1899        b = range(20)
1900        a.append(b)
1901        assert b in a[range(20)] 
1902        assert b in a[range(19)] 
1903        assert not range(17) in a
1904
1905#___________end of Peters tests
1906
1907    def test_add_region_from_polygon(self):
1908        m=Mesh()
1909        region = m.add_region_from_polygon([[0,0],[1,0],[0,1]],
1910                                  max_triangle_area = 88,
1911                                           region_tag='cassady')
1912        self.failUnless(len(m.regions)==1,
1913                        'FAILED!')
1914        self.failUnless(region.getMaxArea()==88,
1915                        'FAILED!')
1916        self.failUnless(len(m.getUserSegments())==3,
1917                        'FAILED!')
1918        self.failUnless(len(m.userVertices)==3,
1919                        'FAILED!')
1920        self.failUnless(region.getTag()=='cassady',
1921                        'FAILED!')
1922       
1923    def test_add_region_from_polygon2(self):
1924        m=Mesh()
1925        m.add_region_from_polygon([[0,0],[1,0],[1,1],[0,1]],
1926                               {'tagin':[0,1],'bom':[2]},
1927                                  max_triangle_area=10)
1928        self.failUnless(len(m.regions)==1,
1929                        'FAILED!')
1930        segs = m.getUserSegments()
1931        self.failUnless(len(segs)==4,
1932                        'FAILED!')
1933        self.failUnless(len(m.userVertices)==4,
1934                        'FAILED!') 
1935        self.failUnless(segs[0].tag=='tagin',
1936                        'FAILED!') 
1937        self.failUnless(segs[1].tag=='tagin',
1938                        'FAILED!') 
1939         
1940        self.failUnless(segs[2].tag=='bom',
1941                        'FAILED!') 
1942        self.failUnless(segs[3].tag=='',
1943                        'FAILED!') 
1944       
1945    def test_add_region_from_polygon3(self):
1946        x=-500
1947        y=-1000
1948        m=Mesh(geo_reference=Geo_reference(56,x,y))
1949
1950        # These are the absolute values
1951        polygon_absolute = [[0,0],[1,0],[1,1],[0,1]]
1952       
1953        x_p = -10
1954        y_p = -40
1955        geo_ref_poly = Geo_reference(56, x_p, y_p)
1956        polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
1957       
1958        poly_point = m.add_region_from_polygon(polygon,
1959                                               {'tagin':[0,1],'bom':[2]},
1960                                               geo_reference=geo_ref_poly,
1961                                               max_triangle_area=10)
1962        # poly_point values are relative to the mesh geo-ref
1963        # make them absolute
1964        self.failUnless(is_inside_polygon([poly_point.x+x,poly_point.y+y],
1965                                       polygon_absolute, closed = False),
1966                        'FAILED!')
1967               
1968        self.failUnless(len(m.regions)==1,
1969                        'FAILED!')
1970        segs = m.getUserSegments()
1971        self.failUnless(len(segs)==4,
1972                        'FAILED!')
1973        self.failUnless(len(m.userVertices)==4,
1974                        'FAILED!') 
1975        self.failUnless(segs[0].tag=='tagin',
1976                        'FAILED!') 
1977        self.failUnless(segs[1].tag=='tagin',
1978                        'FAILED!') 
1979         
1980        self.failUnless(segs[2].tag=='bom',
1981                        'FAILED!') 
1982        self.failUnless(segs[3].tag=='',
1983                        'FAILED!')
1984        verts = m.getUserVertices()
1985        #print "User verts",verts
1986        #print 'polygon',polygon
1987        #vert values are relative
1988        for point,new_point in map(None,polygon,verts):
1989            point_x = point[0] + geo_ref_poly.get_xllcorner()
1990            new_point_x = new_point.x + m.geo_reference.get_xllcorner()
1991            point_y = point[1] + geo_ref_poly.get_yllcorner()
1992            #print "new_point.y",new_point.y
1993            #print "m.geo_ref.get_yllcorner()",m.geo_reference.get_yllcorner()
1994            new_point_y = new_point.y + m.geo_reference.get_yllcorner()
1995            #print "point_y",point_y
1996            #print "new_point_y",new_point_y
1997           
1998            self.failUnless(point_x == new_point_x, ' failed')
1999            self.failUnless(point_y == new_point_y, ' failed')
2000           
2001         
2002    def test_add_region_from_polygon4(self):
2003        x=50000
2004        y=1000
2005        m=Mesh(geo_reference=Geo_reference(56,x,y))
2006        polygon = [[0,0],[1,0],[1,1],[0,1]]
2007       
2008        m.add_region_from_polygon(polygon,
2009                               {'tagin':[0,1],'bom':[2]},
2010                                  max_triangle_area=10)
2011        self.failUnless(len(m.regions)==1,
2012                        'FAILED!')
2013        segs = m.getUserSegments()
2014        self.failUnless(len(segs)==4,
2015                        'FAILED!')
2016        self.failUnless(len(m.userVertices)==4,
2017                        'FAILED!') 
2018        self.failUnless(segs[0].tag=='tagin',
2019                        'FAILED!') 
2020        self.failUnless(segs[1].tag=='tagin',
2021                        'FAILED!') 
2022         
2023        self.failUnless(segs[2].tag=='bom',
2024                        'FAILED!') 
2025        self.failUnless(segs[3].tag=='',
2026                        'FAILED!')
2027        verts = m.getUserVertices()
2028        #print "User verts",verts
2029        #print 'polygon',polygon
2030        #vert values are relative
2031        for point,new_point in map(None,polygon,verts):
2032            point_x = point[0] 
2033            new_point_x = new_point.x + m.geo_reference.get_xllcorner()
2034            #print "point_x",point_x
2035            #print "new_point_x",new_point_x
2036            point_y = point[1] 
2037            new_point_y = new_point.y + m.geo_reference.get_yllcorner()
2038           
2039            self.failUnless(point_x == new_point_x, ' failed')
2040            self.failUnless(point_y == new_point_y, ' failed')
2041
2042
2043    def test_add_hole_from_polygon(self):
2044        x=-500
2045        y=-1000
2046        m=Mesh(geo_reference=Geo_reference(56,x,y))
2047
2048        # These are the absolute values
2049        polygon_absolute = [[0,0],[1,0],[1,1],[0,1]]
2050       
2051        x_p = -10
2052        y_p = -40
2053        geo_ref_poly = Geo_reference(56, x_p, y_p)
2054        polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
2055       
2056        poly_point = m.add_hole_from_polygon(polygon,
2057                                               {'tagin':[0,1],'bom':[2]},
2058                                               geo_reference=geo_ref_poly)
2059        # poly_point values are relative to the mesh geo-ref
2060        # make them absolute
2061        #print "poly_point.x+x",poly_point.x+x
2062        #print "poly_point.y+y",poly_point.y+y
2063        #print "polygon_absolute", polygon_absolute
2064        self.failUnless(is_inside_polygon([poly_point.x+x,poly_point.y+y],
2065                                       polygon_absolute, closed = False),
2066                        'FAILED!')
2067               
2068        self.failUnless(len(m.holes)==1,
2069                        'FAILED!')
2070        segs = m.getUserSegments()
2071        self.failUnless(len(segs)==4,
2072                        'FAILED!')
2073        self.failUnless(len(m.userVertices)==4,
2074                        'FAILED!') 
2075        self.failUnless(segs[0].tag=='tagin',
2076                        'FAILED!') 
2077        self.failUnless(segs[1].tag=='tagin',
2078                        'FAILED!') 
2079         
2080        self.failUnless(segs[2].tag=='bom',
2081                        'FAILED!') 
2082        self.failUnless(segs[3].tag=='',
2083                        'FAILED!')
2084        verts = m.getUserVertices()
2085        #print "User verts",verts
2086        #print 'polygon',polygon
2087        #vert values are relative
2088        for point,new_point in map(None,polygon,verts):
2089            point_x = point[0] + geo_ref_poly.get_xllcorner()
2090            new_point_x = new_point.x + m.geo_reference.get_xllcorner()
2091            point_y = point[1] + geo_ref_poly.get_yllcorner()
2092            #print "new_point.y",new_point.y
2093            #print "m.geo_ref.get_yllcorner()",m.geo_reference.get_yllcorner()
2094            new_point_y = new_point.y + m.geo_reference.get_yllcorner()
2095            #print "point_y",point_y
2096            #print "new_point_y",new_point_y
2097           
2098            self.failUnless(point_x == new_point_x, ' failed')
2099            self.failUnless(point_y == new_point_y, ' failed')
2100
2101    def test_add_circle(self):
2102        x=-500
2103        y=-1000
2104        m=Mesh(geo_reference=Geo_reference(56,x,y))
2105
2106        # These are the absolute values
2107        tag = 'hey'
2108        segment_count = 104
2109        radius = 30
2110        circle_center_absolute = [100,80]       
2111        x_p = -.666
2112        y_p = -.777
2113        geo_ref_poly = Geo_reference(56, x_p, y_p)
2114        circle_center = \
2115                geo_ref_poly.change_points_geo_ref(circle_center_absolute)
2116        circle_center = circle_center[0] #make a list of lists a list
2117        poly_point = m.add_circle(circle_center, radius, segment_count,
2118                                  tag=tag,
2119                                  region=True,
2120                                  center_geo_reference=geo_ref_poly)
2121        # poly_point values are relative to the mesh geo-ref
2122        # make them absolute
2123        #print "poly_point.x+x",poly_point.x+x
2124        #print "polygon_absolute", polygon_absolute
2125     
2126       
2127        #m.export_mesh_file("aaat.msh")
2128       
2129        self.failUnless(len(m.regions)==1,
2130                        'FAILED!')
2131        segs = m.getUserSegments()
2132        self.failUnless(len(segs)==segment_count,
2133                        'FAILED!')
2134        self.failUnless(len(m.userVertices)==segment_count,
2135                        'FAILED!') 
2136        self.failUnless(segs[0].tag==tag,
2137                        'FAILED!') 
2138        self.failUnless(segs[1].tag==tag,
2139                        'FAILED!') 
2140         
2141        verts = m.getUserVertices()
2142       
2143        #m.export_mesh_file("aaat.msh")
2144       
2145    def NOTIMPLEMENTEDtest_auto_set_geo_reference(self):
2146        x=50000
2147        y=1000
2148        m=Mesh(geo_reference=Geo_reference(56,x,y))
2149        polygon = [[0,0],[1,0],[1,1],[0,1]]
2150       
2151        m.add_region_from_polygon(polygon,
2152                               {'tagin':[0,1],'bom':[2]},
2153                                  max_triangle_area=10)
2154        m.auto_set_geo_reference()
2155       
2156 
2157    def test_duplicat_verts_are_removed(self):
2158   
2159     
2160        a = Vertex ( 0.0 ,0.0)
2161        b = Vertex (0.0, 4.0)
2162        c = Vertex (4.0,4.0)
2163        d = Vertex (4.0,0.0)
2164        e = Vertex (4.0,0.0) # duplicate point
2165   
2166        s1 = Segment(a,b, tag = "50")
2167        s2 = Segment(b,c, tag = "40")
2168        s3 = Segment(c,d, tag = "30")
2169        s4 = Segment(d,e, tag = "no where seg")
2170        s5 = Segment(e,a, tag = "20")
2171
2172       
2173        m = Mesh(userVertices=[a,b,c,d,e],
2174                 userSegments=[s1,s2,s3,s4,s5])
2175
2176        seg = m.getUserSegments()
2177        points = m.getUserVertices()
2178        holes = m.getHoles()
2179        regions = m.getRegions()
2180        #fileName = tempfile.mktemp(".tsh")
2181        #fileName = "badmesh.tsh"
2182        #m.export_mesh_file(fileName)
2183        #print "***************************fileName", fileName
2184        #new_m = importMeshFromFile(fileName)
2185        #os.remove(fileName)
2186       
2187        m.generateMesh("Q", maxArea = 2000.1 )
2188
2189        #m.export_mesh_file("from_test_mesh.tsh")
2190        seg = m.getMeshSegments()
2191        self.failUnless(4==len(seg),
2192                        'FAILED!') 
2193
2194        vert = m.getMeshVertices() 
2195        self.failUnless(4==len(vert),
2196                        'FAILED!')
2197 
2198    def test_duplicat_verts_are_removedII(self):
2199   
2200     
2201        a = Vertex ( 0.0 ,0.0)
2202        b = Vertex (0.0, 4.0)
2203        c = Vertex (4.0,4.0)
2204        d = Vertex (4.0,0.0)
2205        e = Vertex (4.0,0.0) # duplicate point
2206        f = Vertex (49.0,0.0) # unused point
2207   
2208        s1 = Segment(a,b, tag = "50")
2209        s2 = Segment(b,c, tag = "40")
2210        s3 = Segment(c,d, tag = "30")
2211        s4 = Segment(d,e, tag = "no where seg")
2212        s5 = Segment(e,a, tag = "20")
2213
2214       
2215        m = Mesh(userVertices=[a,b,c,d,e,f],
2216                 userSegments=[s1,s2,s3,s4,s5])
2217
2218        seg = m.getUserSegments()
2219        points = m.getUserVertices()
2220        holes = m.getHoles()
2221        regions = m.getRegions()
2222        #fileName = tempfile.mktemp(".tsh")
2223        #fileName = "badmesh.tsh"
2224        #m.export_mesh_file(fileName)
2225        #print "***************************fileName", fileName
2226        #new_m = importMeshFromFile(fileName)
2227        #os.remove(fileName)
2228       
2229        m.generateMesh("Q", maxArea = 2000.1 )
2230
2231        #m.export_mesh_file("from_test_mesh.tsh")
2232        seg = m.getMeshSegments()
2233        self.failUnless(4==len(seg),
2234                        'FAILED!') 
2235
2236        vert = m.getMeshVertices() 
2237        self.failUnless(4==len(vert),
2238                        'FAILED!')
2239   
2240    def test_add_vertices(self):
2241        points_ab = [[0.1,1],[0.4,.2],[7,5],[10,5]]
2242        geo =  Geo_reference(56,23,21)
2243        points = geo.change_points_geo_ref(points_ab)
2244        spat = Geospatial_data(points, geo_reference=geo)
2245       
2246        geo_mesh =  Geo_reference(56,100,200)
2247        m = Mesh(geo_reference=geo_mesh)
2248        m.add_vertices(spat)
2249
2250        vert = m.getUserVertices()
2251        #print "vert",vert
2252        self.failUnless(4==len(vert),
2253                        'FAILED!')
2254        vert= m.get_user_vertices(absolute=True)
2255        self.failUnless(vert==points_ab,
2256                        'FAILED!')
2257
2258   
2259    def test_add_vertices_more(self):
2260        points = [[0.1,1],[0.4,.2],[7,5],[10,5]]
2261        #spat = Geospatial_data(points)
2262       
2263        m = Mesh()
2264        m.add_vertices(points)
2265
2266        vert = m.getUserVertices()
2267        #print "vert",vert
2268        self.failUnless(4==len(vert),
2269                        'FAILED!')
2270        vert= m.get_user_vertices(absolute=True)
2271        self.failUnless(vert==points,
2272                        'FAILED!')
2273   
2274    def test_add_verticesII(self):
2275        points_lat_long = [[-33,152],[-35,152],[-35,150],[-33,150]]
2276       
2277        spat = Geospatial_data(data_points=points_lat_long,
2278                               points_are_lats_longs=True)
2279        points_ab = spat.get_data_points( absolute = True)
2280        m = Mesh()
2281        m.add_vertices(spat)
2282
2283        vert = m.getUserVertices()
2284        #print "vert",vert
2285        self.failUnless(4==len(vert),
2286                        'FAILED!')
2287        vert= m.get_user_vertices(absolute=True)
2288        self.failUnless(vert==points_ab,
2289                        'FAILED!')
2290
2291        spat = Geospatial_data(data_points=points_lat_long,
2292                               points_are_lats_longs=True)
2293        points_ab = spat.get_data_points( absolute = True)
2294        geo =  Geo_reference(56,400000,6000000)
2295        spat.set_geo_reference(geo)
2296        m = Mesh()
2297        m.add_vertices(spat)
2298
2299        vert = m.getUserVertices()
2300        #print "vert",vert
2301        self.failUnless(4==len(vert),
2302                        'FAILED!')
2303        vert= m.get_user_vertices(absolute=True)
2304        self.failUnless(vert==points_ab,
2305                        'FAILED!')
2306
2307        #geo =  Geo_reference(56,23,21)
2308        #points = geo.change_points_geo_ref(points_ab)
2309       
2310    def test_get_user_vertices(self):
2311        points_ab = [[0.1,1],[0.4,.2],[7,5],[10,5]]
2312        geo =  Geo_reference(56,23,21)
2313        points = geo.change_points_geo_ref(points_ab)
2314        spat = Geospatial_data(points, geo_reference=geo)
2315       
2316        geo_mesh =  Geo_reference(56,100,200)
2317        m = Mesh(geo_reference=geo_mesh)
2318        m.add_vertices(spat)
2319
2320        vert = m.getUserVertices()
2321        #print "vert",vert
2322        self.failUnless(4==len(vert),
2323                        'FAILED!')
2324        vert= m.get_user_vertices(absolute=True)
2325        self.failUnless(vert==points_ab,
2326                        'FAILED!')
2327        vert= m.get_user_vertices(absolute=False)
2328        points_new = m.geo_reference.get_absolute(vert)
2329       
2330        self.failUnless(points_ab==points_new,
2331                        'FAILED!')
2332
2333    def mode_string_float_problems(self):
2334        numbers = [0.0000000001,1000000000000.0, 1e-19,1e19, 1e-25,1e30,1e40,
2335                   1e41,'0.00001','0.000000000000000000000000000000000001']
2336        numbers = [1e-21,1e-20,1e30,1e35,1e40]
2337        for num in numbers:
2338            mode = 'a' + str(num)
2339            #print " mode += 'a' + str(num)", mode
2340            print "====================="
2341           
2342            try:
2343                mode = 'a' + '%20.20f' %num
2344            except TypeError:
2345                mode = 'a' + str(num)
2346            print "mode += 'a' + '%20.20f' %num", mode
2347        #print "", mode
2348       
2349 
2350   
2351    def testgenerateMesh_calc_mesh_area(self):
2352        a = Vertex (0.0, 0.0)
2353        d = Vertex (0.0, 4.0)
2354        f = Vertex (4.0,0.0)
2355
2356        s1 = Segment(a,d)
2357        s2 = Segment(d,f)
2358        s3 = Segment(a,f)
2359
2360        r1 = Region(0.3, 0.3,tag = 1.3,maxArea = .6)
2361        #print r1
2362        m = Mesh(userVertices=[a,d,f], userSegments=[s1,s2,s3], regions=[r1] )
2363       
2364        m.generateMesh("Q", maxArea = 2.1 )
2365        calc_mesh_area = m.tri_mesh.calc_mesh_area()
2366        #print "calc_mesh_area", calc_mesh_area
2367        delta  = 0.0000000001
2368        self.failUnless((8.0 < calc_mesh_area + delta) or
2369                        (8.0 > calc_mesh_area - delta),
2370                        'generated mesh is wrong!')
2371       
2372def list_comp(A,B):
2373    yes = len(A)==len(B)
2374    for item in A:
2375        if not item in B:
2376            yes = False
2377    return yes
2378           
2379#-------------------------------------------------------------
2380if __name__ == "__main__":
2381    suite = unittest.makeSuite(meshTestCase,'test')
2382    #suite = unittest.makeSuite(meshTestCase,'mode_string_float_problems')
2383    #suite = unittest.makeSuite(meshTestCase,'test_import_mesh')
2384    #suite = unittest.makeSuite(meshTestCase,'test_asciiFile')
2385    #suite = unittest.makeSuite(meshTestCase,'test_mesh2IO')
2386    runner = unittest.TextTestRunner() #verbosity=2)
2387    runner.run(suite)
2388   
Note: See TracBrowser for help on using the repository browser.