Changeset 1751


Ignore:
Timestamp:
Aug 24, 2005, 11:57:09 AM (19 years ago)
Author:
ole
Message:

Changed misspelled 'indexes' to 'indices'

Location:
inundation/pyvolution
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • inundation/pyvolution/combine_pts.py

    r1423 r1751  
    148148    #print "extent",extent
    149149
    150     #get a list of in point indexes
     150    #get a list of in point indices
    151151    #FIXME closed doesn't seems to work here.
    152152    inside_indices = inside_polygon(points['pointlist'],
  • inundation/pyvolution/domain.py

    r1697 r1751  
    144144                     X,
    145145                     location='vertices',
    146                      indexes = None):
     146                     indices = None):
    147147        """Set values for named quantity
    148148
     
    156156        of elements. Otherwise it must be of dimension Nx3.
    157157
    158         Indexes is the set of element ids that the operation applies to
     158        Indices is the set of element ids that the operation applies to
    159159
    160160        The values will be stored in elements following their
     
    197197        self.quantities[name].set_values(X,
    198198                                         location,
    199                                          indexes = indexes)
    200 
    201 
    202 
    203     def get_quantity(self, name, location='vertices', indexes = None):
     199                                         indices = indices)
     200
     201
     202
     203    def get_quantity(self, name, location='vertices', indices = None):
    204204        """Get values for named quantity
    205205
     
    210210        of elements. Otherwise it must be of dimension Nx3.
    211211
    212         Indexes is the set of element ids that the operation applies to.
     212        Indices is the set of element ids that the operation applies to.
    213213
    214214        The values will be stored in elements following their
     
    216216        """
    217217
    218         return self.quantities[name].get_values( location, indexes = indexes)
     218        return self.quantities[name].get_values( location, indices = indices)
    219219
    220220
  • inundation/pyvolution/general_mesh.py

    r1680 r1751  
    226226        return vertex_coordinates
    227227
    228     def get_vertices(self, indexes=None):
     228    def get_vertices(self, indices=None):
    229229        """Get connectivity
    230         indexes is the set of element ids of interest
     230        indices is the set of element ids of interest
    231231        """
    232232
    233233        from Numeric import take
    234234
    235         if (indexes ==  None):
    236             indexes = range(len(self))  #len(self)=number of elements
    237 
    238         return  take(self.triangles, indexes)
     235        if (indices ==  None):
     236            indices = range(len(self))  #len(self)=number of elements
     237
     238        return  take(self.triangles, indices)
    239239
    240240    #FIXME - merge these two
     
    260260   
    261261
    262     def get_unique_vertices(self,  indexes=None):
    263         triangles = self.get_vertices(indexes=indexes)
     262    def get_unique_vertices(self,  indices=None):
     263        triangles = self.get_vertices(indices=indices)
    264264        unique_verts = {}
    265265        for triangle in triangles:
  • inundation/pyvolution/netherlands.py

    r1697 r1751  
    169169for t in domain.evolve(yieldstep = 0.02, finaltime = 15.0):
    170170    domain.write_time()
    171     print domain.quantities['stage'].get_values(location='centroids',indexes=[0])
     171    print domain.quantities['stage'].get_values(location='centroids',
     172                                                indices=[0])
    172173    #V.update_quantity('stage')
    173174    #rpdb.set_active()
  • inundation/pyvolution/quantity.py

    r1750 r1751  
    236236        from Numeric import take
    237237
    238         if (indexes is None):
    239             indexes = range(len(self))
     238        if (indices is None):
     239            indices = range(len(self))
    240240            is_subset = False
    241241        else:
    242242            is_subset = True
    243243        if location == 'centroids':
    244             P = take(self.domain.centroid_coordinates,indexes)
     244            P = take(self.domain.centroid_coordinates,indices)
    245245            if is_subset:
    246                 self.set_values(f(P[:,0], P[:,1]), location, indexes = indexes)
     246                self.set_values(f(P[:,0], P[:,1]), location, indices = indices)
    247247            else:
    248248                self.set_values(f(P[:,0], P[:,1]), location)
     
    251251            if is_subset:
    252252                #Brute force
    253                 for e in indexes:
     253                for e in indices:
    254254                    for i in range(3):
    255255                        self.vertex_values[e,i] = f(P[e,2*i], P[e,2*i+1])
     
    261261
    262262
    263     def set_array_values(self, values, location='vertices', indexes = None):
     263    def set_array_values(self, values, location='vertices', indices = None):
    264264        """Set values for quantity
    265265
     
    269269        Default is "vertices"
    270270
    271         indexes - if this action is carried out on a subset of
     271        indices - if this action is carried out on a subset of
    272272        elements or unique vertices
    273         The element/unique vertex indexes are specified here.
     273        The element/unique vertex indices are specified here.
    274274
    275275        In case of location == 'centroid' the dimension values must
     
    292292        values = array(values).astype(Float)
    293293
    294         if (indexes <> None):
    295             indexes = array(indexes).astype(Int)
    296             msg = 'Number of values must match number of indexes'
    297             assert values.shape[0] == indexes.shape[0], msg
     294        if (indices <> None):
     295            indices = array(indices).astype(Int)
     296            msg = 'Number of values must match number of indices'
     297            assert values.shape[0] == indices.shape[0], msg
    298298
    299299        N = self.centroid_values.shape[0]
     
    302302            assert len(values.shape) == 1, 'Values array must be 1d'
    303303
    304             if indexes == None:
     304            if indices == None:
    305305                msg = 'Number of values must match number of elements'
    306306                assert values.shape[0] == N, msg
     
    308308                self.centroid_values = values
    309309            else:
    310                 msg = 'Number of values must match number of indexes'
    311                 assert values.shape[0] == indexes.shape[0], msg
     310                msg = 'Number of values must match number of indices'
     311                assert values.shape[0] == indices.shape[0], msg
    312312
    313313                #Brute force
    314                 for i in range(len(indexes)):
    315                     self.centroid_values[indexes[i]] = values[i]
     314                for i in range(len(indices)):
     315                    self.centroid_values[indices[i]] = values[i]
    316316
    317317        elif location == 'edges':
     
    330330                   'Values array must be 1d'
    331331
    332             self.set_vertex_values(values.flat, indexes = indexes)
     332            self.set_vertex_values(values.flat, indices = indices)
    333333        else:
    334334            if len(values.shape) == 1:
    335                 self.set_vertex_values(values, indexes = indexes)
    336                 #if indexes == None:
     335                self.set_vertex_values(values, indices = indices)
     336                #if indices == None:
    337337                    #Values are being specified once for each unique vertex
    338338                #    msg = 'Number of values must match number of vertices'
     
    340340                 #   self.set_vertex_values(values)
    341341                #else:
    342                 #    for element_index, value in map(None, indexes, values):
     342                #    for element_index, value in map(None, indices, values):
    343343                #        self.vertex_values[element_index, :] = value
    344344
     
    349349                assert values.shape[1] == 3, msg
    350350
    351                 if indexes == None:
     351                if indices == None:
    352352                    self.vertex_values = values
    353353                else:
    354                     for element_index, value in map(None, indexes, values):
     354                    for element_index, value in map(None, indices, values):
    355355                        self.vertex_values[element_index] = value
    356356            else:
     
    446446    def set_values(self, X,
    447447                   location='vertices',
    448                    indexes = None):
     448                   indices = None):
    449449        """Set values for quantity
    450450
     
    464464        specified points
    465465
    466         If indexex is not 'unique vertices' Indexes is the set of element ids
     466        If indexex is not 'unique vertices' Indices is the set of element ids
    467467        that the operation applies to.
    468         If indexex is 'unique vertices' Indexes is the set of vertex ids
     468        If indexex is 'unique vertices' Indices is the set of vertex ids
    469469        that the operation applies to.
    470470
     
    487487
    488488        import types, Numeric
    489         assert type(indexes) in [types.ListType, types.NoneType,
     489        assert type(indices) in [types.ListType, types.NoneType,
    490490                                 Numeric.ArrayType],\
    491491                                 'Indices must be a list or None'
     
    494494        if callable(X):
    495495            #Use function specific method
    496             self.set_function_values(X, location, indexes = indexes)
     496            self.set_function_values(X, location, indices = indices)
    497497        elif type(X) in [types.FloatType, types.IntType, types.LongType]:
    498498            if location == 'centroids':
    499                 if (indexes ==  None):
     499                if (indices ==  None):
    500500                    self.centroid_values[:] = X
    501501                else:
    502502                    #Brute force
    503                     for i in indexes:
     503                    for i in indices:
    504504                        self.centroid_values[i,:] = X
    505505
    506506            elif location == 'edges':
    507                 if (indexes ==  None):
     507                if (indices ==  None):
    508508                    self.edge_values[:] = X
    509509                else:
    510510                    #Brute force
    511                     for i in indexes:
     511                    for i in indices:
    512512                        self.edge_values[i,:] = X
    513513
    514514            elif location == 'unique vertices':
    515                 if (indexes ==  None):
     515                if (indices ==  None):
    516516                    self.edge_values[:] = X
    517517                else:
    518518
    519519                    #Go through list of unique vertices
    520                     for unique_vert_id in indexes:
     520                    for unique_vert_id in indices:
    521521                        triangles = self.domain.vertexlist[unique_vert_id]
    522522
     
    532532                        self.interpolate()
    533533            else:
    534                 if (indexes ==  None):
     534                if (indices ==  None):
    535535                    self.vertex_values[:] = X
    536536                else:
    537537                    #Brute force
    538                     for i_vertex in indexes:
     538                    for i_vertex in indices:
    539539                        self.vertex_values[i_vertex,:] = X
    540540
    541541        elif type(X) in [Numeric.ArrayType, types.ListType]:
    542542            #Use array specific method
    543             self.set_array_values(X, location, indexes = indexes)
     543            self.set_array_values(X, location, indices = indices)
    544544        elif type(X) == types.StringType:
    545545            #Assume X is a filename
     
    557557
    558558
    559     def get_values(self, location='vertices', indexes = None):
     559    def get_values(self, location='vertices', indices = None):
    560560        """get values for quantity
    561561
     
    569569        of elements. Otherwise it must be of dimension Nx3
    570570
    571         The returned values with be a list the length of indexes
    572         (N if indexes = None).  Each value will be a list of the three
     571        The returned values with be a list the length of indices
     572        (N if indices = None).  Each value will be a list of the three
    573573        vertex values for this quantity.
    574574
    575         Indexes is the set of element ids that the operation applies to.
     575        Indices is the set of element ids that the operation applies to.
    576576
    577577        """
     
    583583
    584584        import types, Numeric
    585         assert type(indexes) in [types.ListType, types.NoneType,
     585        assert type(indices) in [types.ListType, types.NoneType,
    586586                                 Numeric.ArrayType],\
    587587                                 'Indices must be a list or None'
    588588
    589589        if location == 'centroids':
    590             if (indexes ==  None):
    591                 indexes = range(len(self))
    592             return take(self.centroid_values,indexes)
     590            if (indices ==  None):
     591                indices = range(len(self))
     592            return take(self.centroid_values,indices)
    593593        elif location == 'edges':
    594             if (indexes ==  None):
    595                 indexes = range(len(self))
    596             return take(self.edge_values,indexes)
     594            if (indices ==  None):
     595                indices = range(len(self))
     596            return take(self.edge_values,indices)
    597597        elif location == 'unique vertices':
    598             if (indexes ==  None):
    599                 indexes=range(self.domain.coordinates.shape[0])
     598            if (indices ==  None):
     599                indices=range(self.domain.coordinates.shape[0])
    600600            vert_values = []
    601601            #Go through list of unique vertices
    602             for unique_vert_id in indexes:
     602            for unique_vert_id in indices:
    603603                triangles = self.domain.vertexlist[unique_vert_id]
    604604
     
    616616            return Numeric.array(vert_values)
    617617        else:
    618             if (indexes ==  None):
    619                 indexes = range(len(self))
    620             return take(self.vertex_values,indexes)
    621 
    622 
    623     def set_function_values(self, f, location='vertices', indexes = None):
     618            if (indices ==  None):
     619                indices = range(len(self))
     620            return take(self.vertex_values,indices)
     621
     622
     623    def set_function_values(self, f, location='vertices', indices = None):
    624624        """Set values for quantity using specified function
    625625
     
    635635        from Numeric import take
    636636
    637         if (indexes ==  None):
    638             indexes = range(len(self))
     637        if (indices ==  None):
     638            indices = range(len(self))
    639639            is_subset = False
    640640        else:
    641641            is_subset = True
    642642        if location == 'centroids':
    643             P = take(self.domain.centroid_coordinates,indexes)
     643            P = take(self.domain.centroid_coordinates,indices)
    644644            if is_subset:
    645                 self.set_values(f(P[:,0], P[:,1]), location, indexes = indexes)
     645                self.set_values(f(P[:,0], P[:,1]), location, indices = indices)
    646646            else:
    647647                self.set_values(f(P[:,0], P[:,1]), location)
     
    650650            if is_subset:
    651651                #Brute force
    652                 for e in indexes:
     652                for e in indices:
    653653                    for i in range(3):
    654654                        self.vertex_values[e,i] = f(P[e,2*i], P[e,2*i+1])
     
    660660
    661661
    662     def set_array_values(self, values, location='vertices', indexes = None):
     662    def set_array_values(self, values, location='vertices', indices = None):
    663663        """Set values for quantity
    664664
     
    668668        Default is "vertices"
    669669
    670         indexes - if this action is carried out on a subset of
     670        indices - if this action is carried out on a subset of
    671671        elements or unique vertices
    672         The element/unique vertex indexes are specified here.
     672        The element/unique vertex indices are specified here.
    673673
    674674        In case of location == 'centroid' the dimension values must
     
    691691        values = array(values).astype(Float)
    692692
    693         if (indexes <> None):
    694             indexes = array(indexes).astype(Int)
    695             msg = 'Number of values must match number of indexes'
    696             assert values.shape[0] == indexes.shape[0], msg
     693        if (indices <> None):
     694            indices = array(indices).astype(Int)
     695            msg = 'Number of values must match number of indices'
     696            assert values.shape[0] == indices.shape[0], msg
    697697
    698698        N = self.centroid_values.shape[0]
     
    701701            assert len(values.shape) == 1, 'Values array must be 1d'
    702702
    703             if indexes == None:
     703            if indices == None:
    704704                msg = 'Number of values must match number of elements'
    705705                assert values.shape[0] == N, msg
     
    707707                self.centroid_values = values
    708708            else:
    709                 msg = 'Number of values must match number of indexes'
    710                 assert values.shape[0] == indexes.shape[0], msg
     709                msg = 'Number of values must match number of indices'
     710                assert values.shape[0] == indices.shape[0], msg
    711711
    712712                #Brute force
    713                 for i in range(len(indexes)):
    714                     self.centroid_values[indexes[i]] = values[i]
     713                for i in range(len(indices)):
     714                    self.centroid_values[indices[i]] = values[i]
    715715
    716716        elif location == 'edges':
     
    729729                   'Values array must be 1d'
    730730
    731             self.set_vertex_values(values.flat, indexes = indexes)
     731            self.set_vertex_values(values.flat, indices = indices)
    732732        else:
    733733            if len(values.shape) == 1:
    734                 self.set_vertex_values(values, indexes = indexes)
    735                 #if indexes == None:
     734                self.set_vertex_values(values, indices = indices)
     735                #if indices == None:
    736736                    #Values are being specified once for each unique vertex
    737737                #    msg = 'Number of values must match number of vertices'
     
    739739                 #   self.set_vertex_values(values)
    740740                #else:
    741                 #    for element_index, value in map(None, indexes, values):
     741                #    for element_index, value in map(None, indices, values):
    742742                #        self.vertex_values[element_index, :] = value
    743743
     
    748748                assert values.shape[1] == 3, msg
    749749
    750                 if indexes == None:
     750                if indices == None:
    751751                    self.vertex_values = values
    752752                else:
    753                     for element_index, value in map(None, indexes, values):
     753                    for element_index, value in map(None, indices, values):
    754754                        self.vertex_values[element_index] = value
    755755            else:
     
    765765    # FIXME have a get_vertex_values as well, so the 'stage' quantity can be
    766766    # set, based on the elevation
    767     def set_vertex_values(self, A, indexes = None):
     767    def set_vertex_values(self, A, indices = None):
    768768        """Set vertex values for all unique vertices based on input array A
    769769        which has one entry per unique vertex, i.e.
     
    771771        one value for each row in vertexlist.
    772772
    773         indexes is the list of vertex_id's that will be set.
     773        indices is the list of vertex_id's that will be set.
    774774
    775775        Note: Functions not allowed
     
    784784        assert len(A.shape) == 1
    785785
    786         if indexes == None:
     786        if indices == None:
    787787            assert A.shape[0] == self.domain.coordinates.shape[0]
    788788            vertex_list = range(A.shape[0])
    789789        else:
    790             assert A.shape[0] == len(indexes)
    791             vertex_list = indexes
     790            assert A.shape[0] == len(indices)
     791            vertex_list = indices
    792792
    793793        #Go through list of unique vertices
  • inundation/pyvolution/region.py

    r1219 r1751  
    2020
    2121
    22     def build_indexes(self, elements, domain):
     22    def build_indices(self, elements, domain):
    2323        """
    2424        Return a list of triangle_id or vertex_id, depending on the location
     
    5555                                self.X,
    5656                                location=self.location,
    57                                 indexes=self.build_indexes(elements, domain))
     57                                indices=self.build_indices(elements, domain))
    5858
    5959       
     
    8585        if tag == self.tag:
    8686            new_values = domain.get_quantity(self.quantity_initial_value,
    87                           indexes=self.build_indexes(elements, domain),
     87                          indices=self.build_indices(elements, domain),
    8888                          location=self.location) + self.X
    8989            domain.set_quantity(self.quantity_answer, new_values,
    90                                 indexes=self.build_indexes(elements, domain),
     90                                indices=self.build_indices(elements, domain),
    9191                                location=self.location)
    9292
     
    113113           
    114114            new_values = domain.get_quantity(self.quantity_answer,
    115                           indexes=self.build_indexes(elements, domain),
     115                          indices=self.build_indices(elements, domain),
    116116                          location=self.location) \
    117117                          + domain.get_quantity(self.adding_quantity,
    118                           indexes=self.build_indexes(elements, domain),
     118                          indices=self.build_indices(elements, domain),
    119119                          location=self.location)
    120120            domain.set_quantity(self.quantity_answer, new_values,
    121                                 indexes=self.build_indexes(elements, domain),
     121                                indices=self.build_indices(elements, domain),
    122122                                location=self.location)
    123123
  • inundation/pyvolution/test_domain.py

    r1158 r1751  
    1616def set_bottom_friction(tag, elements, domain):
    1717    if tag == "bottom":
    18         #print 'bottom - indexes',elements
    19         domain.set_quantity('friction', 0.09, indexes = elements)
     18        #print 'bottom - indices',elements
     19        domain.set_quantity('friction', 0.09, indices = elements)
    2020
    2121def set_top_friction(tag, elements, domain):
    2222    if tag == "top":
    23         #print 'top - indexes',elements
    24         domain.set_quantity('friction', 1., indexes = elements)
     23        #print 'top - indices',elements
     24        domain.set_quantity('friction', 1., indices = elements)
    2525
    2626
    2727def set_all_friction(tag, elements, domain):
    2828    if tag == "all":
    29         new_values = domain.get_quantity('friction', indexes = elements) + 10.0
    30 
    31         domain.set_quantity('friction', new_values, indexes = elements)
     29        new_values = domain.get_quantity('friction', indices = elements) + 10.0
     30
     31        domain.set_quantity('friction', new_values, indices = elements)
    3232
    3333
  • inundation/pyvolution/test_general_mesh.py

    r1018 r1751  
    3030
    3131        value = [7]
    32         indexes = [1]
     32        #indexes = [1]  #FIXME (Ole): Should this be used
    3333        assert  domain.get_vertices() == domain.triangles
    3434        assert domain.get_vertices([0,4]) == [domain.triangles[0],
  • inundation/pyvolution/test_quantity.py

    r1750 r1751  
    249249        quantity = Quantity(self.mesh4)
    250250        quantity.set_vertex_values([0,1,2,3,4,5])
    251         quantity.set_vertex_values([0,20,30,50], indexes = [0,2,3,5])
     251        quantity.set_vertex_values([0,20,30,50], indices = [0,2,3,5])
    252252
    253253        assert allclose(quantity.vertex_values,
     
    798798        quantity = Quantity(domain,[[1,1,1],[2,2,2]])
    799799        value = [7]
    800         indexes = [1]
     800        indices = [1]
    801801        quantity.set_array_values_by_index(value,
    802802                                           location = 'centroids',
    803                                            indexes = indexes)
     803                                           indices = indices)
    804804        #print "quantity.centroid_values",quantity.centroid_values
    805805
    806806        assert allclose(quantity.centroid_values, [1,7])
    807807
    808         quantity.set_array_values([15,20,25], indexes = indexes)
     808        quantity.set_array_values([15,20,25], indices = indices)
    809809        assert allclose(quantity.centroid_values, [1,20])
    810810
    811         quantity.set_array_values([15,20,25], indexes = indexes)
     811        quantity.set_array_values([15,20,25], indices = indices)
    812812        assert allclose(quantity.centroid_values, [1,20])
    813813
     
    829829                                    [4,4,4],[5,5,5],[6,6,6]])
    830830        value = [7]
    831         indexes = [1]
     831        indices = [1]
    832832        quantity.set_values(value,
    833833                                  location = 'centroids',
    834                                   indexes = indexes)
     834                                  indices = indices)
    835835        #print "quantity.centroid_values",quantity.centroid_values
    836836        assert allclose(quantity.centroid_values, [1,7,3,4,5,6])
    837837
    838838        value = [[15,20,25]]
    839         quantity.set_values(value, indexes = indexes)
     839        quantity.set_values(value, indices = indices)
    840840        #print "1 quantity.vertex_values",quantity.vertex_values
    841841        assert allclose(quantity.vertex_values[1], value[0])
     
    844844        #print "quantity",quantity.vertex_values
    845845        values = [10,100,50]
    846         quantity.set_values(values, indexes = [0,1,5], location = 'centroids')
     846        quantity.set_values(values, indices = [0,1,5], location = 'centroids')
    847847        #print "2 quantity.vertex_values",quantity.vertex_values
    848848        assert allclose(quantity.vertex_values[0], [10,10,10])
     
    858858        #this will be per unique vertex, indexing the vertices
    859859        #print "quantity.vertex_values",quantity.vertex_values
    860         quantity.set_values(values, indexes = [0,1,5])
     860        quantity.set_values(values, indices = [0,1,5])
    861861        #print "quantity.vertex_values",quantity.vertex_values
    862862        assert allclose(quantity.vertex_values[0], [1,50,10])
     
    867867                                    [4,4,4],[5,5,5],[6,6,6]])
    868868        values = [[31,30,29],[400,400,400],[1000,999,998]]
    869         quantity.set_values(values, indexes = [3,3,5])
     869        quantity.set_values(values, indices = [3,3,5])
    870870        quantity.interpolate()
    871871        assert allclose(quantity.centroid_values, [1,2,3,400,5,999])
     
    905905                                    [4,4,4],[5,5,5]])
    906906        value = 7
    907         indexes = [1,5]
     907        indices = [1,5]
    908908        quantity.set_values(value,
    909909                            location = 'unique vertices',
    910                             indexes = indexes)
     910                            indices = indices)
    911911        #print "quantity.centroid_values",quantity.centroid_values
    912912        assert allclose(quantity.vertex_values[0], [0,7,0])
     
    940940
    941941        #print "quantity.get_values(location = 'unique vertices')", \
    942         #      quantity.get_values(indexes=[0,1,2,3,4,5,6,7], \
     942        #      quantity.get_values(indices=[0,1,2,3,4,5,6,7], \
    943943        #                          location = 'unique vertices')
    944944
     
    947947                        quantity.get_values(location = 'unique vertices'))
    948948
    949         indexes = [0,5,3]
     949        indices = [0,5,3]
    950950        answer = [0.5,1,5]
    951951        assert allclose(answer,
    952                         quantity.get_values(indexes=indexes, \
     952                        quantity.get_values(indices=indices, \
    953953                                            location = 'unique vertices'))
    954954        #print "quantity.centroid_values",quantity.centroid_values
     
    977977                                    [4,4,4],[5,5,5],[6,6,6]])
    978978        value = [7]
    979         indexes = [1]
     979        indices = [1]
    980980        quantity.set_values(value,
    981981                            location = 'centroids',
    982                             indexes = indexes)
     982                            indices = indices)
    983983        #print "quantity.centroid_values",quantity.centroid_values
    984984        #print "quantity.get_values(location = 'centroids') ",\
     
    989989
    990990        value = [[15,20,25]]
    991         quantity.set_values(value, indexes = indexes)
     991        quantity.set_values(value, indices = indices)
    992992        #print "1 quantity.vertex_values",quantity.vertex_values
    993993        assert allclose(quantity.vertex_values, quantity.get_values())
     
    997997
    998998        # get a subset of elements
    999         subset = quantity.get_values(location='centroids', indexes=[0,5])
     999        subset = quantity.get_values(location='centroids', indices=[0,5])
    10001000        answer = [quantity.centroid_values[0],quantity.centroid_values[5]]
    10011001        assert allclose(subset, answer)
    10021002
    10031003
    1004         subset = quantity.get_values(location='edges', indexes=[0,5])
     1004        subset = quantity.get_values(location='edges', indices=[0,5])
    10051005        answer = [quantity.edge_values[0],quantity.edge_values[5]]
    10061006        #print "subset",subset
     
    10081008        assert allclose(subset, answer)
    10091009
    1010         subset = quantity.get_values( indexes=[1,5])
     1010        subset = quantity.get_values( indices=[1,5])
    10111011        answer = [quantity.vertex_values[1],quantity.vertex_values[5]]
    10121012        #print "subset",subset
Note: See TracChangeset for help on using the changeset viewer.