source: inundation/ga/storm_surge/pyvolution/test_quantity.py @ 1454

Last change on this file since 1454 was 1393, checked in by steve, 20 years ago

Added ghosts to rectangle
File size: 30.9 KB
RevLine 
[1018]1#!/usr/bin/env python
2
3import unittest
4from math import sqrt, pi
5
6
7from quantity import *
8from config import epsilon
9from Numeric import allclose, array, ones, Float
10
11
12class Test_Quantity(unittest.TestCase):
13    def setUp(self):
14        from domain import Domain
15
16        a = [0.0, 0.0]
17        b = [0.0, 2.0]
18        c = [2.0, 0.0]
19        d = [0.0, 4.0]
20        e = [2.0, 2.0]
21        f = [4.0, 0.0]
22
23        points = [a, b, c, d, e, f]
24
25        #bac, bce, ecf, dbe
26        elements = [ [1,0,2], [1,2,4], [4,2,5], [3,1,4] ]
27
28        self.mesh1 = Domain(points[:3], [elements[0]])
29        self.mesh1.check_integrity()
30
31        self.mesh4 = Domain(points, elements)
32        self.mesh4.check_integrity()
33
34    def tearDown(self):
35        pass
36        #print "  Tearing down"
37
38
39    def test_creation(self):
40
41        quantity = Quantity(self.mesh1, [[1,2,3]])
42        assert allclose(quantity.vertex_values, [[1.,2.,3.]])
43
44        try:
45            quantity = Quantity()
46        except:
47            pass
48        else:
49            raise 'Should have raised empty quantity exception'
50
51
52        try:
53            quantity = Quantity([1,2,3])
54        except AssertionError:
55            pass
56        except:
57            raise 'Should have raised "mising mesh object" error'
58
59
60    def test_creation_zeros(self):
61
62        quantity = Quantity(self.mesh1)
63        assert allclose(quantity.vertex_values, [[0.,0.,0.]])
64
65
66        quantity = Quantity(self.mesh4)
67        assert allclose(quantity.vertex_values, [[0.,0.,0.], [0.,0.,0.],
68                                                 [0.,0.,0.], [0.,0.,0.]])
69
70
71    def test_interpolation(self):
72        quantity = Quantity(self.mesh1, [[1,2,3]])
73        assert allclose(quantity.centroid_values, [2.0]) #Centroid
74
75        assert allclose(quantity.edge_values, [[2.5, 2.0, 1.5]])
76
77
78    def test_interpolation2(self):
79        quantity = Conserved_quantity(self.mesh4,
80                            [[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
81        assert allclose(quantity.centroid_values, [2., 5., 3., 0.]) #Centroid
82
83
84        quantity.extrapolate_second_order()
85
86        assert allclose(quantity.vertex_values, [[2., 2., 2.],
87                                               [3.+2./3, 6.+2./3, 4.+2./3],
88                                               [7.5, 0.5, 1.],
89                                               [-5, -2.5, 7.5]])
90
91        #print quantity.edge_values
92        assert allclose(quantity.edge_values, [[2.5, 2.0, 1.5],
93                                               [5., 5., 5.],
94                                               [4.5, 4.5, 0.],
95                                               [3.0, -1.5, -1.5]])
96
97    def test_boundary_allocation(self):
98        quantity = Conserved_quantity(self.mesh4,
99                            [[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
100
101        assert quantity.boundary_values.shape[0] == len(self.mesh4.boundary)
102
103
104    def test_set_values(self):
105        quantity = Quantity(self.mesh4)
106
107
108        quantity.set_values([[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]],
109                            location = 'vertices')
110        assert allclose(quantity.vertex_values,
111                        [[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
112        assert allclose(quantity.centroid_values, [2., 5., 3., 0.]) #Centroid
113        assert allclose(quantity.edge_values, [[2.5, 2.0, 1.5],
114                                               [5., 5., 5.],
115                                               [4.5, 4.5, 0.],
116                                               [3.0, -1.5, -1.5]])
117
118
119        #Test default
120        quantity.set_values([[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
121        assert allclose(quantity.vertex_values,
122                        [[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
123        assert allclose(quantity.centroid_values, [2., 5., 3., 0.]) #Centroid
124        assert allclose(quantity.edge_values, [[2.5, 2.0, 1.5],
125                                               [5., 5., 5.],
126                                               [4.5, 4.5, 0.],
127                                               [3.0, -1.5, -1.5]])
128
129        #Test centroids
130        quantity.set_values([1,2,3,4], location = 'centroids')
131        assert allclose(quantity.centroid_values, [1., 2., 3., 4.]) #Centroid
132
133        #Test edges
134        quantity.set_values([[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]],
135                            location = 'edges')
136        assert allclose(quantity.edge_values,
137                        [[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
138
139        #Test exceptions
140        try:
141            quantity.set_values([[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]],
142                                location = 'bas kamel tuba')
143        except:
144            pass
145
146
147        try:
148            quantity.set_values([[1,2,3], [0,0,9]])
149        except AssertionError:
150            pass
151        except:
152            raise 'should have raised Assertionerror'
153
154
155
156    def test_set_values_const(self):
157        quantity = Quantity(self.mesh4)
158
159        quantity.set_values(1.0, location = 'vertices')
160        assert allclose(quantity.vertex_values,
161                        [[1,1,1], [1,1,1], [1,1,1], [1, 1, 1]])
162        assert allclose(quantity.centroid_values, [1, 1, 1, 1]) #Centroid
163        assert allclose(quantity.edge_values, [[1, 1, 1],
164                                               [1, 1, 1],
165                                               [1, 1, 1],
166                                               [1, 1, 1]])
167
168
169        quantity.set_values(2.0, location = 'centroids')
170        assert allclose(quantity.centroid_values, [2, 2, 2, 2])
171
172        quantity.set_values(3.0, location = 'edges')
173        assert allclose(quantity.edge_values, [[3, 3, 3],
174                                               [3, 3, 3],
175                                               [3, 3, 3],
176                                               [3, 3, 3]])
177
178
179    def test_set_values_func(self):
180        quantity = Quantity(self.mesh4)
181
182        def f(x, y):
183            return x+y
184
185        quantity.set_values(f, location = 'vertices')
186        #print "quantity.vertex_values",quantity.vertex_values
187        assert allclose(quantity.vertex_values,
188                        [[2,0,2], [2,2,4], [4,2,4], [4,2,4]])
189        assert allclose(quantity.centroid_values,
190                        [4.0/3, 8.0/3, 10.0/3, 10.0/3])
191        assert allclose(quantity.edge_values,
192                        [[1,2,1], [3,3,2], [3,4,3], [3,4,3]])
193
194
195        quantity.set_values(f, location = 'centroids')
196        assert allclose(quantity.centroid_values,
197                        [4.0/3, 8.0/3, 10.0/3, 10.0/3])
198
199
200    def test_integral(self):
201        quantity = Quantity(self.mesh4)
202
[1393]203        #Try constants first
204        const = 5
[1018]205        quantity.set_values(const, location = 'vertices')
[1393]206        #print 'Q', quantity.get_integral()
[1018]207
[1393]208        assert allclose(quantity.get_integral(), self.mesh4.get_area() * const)
[1018]209
[1393]210        #Try with a linear function
[1018]211        def f(x, y):
212            return x+y
213
214        quantity.set_values(f, location = 'vertices')
215
216
[1393]217        ref_integral = (4.0/3 + 8.0/3 + 10.0/3 + 10.0/3) * 2
[1018]218
[1393]219        assert allclose (quantity.get_integral(), ref_integral)
[1018]220
221
222
223    def test_set_vertex_values(self):
224        quantity = Quantity(self.mesh4)
225        quantity.set_vertex_values([0,1,2,3,4,5])
226
227        assert allclose(quantity.vertex_values,
228                        [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
229        assert allclose(quantity.centroid_values,
230                        [1., 7./3, 11./3, 8./3]) #Centroid
231        assert allclose(quantity.edge_values, [[1., 1.5, 0.5],
232                                               [3., 2.5, 1.5],
233                                               [3.5, 4.5, 3.],
234                                               [2.5, 3.5, 2]])
235
236
237    def test_set_vertex_values_subset(self):
238        quantity = Quantity(self.mesh4)
239        quantity.set_vertex_values([0,1,2,3,4,5])
240        quantity.set_vertex_values([0,20,30,50], indexes = [0,2,3,5])
241
242        assert allclose(quantity.vertex_values,
243                        [[1,0,20], [1,20,4], [4,20,50], [30,1,4]])
244
245    def test_set_vertex_values_using_general_interface(self):
246        quantity = Quantity(self.mesh4)
247
248
249        quantity.set_values([0,1,2,3,4,5])
250
251
252        assert allclose(quantity.vertex_values,
253                        [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
254
255        #Centroid
256        assert allclose(quantity.centroid_values, [1., 7./3, 11./3, 8./3])
257
258        assert allclose(quantity.edge_values, [[1., 1.5, 0.5],
259                                               [3., 2.5, 1.5],
260                                               [3.5, 4.5, 3.],
261                                               [2.5, 3.5, 2]])
262
263
264
265
266    def test_gradient(self):
267        quantity = Conserved_quantity(self.mesh4)
268
269        #Set up for a gradient of (3,0) at mid triangle
270        quantity.set_values([2.0, 4.0, 8.0, 2.0],
271                            location = 'centroids')
272
273
274
275        #Gradients
276        a, b = quantity.compute_gradients()
277
278        #gradient bewteen t0 and t1 is undefined as det==0
279        assert a[0] == 0.0
280        assert b[0] == 0.0
281        #The others are OK
282        for i in range(1,4):
283            assert a[i] == 3.0
284            assert b[i] == 0.0
285
286
287        quantity.extrapolate_second_order()
288
289        #print quantity.vertex_values
290        assert allclose(quantity.vertex_values, [[2., 2.,  2.],
291                                                 [0., 6.,  6.],
292                                                 [6., 6., 12.],
293                                                 [0., 0.,  6.]])
294
295
296    def test_second_order_extrapolation2(self):
297        quantity = Conserved_quantity(self.mesh4)
298
299        #Set up for a gradient of (3,1), f(x) = 3x+y
300        quantity.set_values([2.0+2.0/3, 4.0+4.0/3, 8.0+2.0/3, 2.0+8.0/3],
301                            location = 'centroids')
302
303        #Gradients
304        a, b = quantity.compute_gradients()
305
306        #gradient bewteen t0 and t1 is undefined as det==0
307        assert a[0] == 0.0
308        assert b[0] == 0.0
309        #The others are OK
310        for i in range(1,4):
311            assert allclose(a[i], 3.0)
312            assert allclose(b[i], 1.0)
313
314        quantity.extrapolate_second_order()
315
316        #print quantity.vertex_values
317        assert allclose(quantity.vertex_values[1,0], 2.0)
318        assert allclose(quantity.vertex_values[1,1], 6.0)
319        assert allclose(quantity.vertex_values[1,2], 8.0)
320
321
322
323    def test_first_order_extrapolator(self):
324        quantity = Conserved_quantity(self.mesh4)
325
326        #Test centroids
327        quantity.set_values([1.,2.,3.,4.], location = 'centroids')
328        assert allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
329
330        #Extrapolate
331        quantity.extrapolate_first_order()
332
333        #Check vertices but not edge values
334        assert allclose(quantity.vertex_values,
335                        [[1,1,1], [2,2,2], [3,3,3], [4, 4, 4]])
336
337
338    def test_second_order_extrapolator(self):
339        quantity = Conserved_quantity(self.mesh4)
340
341        #Set up for a gradient of (3,0) at mid triangle
342        quantity.set_values([2.0, 4.0, 8.0, 2.0],
343                            location = 'centroids')
344
345
346
347        quantity.extrapolate_second_order()
348        quantity.limit()
349
350
351        #Assert that central triangle is limited by neighbours
352        assert quantity.vertex_values[1,0] >= quantity.vertex_values[0,0]
353        assert quantity.vertex_values[1,0] >= quantity.vertex_values[3,1]
354
355        assert quantity.vertex_values[1,1] <= quantity.vertex_values[2,1]
356        assert quantity.vertex_values[1,1] >= quantity.vertex_values[0,2]
357
358        assert quantity.vertex_values[1,2] <= quantity.vertex_values[2,0]
359        assert quantity.vertex_values[1,2] >= quantity.vertex_values[3,1]
360
361
362        #Assert that quantities are conserved
363        from Numeric import sum
364        for k in range(quantity.centroid_values.shape[0]):
365            assert allclose (quantity.centroid_values[k],
366                             sum(quantity.vertex_values[k,:])/3)
367
368
369
370
371
372    def test_limiter(self):
373        quantity = Conserved_quantity(self.mesh4)
374
375        #Create a deliberate overshoot (e.g. from gradient computation)
376        quantity.set_values([[3,0,3], [2,2,6], [5,3,8], [8,3,5]])
377
378
379        #Limit
380        quantity.limit()
381
382        #Assert that central triangle is limited by neighbours
383        assert quantity.vertex_values[1,0] >= quantity.vertex_values[0,0]
384        assert quantity.vertex_values[1,0] <= quantity.vertex_values[3,1]
385
386        assert quantity.vertex_values[1,1] <= quantity.vertex_values[2,1]
387        assert quantity.vertex_values[1,1] >= quantity.vertex_values[0,2]
388
389        assert quantity.vertex_values[1,2] <= quantity.vertex_values[2,0]
390        assert quantity.vertex_values[1,2] <= quantity.vertex_values[3,1]
391
392
393
394        #Assert that quantities are conserved
395        from Numeric import sum
396        for k in range(quantity.centroid_values.shape[0]):
397            assert allclose (quantity.centroid_values[k],
398                             sum(quantity.vertex_values[k,:])/3)
399
400
401    def test_limiter2(self):
402        """Taken from test_shallow_water
403        """
404        quantity = Conserved_quantity(self.mesh4)
405
406        #Test centroids
407        quantity.set_values([2.,4.,8.,2.], location = 'centroids')
408        assert allclose(quantity.centroid_values, [2, 4, 8, 2]) #Centroid
409
410
411        #Extrapolate
412        quantity.extrapolate_second_order()
413
414        assert allclose(quantity.vertex_values[1,:], [0.0, 6, 6])
415
416        #Limit
417        quantity.limit()
418
419
420        assert allclose(quantity.vertex_values[1,:], [2.2, 4.9, 4.9])
421
422
423        #Assert that quantities are conserved
424        from Numeric import sum
425        for k in range(quantity.centroid_values.shape[0]):
426            assert allclose (quantity.centroid_values[k],
427                             sum(quantity.vertex_values[k,:])/3)
428
429
430
431
432
433    def test_distribute_first_order(self):
434        quantity = Conserved_quantity(self.mesh4)
435
436        #Test centroids
437        quantity.set_values([1.,2.,3.,4.], location = 'centroids')
438        assert allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
439
440
441        #Extrapolate
442        quantity.extrapolate_first_order()
443
444        #Interpolate
445        quantity.interpolate_from_vertices_to_edges()
446
447        assert allclose(quantity.vertex_values,
448                        [[1,1,1], [2,2,2], [3,3,3], [4, 4, 4]])
449        assert allclose(quantity.edge_values, [[1,1,1], [2,2,2],
450                                               [3,3,3], [4, 4, 4]])
451
452
453    def test_distribute_second_order(self):
454        quantity = Conserved_quantity(self.mesh4)
455
456        #Test centroids
457        quantity.set_values([2.,4.,8.,2.], location = 'centroids')
458        assert allclose(quantity.centroid_values, [2, 4, 8, 2]) #Centroid
459
460
461        #Extrapolate
462        quantity.extrapolate_second_order()
463
464        assert allclose(quantity.vertex_values[1,:], [0.0, 6, 6])
465
466
467    def test_update_explicit(self):
468        quantity = Conserved_quantity(self.mesh4)
469
470        #Test centroids
471        quantity.set_values([1.,2.,3.,4.], location = 'centroids')
472        assert allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
473
474        #Set explicit_update
475        quantity.explicit_update = array( [1.,1.,1.,1.] )
476
477        #Update with given timestep
478        quantity.update(0.1)
479
480        x = array([1, 2, 3, 4]) + array( [.1,.1,.1,.1] )
481        assert allclose( quantity.centroid_values, x)
482
483    def test_update_semi_implicit(self):
484        quantity = Conserved_quantity(self.mesh4)
485
486        #Test centroids
487        quantity.set_values([1.,2.,3.,4.], location = 'centroids')
488        assert allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
489
490        #Set semi implicit update
491        quantity.semi_implicit_update = array([1.,1.,1.,1.])
492
493        #Update with given timestep
494        timestep = 0.1
495        quantity.update(timestep)
496
497        sem = array([1.,1.,1.,1.])/array([1, 2, 3, 4])
498        denom = ones(4, Float)-timestep*sem
499
500        x = array([1, 2, 3, 4])/denom
501        assert allclose( quantity.centroid_values, x)
502
503
504    def test_both_updates(self):
505        quantity = Conserved_quantity(self.mesh4)
506
507        #Test centroids
508        quantity.set_values([1.,2.,3.,4.], location = 'centroids')
509        assert allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
510
511        #Set explicit_update
512        quantity.explicit_update = array( [4.,3.,2.,1.] )
513
514        #Set semi implicit update
515        quantity.semi_implicit_update = array( [1.,1.,1.,1.] )
516
517        #Update with given timestep
518        timestep = 0.1
519        quantity.update(0.1)
520
521        sem = array([1.,1.,1.,1.])/array([1, 2, 3, 4])
522        denom = ones(4, Float)-timestep*sem
523
524        x = array([1, 2, 3, 4]) + array( [.4,.3,.2,.1] )
525        x /= denom
526        assert allclose( quantity.centroid_values, x)
527
528
529
530
531    #Test smoothing
532    def test_smoothing(self):
533
534        from mesh_factory import rectangular
535        from shallow_water import Domain, Transmissive_boundary
536        from Numeric import zeros, Float
537        from util import mean
538
539        #Create basic mesh
540        points, vertices, boundary = rectangular(2, 2)
541
542        #Create shallow water domain
543        domain = Domain(points, vertices, boundary)
544        domain.default_order=2
545        domain.reduction = mean
546
547
548        #Set some field values
549        domain.set_quantity('elevation', lambda x,y: x)
550        domain.set_quantity('friction', 0.03)
551
552
553        ######################
554        # Boundary conditions
555        B = Transmissive_boundary(domain)
556        domain.set_boundary( {'left': B, 'right': B, 'top': B, 'bottom': B})
557
558
559        ######################
560        #Initial condition - with jumps
561
562        bed = domain.quantities['elevation'].vertex_values
563        stage = zeros(bed.shape, Float)
564
565        h = 0.03
566        for i in range(stage.shape[0]):
567            if i % 2 == 0:
568                stage[i,:] = bed[i,:] + h
569            else:
570                stage[i,:] = bed[i,:]
571
572        domain.set_quantity('stage', stage)
573
574        stage = domain.quantities['stage']
575
576        #Get smoothed stage
577        A, V = stage.get_vertex_values(xy=False, smooth=True)
578        Q = stage.vertex_values
579
580
581        assert A.shape[0] == 9
582        assert V.shape[0] == 8
583        assert V.shape[1] == 3
584
585        #First four points
586        assert allclose(A[0], (Q[0,2] + Q[1,1])/2)
587        assert allclose(A[1], (Q[1,0] + Q[3,1] + Q[2,2])/3)
588        assert allclose(A[2], Q[3,0])
589        assert allclose(A[3], (Q[0,0] + Q[5,1] + Q[4,2])/3)
590
591        #Center point
592        assert allclose(A[4], (Q[0,1] + Q[1,2] + Q[2,0] +\
593                               Q[5,0] + Q[6,2] + Q[7,1])/6)
594
595
596        #Check V
597        assert allclose(V[0,:], [3,4,0])
598        assert allclose(V[1,:], [1,0,4])
599        assert allclose(V[2,:], [4,5,1])
600        assert allclose(V[3,:], [2,1,5])
601        assert allclose(V[4,:], [6,7,3])
602        assert allclose(V[5,:], [4,3,7])
603        assert allclose(V[6,:], [7,8,4])
604        assert allclose(V[7,:], [5,4,8])
605
606        #Get smoothed stage with XY
607        X, Y, A1, V1 = stage.get_vertex_values(xy=True, smooth=True)
608
609        assert allclose(A, A1)
610        assert allclose(V, V1)
611
612        #Check XY
613        assert allclose(X[4], 0.5)
614        assert allclose(Y[4], 0.5)
615
616        assert allclose(X[7], 1.0)
617        assert allclose(Y[7], 0.5)
618
619
620
621
622    def test_vertex_values_no_smoothing(self):
623
624        from mesh_factory import rectangular
625        from shallow_water import Domain, Transmissive_boundary
626        from Numeric import zeros, Float
627        from util import mean
628
629
630        #Create basic mesh
631        points, vertices, boundary = rectangular(2, 2)
632
633        #Create shallow water domain
634        domain = Domain(points, vertices, boundary)
635        domain.default_order=2
636        domain.reduction = mean
637
638
639        #Set some field values
640        domain.set_quantity('elevation', lambda x,y: x)
641        domain.set_quantity('friction', 0.03)
642
643
644        ######################
645        #Initial condition - with jumps
646
647        bed = domain.quantities['elevation'].vertex_values
648        stage = zeros(bed.shape, Float)
649
650        h = 0.03
651        for i in range(stage.shape[0]):
652            if i % 2 == 0:
653                stage[i,:] = bed[i,:] + h
654            else:
655                stage[i,:] = bed[i,:]
656
657        domain.set_quantity('stage', stage)
658
659        #Get stage
660        stage = domain.quantities['stage']
661        A, V = stage.get_vertex_values(xy=False, smooth=False)
662        Q = stage.vertex_values.flat
663
664        for k in range(8):
665            assert allclose(A[k], Q[k])
666
667
668        for k in range(8):
669            assert V[k, 0] == 3*k
670            assert V[k, 1] == 3*k+1
671            assert V[k, 2] == 3*k+2
672
673
674
675        X, Y, A1, V1 = stage.get_vertex_values(xy=True, smooth=False)
676
677
678        assert allclose(A, A1)
679        assert allclose(V, V1)
680
681        #Check XY
682        assert allclose(X[1], 0.5)
683        assert allclose(Y[1], 0.5)
684        assert allclose(X[4], 0.0)
685        assert allclose(Y[4], 0.0)
686        assert allclose(X[12], 1.0)
687        assert allclose(Y[12], 0.0)
688
689
690
691    def set_array_values_by_index(self):
692
693        from mesh_factory import rectangular
694        from shallow_water import Domain
695        from Numeric import zeros, Float
696
697        #Create basic mesh
698        points, vertices, boundary = rectangular(1, 1)
699
700        #Create shallow water domain
701        domain = Domain(points, vertices, boundary)
702        #print "domain.number_of_elements ",domain.number_of_elements
703        quantity = Quantity(domain,[[1,1,1],[2,2,2]])
704        value = [7]
705        indexes = [1]
706        quantity.set_array_values_by_index(value,
707                                           location = 'centroids',
708                                           indexes = indexes)
709        #print "quantity.centroid_values",quantity.centroid_values
710
711        assert allclose(quantity.centroid_values, [1,7])
712
713        quantity.set_array_values([15,20,25], indexes = indexes)
714        assert allclose(quantity.centroid_values, [1,20])
715
716        quantity.set_array_values([15,20,25], indexes = indexes)
717        assert allclose(quantity.centroid_values, [1,20])
718
719    def test_setting_some_vertex_values(self):
720        """
721        set values based on triangle lists.
722        """
723        from mesh_factory import rectangular
724        from shallow_water import Domain
725        from Numeric import zeros, Float
726
727        #Create basic mesh
728        points, vertices, boundary = rectangular(1, 3)
729        #print "vertices",vertices
730        #Create shallow water domain
731        domain = Domain(points, vertices, boundary)
732        #print "domain.number_of_elements ",domain.number_of_elements
733        quantity = Quantity(domain,[[1,1,1],[2,2,2],[3,3,3],
734                                    [4,4,4],[5,5,5],[6,6,6]])
735        value = [7]
736        indexes = [1]
737        quantity.set_values(value,
738                                  location = 'centroids',
739                                  indexes = indexes)
740        #print "quantity.centroid_values",quantity.centroid_values
741        assert allclose(quantity.centroid_values, [1,7,3,4,5,6])
742
743        value = [[15,20,25]]
744        quantity.set_values(value, indexes = indexes)
745        #print "1 quantity.vertex_values",quantity.vertex_values
746        assert allclose(quantity.vertex_values[1], value[0])
747
748
749        #print "quantity",quantity.vertex_values
750        values = [10,100,50]
751        quantity.set_values(values, indexes = [0,1,5], location = 'centroids')
752        #print "2 quantity.vertex_values",quantity.vertex_values
753        assert allclose(quantity.vertex_values[0], [10,10,10])
754        assert allclose(quantity.vertex_values[5], [50,50,50])
755        #quantity.interpolate()
756        #print "quantity.centroid_values",quantity.centroid_values
757        assert allclose(quantity.centroid_values, [10,100,3,4,5,50])
758
759
760        quantity = Quantity(domain,[[1,1,1],[2,2,2],[3,3,3],
761                                    [4,4,4],[5,5,5],[6,6,6]])
762        values = [10,100,50]
763        #this will be per unique vertex, indexing the vertices
764        #print "quantity.vertex_values",quantity.vertex_values
765        quantity.set_values(values, indexes = [0,1,5])
766        #print "quantity.vertex_values",quantity.vertex_values
767        assert allclose(quantity.vertex_values[0], [1,50,10])
768        assert allclose(quantity.vertex_values[5], [6,6,6])
769        assert allclose(quantity.vertex_values[1], [100,10,50])
770
771        quantity = Quantity(domain,[[1,1,1],[2,2,2],[3,3,3],
772                                    [4,4,4],[5,5,5],[6,6,6]])
773        values = [[31,30,29],[400,400,400],[1000,999,998]]
774        quantity.set_values(values, indexes = [3,3,5])
775        quantity.interpolate()
776        assert allclose(quantity.centroid_values, [1,2,3,400,5,999])
777
778        values = [[1,1,1],[2,2,2],[3,3,3],
779                                    [4,4,4],[5,5,5],[6,6,6]]
780        quantity.set_values(values)
781
782        # testing the standard set values by vertex
783        # indexed by vertex_id in general_mesh.coordinates
784        values = [0,1,2,3,4,5,6,7]
785
786        quantity.set_values(values)
787        #print "1 quantity.vertex_values",quantity.vertex_values
788        assert allclose(quantity.vertex_values,[[ 4.,  5.,  0.],
789                                                [ 1.,  0.,  5.],
790                                                [ 5.,  6.,  1.],
791                                                [ 2.,  1.,  6.],
792                                                [ 6.,  7.,  2.],
793                                                [ 3.,  2.,  7.]])
794
795    def test_setting_unique_vertex_values(self):
796        """
797        set values based on unique_vertex lists.
798        """
799        from mesh_factory import rectangular
800        from shallow_water import Domain
801        from Numeric import zeros, Float
802
803        #Create basic mesh
804        points, vertices, boundary = rectangular(1, 3)
805        #print "vertices",vertices
806        #Create shallow water domain
807        domain = Domain(points, vertices, boundary)
808        #print "domain.number_of_elements ",domain.number_of_elements
809        quantity = Quantity(domain,[[0,0,0],[1,1,1],[2,2,2],[3,3,3],
810                                    [4,4,4],[5,5,5]])
811        value = 7
812        indexes = [1,5]
813        quantity.set_values(value,
814                                  location = 'unique vertices',
815                                  indexes = indexes)
816        #print "quantity.centroid_values",quantity.centroid_values
817        assert allclose(quantity.vertex_values[0], [0,7,0])
818        assert allclose(quantity.vertex_values[1], [7,1,7])
819        assert allclose(quantity.vertex_values[2], [7,2,7])
820
821
822    def test_get_values(self):
823        """
824        get values based on triangle lists.
825        """
826        from mesh_factory import rectangular
827        from shallow_water import Domain
828        from Numeric import zeros, Float
829
830        #Create basic mesh
831        points, vertices, boundary = rectangular(1, 3)
832
833        #print "points",points
834        #print "vertices",vertices
835        #print "boundary",boundary
836
837        #Create shallow water domain
838        domain = Domain(points, vertices, boundary)
839        #print "domain.number_of_elements ",domain.number_of_elements
840        quantity = Quantity(domain,[[0,0,0],[1,1,1],[2,2,2],[3,3,3],
841                                    [4,4,4],[5,5,5]])
842
843        #print "quantity.get_values(location = 'unique vertices')", \
844        #      quantity.get_values(location = 'unique vertices')
845
846        #print "quantity.get_values(location = 'unique vertices')", \
847        #      quantity.get_values(indexes=[0,1,2,3,4,5,6,7], \
848        #                          location = 'unique vertices')
849
850        answer = [0.5,2,4,5,0,1,3,4.5]
851        assert allclose(answer,
852                        quantity.get_values(location = 'unique vertices'))
853
854        indexes = [0,5,3]
855        answer = [0.5,1,5]
856        assert allclose(answer,
857                        quantity.get_values(indexes=indexes, \
858                                            location = 'unique vertices'))
859        #print "quantity.centroid_values",quantity.centroid_values
860        #print "quantity.get_values(location = 'centroids') ",\
861        #      quantity.get_values(location = 'centroids')
862
863    def test_getting_some_vertex_values(self):
864        """
865        get values based on triangle lists.
866        """
867        from mesh_factory import rectangular
868        from shallow_water import Domain
869        from Numeric import zeros, Float
870
871        #Create basic mesh
872        points, vertices, boundary = rectangular(1, 3)
873
874        #print "points",points
875        #print "vertices",vertices
876        #print "boundary",boundary
877
878        #Create shallow water domain
879        domain = Domain(points, vertices, boundary)
880        #print "domain.number_of_elements ",domain.number_of_elements
881        quantity = Quantity(domain,[[1,1,1],[2,2,2],[3,3,3],
882                                    [4,4,4],[5,5,5],[6,6,6]])
883        value = [7]
884        indexes = [1]
885        quantity.set_values(value,
886                                  location = 'centroids',
887                                  indexes = indexes)
888        #print "quantity.centroid_values",quantity.centroid_values
889        #print "quantity.get_values(location = 'centroids') ",\
890        #      quantity.get_values(location = 'centroids')
891        assert allclose(quantity.centroid_values,
892                        quantity.get_values(location = 'centroids'))
893
894
895        value = [[15,20,25]]
896        quantity.set_values(value, indexes = indexes)
897        #print "1 quantity.vertex_values",quantity.vertex_values
898        assert allclose(quantity.vertex_values, quantity.get_values())
899
900        assert allclose(quantity.edge_values,
901                        quantity.get_values(location = 'edges'))
902
903        # get a subset of elements
904        subset = quantity.get_values(location='centroids', indexes=[0,5])
905        answer = [quantity.centroid_values[0],quantity.centroid_values[5]]
906        assert allclose(subset, answer)
907
908
909        subset = quantity.get_values(location='edges', indexes=[0,5])
910        answer = [quantity.edge_values[0],quantity.edge_values[5]]
911        #print "subset",subset
912        #print "answer",answer
913        assert allclose(subset, answer)
914
915        subset = quantity.get_values( indexes=[1,5])
916        answer = [quantity.vertex_values[1],quantity.vertex_values[5]]
917        #print "subset",subset
918        #print "answer",answer
919        assert allclose(subset, answer)
920
921
922
923#-------------------------------------------------------------
924if __name__ == "__main__":
925    suite = unittest.makeSuite(Test_Quantity,'test')
926    #print "restricted test"
927    #suite = unittest.makeSuite(Test_Quantity,'test_set_vertex_values_subset')
928    runner = unittest.TextTestRunner()
929    runner.run(suite)
Note: See TracBrowser for help on using the repository browser.