source: branches/numpy/anuga/culvert_flows/test_culvert_routines.py @ 6982

Last change on this file since 6982 was 6902, checked in by rwilson, 16 years ago

Back-merge from Numeric trunk to numpy branch.
File size: 20.1 KB
Line 
1#!/usr/bin/env python
2
3
4import unittest
5import os.path
6import sys
7
8from anuga.utilities.system_tools import get_pathname_from_package
9from anuga.culvert_flows.culvert_routines import boyd_generalised_culvert_model
10import numpy as num
11
12
13class Test_culvert_routines(unittest.TestCase):
14    def setUp(self):
15        pass
16
17    def tearDown(self):
18        pass
19
20
21    def test_boyd_0(self):
22        """test_boyd_0
23       
24        This tests the Boyd routine with data obtained from ??? by Petar Milevski
25        This test is the only one that passed in late February 2009
26        """
27     
28        g=9.81
29        culvert_slope=0.1  # Downward
30
31        inlet_depth=2.0
32        outlet_depth=0.0
33
34        culvert_length=4.0
35        culvert_width=1.2
36        culvert_height=0.75
37
38        culvert_type='box'
39        manning=0.013
40        sum_loss=0.0
41
42        inlet_specific_energy=inlet_depth #+0.5*v**2/g
43        z_in = 0.0
44        z_out = -culvert_length*culvert_slope/100
45        E_in = z_in+inlet_depth # +
46        E_out = z_out+outlet_depth # +
47        delta_total_energy = E_in-E_out
48
49        Q, v, d = boyd_generalised_culvert_model(inlet_depth, 
50                                                 outlet_depth,
51                                                 inlet_specific_energy, 
52                                                 delta_total_energy, 
53                                                 g,
54                                                 culvert_length,
55                                                 culvert_width,
56                                                 culvert_height,
57                                                 culvert_type,
58                                                 manning,
59                                                 sum_loss)
60       
61        #print Q, v, d
62        assert num.allclose(Q, 3.118, rtol=1.0e-3)
63       
64
65        #assert num.allclose(v, 0.93)
66        #assert num.allclose(d, 0.0)
67       
68
69    def Xtest_boyd_00(self):
70        """test_boyd_00
71       
72        This tests the Boyd routine with data obtained from ??? by Petar Milevski   
73        """
74        # FIXME(Ole): This test fails (20 Feb 2009)
75
76        g=9.81
77        culvert_slope=0.1  # Downward
78
79        inlet_depth=0.2
80        outlet_depth=0.0
81
82        culvert_length=4.0
83        culvert_width=1.2
84        culvert_height=0.75
85
86        culvert_type='box'
87        manning=0.013
88        sum_loss=0.0
89
90        inlet_specific_energy=inlet_depth #+0.5*v**2/g
91        z_in = 0.0
92        z_out = -culvert_length*culvert_slope/100
93        E_in = z_in+inlet_depth # +
94        E_out = z_out+outlet_depth # +
95        delta_total_energy = E_in-E_out
96
97        Q, v, d = boyd_generalised_culvert_model(inlet_depth, 
98                                                 outlet_depth,
99                                                 inlet_specific_energy, 
100                                                 delta_total_energy, 
101                                                 g,
102                                                 culvert_length,
103                                                 culvert_width,
104                                                 culvert_height,
105                                                 culvert_type,
106                                                 manning,
107                                                 sum_loss)
108       
109        #print Q, v, d
110        assert num.allclose(Q, 0.185, rtol=1.0e-3)
111        #assert num.allclose(v, 0.93)
112        #assert num.allclose(d, 0.0)
113       
114    def Xtest_boyd_1(self):
115        """test_boyd_1
116       
117        This tests the Boyd routine with data obtained from ??? by Petar Milevski   
118        """
119        # FIXME(Ole): This test fails (20 Feb 2009)
120
121        g=9.81
122        culvert_slope=0.01  # Downward
123
124        inlet_depth=0.263
125        outlet_depth=0.0
126
127        culvert_length=4.0
128        culvert_width=0.75
129        culvert_height=0.75
130       
131        culvert_type='pipe'
132        manning=0.013
133        sum_loss=1.5
134
135        inlet_specific_energy=inlet_depth #+0.5*v**2/g
136        z_in = 0.0
137        z_out = -culvert_length*culvert_slope/100
138        E_in = z_in+inlet_depth  #+ 0.5*v**2/g
139        E_out = z_out+outlet_depth  #+ 0.5*v**2/g
140        delta_total_energy = E_in-E_out
141
142        Q, v, d = boyd_generalised_culvert_model(inlet_depth, 
143                                                 outlet_depth,
144                                                 inlet_specific_energy, 
145                                                 delta_total_energy, 
146                                                 g,
147                                                 culvert_length,
148                                                 culvert_width,
149                                                 culvert_height,
150                                                 culvert_type,
151                                                 manning,
152                                                 sum_loss)
153       
154        print Q, v, d
155        assert num.allclose(Q, 0.10, rtol=1.0e-2) #inflow
156        assert num.allclose(v, 1.13, rtol=1.0e-2) #outflow velocity
157        assert num.allclose(d, 0.15, rtol=1.0e-2) #depth at outlet used to calc v
158       
159    def Xtest_boyd_2(self):
160        """test_boyd_2
161       
162        This tests the Boyd routine with data obtained from ??? by Petar Milevski   
163        """
164        # FIXME(Ole): This test fails (20 Feb 2009)
165
166        g=9.81
167        culvert_slope=0.01  # Downward
168
169        inlet_depth=1.135
170        outlet_depth=0.0
171
172        culvert_length=4.0
173        culvert_width=0.75
174        culvert_height=0.75
175       
176        culvert_type='pipe'
177        manning=0.013
178        sum_loss=1.5
179
180        inlet_specific_energy=inlet_depth #+0.5*v**2/g
181        z_in = 0.0
182        z_out = -culvert_length*culvert_slope/100
183        E_in = z_in+inlet_depth  #+ 0.5*v**2/g
184        E_out = z_out+outlet_depth  #+ 0.5*v**2/g
185        delta_total_energy = E_in-E_out
186
187        Q, v, d = boyd_generalised_culvert_model(inlet_depth, 
188                                                 outlet_depth,
189                                                 inlet_specific_energy, 
190                                                 delta_total_energy, 
191                                                 g,
192                                                 culvert_length,
193                                                 culvert_width,
194                                                 culvert_height,
195                                                 culvert_type,
196                                                 manning,
197                                                 sum_loss)
198       
199        print Q, v, d
200        assert num.allclose(Q, 1.00, rtol=1.0e-2) #inflow
201        assert num.allclose(v, 2.59, rtol=1.0e-2) #outflow velocity
202        assert num.allclose(d, 0.563, rtol=1.0e-2) #depth at outlet used to calc v 
203
204    def Xtest_boyd_3(self):
205        """test_boyd_3
206       
207        This tests the Boyd routine with data obtained from ??? by Petar Milevski   
208        """
209        # FIXME(Ole): This test fails (20 Feb 2009)
210
211        g=9.81
212        culvert_slope=0.01  # Downward
213
214        inlet_depth=12.747
215        outlet_depth=0.0
216
217        culvert_length=4.0
218        culvert_width=0.75
219        culvert_height=0.75
220       
221        culvert_type='pipe'
222        manning=0.013
223        sum_loss=1.5
224
225        inlet_specific_energy=inlet_depth #+0.5*v**2/g
226        z_in = 0.0
227        z_out = -culvert_length*culvert_slope/100
228        E_in = z_in+inlet_depth  #+ 0.5*v**2/g
229        E_out = z_out+outlet_depth  #+ 0.5*v**2/g
230        delta_total_energy = E_in-E_out
231
232        Q, v, d = boyd_generalised_culvert_model(inlet_depth, 
233                                                 outlet_depth,
234                                                 inlet_specific_energy, 
235                                                 delta_total_energy, 
236                                                 g,
237                                                 culvert_length,
238                                                 culvert_width,
239                                                 culvert_height,
240                                                 culvert_type,
241                                                 manning,
242                                                 sum_loss)
243       
244        print Q, v, d
245        assert num.allclose(Q, 5.00, rtol=1.0e-2) #inflow
246        assert num.allclose(v, 11.022, rtol=1.0e-2) #outflow velocity
247        assert num.allclose(d, 0.72, rtol=1.0e-2) #depth at outlet used to calc v
248
249    def Xtest_boyd_4(self):
250        """test_boyd_4
251       
252        This tests the Boyd routine with data obtained from ??? by Petar Milevski   
253        """
254        # FIXME(Ole): This test fails (20 Feb 2009)
255
256        g=9.81
257        culvert_slope=0.01  # Downward
258
259        inlet_depth=1.004
260        outlet_depth=1.00
261
262        culvert_length=4.0
263        culvert_width=0.75
264        culvert_height=0.75
265       
266        culvert_type='pipe'
267        manning=0.013
268        sum_loss=1.5
269
270        inlet_specific_energy=inlet_depth #+0.5*v**2/g
271        z_in = 0.0
272        z_out = -culvert_length*culvert_slope/100
273        E_in = z_in+inlet_depth  #+ 0.5*v**2/g
274        E_out = z_out+outlet_depth  #+ 0.5*v**2/g
275        delta_total_energy = E_in-E_out
276
277        Q, v, d = boyd_generalised_culvert_model(inlet_depth, 
278                                                 outlet_depth,
279                                                 inlet_specific_energy, 
280                                                 delta_total_energy, 
281                                                 g,
282                                                 culvert_length,
283                                                 culvert_width,
284                                                 culvert_height,
285                                                 culvert_type,
286                                                 manning,
287                                                 sum_loss)
288       
289        print Q, v, d
290        assert num.allclose(Q, 0.10, rtol=1.0e-2) #inflow
291        assert num.allclose(v, 0.22, rtol=1.0e-2) #outflow velocity
292        assert num.allclose(d, 0.76, rtol=1.0e-2) #depth at outlet used to calc v
293
294    def Xtest_boyd_5(self):
295        """test_boyd_5
296       
297        This tests the Boyd routine with data obtained from ??? by Petar Milevski   
298        """
299        # FIXME(Ole): This test fails (20 Feb 2009)
300
301        g=9.81
302        culvert_slope=0.01  # Downward
303
304        inlet_depth=1.401
305        outlet_depth=1.00
306
307        culvert_length=4.0
308        culvert_width=0.75
309        culvert_height=0.75
310       
311        culvert_type='pipe'
312        manning=0.013
313        sum_loss=1.5
314
315        inlet_specific_energy=inlet_depth #+0.5*v**2/g
316        z_in = 0.0
317        z_out = -culvert_length*culvert_slope/100
318        E_in = z_in+inlet_depth  #+ 0.5*v**2/g
319        E_out = z_out+outlet_depth  #+ 0.5*v**2/g
320        delta_total_energy = E_in-E_out
321
322        Q, v, d = boyd_generalised_culvert_model(inlet_depth, 
323                                                 outlet_depth,
324                                                 inlet_specific_energy, 
325                                                 delta_total_energy, 
326                                                 g,
327                                                 culvert_length,
328                                                 culvert_width,
329                                                 culvert_height,
330                                                 culvert_type,
331                                                 manning,
332                                                 sum_loss)
333       
334        print Q, v, d
335        assert num.allclose(Q, 1.00, rtol=1.0e-2) #inflow
336        assert num.allclose(v, 2.204, rtol=1.0e-2) #outflow velocity
337        assert num.allclose(d, 0.76, rtol=1.0e-2) #depth at outlet used to calc v
338
339
340    def Xtest_boyd_6(self):
341        """test_boyd_5
342       
343        This tests the Boyd routine with data obtained from ??? by Petar Milevski   
344        """
345        # FIXME(Ole): This test fails (20 Feb 2009)
346
347        g=9.81
348        culvert_slope=0.01  # Downward
349
350        inlet_depth=12.747
351        outlet_depth=1.00
352
353        culvert_length=4.0
354        culvert_width=0.75
355        culvert_height=0.75
356       
357        culvert_type='pipe'
358        manning=0.013
359        sum_loss=1.5
360
361        inlet_specific_energy=inlet_depth #+0.5*v**2/g
362        z_in = 0.0
363        z_out = -culvert_length*culvert_slope/100
364        E_in = z_in+inlet_depth  #+ 0.5*v**2/g
365        E_out = z_out+outlet_depth  #+ 0.5*v**2/g
366        delta_total_energy = E_in-E_out
367
368        Q, v, d = boyd_generalised_culvert_model(inlet_depth, 
369                                                 outlet_depth,
370                                                 inlet_specific_energy, 
371                                                 delta_total_energy, 
372                                                 g,
373                                                 culvert_length,
374                                                 culvert_width,
375                                                 culvert_height,
376                                                 culvert_type,
377                                                 manning,
378                                                 sum_loss)
379       
380        print Q, v, d
381        assert num.allclose(Q, 5.00, rtol=1.0e-2) #inflow
382        assert num.allclose(v, 11.022, rtol=1.0e-2) #outflow velocity
383        assert num.allclose(d, 0.76, rtol=1.0e-2) #depth at outlet used to calc v
384
385
386    def Xtest_boyd_7(self):
387        """test_boyd_7
388       
389        This tests the Boyd routine with data obtained from ??? by Petar Milevski   
390        """
391        # FIXME(Ole): This test fails (20 Feb 2009)
392
393        g=9.81
394        culvert_slope=0.1  # Downward
395
396        inlet_depth=0.303
397        outlet_depth=0.00
398
399        culvert_length=4.0
400        culvert_width=0.75
401        culvert_height=0.75
402       
403        culvert_type='pipe'
404        manning=0.013
405        sum_loss=1.5
406
407        inlet_specific_energy=inlet_depth #+0.5*v**2/g
408        z_in = 0.0
409        z_out = -culvert_length*culvert_slope/100
410        E_in = z_in+inlet_depth  #+ 0.5*v**2/g
411        E_out = z_out+outlet_depth  #+ 0.5*v**2/g
412        delta_total_energy = E_in-E_out
413
414        Q, v, d = boyd_generalised_culvert_model(inlet_depth, 
415                                                 outlet_depth,
416                                                 inlet_specific_energy, 
417                                                 delta_total_energy, 
418                                                 g,
419                                                 culvert_length,
420                                                 culvert_width,
421                                                 culvert_height,
422                                                 culvert_type,
423                                                 manning,
424                                                 sum_loss)
425       
426        print Q, v, d
427        assert num.allclose(Q, 0.10, rtol=1.0e-2) #inflow
428        assert num.allclose(v, 1.13, rtol=1.0e-2) #outflow velocity
429        assert num.allclose(d, 0.19, rtol=1.0e-2) #depth at outlet used to calc v
430
431
432    def Xtest_boyd_8(self):
433        """test_boyd_8
434       
435        This tests the Boyd routine with data obtained from ??? by Petar Milevski   
436        """
437        # FIXME(Ole): This test fails (20 Feb 2009)
438
439        g=9.81
440        culvert_slope=0.1  # Downward
441
442        inlet_depth=1.135
443        outlet_depth=0.00
444
445        culvert_length=4.0
446        culvert_width=0.75
447        culvert_height=0.75
448       
449        culvert_type='pipe'
450        manning=0.013
451        sum_loss=1.5
452
453        inlet_specific_energy=inlet_depth #+0.5*v**2/g
454        z_in = 0.0
455        z_out = -culvert_length*culvert_slope/100
456        E_in = z_in+inlet_depth  #+ 0.5*v**2/g
457        E_out = z_out+outlet_depth  #+ 0.5*v**2/g
458        delta_total_energy = E_in-E_out
459
460        Q, v, d = boyd_generalised_culvert_model(inlet_depth, 
461                                                 outlet_depth,
462                                                 inlet_specific_energy, 
463                                                 delta_total_energy, 
464                                                 g,
465                                                 culvert_length,
466                                                 culvert_width,
467                                                 culvert_height,
468                                                 culvert_type,
469                                                 manning,
470                                                 sum_loss)
471       
472        print Q, v, d
473        assert num.allclose(Q, 1.00, rtol=1.0e-2) #inflow
474        assert num.allclose(v, 2.204, rtol=1.0e-2) #outflow velocity
475        assert num.allclose(d, 0.76, rtol=1.0e-2) #depth at outlet used to calc v
476
477    def Xtest_boyd_9(self):
478        """test_boyd_9
479       
480        This tests the Boyd routine with data obtained from ??? by Petar Milevski   
481        """
482        # FIXME(Ole): This test fails (20 Feb 2009)
483
484        g=9.81
485        culvert_slope=0.1  # Downward
486
487        inlet_depth=1.1504
488        outlet_depth=1.5
489
490        culvert_length=4.0
491        culvert_width=0.75
492        culvert_height=0.75
493       
494        culvert_type='pipe'
495        manning=0.013
496        sum_loss=1.5
497
498        inlet_specific_energy=inlet_depth #+0.5*v**2/g
499        z_in = 0.0
500        z_out = -culvert_length*culvert_slope/100
501        E_in = z_in+inlet_depth  #+ 0.5*v**2/g
502        E_out = z_out+outlet_depth  #+ 0.5*v**2/g
503        delta_total_energy = E_in-E_out
504
505        Q, v, d = boyd_generalised_culvert_model(inlet_depth, 
506                                                 outlet_depth,
507                                                 inlet_specific_energy, 
508                                                 delta_total_energy, 
509                                                 g,
510                                                 culvert_length,
511                                                 culvert_width,
512                                                 culvert_height,
513                                                 culvert_type,
514                                                 manning,
515                                                 sum_loss)
516       
517        print Q, v, d
518        assert num.allclose(Q, 0.10, rtol=1.0e-2) #inflow
519        assert num.allclose(v, 0.22, rtol=1.0e-2) #outflow velocity
520        assert num.allclose(d, 0.76, rtol=1.0e-2) #depth at outlet used to calc v
521
522
523    def Xtest_boyd_10(self):
524        """test_boyd_9
525       
526        This tests the Boyd routine with data obtained from ??? by Petar Milevski   
527        """
528        # FIXME(Ole): This test fails (20 Feb 2009)
529
530        g=9.81
531        culvert_slope=0.1  # Downward
532
533        inlet_depth=1.901
534        outlet_depth=1.5
535
536        culvert_length=4.0
537        culvert_width=0.75
538        culvert_height=0.75
539       
540        culvert_type='pipe'
541        manning=0.013
542        sum_loss=1.5
543
544        inlet_specific_energy=inlet_depth #+0.5*v**2/g
545        z_in = 0.0
546        z_out = -culvert_length*culvert_slope/100
547        E_in = z_in+inlet_depth  #+ 0.5*v**2/g
548        E_out = z_out+outlet_depth  #+ 0.5*v**2/g
549        delta_total_energy = E_in-E_out
550
551        Q, v, d = boyd_generalised_culvert_model(inlet_depth, 
552                                                 outlet_depth,
553                                                 inlet_specific_energy, 
554                                                 delta_total_energy, 
555                                                 g,
556                                                 culvert_length,
557                                                 culvert_width,
558                                                 culvert_height,
559                                                 culvert_type,
560                                                 manning,
561                                                 sum_loss)
562       
563        print Q, v, d
564        assert num.allclose(Q, 1.00, rtol=1.0e-2) #inflow
565        assert num.allclose(v, 2.204, rtol=1.0e-2) #outflow velocity
566        assert num.allclose(d, 0.76, rtol=1.0e-2) #depth at outlet used to calc v
567   
568               
569#-------------------------------------------------------------
570if __name__ == "__main__":
571    suite = unittest.makeSuite(Test_culvert_routines, 'test')
572    runner = unittest.TextTestRunner()
573    runner.run(suite)
574
Note: See TracBrowser for help on using the repository browser.