Changeset 4902


Ignore:
Timestamp:
Jan 4, 2008, 11:36:52 AM (17 years ago)
Author:
duncan
Message:

Removing some of the old pmesh mesh triangulation data structure

Location:
anuga_core/source/anuga
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • anuga_core/source/anuga/abstract_2d_finite_volumes/pmesh2domain.py

    r4901 r4902  
    175175    point_titles  = mesh_dict['vertex_attribute_titles']
    176176    geo_reference  = mesh_dict['geo_reference']
    177     for quantity, value_vector in map (None, point_titles, point_atts):
    178         vertex_quantity_dict[quantity] = value_vector
     177    if point_atts != None:
     178        for quantity, value_vector in map (None, point_titles, point_atts):
     179            vertex_quantity_dict[quantity] = value_vector
    179180    tag_dict = pmesh_dict_to_tag_dict(mesh_dict)
    180181    tagged_elements_dict = build_tagged_elements_dictionary(mesh_dict)

  • anuga_core/source/anuga/load_mesh/loadASCII.py

    r4901 r4902  
    193193        for fragment in fragments:
    194194            apointattributes.append(float(fragment))
    195         pointattributes.append(apointattributes)
     195        if apointattributes != []:
     196            pointattributes.append(apointattributes)
    196197       
    197198    ######### loading the point title info
    … …  
    262263    meshDict = {}
    263264    meshDict['vertices'] = points
    264     meshDict['vertex_attributes'] = pointattributes
     265    if pointattributes == []:
     266        meshDict['vertex_attributes'] = None
     267    else:
     268        meshDict['vertex_attributes'] = pointattributes
    265269    meshDict['triangles'] = triangles
    266270    meshDict['triangle_tags'] = triangleattributes
    … …  
    458462     
    459463    numVert = str(len(vertices))
    460     if (numVert == "0") or len(vertices_attributes) == 0:
     464    #print "load vertices_attributes", vertices_attributes
     465    # Don't understand why we have to do vertices_attributes[0] is None,
     466    # but it doesn't work otherwise...
     467    if vertices_attributes == None or \
     468           (numVert == "0") or \
     469           len(vertices_attributes) == 0:
    461470        numVertAttrib = "0"
    462471    else:
    … …  
    469478        attlist = ""
    470479       
    471         if vertices_attributes == []:
     480        if vertices_attributes == None or \
     481               vertices_attributes == []:
    472482            attlist = ""
    473483        else:
    … …  
    640650    #the triangulation
    641651    mesh['vertices'] = array(mesh['vertices']).astype(Float)
    642     mesh['vertex_attributes'] = array(mesh['vertex_attributes']).astype(Float)
     652    if mesh['vertex_attributes'] != None:
     653        mesh['vertex_attributes'] = \
     654               array(mesh['vertex_attributes']).astype(Float)
    643655    mesh['vertex_attribute_titles'] = array(mesh['vertex_attribute_titles']).astype(Character)
    644656    mesh['segments'] = array(mesh['segments']).astype(IntType)
    … …  
    690702                                                   'num_of_dimensions'))
    691703        outfile.variables['vertices'][:] = mesh['vertices']
    692         if (mesh['vertex_attributes'].shape[0] > 0 and mesh['vertex_attributes'].shape[1] > 0):
     704        if mesh['vertex_attributes']  != None and \
     705               (mesh['vertex_attributes'].shape[0] > 0 and mesh['vertex_attributes'].shape[1] > 0):
    693706            outfile.createDimension('num_of_vertex_attributes',
    694707                                    mesh['vertex_attributes'].shape[1])
    … …  
    829842    #throws prints to screen if file not present
    830843    fid = NetCDFFile(file_name, 'r')
    831 
    832844    mesh = {}
    833845    # Get the variables
    … …  
    840852        mesh['vertex_attributes'] = fid.variables['vertex_attributes'][:]
    841853    except KeyError:
    842         mesh['vertex_attributes'] = []
    843         for ob in mesh['vertices']:
    844             mesh['vertex_attributes'].append([])
     854        mesh['vertex_attributes'] = None
     855        #for ob in mesh['vertices']:
     856            #mesh['vertex_attributes'].append([])
     857   
    845858    mesh['vertex_attribute_titles'] = []
    846859    try:

  • anuga_core/source/anuga/load_mesh/test_loadASCII.py

    r4899 r4902  
    9494        self.tri_dict['segments'] = [[0,1]]
    9595        self.tri_dict['triangle_tags'] = ['']
    96         self.tri_dict['vertex_attributes'] = [[],[],[]]
     96        self.tri_dict['vertex_attributes'] = None
    9797        self.tri_dict['triangle_neighbors'] = [[0,0,0]]
    9898        self.tri_dict['segment_tags'] = ['']
    … …  
    112112        self.seg_dict['segments'] = [[0,1]]
    113113        self.seg_dict['triangle_tags'] = []
    114         self.seg_dict['vertex_attributes'] = [[],[]]
     114        self.seg_dict['vertex_attributes'] = None
    115115        self.seg_dict['triangle_neighbors'] = []
    116116        self.seg_dict['segment_tags'] = ['']
    … …  
    476476            self.failUnless(ob  == ldob,
    477477                        fail_string + ' failed!! Test triangle_tags')
    478         self.failUnless(loaded_dict['vertex_attributes']  ==
    479                         dict['vertex_attributes'],
     478        # A bit hacky
     479        self.failUnless((loaded_dict['vertex_attributes']  ==
     480                        dict['vertex_attributes']) or \
     481                        (loaded_dict['vertex_attributes']  == None and \
     482                         dict['vertex_attributes'] == []),
    480483                        fail_string + ' failed!! Test vertex_attributes')
    481484 
    … …  
    545548
    546549    suite = unittest.makeSuite(loadASCIITestCase,'test')
    547     #suite = unittest.makeSuite(loadASCIITestCase,'test_rs')
     550    #suite = unittest.makeSuite(loadASCIITestCase,'test_read_write_tsh_file4')
    548551    runner = unittest.TextTestRunner() #verbosity=2)
    549552    runner.run(suite)

  • anuga_core/source/anuga/mesh_engine/mesh_engine.py

    r4901 r4902  
    155155            mesh_dict['generatedtriangleattributelist'] = None
    156156           
     157        if mesh_dict['generatedpointattributelist'].shape[1] == 0:
     158            mesh_dict['generatedpointattributelist'] = None
    157159        if trianglelist.shape[0] == 0:
    158160            # There are no triangles.

  • anuga_core/source/anuga/pmesh/graphical_mesh_generator.py

    r4901 r4902  
    11151115                                    self.canvas,
    11161116                                    self.SCALE)
    1117     def normalise4ObjMesh(self):
     1117    def obsolete_normalise4ObjMesh(self):
    11181118        if self.mesh:
    11191119            self.clearSelections()
    … …  
    11241124            self.ResizeToFit()
    11251125           
    1126     def normaliseMesh(self):
     1126    def obsolete_nnormaliseMesh(self):
    11271127        if self.mesh:
    11281128            self.clearSelections()

  • anuga_core/source/anuga/pmesh/mesh.py

    r4901 r4902  
    522522                 triangle_neighbors,
    523523                 segment_tags,
     524                 vertex_attributes,
     525                 vertex_attribute_titles=None
    524526                 ):
    525527       
    … …  
    531533        self.segment_tags = segment_tags # list of strings
    532534        self.vertices = ensure_numeric(vertices)
    533 
     535        # This is needed for __cmp__
     536        if vertex_attributes is None:
     537            self.vertex_attributes = []
     538        else:
     539            self.vertex_attributes = ensure_numeric(vertex_attributes)
     540        if vertex_attribute_titles is None:
     541            self.vertex_attribute_titles = []
     542        else:
     543            self.vertex_attribute_titles = vertex_attribute_titles
    534544       
    535545    def draw_triangulation(self, canvas, scale=1, xoffset=0, yoffset=0,
    … …  
    10941104        self.userSegments = []
    10951105        self.alphaUserSegments = []
    1096                
     1106
     1107       #FIXME see where this is used. return an array instead
    10971108    def getTriangulation(self):
    1098         return self.meshTriangles
     1109        #return self.meshTriangles
     1110        return self.tri_mesh.triangles.tolist()
    10991111   
    11001112    def getMeshVertices(self):
    1101         return self.meshVertices
     1113        #return self.meshVertices
     1114        return self.tri_mesh.vertices
    11021115 
     1116    def getMeshVerticeAttributes(self):
     1117        #return self.meshVertices
     1118        return self.tri_mesh.vertex_attributes
     1119   
    11031120    def getMeshSegments(self):
    1104         return self.meshSegments
     1121        #return self.meshSegments
     1122        return self.tri_mesh.segments
     1123   
     1124    def getMeshSegmentTags(self):
     1125        #return self.meshSegments
     1126        return self.tri_mesh.segment_tags
    11051127   
    11061128    def getHoles(self):
    … …  
    12331255        #FIXME (DSG-DSG)  move above section into generate_mesh.py
    12341256       
    1235         if generatedMesh['generatedpointattributelist'].shape[1] ==0:
     1257        if generatedMesh['generatedpointattributelist'] is None or \
     1258               generatedMesh['generatedpointattributelist'].shape[1] ==0:
    12361259            self.attributeTitles = []
    12371260        generatedMesh['generatedpointattributetitlelist']= \
    … …  
    14441467        Convert the Mesh to a dictionary of lists describing the
    14451468        triangulation variables;
     1469
     1470        This is used by __cmp__
    14461471        generated point list: [(x1,y1),(x2,y2),...] (Tuples of doubles)
    14471472        generated point attribute list: [(a11,a12,...),(a21,a22),...]
    … …  
    14631488        """
    14641489       
    1465         meshDict = {}       
    1466         pointlist=[]
    1467         pointattributelist=[]
    1468 
    1469 
    1470         self.maxVertexIndex=0
    1471         for vertex in self.meshVertices:
    1472             vertex.index = self.maxVertexIndex
    1473             pointlist.append((vertex.x,vertex.y))
    1474             pointattributelist.append((vertex.attributes))           
    1475             self.maxVertexIndex += 1
    1476 
    1477         meshDict['generatedpointlist'] = pointlist
    1478         meshDict['generatedpointattributelist'] = pointattributelist
    1479         meshDict['generatedpointattributetitlelist'] = self.attributeTitles
    1480         #segments
    1481         segmentlist=[]
    1482         segmenttaglist=[]
    1483         for seg in self.meshSegments:
    1484             segmentlist.append((seg.vertices[0].index,seg.vertices[1].index))
    1485             segmenttaglist.append(seg.tag)
    1486         meshDict['generatedsegmentlist'] =segmentlist
    1487         meshDict['generatedsegmenttaglist'] =segmenttaglist
    1488 
    1489         # Make sure that the indexation is correct
    1490         index = 0
    1491         for tri in self.meshTriangles:
    1492             tri.index = index           
    1493             index += 1
    1494 
    1495         trianglelist = []
    1496         triangleattributelist = []
    1497         triangleneighborlist = []
    1498         for tri in self.meshTriangles: 
    1499             trianglelist.append((tri.vertices[0].index,tri.vertices[1].index,
    1500                                  tri.vertices[2].index)) 
    1501             triangleattributelist.append([tri.attribute])
    1502             neighborlist = [-1,-1,-1]
    1503             for neighbor,index in map(None,tri.neighbors,
    1504                                       range(len(tri.neighbors))):
    1505                 if neighbor:   
    1506                     neighborlist[index] = neighbor.index
    1507             triangleneighborlist.append(neighborlist)
    1508        
    1509         meshDict['generatedtrianglelist'] = trianglelist
    1510         meshDict['generatedtriangleattributelist'] = triangleattributelist
    1511         meshDict['generatedtriangleneighborlist'] = triangleneighborlist
    1512        
     1490        meshDict = {}   
     1491        #print "old meshDict['generatedpointattributetitlelist']",meshDict['generatedpointattributetitlelist']
     1492        #print "self.tri_mesh", self.tri_mesh
     1493        if self.tri_mesh is not None:
     1494            #print "self.tri_mesh.triangles.tolist()", self.tri_mesh.triangles.tolist()
     1495            meshDict['generatedtrianglelist'] = self.tri_mesh.triangles.tolist()
     1496            meshDict['generatedtriangleattributelist'] = self.tri_mesh.triangle_tags
     1497            meshDict['generatedtriangleneighborlist'] = self.tri_mesh.triangle_neighbors.tolist()
     1498            meshDict['generatedpointlist'] = self.tri_mesh.vertices.tolist()
     1499            if  self.tri_mesh.vertex_attributes == []:
     1500                meshDict['generatedpointattributelist'] = []
     1501            #meshDict['generatedpointattributelist'] = self.tri_mesh.vertex_attributes
     1502            meshDict['generatedpointattributetitlelist'] = \
     1503                       self.tri_mesh.vertex_attribute_titles
     1504            meshDict['generatedsegmentlist'] = self.tri_mesh.segments.tolist()
     1505            meshDict['generatedsegmenttaglist'] = self.tri_mesh.segment_tags
     1506        else:
     1507            meshDict['generatedtrianglelist'] = []
     1508            meshDict['generatedtriangleattributelist'] = []
     1509            meshDict['generatedtriangleneighborlist'] = []
     1510            meshDict['generatedpointlist'] = []
     1511            meshDict['generatedpointattributelist'] = []
     1512            meshDict['generatedpointattributetitlelist'] = []
     1513            meshDict['generatedsegmentlist'] = []
     1514            meshDict['generatedsegmenttaglist'] = []
     1515           
     1516        #print "new meshDict['generatedpointattributetitlelist']",meshDict['generatedpointattributetitlelist']
    15131517        #print "mesh.Mesh2MeshList*)*)"
    15141518        #print meshDict
    … …  
    15351539        generated point list: [(x1,y1),(x2,y2),...] (Tuples of doubles) 
    15361540        generated point attribute list:[(P1att1,P1attt2, ...),
    1537             (P2att1,P2attt2,...),...]
     1541            (P2att1,P2attt2,...),...]- not implemented
    15381542        generated point attribute title list:[A1Title, A2Title ...]
    1539             (list of strings)
     1543            (list of strings) - not implemented
    15401544        generated segment list: [(point1,point2),(p3,p4),...]
    15411545            (Tuples of integers)
    1542         generated segment marker list: [S1Tag, S2Tag, ...] (list of ints)
     1546        generated segment marker list: [S1Tag, S2Tag, ...] (list of strings)
    15431547        triangle list:  [(point1,point2, point3),(p5,p4, p1),...]
    15441548            (Tuples of integers)
    … …  
    15461550            (t5,t4, t1),...] (Tuples of integers)
    15471551            -1 means there's no triangle neighbor
    1548         triangle attribute list: [(T1att), (T2att), ...]
    1549 
    1550         """
    1551         #Clear the current generated mesh values
    1552         self.meshTriangles=[]
    1553         self.attributeTitles=[]
    1554         self.meshSegments=[]
    1555         self.meshVertices=[]
    1556 
    1557         #print "mesh.setTriangulation@#@#@#"
    1558         #print genDict
    1559         #print "@#@#@#"
    1560 
    1561         self.maxVertexIndex = 0
    1562         for point in genDict['generatedpointlist']:
    1563             v=Vertex(point[0], point[1])
    1564             v.index =  self.maxVertexIndex
    1565             self.maxVertexIndex +=1
    1566             self.meshVertices.append(v)
    1567 
    1568         self.attributeTitles = genDict['generatedpointattributetitlelist']
    1569 
    1570         index = 0
    1571         for seg,marker in map(None,genDict['generatedsegmentlist'],
    1572                               genDict['generatedsegmentmarkerlist']):
    1573             segObject = Segment( self.meshVertices[int(seg[0])],
    1574                            self.meshVertices[int(seg[1])], tag = marker )
    1575             segObject.index = index
    1576             index +=1
    1577             self.meshSegments.append(segObject)
    1578 
    1579         index = 0
    1580         for triangle in genDict['generatedtrianglelist']:
    1581             tObject =Triangle( self.meshVertices[int(triangle[0])],
    1582                         self.meshVertices[int(triangle[1])],
    1583                         self.meshVertices[int(triangle[2])] )
    1584             tObject.index = index
    1585             index +=1
    1586             self.meshTriangles.append(tObject)
    1587 
    1588         if genDict['generatedtriangleattributelist'] is not None:
    1589             index = 0
    1590             for att in genDict['generatedtriangleattributelist']:
    1591                 if att == []:
    1592                     self.meshTriangles[index].setAttribute("")
    1593                 else:
    1594                     self.meshTriangles[index].setAttribute(att)
    1595                 index += 1
    1596            
    1597         index = 0
    1598         for att in genDict['generatedpointattributelist']:
    1599             if att == None:
    1600                 self.meshVertices[index].setAttributes([])
    1601             else:
    1602                 self.meshVertices[index].setAttributes(att)
    1603             index += 1
    1604    
    1605         index = 0
    1606         for triangle in genDict['generatedtriangleneighborlist']:
    1607             # Build a list of triangle object neighbors
    1608             ObjectNeighbor = []
    1609             for neighbor in triangle:
    1610                 if ( neighbor != -1):
    1611                     ObjectNeighbor.append(self.meshTriangles[int(neighbor)])
    1612                 else:
    1613                     ObjectNeighbor.append(None)
    1614             self.meshTriangles[index].setNeighbors(ObjectNeighbor[0],
    1615                                                    ObjectNeighbor[1],
    1616                                                    ObjectNeighbor[2])
    1617             index += 1
    1618        
     1552        triangle attribute list: [(T1att), (T2att), ...](list of strings)
     1553
     1554        """
    16191555        # Setting up the rigid triangulation
    16201556        self.tri_mesh = Rigid_triangulation(
    … …  
    16251561            ,genDict['generatedtriangleneighborlist']
    16261562            ,genDict['generatedsegmentmarkerlist']
     1563            ,genDict['generatedpointattributelist']
     1564            ,genDict['generatedpointattributetitlelist']
    16271565            )
    16281566           
    … …  
    21952133        Used to produce .tsh file
    21962134        """
    2197        
    2198         meshDict = {}       
    2199         vertices=[]
    2200         vertex_attributes=[]
    2201 
    2202         self.maxVertexIndex=0
    2203         for vertex in self.meshVertices:
    2204             vertex.index = self.maxVertexIndex
    2205             vertices.append([vertex.x,vertex.y])
    2206             vertex_attributes.append(vertex.attributes)           
    2207             self.maxVertexIndex += 1
    2208 
    2209         meshDict['vertices'] = vertices
    2210         meshDict['vertex_attributes'] = vertex_attributes
    2211         meshDict['vertex_attribute_titles'] = self.attributeTitles
    2212         #segments
    2213         segments=[]
    2214         segment_tags=[]
    2215         for seg in self.meshSegments:
    2216             segments.append([seg.vertices[0].index,seg.vertices[1].index])
    2217             segment_tags.append(seg.tag)
    2218         meshDict['segments'] =segments
    2219         meshDict['segment_tags'] =segment_tags
    2220 
    2221         # Make sure that the indexation is correct
    2222         index = 0
    2223         for tri in self.meshTriangles:
    2224             tri.index = index           
    2225             index += 1
    2226 
    2227         triangles = []
    2228         triangle_tags = []
    2229         triangle_neighbors = []
    2230         for tri in self.meshTriangles: 
    2231             triangles.append([tri.vertices[0].index,
    2232                               tri.vertices[1].index,
    2233                               tri.vertices[2].index]) 
    2234             triangle_tags.append(tri.attribute)
    2235             neighborlist = [-1,-1,-1]
    2236             for neighbor,index in map(None,tri.neighbors,
    2237                                       range(len(tri.neighbors))):
    2238                 if neighbor:   
    2239                     neighborlist[index] = neighbor.index
    2240             triangle_neighbors.append(neighborlist)
    2241        
    2242         meshDict['triangles'] = triangles
    2243         meshDict['triangle_tags'] = triangle_tags
    2244         meshDict['triangle_neighbors'] = triangle_neighbors
    2245        
     2135        meshDict = {}
    22462136        if self.tri_mesh is not None:
    22472137            meshDict['triangles'] = self.tri_mesh.triangles
    … …  
    22492139            #print "mesh meshDict['triangle_tags']", meshDict['triangle_tags']
    22502140            meshDict['triangle_neighbors'] = self.tri_mesh.triangle_neighbors
     2141            meshDict['vertices'] = self.tri_mesh.vertices
     2142            meshDict['vertex_attributes'] = self.tri_mesh.vertex_attributes
     2143            meshDict['vertex_attribute_titles'] = \
     2144                               self.tri_mesh.vertex_attribute_titles
     2145            meshDict['segments'] = self.tri_mesh.segments
     2146            meshDict['segment_tags'] = self.tri_mesh.segment_tags
    22512147        else:
    22522148            meshDict['triangles'] = []
    22532149            meshDict['triangle_tags'] = []
    22542150            meshDict['triangle_neighbors'] = []
     2151            meshDict['vertices'] = []
     2152            meshDict['vertex_attributes'] = []
     2153            meshDict['vertex_attribute_titles'] = []
     2154            meshDict['segments'] = []
     2155            meshDict['segment_tags'] = []
    22552156        #print "mesh.Mesh2IOTriangulationDict*)*)"
    22562157        #print meshDict
    … …  
    23352236        """
    23362237        #Clear the current generated mesh values
    2337         self.meshTriangles = []
    2338         self.attributeTitles = []
    2339         self.meshSegments = []
    2340         self.meshVertices = []
    23412238        self.tri_mesh = None
    23422239       
    2343         #print "mesh.setTriangulation@#@#@#"
    2344         #print genDict
    2345         #print "@#@#@#"
    2346 
    2347         self.maxVertexIndex = 0
    2348         for point in genDict['vertices']:
    2349             v=Vertex(point[0], point[1])
    2350             v.index =  self.maxVertexIndex
    2351             self.maxVertexIndex +=1
    2352             self.meshVertices.append(v)
    2353 
    2354         self.attributeTitles = genDict['vertex_attribute_titles']
    2355 
    2356         index = 0
    2357         for seg,tag in map(None,genDict['segments'],genDict['segment_tags']):
    2358             segObject = Segment( self.meshVertices[int(seg[0])],
    2359                            self.meshVertices[int(seg[1])], tag = tag )
    2360             segObject.index = index
    2361             index +=1
    2362             self.meshSegments.append(segObject)
    2363 
    2364         index = 0
    2365         for triangle in genDict['triangles']:
    2366             tObject =Triangle( self.meshVertices[int(triangle[0])],
    2367                         self.meshVertices[int(triangle[1])],
    2368                         self.meshVertices[int(triangle[2])] )
    2369             tObject.index = index
    2370             index +=1
    2371             self.meshTriangles.append(tObject)
    2372 
    2373         index = 0
    2374         for att in genDict['triangle_tags']:
    2375             if att == []:
    2376                 self.meshTriangles[index].setAttribute("")
    2377             else:
    2378                 self.meshTriangles[index].setAttribute(att)
    2379             index += 1
    2380            
    2381         index = 0
    2382         for att in genDict['vertex_attributes']:
    2383             if att == None:
    2384                 self.meshVertices[index].setAttributes([])
    2385             else:
    2386                 self.meshVertices[index].setAttributes(att)
    2387             index += 1
    2388    
    2389         index = 0
    2390         for triangle in genDict['triangle_neighbors']:
    2391             # Build a list of triangle object neighbors
    2392             ObjectNeighbor = []
    2393             for neighbor in triangle:
    2394                 if ( neighbor != -1):
    2395                     ObjectNeighbor.append(self.meshTriangles[int(neighbor)])
    2396                 else:
    2397                     ObjectNeighbor.append(None)
    2398             self.meshTriangles[index].setNeighbors(ObjectNeighbor[0],
    2399                                                    ObjectNeighbor[1],
    2400                                                    ObjectNeighbor[2])
    2401             index += 1
    2402 
    24032240        self.tri_mesh = Rigid_triangulation(
    24042241            genDict['triangles']
    … …  
    24082245            ,genDict['triangle_neighbors']
    24092246            ,genDict['segment_tags']
     2247            ,genDict['vertex_attributes']
     2248            ,genDict['vertex_attribute_titles']
    24102249            )
    2411 
     2250        self.attributeTitles = genDict['vertex_attribute_titles']
     2251        self.maxVertexIndex = len(genDict['vertices'])
     2252        #print "self.maxVertexIndex ", self.maxVertexIndex
     2253       
    24122254    def IOOutline2Mesh(self, genDict):
    24132255        """

  • anuga_core/source/anuga/pmesh/test_mesh.py

    r4899 r4902  
    107107        result = 1.414214
    108108        delta  = 0.00001
    109        
    110         self.failUnless((m.meshTriangles[1].vertices[0].x < result + delta) or
    111                         (m.meshTriangles[1].vertices[0].x > result - delta),
     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),
    112118                        'generated mesh is wrong!')
    113 
     119       
    114120    def test_regionalMaxArea(self):
    115121        v0 = Vertex (0.0, 0.0)
    … …  
    133139        #print "len(m.meshTriangles)",len(m.meshTriangles)
    134140
    135         self.failUnless(len(m.meshTriangles) == 2,
     141        self.failUnless(len(m.getTriangulation()) == 2,
    136142                        'test_regionalMaxArea 1:generated mesh is wrong!')
    137143       
    … …  
    143149        m.generateMesh("Q", maxArea = 36 )
    144150       
    145         self.failUnless(len(m.meshTriangles) >= 6,
     151        self.failUnless(len(m.getTriangulation()) >= 6,
    146152                        'testregion_with_maxarea 2: # of tris is wrong!')   
    147153       
    … …  
    155161        #print "len(m.meshTriangles)",len(m.meshTriangles)
    156162       
    157         self.failUnless(len(m.meshTriangles) >= 8,
     163        self.failUnless(len(m.getTriangulation()) >= 8,
    158164                        'testregion_with_maxarea 3: # of tris is wrong!')
    159165               
    … …  
    165171                 regions=[r1,r2] )
    166172        m.generateMesh("Q", maxArea = 8 )
    167         self.failUnless(len(m.meshTriangles) >= 8,
     173        self.failUnless(len(m.getTriangulation()) >= 8,
    168174                        'testregion_with_maxarea 4: # of tris is wrong!')   
    169175
    … …  
    175181                 regions=[r1,r2] )
    176182        m.generateMesh("Q", maxArea = 36,isRegionalMaxAreas = False )     
    177         self.failUnless(len(m.meshTriangles) == 2,
     183        self.failUnless(len(m.getTriangulation()) == 2,
    178184                        'test_regionalMaxArea 5:generated mesh is wrong!')
    179185       
    … …  
    184190                 regions=[r1,r2] )
    185191        m.generateMesh("Q",isRegionalMaxAreas = False )
    186         self.failUnless(len(m.meshTriangles) == 2,
     192        self.failUnless(len(m.getTriangulation()) == 2,
    187193                        'test_regionalMaxArea 5:generated mesh is wrong!')
    188194       
    … …  
    206212        m.generate_mesh(maximum_triangle_area=36,verbose=False)         
    207213
    208         self.failUnless(len(m.meshTriangles) == 2,
     214        self.failUnless(len(m.getTriangulation()) == 2,
    209215                        'test_regionalMaxArea 1:generated mesh is wrong!')
    210216       
    … …  
    216222        m.generate_mesh(maximum_triangle_area=36,verbose=False) 
    217223       
    218         self.failUnless(len(m.meshTriangles) >= 6,
     224        self.failUnless(len(m.getTriangulation()) >= 6,
    219225                        'testregion_with_maxarea 2: # of tris is wrong!')   
    220226               
    … …  
    225231                 regions=[r1,r2] )
    226232        m.generate_mesh(maximum_triangle_area=36,verbose=False)         
    227         #print "len(m.meshTriangles)",len(m.meshTriangles)
    228        
    229         self.failUnless(len(m.meshTriangles) >= 8,
     233        #print "len(m.getTriangulation())",len(m.getTriangulation())
     234       
     235        self.failUnless(len(m.getTriangulation()) >= 8,
    230236                        'testregion_with_maxarea 3: # of tris is wrong!')
    231237                         
    … …  
    236242                 regions=[r1,r2] )
    237243        m.generate_mesh(maximum_triangle_area=8,verbose=False)   
    238         self.failUnless(len(m.meshTriangles) >= 8,
     244        self.failUnless(len(m.getTriangulation()) >= 8,
    239245                        'testregion_with_maxarea 4: # of tris is wrong!')   
    240246
    … …  
    244250        userSegments=[s1,s2,s3,s4,s5], regions=[r1,r2] )
    245251        m.generate_mesh(verbose=False)
    246         #print "en(m.meshTriangles)", len(m.meshTriangles)
    247         self.failUnless(len(m.meshTriangles) >= 8,
     252        #print "en(m.getTriangulation())", len(m.getTriangulation())
     253        self.failUnless(len(m.getTriangulation()) >= 8,
    248254        'You have issues!')
    249255       
    … …  
    418424        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] )
    419425        m.generateMesh("Q", maxArea = 2.1 )
    420        
    421         Triangulation =  m.getTriangulation()
     426
     427        # FIXME test the region
     428        #Triangulation =  m.getTriangulation()
     429        Triangulation = m.tri_mesh.triangle_tags
    422430        #print Triangulation[0].attribute
    423431        #print Triangulation[1].attribute
    … …  
    426434        #print Triangulation[4].attribute
    427435       
    428         self.failUnless(Triangulation[0].attribute == "" and
    429                         Triangulation[1].attribute == "22" and
    430                         Triangulation[2].attribute == "" and
    431                         Triangulation[3].attribute == "11" and
    432                         Triangulation[4].attribute == "22" ,
     436        self.failUnless(Triangulation[0] == "" and
     437                        Triangulation[1] == "22" and
     438                        Triangulation[2] == "" and
     439                        Triangulation[3] == "11" and
     440                        Triangulation[4] == "22" ,
    433441                        'region attributes are wrong!')   
    434442
    … …  
    449457        m.generateMesh("Q", maxArea = 2.1)
    450458
    451         vert = m.getMeshVertices()
    452        
    453         self.failUnless(vert[0].attributes == [12.0, 2.0] and
    454                         vert[1].attributes == [9.0, 7.0] and
    455                         vert[2].attributes == [14.0,3.0] and
    456                         vert[3].attributes == [12.232233047033631, 4.4142135623730949] and
    457                         vert[4].attributes == [13.0, 2.5] ,
     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] ,
    458466                        'vertex attributes are wrong!')
    459467
    … …  
    476484        m.generateMesh("Q", maxArea = 2.1 )
    477485
    478         vert = m.getMeshVertices()
    479         self.failUnless(vert[0].attributes == [] and
    480                         vert[1].attributes == [] and
    481                         vert[2].attributes == [] and
    482                         vert[3].attributes == [] and
    483                         vert[4].attributes == [],
     486        vert = m.getMeshVerticeAttributes()
     487        #print "vert", vert
     488        self.failUnless(vert == [],
    484489                        'vertex attributes are wrong!')
    485490
    … …  
    499504
    500505        #m.export_mesh_file("from_test_mesh.tsh")
    501         seg = m.getMeshSegments()
     506        seg = m.getMeshSegmentTags()
    502507        #print "seg",seg
    503508        #print "seg[0].tag"
    … …  
    505510        #print "seg[0].tag"
    506511       
    507         self.failUnless(seg[0].tag == 5 and
    508                         seg[1].tag == 7 and
    509                         seg[2].tag == 9 and
    510                         seg[3].tag == 7 and
    511                         seg[4].tag == 9,
     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,
    512517                        'seg tags are wrong')
    513518           
    … …  
    529534        m.generateMesh("Q", maxArea = 2.1)
    530535
    531         seg = m.getMeshSegments()
    532         self.failUnless(seg[0].tag == "exterior" and
    533                         seg[1].tag == "exterior" and
    534                         seg[2].tag == "exterior" and
    535                         seg[3].tag == "" and
    536                         seg[4].tag == "exterior",
     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",
    537542                        '2nd seg tags are wrong')
    538543
    … …  
    821826                        'loading and saving of a mesh geo refs failed')
    822827
    823     def test_normaliseMesh(self):
     828    def DONTtest_normaliseMesh(self):
    824829       
    825830        a_att = [5.0,2.0]
    … …  
    890895
    891896        #Trim mesh, so it should like like m_returned
    892         m.meshVertices = []
    893         m.meshTriangles = []
    894         m.meshSegments = []
     897        m.tri_mesh = None
    895898        m.userVertices=[a,b,c]
    896899        #print "mesh ***************dsg*", m
    … …  
    15561559                 userSegments=[s1,s2,s3,s4],
    15571560                 regions=[r1])
    1558         titles = ['ele','friction']
     1561        titles = ['ele','friction'] #Feed in directly!
    15591562        m.attributeTitles = titles
    15601563        m.generateMesh("Qa2.1")
    … …  
    15621565        seg = m.getMeshSegments()
    15631566        verts = m.getMeshVertices()
     1567        vert_as = m.getMeshVerticeAttributes()
     1568        seg_tags = m.getMeshSegmentTags()
    15641569        dict = m.Mesh2IOTriangulationDict()
    15651570        #print "dict",dict
    … …  
    15741579                         'test_Mesh2IOTriangulationDict failed. test 2')
    15751580
    1576        
    1577         for pimport,pactual,pimpatt in map(None,dict['vertices'],
    1578                                            verts,dict['vertex_attributes']):
    1579             #assert all_close( pimport, (pactual.x,pactual.y))
    1580             self.failUnless( pimport == [pactual.x,pactual.y],
    1581                         'test_Mesh2IOTriangulationDict failed. test 2.1')
    1582             self.failUnless( pimpatt == pactual.attributes,
    1583                         'test_Mesh2IOTriangulationDict failed. test 2.2')
     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
    15841586        self.failUnless( dict['segments'][0] == [0,1],
    1585                         'test_Mesh2IOTriangulationDict failed. test 3')
    1586         for segimp,segactual in map(None,dict['segment_tags'],seg):
    1587             self.failUnless( segimp == segactual.tag,
    1588                         'test_Mesh2IOTriangulationDict failed. test 4')
     1587                        'test_Mesh2IODict failed. test 3')
     1588       
     1589        self.failUnless( dict['segment_tags'] == seg_tags,
     1590                        'test_Mesh2IODict failed. test 3')
    15891591        #print " dict['triangles'][0]", dict['triangles'][0]
    15901592        self.failUnless( dict['triangles'][0] == [3,2,4],
    1591                         'test_Mesh2IOTriangulationDict failed. test 5')
     1593                        'test_Mesh2IODict failed. test 5')
    15921594        self.failUnless( dict['triangle_neighbors'][0] == [-1,2,3],
    1593                         'test_Mesh2IOTriangulationDict failed. test 6')
     1595                        'test_Mesh2IODict failed. test 6')
     1596        #print "dict['triangle_tags'][0]", dict['triangle_tags'][0]
    15941597        self.failUnless( dict['triangle_tags'][0] == "1.3",
    1595                          'test_Mesh2IOTriangulationDict failed. test 7')
     1598                         'test_Mesh2IODict failed. test 7')
    15961599
    15971600 
    … …  
    16231626        seg = m.getMeshSegments()
    16241627        verts = m.getMeshVertices()
     1628        vert_as = m.getMeshVerticeAttributes()
    16251629        dict = m.Mesh2IODict()
     1630        seg_tags = m.getMeshSegmentTags()
    16261631        #print "dict",dict
    16271632       
    … …  
    16351640                         'test_Mesh2IOTriangulationDict failed. test 2')
    16361641
    1637        
    1638         for pimport,pactual,pimpatt in map(None,dict['vertices'],
    1639                                            verts,dict['vertex_attributes']):
    1640             #assert all_close( pimport, (pactual.x,pactual.y))
    1641             self.failUnless( pimport == [pactual.x,pactual.y],
    1642                         'test_Mesh2IODict failed. test 2.1')
    1643             self.failUnless( pimpatt == pactual.attributes,
    1644                         'test_Mesh2IODict failed. test 2.2')
     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
    16451647        self.failUnless( dict['segments'][0] == [0,1],
    16461648                        'test_Mesh2IODict failed. test 3')
    1647         for segimp,segactual in map(None,dict['segment_tags'],seg):
    1648             self.failUnless( segimp == segactual.tag,
    1649                         'test_Mesh2IODict failed. test 4')
     1649       
     1650        self.failUnless( dict['segment_tags'] == seg_tags,
     1651                        'test_Mesh2IODict failed. test 3')
    16501652        #print " dict['triangles'][0]", dict['triangles'][0]
    16511653        self.failUnless( dict['triangles'][0] == [3,2,4],
    … …  
    23582360    #suite = unittest.makeSuite(meshTestCase,'mode_string_float_problems')
    23592361    #suite = unittest.makeSuite(meshTestCase,'test_import_mesh')
    2360     #suite = unittest.makeSuite(meshTestCase,'test_Mesh2IODict')
    2361     runner = unittest.TextTestRunner() # verbosity=2)
     2362    #suite = unittest.makeSuite(meshTestCase,'test_asciiFile')
     2363    #suite = unittest.makeSuite(meshTestCase,'test_mesh2IO')
     2364    runner = unittest.TextTestRunner() #verbosity=2)
    23622365    runner.run(suite)
    23632366   

  • anuga_core/source/anuga/pmesh/test_mesh_interface.py

    r4899 r4902  
    387387       
    388388        #print "file_name",file_name
    389         self.failUnless(len(m.meshTriangles) <= 900,
    390                         'Test mesh interface failed!')
    391         self.failUnless(len(m.meshTriangles) >= 200,
     389        self.failUnless(len(m.getTriangulation()) <= 900,
     390                        'Test mesh interface failed!')
     391        self.failUnless(len(m.getTriangulation()) >= 200,
    392392                        'Test mesh interface failed!')
    393393       
    … …  
    403403       
    404404        #print "len(m.meshTriangles)",len(m.meshTriangles)
    405         self.failUnless(len(m.meshTriangles) <= 100,
     405        self.failUnless(len(m.getTriangulation()) <= 100,
    406406                        'Test mesh interface failed!')
    407407
    … …  
    442442        #print "file_name",file_name
    443443        #print "len(m.meshTriangles",len(m.meshTriangles)
    444         self.failUnless(len(m.meshTriangles) <= 2000,
     444        self.failUnless(len(m.getTriangulation()) <= 2000,
    445445                        'Test mesh interface failed!')
    446446 
    447         self.failUnless(len(m.meshTriangles) >= 900,
     447        self.failUnless(len(m.getTriangulation()) >= 900,
    448448                        'Test mesh interface failed!')
    449449
    … …  
    489489        #print "file_name",file_name
    490490        #print "len(m.meshTriangles",len(m.meshTriangles)
    491         self.failUnless(len(m.meshTriangles) <= 2000,
     491        self.failUnless(len(m.getTriangulation()) <= 2000,
    492492                        'Test mesh interface failed!')
    493493 
    494         self.failUnless(len(m.meshTriangles) >= 900,
     494        self.failUnless(len(m.getTriangulation()) >= 900,
    495495                        'Test mesh interface failed!')
    496496
    … …  
    538538        #print "file_name",file_name
    539539        #print "len(m.meshTriangles",len(m.meshTriangles)
    540         self.failUnless(len(m.meshTriangles) <= 3000,
     540        self.failUnless(len(m.getTriangulation()) <= 3000,
    541541                        'Test mesh interface failed!')
    542542 
    543         self.failUnless(len(m.meshTriangles) >= 2000,
     543        self.failUnless(len(m.getTriangulation()) >= 2000,
    544544                        'Test mesh interface failed!')
    545545
Note: See TracChangeset for help on using the changeset viewer.