Changeset 968


Ignore:
Timestamp:
Feb 28, 2005, 2:25:04 PM (20 years ago)
Author:
duncan
Message:

change of the loadASCII .tsh dictionary structure

Location:
inundation/ga/storm_surge
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • inundation/ga/storm_surge/pmesh/load_mesh/loadASCII.py

    r960 r968  
    5757    fd = open(ofile,'r')
    5858    dict = read_triangulation(fd)
    59     dict_mesh = read_mesh(fd)
     59    dict_mesh = read_outline(fd)
    6060    for element in dict_mesh.keys():
    6161        dict[element] = dict_mesh[element]
    … …  
    163163        segmentmarkers.append(stringmarker)
    164164    meshDict = {}
    165     meshDict['generatedpointlist'] = points
    166     meshDict['generatedpointattributelist'] = pointattributes
    167     meshDict['generatedtrianglelist'] = triangles
    168     meshDict['generatedtriangleattributelist'] = triangleattributes
    169     meshDict['generatedtriangleneighborlist'] = triangleneighbors
    170     meshDict['generatedsegmentlist'] = segments
    171     meshDict['generatedsegmentmarkerlist'] = segmentmarkers
    172     meshDict['generatedpointattributetitlelist'] = vertTitle
     165    meshDict['vertices'] = points
     166    meshDict['vertex_attributes'] = pointattributes
     167    meshDict['triangles'] = triangles
     168    meshDict['triangle_markers'] = triangleattributes
     169    meshDict['triangle_neighbors'] = triangleneighbors
     170    meshDict['segments'] = segments
     171    meshDict['segment_markers'] = segmentmarkers
     172    meshDict['vertex_attribute_titles'] = vertTitle
    173173    return meshDict
    174174   
    … …  
    184184    """
    185185    fd = open(ofile,'r')
    186     meshDict = read_mesh(fd)
     186    meshDict = read_outline(fd)
    187187    fd.close()
    188188    return meshDict
    189189
    190 def read_mesh(fd):
     190def read_outline(fd):
    191191    """
    192192    Note, if a file has no mesh info, it can still be read - the meshdic
    … …  
    316316       
    317317    meshDict = {}
    318     meshDict['pointlist'] = points
    319     meshDict['pointattributelist'] = pointattributes
    320     meshDict['segmentlist'] = segments
    321     meshDict['segmentmarkerlist'] = segmentmarkers
    322     meshDict['holelist'] = holes
    323     meshDict['regionlist'] = regions
    324     meshDict['regionattributelist'] = regionattributes
    325     meshDict['regionmaxarealist'] = regionmaxareas
    326 
     318    meshDict['points'] = points
     319    meshDict['point_attributes'] = pointattributes
     320    meshDict['outline_segments'] = segments
     321    meshDict['outline_segment_markers'] = segmentmarkers
     322    meshDict['holes'] = holes
     323    meshDict['regions'] = regions
     324    meshDict['region_markers'] = regionattributes
     325    meshDict['region_max_areas'] = regionmaxareas
     326    #print "meshDict",meshDict
    327327    return meshDict
    328328
    … …  
    353353def write_ASCII_triangulation(fd,
    354354                               gen_dict):
    355     vertices = gen_dict['generatedpointlist']
    356     vertices_attributes = gen_dict['generatedpointattributelist']
     355    vertices = gen_dict['vertices']
     356    vertices_attributes = gen_dict['vertex_attributes']
    357357    try:
    358         vertices_attribute_titles = gen_dict['generatedpointattributetitlelist']
    359    
     358        vertices_attribute_titles = gen_dict['vertex_attribute_titles']   
    360359    except KeyError, e:
    361360        #FIXME is this the best way?
    … …  
    365364            raise KeyError, e
    366365       
    367     triangles = gen_dict['generatedtrianglelist']
    368     triangles_attributes = gen_dict['generatedtriangleattributelist']
    369     triangle_neighbors = gen_dict['generatedtriangleneighborlist']
    370        
    371     segments = gen_dict['generatedsegmentlist']
    372     segment_markers = gen_dict['generatedsegmentmarkerlist']
     366    triangles = gen_dict['triangles']
     367    triangles_attributes = gen_dict['triangle_markers']
     368    triangle_neighbors = gen_dict['triangle_neighbors']
     369       
     370    segments = gen_dict['segments']
     371    segment_markers = gen_dict['segment_markers']
    373372     
    374373    numVert = str(len(vertices))
    … …  
    465464        raise IOError, msg
    466465
    467        
    468 def write_ASCII_mesh(fd,
     466
     467def write_ASCII_outline(fd,
    469468                     dict):
    470     points = dict['pointlist']
    471     point_attributes = dict['pointattributelist']
    472     segments = dict['segmentlist']
    473     segment_markers = dict['segmentmarkerlist']
    474     holes = dict['holelist']
    475     regions = dict['regionlist']
     469    points = dict['points']
     470    point_attributes = dict['point_attributes']
     471    segments = dict['outline_segments']
     472    segment_markers = dict['outline_segment_markers']
     473    holes = dict['holes']
     474    regions = dict['regions']
     475    region_markers = dict['region_markers']
     476    region_max_areas = dict['region_max_areas']
    476477       
    477478    num_points = str(len(points))
    … …  
    523524                 + str(r[0]) + " "
    524525                 + str(r[1])+ " "
    525                  + str(r[2]) + "\n")
     526                 + str(region_markers[i]) + "\n")
    526527       
    527528    # <index> [<MaxArea>|""]
    … …  
    531532             " # <# of regions>, next lines <Region #> [Max Area] ...Mesh Regions..." + "\n")
    532533    for i,r in enumerate(regions):
    533         if len(r) < 4:
     534        if region_max_areas[i] <= 0 :
    534535            area = ""
    535536        else:
    536             area = str(r[3])
     537            area = str(region_max_areas[i])
    537538           
    538539        fd.write(str(i) + " " + area + "\n")
     540
     541       #FIXME -old, remove
     542def write_ASCII_mesh_old(fd,
     543                     dict):
     544    """
     545    use write_ASCII_outline
     546    """
     547    pass
    539548
    540549

  • inundation/ga/storm_surge/pmesh/load_mesh/test_loadASCII.py

    r935 r968  
    3535    def test_import_mesh(self):
    3636        dict ={}
    37         dict['segmentlist'] = [(0, 1), (1, 2), (0, 2), (0, 3)]
    38         dict['segmentmarkerlist'] = ['50', '40', '30', '20']
    39         dict['holelist'] = [(0.2, 0.6)]
    40         dict['pointattributelist'] = [[5, 2], [4, 2], [3, 2], [2,2]]
    41         dict['regionlist'] = [(0.3, 0.3, '1.3',36.0)]
    42         dict['pointlist'] = [(0.0, 0.0), (0.0, 4.0), (4.0, 0.0), (1.0, 1.0)]
     37        dict['outline_segments'] = [(0, 1), (1, 2), (0, 2), (0, 3)]
     38        dict['outline_segment_markers'] = ['50', '40', '30', '20']
     39        dict['holes'] = [(0.2, 0.6)]
     40        dict['point_attributes'] = [[5, 2], [4, 2], [3, 2], [2,2]]
     41        dict['regions'] = [(0.3, 0.3)]
     42        dict['region_markers'] = ['1.3']
     43        dict['region_max_areas'] = [36.0]
     44        dict['points'] = [(0.0, 0.0), (0.0, 4.0), (4.0, 0.0), (1.0, 1.0)]
    4345
    4446        fileName = tempfile.mktemp(".txt")
    4547        fd = open(fileName,'w')
    46         write_ASCII_mesh(fd,dict)
     48        write_ASCII_outline(fd,dict)
    4749        fd.close()
    4850        loaded_dict = import_mesh(fileName)
    … …  
    5759
    5860       
    59         self.failUnless(array(loaded_dict['pointlist'])  ==
    60                         array(dict['pointlist']),
     61        self.failUnless(array(loaded_dict['points'])  ==
     62                        array(dict['points']),
    6163                         'test_import_mesh failed. Test 1')
    62         self.failUnless(array(loaded_dict['pointattributelist'])  ==
    63                         array(dict['pointattributelist']),
     64        self.failUnless(array(loaded_dict['point_attributes'])  ==
     65                        array(dict['point_attributes']),
    6466                         'test_import_mesh failed. Test 2')
    65         self.failUnless(array(loaded_dict['segmentlist'])  ==
    66                         array(dict['segmentlist']),
     67        self.failUnless(array(loaded_dict['outline_segments'])  ==
     68                        array(dict['outline_segments']),
    6769                         'test_import_mesh failed. Test 3')
    68         self.failUnless(array(loaded_dict['segmentmarkerlist'])  ==
    69                         array(dict['segmentmarkerlist']),
     70        self.failUnless(array(loaded_dict['outline_segment_markers'])  ==
     71                        array(dict['outline_segment_markers']),
    7072                         'test_import_mesh failed. Test 4')
    71        
    72         for regimp,regactual,regattimp, regmaxarea in map(None,loaded_dict['regionlist'],dict['regionlist'], loaded_dict['regionattributelist'], loaded_dict['regionmaxarealist']):
    73             self.failUnless( regimp == [regactual[0],regactual[1]],
    74                         'loadASCIITestCase failed. test 6')
    75             self.failUnless( regattimp == regactual[2],
    76                         'loadASCIITestCase failed. test 7')
    77             self.failUnless( regmaxarea == regactual[3],
    78                         'loadASCIITestCase failed. test 7')
    79 
    80 
    81         self.failUnless(array(loaded_dict['holelist'])  ==
    82                         array(dict['holelist']),
     73        #print "loaded_dict['regions']",loaded_dict['regions']
     74        #print "dict['regions']",dict['regions']
     75        self.failUnless(array(loaded_dict['regions'])  ==
     76                        array(dict['regions']),
     77                         'test_import_mesh failed. Test 5')
     78        self.failUnless(array(loaded_dict['region_markers'])  ==
     79                        array(dict['region_markers']),
     80                         'test_import_mesh failed. Test 5')
     81        self.failUnless(array(loaded_dict['region_max_areas'])  ==
     82                        array(dict['region_max_areas']),
     83                         'test_import_mesh failed. Test 5')
     84
     85        self.failUnless(array(loaded_dict['holes'])  ==
     86                        array(dict['holes']),
    8387                         'test_import_mesh failed. Test 6')
    8488       
    … …  
    8892
    8993        meshDict = {}
    90         meshDict['generatedpointlist'] = [(0.0, 0.0), (0.0, 4.0),
     94        meshDict['vertices'] = [(0.0, 0.0), (0.0, 4.0),
    9195                                          (4.0, 0.0), (1.0, 1.0), (2.0, 2.0)]
    92         meshDict['generatedtrianglelist'] = [(3, 2, 4), (1, 0, 3),
     96        meshDict['triangles'] = [(3, 2, 4), (1, 0, 3),
    9397                                             (3, 4,1), (2, 3, 0)]
    94         meshDict['generatedsegmentlist'] = [(0, 1), (1, 4), (2, 0),
     98        meshDict['segments'] = [(0, 1), (1, 4), (2, 0),
    9599                                            (0, 3), (4, 2)]
    96         meshDict['generatedtriangleattributelist'] = [['1.3'], ['1.3'],
     100        meshDict['triangle_markers'] = [['1.3'], ['1.3'],
    97101                                                      ['1.3'], ['1.3']]
    98         meshDict['generatedpointattributelist'] = [[1.2,2.], [1.2,2.], [1.2,2.], [1.2,2.], [1.2,3.]]
    99         meshDict['generatedtriangleneighborlist'] = [[-1, 2, 3], [3, 2, -1],
     102        meshDict['vertex_attributes'] = [[1.2,2.], [1.2,2.], [1.2,2.], [1.2,2.], [1.2,3.]]
     103        meshDict['triangle_neighbors'] = [[-1, 2, 3], [3, 2, -1],
    100104                                                     [-1, 1, 0], [1, -1, 0]]
    101         meshDict['generatedsegmentmarkerlist'] = ['50', '40', '30', '20', '40']
    102         meshDict['generatedpointattributetitlelist'] = ['bed elevation', 'height']
     105        meshDict['segment_markers'] = ['50', '40', '30', '20', '40']
     106        meshDict['vertex_attribute_titles'] = ['bed elevation', 'height']
    103107       
    104108        fileName = tempfile.mktemp(".tsh")
    … …  
    112116        #print "*(*("
    113117       
    114         self.failUnless(array(meshDict['generatedpointlist'])  ==
    115                         array(loadedDict['generatedpointlist']),
     118        self.failUnless(array(meshDict['vertices'])  ==
     119                        array(loadedDict['vertices']),
    116120                         'test_export_triangulation_file failed. Test 1')
    117         self.failUnless(array(meshDict['generatedtrianglelist'])  ==
    118                         array(loadedDict['generatedtrianglelist']),
     121        self.failUnless(array(meshDict['triangles'])  ==
     122                        array(loadedDict['triangles']),
    119123                         'test_export_triangulation_file failed. Test 2')
    120         self.failUnless(array(meshDict['generatedsegmentlist'])  ==
    121                         array(loadedDict['generatedsegmentlist']),
     124        self.failUnless(array(meshDict['segments'])  ==
     125                        array(loadedDict['segments']),
    122126                         'test_export_triangulation_file failed. Test 3')
    123         self.failUnless(array(meshDict['generatedtriangleattributelist'])  ==
    124                         array(loadedDict['generatedtriangleattributelist']),
     127        self.failUnless(array(meshDict['triangle_markers'])  ==
     128                        array(loadedDict['triangle_markers']),
    125129                         'test_export_triangulation_file failed. Test 4')
    126130       
    127         self.failUnless(meshDict['generatedpointattributelist']  ==
    128                         loadedDict['generatedpointattributelist'],
     131        self.failUnless(meshDict['vertex_attributes']  ==
     132                        loadedDict['vertex_attributes'],
    129133                         'test_export_triangulation_file failed. Test 5')
    130         self.failUnless(array(meshDict['generatedtriangleneighborlist'])  ==
    131                         array(loadedDict['generatedtriangleneighborlist']),
     134        self.failUnless(array(meshDict['triangle_neighbors'])  ==
     135                        array(loadedDict['triangle_neighbors']),
    132136                         'test_export_triangulation_file failed. Test 6')
    133         self.failUnless(array(meshDict['generatedsegmentmarkerlist'])  ==
    134                         array(loadedDict['generatedsegmentmarkerlist']),
     137        self.failUnless(array(meshDict['segment_markers'])  ==
     138                        array(loadedDict['segment_markers']),
    135139                         'test_export_triangulation_file failed. Test 7')
    136         self.failUnless(array(meshDict['generatedpointattributetitlelist'])  ==
    137                         array(loadedDict['generatedpointattributetitlelist']),
     140        self.failUnless(array(meshDict['vertex_attribute_titles'])  ==
     141                        array(loadedDict['vertex_attribute_titles']),
    138142                         'test_export_triangulation_file failed. Test 8')
    139143           

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

    r958 r968  
    2929
    3030SET_COLOUR='red'
     31NOMAXAREA=-999
    3132
    3233
    … …  
    818819        segment list: [(point1,point2),(p3,p4),...] (Tuples of integers)
    819820        hole list: [(x1,y1),...](Tuples of doubles, one inside each hole region)
    820         regionlist: [ (x1,y1,index),...] (Tuple of 3 doubles)
     821        regionlist: [ (x1,y1,marker, max area),...] (Tuple of 3-4 doubles)
     822       
    821823        Note, this adds an index attribute to the user Vertex objects.
    822         """
    823        
     824
     825        Used to produce .tsh file and output to triangle
     826        """
    824827        if userVertices is None:
    825828            userVertices = self.getUserVertices()
    … …  
    879882        generated point attribute title list:[A1Title, A2Title ...] (list of strings)
    880883        generated segment list: [(point1,point2),(p3,p4),...] (Tuples of integers)
    881         hole list: [(x1,y1),...](Tuples of doubles, one inside each hole region)
    882         regionlist: [ (x1,y1,index),...] (Tuple of 3 doubles)
    883         Note, this adds an index attribute to the user Vertex objects.
     884        generated segment marker list: [marker,marker,...] list of strings
     885
     886        generated triangle list: [(p1,p2,p3), (p4,p5,p6),....] tuple of points
     887
     888        generated triangle attribute list: [s1,s2,...] list of strings
     889
     890        generated triangle neighbor list: [(t1,t2,t3), (t4,t5,t6),....] tuple of triangles
     891       
     892        Used to produce .tsh file
    884893        """
    885894       
    … …  
    931940        meshDict['generatedtriangleneighborlist'] = triangleneighborlist
    932941       
    933         #print "*)*)"
     942        #print "mesh.Mesh2MeshList*)*)"
    934943        #print meshDict
    935         #print "*)*)"
     944        #print "mesh.Mesh2MeshList*)*)"
    936945
    937946        return meshDict
    … …  
    968977        self.meshVertices=[]
    969978
    970         #print "@#@#@#"
     979        #print "mesh.setTriangulation@#@#@#"
    971980        #print genDict
    972981        #print "@#@#@#"
    … …  
    10441053        mesh is an instance of a mesh object
    10451054        """
    1046 
    10471055        #Clear the current user mesh values
    10481056        self.clearUserSegments()
    … …  
    10511059        self.Regions=[]
    10521060
    1053         #print "@#@#@#"
     1061        #print "mesh.setMesh@#@#@#"
    10541062        #print genDict
    10551063        #print "@#@#@#"
    … …  
    15461554        """
    15471555        fd = open(ofile,'w')
    1548         gen_dict = self.Mesh2MeshList()
     1556        gen_dict = self.Mesh2IOTriangulationDict()
    15491557        load_mesh.loadASCII.write_ASCII_triangulation(fd,gen_dict)
    15501558        self.writeASCIImesh(fd,
    … …  
    15621570        meshDict = {}
    15631571       
    1564         meshDict['generatedpointlist'] = []
    1565         meshDict['generatedpointattributelist'] = []
    1566         meshDict['generatedsegmentlist'] = []
    1567         meshDict['generatedsegmentmarkerlist'] = []
    1568         meshDict['generatedtrianglelist'] = []
    1569         meshDict['generatedtriangleattributelist'] = []
    1570         meshDict['generatedtriangleneighborlist'] = []
     1572        meshDict['vertices'] = []
     1573        meshDict['vertex_attributes'] = []
     1574        meshDict['segments'] = []
     1575        meshDict['segment_markers'] = []
     1576        meshDict['triangles'] = []
     1577        meshDict['triangle_markers'] = []
     1578        meshDict['triangle_neighbors'] = []
    15711579       
    15721580        load_mesh.loadASCII.write_ASCII_triangulation(fd,meshDict)
    … …  
    16571665                       regions):
    16581666       
    1659         dict = self.Mesh2triangList(userVertices,
     1667        dict = self.Mesh2IOOutlineDict(userVertices,
    16601668                       userSegments,
    16611669                       holes,
    16621670                       regions)
    1663         #print "mesh*********"
     1671        #print "mesh.writeASCIImesh*********"
    16641672        #print "dict",dict
    16651673        #print "mesh*********"
    1666         load_mesh.loadASCII.write_ASCII_mesh(fd, dict)
     1674        load_mesh.loadASCII.write_ASCII_outline(fd, dict)
    16671675               
    16681676    def exportxyafile(self,ofile):
    … …  
    17001708
    17011709        load_mesh.loadASCII.export_xya_file(ofile, xya_dict, title, delimiter = " ")
     1710
     1711       
     1712########### IO CONVERTERS ##################
     1713        """
     1714        The dict fromat for IO with .tsh files is;
     1715        (the triangulation)
     1716        vertices: [[x1,y1],[x2,y2],...] (lists of doubles)
     1717        vertex_attributes: [[a11,a12,...],[a21,a22],...] (lists of doubles)
     1718        vertex_attribute_titles:[A1Title, A2Title ...] (A list of strings)
     1719        segments: [[v1,v2],[v3,v4],...] (lists of integers)
     1720        segment_markers : [marker,marker,...] list of strings
     1721        triangles : [(v1,v2,v3), (v4,v5,v6),....] lists of points
     1722        triangle markers: [s1,s2,...] A list of strings
     1723        triangle neighbors: [[t1,t2,t3], [t4,t5,t6],..] lists of triangles
     1724       
     1725        (the outline)   
     1726        points: [[x1,y1],[x2,y2],...] (lists of doubles)
     1727        point_attributes: [[a11,a12,...],[a21,a22],...] (lists of doubles)
     1728        outline_segments: [[point1,point2],[p3,p4],...] (lists of integers)
     1729        outline_segment_markers : [marker1,marker2,...] list of strings
     1730        holes : [[x1,y1],...](List of doubles, one inside each hole region)
     1731        regions : [ [x1,y1],...] (List of 4 doubles)
     1732        region_markers : [marker1,marker2,...] (list of strings)
     1733        region_max_areas: [ma1,ma2,...] (A list of doubles)
     1734        {Convension: A -ve max area means no max area}
     1735       
     1736        """
     1737     
     1738
     1739                               
     1740    def Mesh2IODict(self):
     1741        """
     1742        Convert the triangulation and outline info of a mesh to a dictionary
     1743        structure
     1744        """
     1745        dict = self.Mesh2IOTriangulationDict()
     1746        dict_mesh = self.Mesh2IOOutlineDict()
     1747        for element in dict_mesh.keys():
     1748            dict[element] = dict_mesh[element]
     1749        return dict
     1750   
     1751    def Mesh2IOTriangulationDict(self):
     1752        """
     1753        Convert the Mesh to a dictionary of lists describing the
     1754        triangulation variables;
     1755       
     1756        Used to produce .tsh file
     1757        """
     1758       
     1759        meshDict = {}       
     1760        vertices=[]
     1761        vertex_attributes=[]
     1762
     1763
     1764        self.maxVertexIndex=0
     1765        for vertex in self.meshVertices:
     1766            vertex.index = self.maxVertexIndex
     1767            vertices.append([vertex.x,vertex.y])
     1768            vertex_attributes.append(vertex.attributes)           
     1769            self.maxVertexIndex += 1
     1770
     1771        meshDict['vertices'] = vertices
     1772        meshDict['vertex_attributes'] = vertex_attributes
     1773        meshDict['vertex_attribute_titles'] = self.attributeTitles
     1774        #segments
     1775        segments=[]
     1776        segment_markers=[]
     1777        for seg in self.meshSegments:
     1778            segments.append([seg.vertices[0].index,seg.vertices[1].index])
     1779            segment_markers.append(seg.marker)
     1780        meshDict['segments'] =segments
     1781        meshDict['segment_markers'] =segment_markers
     1782
     1783        # Make sure that the indexation is correct
     1784        index = 0
     1785        for tri in self.meshTriangles:
     1786            tri.index = index           
     1787            index += 1
     1788
     1789        triangles = []
     1790        triangle_markers = []
     1791        triangle_neighbors = []
     1792        for tri in self.meshTriangles: 
     1793            triangles.append([tri.vertices[0].index,tri.vertices[1].index,tri.vertices[2].index]) 
     1794            triangle_markers.append([tri.attribute])
     1795            neighborlist = [-1,-1,-1]
     1796            for neighbor,index in map(None,tri.neighbors,
     1797                                      range(len(tri.neighbors))):
     1798                if neighbor:   
     1799                    neighborlist[index] = neighbor.index
     1800            triangle_neighbors.append(neighborlist)
     1801       
     1802        meshDict['triangles'] = triangles
     1803        meshDict['triangle_markers'] = triangle_markers
     1804        meshDict['triangle_neighbors'] = triangle_neighbors
     1805       
     1806        #print "mesh.Mesh2IOTriangulationDict*)*)"
     1807        #print meshDict
     1808        #print "mesh.Mesh2IOTriangulationDict*)*)"
     1809
     1810        return meshDict
     1811
     1812                                                     
     1813    def Mesh2IOOutlineDict(self, userVertices=None,
     1814                        userSegments=None,
     1815                        holes=None,
     1816                        regions=None):
     1817        """
     1818        Convert the mesh outline to a dictionary of the lists needed for the
     1819        triang module;
     1820       
     1821        Note, this adds an index attribute to the user Vertex objects.
     1822
     1823        Used to produce .tsh file and output to triangle
     1824        """
     1825        if userVertices is None:
     1826            userVertices = self.getUserVertices()
     1827        if userSegments is None:
     1828            userSegments = self.getUserSegments()
     1829        if holes is None:
     1830            holes = self.getHoles()
     1831        if regions is None:
     1832            regions = self.getRegions()
     1833           
     1834        meshDict = {}
     1835       
     1836        pointlist=[]
     1837        pointattributelist=[]
     1838        index = 0
     1839        for vertex in userVertices:
     1840            vertex.index = index
     1841            pointlist.append([vertex.x,vertex.y])
     1842            pointattributelist.append(vertex.attributes)
     1843           
     1844            index += 1
     1845        meshDict['points'] = pointlist
     1846        meshDict['point_attributes'] = pointattributelist
     1847
     1848        segmentlist=[]
     1849        segmentmarkerlist=[]
     1850        for seg in userSegments:
     1851            segmentlist.append([seg.vertices[0].index,seg.vertices[1].index])
     1852            segmentmarkerlist.append(seg.marker)
     1853        meshDict['outline_segments'] =segmentlist
     1854        meshDict['outline_segment_markers'] =segmentmarkerlist
     1855       
     1856        holelist=[]
     1857        for hole in holes:
     1858            holelist.append([hole.x,hole.y])
     1859        meshDict['holes'] = holelist
     1860       
     1861        regionlist=[]
     1862        regionmarkerlist = []
     1863        regionmaxarealist = []
     1864        for region in regions:
     1865            regionlist.append([region.x,region.y])
     1866            regionmarkerlist.append(region.getTag())
     1867           
     1868            if (region.getMaxArea() != None):
     1869                regionmaxarealist.append(region.getMaxArea())
     1870            else:
     1871                regionmaxarealist.append( NOMAXAREA)
     1872        meshDict['regions'] = regionlist
     1873        meshDict['region_markers'] = regionmarkerlist
     1874        meshDict['region_max_areas'] = regionmaxarealist
     1875        #print "*(*("
     1876        #print meshDict
     1877        #print meshDict['regionlist']
     1878        #print "*(*("
     1879        return meshDict
     1880         
     1881
     1882    def IOTriangulation2Mesh(self, genDict):
     1883        """
     1884        Set the mesh attributes given an tsh IO dictionary
     1885        """
     1886        #Clear the current generated mesh values
     1887        self.meshTriangles=[]
     1888        self.attributeTitles=[]
     1889        self.meshSegments=[]
     1890        self.meshVertices=[]
     1891
     1892        #print "mesh.setTriangulation@#@#@#"
     1893        #print genDict
     1894        #print "@#@#@#"
     1895
     1896        self.maxVertexIndex = 0
     1897        for point in genDict['vertices']:
     1898            v=Vertex(point[0], point[1])
     1899            v.index =  self.maxVertexIndex
     1900            self.maxVertexIndex +=1
     1901            self.meshVertices.append(v)
     1902
     1903        self.attributeTitles = genDict['vertex_attribute_titles']
     1904
     1905        index = 0
     1906        for seg,marker in map(None,genDict['segments'],genDict['segment_markers']):
     1907            segObject = Segment( self.meshVertices[seg[0]],
     1908                           self.meshVertices[seg[1]], marker = marker )
     1909            segObject.index = index
     1910            index +=1
     1911            self.meshSegments.append(segObject)
     1912
     1913        index = 0
     1914        for triangle in genDict['triangles']:
     1915            tObject =Triangle( self.meshVertices[triangle[0]],
     1916                        self.meshVertices[triangle[1]],
     1917                        self.meshVertices[triangle[2]] )
     1918            tObject.index = index
     1919            index +=1
     1920            self.meshTriangles.append(tObject)
     1921
     1922        index = 0
     1923        for att in genDict['triangle_markers']:
     1924            if att == []:
     1925                self.meshTriangles[index].setAttribute("")
     1926            else:
     1927                # Note, is the first attribute always the region att?
     1928                # haven't confirmed this
     1929                #Peter - I think so (from manuel)
     1930                #...the first such value is assumed to be a regional attribute...
     1931                self.meshTriangles[index].setAttribute(att[0])
     1932            index += 1
     1933           
     1934        index = 0
     1935        for att in genDict['vertex_attributes']:
     1936            if att == None:
     1937                self.meshVertices[index].setAttributes([])
     1938            else:
     1939                self.meshVertices[index].setAttributes(att)
     1940            index += 1
     1941   
     1942        index = 0
     1943        for triangle in genDict['triangle_neighbors']:
     1944            # Build a list of triangle object neighbors
     1945            ObjectNeighbor = []
     1946            for neighbor in triangle:
     1947                if ( neighbor != -1):
     1948                    ObjectNeighbor.append(self.meshTriangles[neighbor])
     1949                else:
     1950                    ObjectNeighbor.append(None)
     1951            self.meshTriangles[index].setNeighbors(ObjectNeighbor[0],ObjectNeighbor[1],ObjectNeighbor[2])
     1952            index += 1
     1953
     1954
     1955    def IOOutline2Mesh(self, genDict):
     1956        """
     1957        Set the outline (user Mesh attributes) given a IO tsh dictionary
     1958       
     1959        mesh is an instance of a mesh object
     1960        """
     1961        #Clear the current user mesh values
     1962        self.clearUserSegments()
     1963        self.userVertices=[]
     1964        self.Holes=[]
     1965        self.Regions=[]
     1966
     1967        #print "mesh.setMesh@#@#@#"
     1968        #print genDict
     1969        #print "@#@#@#"
     1970       
     1971        #index = 0
     1972        for point in genDict['points']:
     1973            v=Vertex(point[0], point[1])
     1974            #v.index = index
     1975            #index +=1
     1976            self.userVertices.append(v)
     1977
     1978        #index = 0
     1979        for seg,marker in map(None,genDict['outline_segments'],genDict['outline_segment_markers']):
     1980            segObject = Segment( self.userVertices[seg[0]],
     1981                           self.userVertices[seg[1]], marker = marker )
     1982            #segObject.index = index
     1983            #index +=1
     1984            self.userSegments.append(segObject)
     1985
     1986# Remove the loading of attribute info.
     1987# Have attribute info added using least_squares in pyvolution
     1988#         index = 0
     1989#         for att in genDict['point_attributes']:
     1990#             if att == None:
     1991#                 self.userVertices[index].setAttributes([])
     1992#             else:
     1993#                 self.userVertices[index].setAttributes(att)
     1994#            index += 1
     1995       
     1996        #index = 0
     1997        for point in genDict['holes']:
     1998            h=Hole(point[0], point[1])
     1999            #h.index = index
     2000            #index +=1
     2001            self.holes.append(h)
     2002
     2003        #index = 0
     2004        for reg,att,maxArea in map(None,
     2005                                   genDict['regions'],
     2006                                   genDict['region_markers'],
     2007                                   genDict['region_max_areas']):
     2008            Object = Region( reg[0],
     2009                             reg[1],
     2010                             tag = att,
     2011                             maxArea = maxArea)
     2012            #Object.index = index
     2013            #index +=1
     2014            self.regions.append(Object)
     2015 
     2016############################################
     2017
    17022018       
    17032019    def refineSet(self,setName):
    … …  
    19242240        except SyntaxError:
    19252241            dict = load_mesh.loadASCII.load_points_file(ofile, delimiter = ' ')
    1926         #print "dict",dict   
     2242        #print "dict",dict   outline_   
    19272243        dict['segmentlist'] = []
    19282244        dict['segmentmarkerlist'] = []
    … …  
    19322248        dict['holelist'] = []
    19332249        newmesh= Mesh()
    1934         newmesh.setMesh(dict)
     2250        newmesh.setMesh(dict) #FIXME use IOOutline2Mesh
    19352251        counter = newmesh.removeDuplicatedUserVertices()
    19362252        if (counter >0):
    … …  
    19392255        #print "loading " + ofile
    19402256        dict = load_mesh.loadASCII.load_points_file(ofile)
    1941         #print "dict",dict   
     2257        #print "dict",dict     
    19422258        dict['segmentlist'] = []
    19432259        dict['segmentmarkerlist'] = []
    … …  
    19452261        dict['regionattributelist'] = []
    19462262        dict['regionmaxarealist'] = []
    1947         dict['holelist'] = []
     2263        dict['holelist'] = [] 
    19482264        newmesh= Mesh()
    1949         newmesh.setMesh(dict)
     2265        newmesh.setMesh(dict) #FIXME use IOOutline2Mesh
    19502266        counter = newmesh.removeDuplicatedUserVertices()
    19512267        if (counter >0):
    … …  
    19542270        dict = load_mesh.loadASCII.import_triangulation(ofile)
    19552271        newmesh= Mesh()
    1956         newmesh.setMesh(dict)
    1957         newmesh.setTriangulation(dict)
     2272        newmesh.IOOutline2Mesh(dict)
     2273        newmesh.IOTriangulation2Mesh(dict)
    19582274    else:
    19592275        raise RuntimeError
    … …  
    21612477    return u
    21622478
    2163 
    21642479"""Refines triangles
    21652480

  • inundation/ga/storm_surge/pmesh/meshHarness.py

    r935 r968  
    10891089        os.remove(fileName)
    10901090
    1091         for pimport,pactual,pimpatt in map(None,dict['pointlist'],points,dict['pointattributelist']):
     1091        for pimport,pactual,pimpatt in map(None,dict['points'],points,dict['point_attributes']):
    10921092            self.failUnless( pimport == [pactual.x,pactual.y],
    10931093                        'loadASCIITestCase failed. test 1')
    10941094            self.failUnless( pimpatt == pactual.attributes,
    10951095                        'loadASCIITestCase failed. test 1.1')
    1096         self.failUnless( dict['segmentlist'][0] == [0,1],
     1096        self.failUnless( dict['outline_segments'][0] == [0,1],
    10971097                        'loadASCIITestCase failed. test 3')
    1098         for segimp,segactual in map(None,dict['segmentmarkerlist'],seg):
     1098        for segimp,segactual in map(None,dict['outline_segment_markers'],seg):
    10991099            self.failUnless( segimp == segactual.marker,
    11001100                        'loadASCIITestCase failed. test 4')
    1101         for holeimp,holeactual in map(None,dict['holelist'],holes):
     1101        for holeimp,holeactual in map(None,dict['holes'],holes):
    11021102            self.failUnless( holeimp == [holeactual.x,holeactual.y],
    11031103                        'loadASCIITestCase failed. test 5')
    1104         for regimp,regactual,regattimp, regmaxarea in map(None,dict['regionlist'],regions, dict['regionattributelist'], dict['regionmaxarealist']):
     1104        for regimp,regactual,regattimp, regmaxarea in map(None,dict['regions'],regions, dict['region_markers'], dict['region_max_areas']):
    11051105            self.failUnless( regimp == [regactual.x,regactual.y],
    11061106                        'loadASCIITestCase failed. test 6')
    … …  
    11101110                        'loadASCIITestCase failed. test 7')
    11111111
    1112        
     1112
     1113    def test_Mesh2MeshList(self):
     1114
     1115        a_att = [5,2]
     1116        d_att =[4,2]
     1117        f_att = [3,2]
     1118        e_att = [2,2]
     1119        a_xy = [0.0, 0.0]
     1120        a = Vertex ( a_xy[0],a_xy[1]) #, attributes =a_att)
     1121        d = Vertex (0.0, 4.0) #, attributes =d_att)
     1122        f = Vertex (4.0,0.0) #, attributes =f_att)
     1123        e = Vertex (1.0,1.0) #, attributes =e_att)
     1124   
     1125        s1 = Segment(a,d, marker = "50")
     1126        s2 = Segment(d,f, marker = "40")
     1127        s3 = Segment(a,f, marker = "30")
     1128        s4 = Segment(a,e, marker = "20")
     1129     
     1130        r1 = Region(0.3, 0.3,tag = "1.3", maxArea = 45)
     1131        m = Mesh(userVertices=[a,d,f,e],
     1132                 userSegments=[s1,s2,s3,s4],
     1133                 regions=[r1])
     1134
     1135        m.generateMesh("QApza2.1")
     1136
     1137        seg = m.getMeshSegments()
     1138        points = m.getMeshVertices()
     1139        dict = m.Mesh2MeshList()
     1140        print "dict",dict
     1141        # test not finished...
     1142 
     1143    def test_Mesh2IOTriangulationDict(self):
     1144
     1145        a_att = [5,2]
     1146        d_att =[4,2]
     1147        f_att = [3,2]
     1148        e_att = [2,2]
     1149        a_xy = [0.0, 0.0]
     1150        a = Vertex ( a_xy[0],a_xy[1] , attributes =a_att)
     1151        d = Vertex (0.0, 4.0 , attributes =d_att)
     1152        f = Vertex (4.0,0.0 , attributes =f_att)
     1153        e = Vertex (1.0,1.0 , attributes =e_att)
     1154   
     1155        s1 = Segment(a,d, marker = "50")
     1156        s2 = Segment(d,f, marker = "40")
     1157        s3 = Segment(a,f, marker = "30")
     1158        s4 = Segment(a,e, marker = "20")
     1159     
     1160        r1 = Region(0.3, 0.3,tag = "1.3", maxArea = 45)
     1161        m = Mesh(userVertices=[a,d,f,e],
     1162                 userSegments=[s1,s2,s3,s4],
     1163                 regions=[r1])
     1164        titles = ['ele','friction']
     1165        m.attributeTitles = titles
     1166        m.generateMesh("QApza2.1")
     1167
     1168        seg = m.getMeshSegments()
     1169        verts = m.getMeshVertices()
     1170        dict = m.Mesh2IOTriangulationDict()
     1171        #print "dict",dict
     1172       
     1173        self.failUnless( dict['vertex_attribute_titles'] == titles,
     1174                         'test_Mesh2IOTriangulationDict failed. test 1')
     1175        answer = [a_xy,[0.0, 4.0],[4.0,0.0], [1.0,1.0], [2.0,2.0]]
     1176        #print "answer",answer
     1177        #print "dict['vertices']",dict['vertices']
     1178       
     1179        self.failUnless( dict['vertices'] == answer,
     1180                         'test_Mesh2IOTriangulationDict failed. test 2')
     1181
     1182       
     1183        for pimport,pactual,pimpatt in map(None,dict['vertices'],
     1184                                           verts,dict['vertex_attributes']):
     1185            #assert all_close( pimport, (pactual.x,pactual.y))
     1186            self.failUnless( pimport == [pactual.x,pactual.y],
     1187                        'test_Mesh2IOTriangulationDict failed. test 2.1')
     1188            self.failUnless( pimpatt == pactual.attributes,
     1189                        'test_Mesh2IOTriangulationDict failed. test 2.2')
     1190        self.failUnless( dict['segments'][0] == [0,1],
     1191                        'test_Mesh2IOTriangulationDict failed. test 3')
     1192        for segimp,segactual in map(None,dict['segment_markers'],seg):
     1193            self.failUnless( segimp == segactual.marker,
     1194                        'test_Mesh2IOTriangulationDict failed. test 4')
     1195        #print " dict['triangles'][0]", dict['triangles'][0]
     1196        self.failUnless( dict['triangles'][0] == [3,2,4],
     1197                        'test_Mesh2IOTriangulationDict failed. test 5')
     1198        self.failUnless( dict['triangle_neighbors'][0] == [-1,2,3],
     1199                        'test_Mesh2IOTriangulationDict failed. test 6')
     1200        self.failUnless( dict['triangle_markers'][0] == ["1.3"],
     1201                         'test_Mesh2IOTriangulationDict failed. test 7')
     1202
     1203 
     1204    def test_Mesh2IODict(self):
     1205
     1206        a_att = [5,2]
     1207        d_att =[4,2]
     1208        f_att = [3,2]
     1209        e_att = [2,2]
     1210        a_xy = [0.0, 0.0]
     1211        a = Vertex ( a_xy[0],a_xy[1] , attributes =a_att)
     1212        d = Vertex (0.0, 4.0 , attributes =d_att)
     1213        f = Vertex (4.0,0.0 , attributes =f_att)
     1214        e = Vertex (1.0,1.0 , attributes =e_att)
     1215   
     1216        s1 = Segment(a,d, marker = "50")
     1217        s2 = Segment(d,f, marker = "40")
     1218        s3 = Segment(a,f, marker = "30")
     1219        s4 = Segment(a,e, marker = "20")
     1220     
     1221        r1 = Region(0.3, 0.3,tag = "1.3", maxArea = 45)
     1222        m = Mesh(userVertices=[a,d,f,e],
     1223                 userSegments=[s1,s2,s3,s4],
     1224                 regions=[r1])
     1225        titles = ['ele','friction']
     1226        m.attributeTitles = titles
     1227        m.generateMesh("QApza2.1")
     1228
     1229        seg = m.getMeshSegments()
     1230        verts = m.getMeshVertices()
     1231        dict = m.Mesh2IODict()
     1232        #print "dict",dict
     1233       
     1234        self.failUnless( dict['vertex_attribute_titles'] == titles,
     1235                         'test_Mesh2IOTriangulationDict failed. test 1')
     1236        answer = [a_xy,[0.0, 4.0],[4.0,0.0], [1.0,1.0], [2.0,2.0]]
     1237        #print "answer",answer
     1238        #print "dict['vertices']",dict['vertices']
     1239       
     1240        self.failUnless( dict['vertices'] == answer,
     1241                         'test_Mesh2IOTriangulationDict failed. test 2')
     1242
     1243       
     1244        for pimport,pactual,pimpatt in map(None,dict['vertices'],
     1245                                           verts,dict['vertex_attributes']):
     1246            #assert all_close( pimport, (pactual.x,pactual.y))
     1247            self.failUnless( pimport == [pactual.x,pactual.y],
     1248                        'test_Mesh2IODict failed. test 2.1')
     1249            self.failUnless( pimpatt == pactual.attributes,
     1250                        'test_Mesh2IODict failed. test 2.2')
     1251        self.failUnless( dict['segments'][0] == [0,1],
     1252                        'test_Mesh2IODict failed. test 3')
     1253        for segimp,segactual in map(None,dict['segment_markers'],seg):
     1254            self.failUnless( segimp == segactual.marker,
     1255                        'test_Mesh2IODict failed. test 4')
     1256        #print " dict['triangles'][0]", dict['triangles'][0]
     1257        self.failUnless( dict['triangles'][0] == [3,2,4],
     1258                        'test_Mesh2IODict failed. test 5')
     1259        self.failUnless( dict['triangle_neighbors'][0] == [-1,2,3],
     1260                        'test_Mesh2IODict failed. test 6')
     1261        self.failUnless( dict['triangle_markers'][0] == ["1.3"],
     1262                         'test_Mesh2IODict failed. test 7')
     1263
     1264        seg = m.getUserSegments()
     1265        points = m.getUserVertices()
     1266        holes = m.getHoles()
     1267        regions = m.getRegions()
     1268       
     1269        for pimport,pactual,pimpatt in map(None,dict['points'],points,dict['point_attributes']):
     1270            self.failUnless( pimport == [pactual.x,pactual.y],
     1271                        'test_Mesh2IODict failed. test 1')
     1272            self.failUnless( pimpatt == pactual.attributes,
     1273                        'test_Mesh2IODict failed. test 1.1')
     1274        self.failUnless( dict['outline_segments'][0] == [0,1],
     1275                        'test_Mesh2IODict failed. test 3')
     1276        for segimp,segactual in map(None,dict['outline_segment_markers'],seg):
     1277            self.failUnless( segimp == segactual.marker,
     1278                        'test_Mesh2IODict failed. test 4')
     1279        for holeimp,holeactual in map(None,dict['holes'],holes):
     1280            self.failUnless( holeimp == [holeactual.x,holeactual.y],
     1281                        'test_Mesh2IODict failed. test 5')
     1282       
     1283        for regimp,regactual,regattimp, regmaxarea in map(None,dict['regions'],regions, dict['region_markers'], dict['region_max_areas']):
     1284            self.failUnless( regimp == [regactual.x,regactual.y],
     1285                        'loadASCIITestCase failed. test 6')
     1286            self.failUnless( regattimp == regactual.getTag(),
     1287                        'loadASCIITestCase failed. test 7')
     1288            self.failUnless( regmaxarea == regactual.getMaxArea(),
     1289                        'loadASCIITestCase failed. test 7')
     1290   
     1291           
     1292       
     1293    def test_Mesh2IOOutlineDict(self):
     1294
     1295        a_att = [5,2]
     1296        d_att =[4,2]
     1297        f_att = [3,2]
     1298        e_att = [2,2]
     1299        a_xy = [0.0, 0.0]
     1300        a = Vertex ( a_xy[0],a_xy[1] , attributes =a_att)
     1301        d = Vertex (0.0, 4.0 , attributes =d_att)
     1302        f = Vertex (4.0,0.0 , attributes =f_att)
     1303        e = Vertex (1.0,1.0 , attributes =e_att)
     1304   
     1305        s1 = Segment(a,d, marker = "50")
     1306        s2 = Segment(d,f, marker = "40")
     1307        s3 = Segment(a,f, marker = "30")
     1308        s4 = Segment(a,e, marker = "20")
     1309     
     1310        r1 = Region(0.3, 0.3,tag = "1.3", maxArea = 45)
     1311        m = Mesh(userVertices=[a,d,f,e],
     1312                 userSegments=[s1,s2,s3,s4],
     1313                 regions=[r1])
     1314        titles = ['ele','friction']
     1315        m.attributeTitles = titles
     1316        m.generateMesh("QApza2.1")
     1317
     1318        seg = m.getMeshSegments()
     1319        verts = m.getMeshVertices()
     1320        dict = m.Mesh2IOOutlineDict()
     1321       
     1322        seg = m.getUserSegments()
     1323        points = m.getUserVertices()
     1324        holes = m.getHoles()
     1325        regions = m.getRegions()
     1326       
     1327        for pimport,pactual,pimpatt in map(None,dict['points'],points,dict['point_attributes']):
     1328            self.failUnless( pimport == [pactual.x,pactual.y],
     1329                        'loadASCIITestCase failed. test 1')
     1330            self.failUnless( pimpatt == pactual.attributes,
     1331                        'loadASCIITestCase failed. test 1.1')
     1332        self.failUnless( dict['outline_segments'][0] == [0,1],
     1333                        'loadASCIITestCase failed. test 3')
     1334        for segimp,segactual in map(None,dict['outline_segment_markers'],seg):
     1335            self.failUnless( segimp == segactual.marker,
     1336                        'loadASCIITestCase failed. test 4')
     1337        for holeimp,holeactual in map(None,dict['holes'],holes):
     1338            self.failUnless( holeimp == [holeactual.x,holeactual.y],
     1339                        'loadASCIITestCase failed. test 5')
     1340        #for regimp,regactual in map(None,dict['regions'],regions):
     1341         #   self.failUnless( [regimp[0],regimp[1]]==[regactual.x,regactual.y],
     1342          #              'loadASCIITestCase failed. test 6')
     1343           # self.failUnless( regimp[2] == regactual.getTag(),
     1344            #            'loadASCIITestCase failed. test 7')
     1345            #self.failUnless( regimp[3] == regactual.getMaxArea(),
     1346             #           'loadASCIITestCase failed. test 7')
     1347
     1348           
     1349        for regimp,regactual,regattimp, regmaxarea in map(None,dict['regions'],regions, dict['region_markers'], dict['region_max_areas']):
     1350            self.failUnless( regimp == [regactual.x,regactual.y],
     1351                        'loadASCIITestCase failed. test 6')
     1352            self.failUnless( regattimp == regactual.getTag(),
     1353                        'loadASCIITestCase failed. test 7')
     1354            self.failUnless( regmaxarea == regactual.getMaxArea(),
     1355                        'loadASCIITestCase failed. test 7')
     1356   
     1357           
    11131358#-------------------------------------------------------------
    11141359if __name__ == "__main__":
    11151360    suite = unittest.makeSuite(meshTestCase,'test')
    1116     #suite = unittest.makeSuite(meshTestCase,'test_import_mesh')
     1361    #suite = unittest.makeSuite(meshTestCase,'test_loadxy2')
    11171362    runner = unittest.TextTestRunner() #verbosity=2)
    11181363    runner.run(suite)

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

    r923 r968  
    7070    # load in the .tsh file
    7171    mesh_dict = mesh_file_to_mesh_dictionary(mesh_file)
    72     vertex_coordinates = mesh_dict['generatedpointlist']
    73     triangles = mesh_dict['generatedtrianglelist']
    74    
    75     old_point_attributes = mesh_dict['generatedpointattributelist']
    76     old_title_list = mesh_dict['generatedpointattributetitlelist']
     72    vertex_coordinates = mesh_dict['vertices']
     73    triangles = mesh_dict['triangles']
     74   
     75    old_point_attributes = mesh_dict['vertex_attributes']
     76    old_title_list = mesh_dict['vertex_attribute_titles']
    7777    if verbose:print "tsh file loaded"
    7878   
    … …  
    9797    # convert array to list of lists
    9898    new_point_attributes = f.tolist()
    99 
    10099    #FIXME have this overwrite attributes with the same title - DSG
    101100    #Put the newer attributes last
    … …  
    105104        for i in range(len(old_point_attributes)):
    106105            old_point_attributes[i].extend(new_point_attributes[i])
    107         mesh_dict['generatedpointattributelist'] = old_point_attributes
    108         mesh_dict['generatedpointattributetitlelist'] = old_title_list
     106        mesh_dict['vertex_attributes'] = old_point_attributes
     107        mesh_dict['vertex_attribute_titles'] = old_title_list
    109108    else:
    110         mesh_dict['generatedpointattributelist'] = new_point_attributes
    111         mesh_dict['generatedpointattributetitlelist'] = title_list
     109        mesh_dict['vertex_attributes'] = new_point_attributes
     110        mesh_dict['vertex_attribute_titles'] = title_list
    112111   
    113112    export_triangulation_file(mesh_output_file, mesh_dict)

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

    r905 r968  
    6767    mesh_dict = mesh_file_to_mesh_dictionary(fileName)
    6868    #print "mesh_dict",mesh_dict
    69     vertex_coordinates = mesh_dict['generatedpointlist']
    70     volumes = mesh_dict['generatedtrianglelist']
     69    vertex_coordinates = mesh_dict['vertices']
     70    volumes = mesh_dict['triangles']
    7171
    7272    #if setting_function:
    … …  
    7979
    8080    vertex_quantity_dict = {}
    81     point_atts = transpose(mesh_dict['generatedpointattributelist'])
    82     point_titles  = mesh_dict['generatedpointattributetitlelist']
    83     #print "point_titles",point_titles
     81    point_atts = transpose(mesh_dict['vertex_attributes'])
     82    point_titles  = mesh_dict['vertex_attribute_titles']
    8483    for quantity, value_vector in map (None, point_titles, point_atts):
    8584        vertex_quantity_dict[quantity] = value_vector
    … …  
    9695    { (tag): [e1, e2, e3..] }
    9796    """
    98     tri_atts = mesh_dict['generatedtriangleattributelist']
     97    tri_atts = mesh_dict['triangle_markers']
    9998    #print "tri_atts", tri_atts
    10099    tagged_elements = {}
    … …  
    122121    to a dictionary of markers, indexed with volume id and face number.
    123122    """
    124     triangles = mesh_dict['generatedtrianglelist']
     123    triangles = mesh_dict['triangles']
    125124    sides = calc_sides(triangles)
    126125    marker_dict = {}
    127     for seg, marker in map(None,mesh_dict['generatedsegmentlist'],
    128                            mesh_dict['generatedsegmentmarkerlist']):
     126    for seg, marker in map(None,mesh_dict['segments'],
     127                           mesh_dict['segment_markers']):
    129128        v1 = seg[0]
    130129        v2 = seg[1]

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

    r889 r968  
    887887        # create a .tsh file, no user outline
    888888        mesh_dic = {}
    889         mesh_dic['generatedpointlist'] = [[0.0, 0.0],
     889        mesh_dic['vertices'] = [[0.0, 0.0],
    890890                                          [0.0, 5.0],
    891891                                          [5.0, 0.0]]
    892         mesh_dic['generatedtrianglelist'] =  [[0, 2, 1]]
    893         mesh_dic['generatedsegmentlist'] = [[0, 1], [2, 0], [1, 2]]
    894         mesh_dic['generatedtriangleattributelist'] = [['']]
    895         mesh_dic['generatedpointattributelist'] = [[], [], []]
    896         mesh_dic['generatedpointattributetitlelist'] = []
    897         mesh_dic['generatedtriangleneighborlist'] = [[-1, -1, -1]]
    898         mesh_dic['generatedsegmentmarkerlist'] = ['external',
     892        mesh_dic['triangles'] =  [[0, 2, 1]]
     893        mesh_dic['segments'] = [[0, 1], [2, 0], [1, 2]]
     894        mesh_dic['triangle_markers'] = [['']]
     895        mesh_dic['vertex_attributes'] = [[], [], []]
     896        mesh_dic['vertiex_attribute_titles'] = []
     897        mesh_dic['triangle_neighbors'] = [[-1, -1, -1]]
     898        mesh_dic['segment_markers'] = ['external',
    899899                                                  'external',
    900900                                                  'external']       
    … …  
    915915        # load in the .tsh file we just wrote
    916916        mesh_dic = mesh_file_to_mesh_dictionary(mesh_output_file)
    917 
    918         assert allclose(mesh_dic['generatedpointattributelist'],
    919                         [[0.0, 0.0],
    920                          [5.0, 10.0],
    921                          [5.0,10.0]])
    922        
    923         self.failUnless(mesh_dic['generatedpointattributetitlelist']  ==
     917        #print "mesh_dic",mesh_dic
     918        ans =[[0.0, 0.0],
     919              [5.0, 10.0],
     920              [5.0,10.0]]
     921        assert allclose(mesh_dic['vertex_attributes'],ans)
     922       
     923        self.failUnless(mesh_dic['vertex_attribute_titles']  ==
    924924                        ['elevation','stage'],
    925925                        'test_fit_to_mesh_file failed')
    … …  
    937937        # create a .tsh file, no user outline
    938938        mesh_dic = {}
    939         mesh_dic['generatedpointlist'] = [[0.0, 0.0],
     939        mesh_dic['vertices'] = [[0.0, 0.0],
    940940                                          [0.0, 5.0],
    941941                                          [5.0, 0.0]]
    942         mesh_dic['generatedtrianglelist'] =  [[0, 2, 1]]
    943         mesh_dic['generatedsegmentlist'] = [[0, 1], [2, 0], [1, 2]]
    944         mesh_dic['generatedtriangleattributelist'] = [['']]
    945         mesh_dic['generatedpointattributelist'] = [[1,2], [1,2], [1,2]]
    946         mesh_dic['generatedpointattributetitlelist'] = ['density', 'temp']
    947         mesh_dic['generatedtriangleneighborlist'] = [[-1, -1, -1]]
    948         mesh_dic['generatedsegmentmarkerlist'] = ['external',
     942        mesh_dic['triangles'] =  [[0, 2, 1]]
     943        mesh_dic['segments'] = [[0, 1], [2, 0], [1, 2]]
     944        mesh_dic['triangle_markers'] = [['']]
     945        mesh_dic['vertex_attributes'] = [[1,2], [1,2], [1,2]]
     946        mesh_dic['vertex_attribute_titles'] = ['density', 'temp']
     947        mesh_dic['triangle_neighbors'] = [[-1, -1, -1]]
     948        mesh_dic['segment_markers'] = ['external',
    949949                                                  'external',
    950950                                                  'external']       
    … …  
    966966        mesh_dic = mesh_file_to_mesh_dictionary(mesh_output_file)
    967967
    968         assert allclose(mesh_dic['generatedpointattributelist'],
     968        assert allclose(mesh_dic['vertex_attributes'],
    969969                        [[1.0, 2.0,0.0, 0.0],
    970970                         [1.0, 2.0,5.0, 10.0],
    971971                         [1.0, 2.0,5.0,10.0]])
    972972       
    973         self.failUnless(mesh_dic['generatedpointattributetitlelist']  ==
     973        self.failUnless(mesh_dic['vertex_attribute_titles']  ==
    974974                        ['density', 'temp','elevation','stage'],
    975975                        'test_fit_to_mesh_file failed')

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

    r773 r968  
    118118         p2 = [0.0, 1.0]
    119119         p3 = [0.646446609407, 0.353553390593]
    120          meshDict['generatedpointlist'] = [p0,p1,p2,p3]
    121          meshDict['generatedpointattributelist'] = [[0.0, 0.0,7.0],[10.0, 0.0,7.0],[0.0, 10.0,7.0],[6.46446609407, 3.53553390593,7.0]]
    122          meshDict['generatedtrianglelist'] = [[0,3,2],[0,1,3]]
    123          meshDict['generatedtriangleattributelist'] = [6.6,6.6]
    124          meshDict['generatedtriangleneighbors'] = [[-1,-1,1],[-1,0,-1]]
    125          meshDict['generatedsegmentlist'] = [[1,0],[0,2],[2,3],[3,1]]
    126          meshDict['generatedsegmentmarkerlist'] = [2,3,1,1]
     120         meshDict['vertices'] = [p0,p1,p2,p3]
     121         meshDict['vertex_attributes'] = [[0.0, 0.0,7.0],[10.0, 0.0,7.0],[0.0, 10.0,7.0],[6.46446609407, 3.53553390593,7.0]]
     122         meshDict['triangles'] = [[0,3,2],[0,1,3]]
     123         meshDict['triangle_markers'] = [6.6,6.6]
     124         meshDict['triangle_neighbors'] = [[-1,-1,1],[-1,0,-1]]
     125         meshDict['segments'] = [[1,0],[0,2],[2,3],[3,1]]
     126         meshDict['segment_markers'] = [2,3,1,1]
    127127       
    128128         domain = Domain.pmesh_dictionary_to_domain(meshDict)
Note: See TracChangeset for help on using the changeset viewer.